looply-cli 0.0.0-stage → 0.2.0

package/dist/autonomy-tick.js

@@ -0,0 +1,616 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideAutonomyTick = exports.MAX_CONTROLLERS_PER_TICK = void 0;
+exports.autonomyTick = autonomyTick;
+const autonomy_controller_1 = require("./autonomy-controller");
+Object.defineProperty(exports, "decideAutonomyTick", { enumerable: true, get: function () { return autonomy_controller_1.decideAutonomyTick; } });
+const autonomy_store_1 = require("./autonomy-store");
+const spend_ledger_1 = require("./spend-ledger");
+const run_launcher_1 = require("./run-launcher");
+/**
+ * Do at most one thing for at most one controller.
+ *
+ * Never throws for an ordinary refusal, an unreachable server or an unreadable
+ * record: those are outcomes, and the daemon loop must not be the place they
+ * are discovered. A genuine programming error still propagates.
+ */
+async function autonomyTick(deps) {
+    const read = await deps.autonomy.read();
+    if (!read.ok) {
+        // The record of what this machine may spend cannot be read. Nothing is
+        // attempted against a budget it cannot account for.
+        return { action: { kind: 'idle', because: read.because } };
+    }
+    // Live grants, PLUS finished ones the server has not been told about. A
+    // pursuit that ended still owes one thing, and a tick that only looked at
+    // live grants would leave that owed for ever — the phone would show a night's
+    // work still running against a machine that finished hours ago.
+    const live = read.progress.filter((g) => g.state === 'authorized' || g.projectedAt === undefined);
+    if (live.length === 0) {
+        return { action: { kind: 'idle', because: 'no grant is live or owes a report here' } };
+    }
+    // Deterministic order, then rotated. `expiresAt` is stamped at authorization
+    // and never moves, so ascending is oldest-grant-first; the id breaks ties so
+    // two grants authorized in the same millisecond still order the same way on
+    // every machine and every tick.
+    const ordered = [...live].sort((a, b) => a.expiresAt.localeCompare(b.expiresAt) || a.controllerId.localeCompare(b.controllerId));
+    // ───────────────────────────────────────────────────────────────────────────
+    // SELECTED IS NOT THE SAME AS ACTIONABLE.
+    //
+    // The turn used to go to whichever grant sorted first, and it kept going
+    // there whatever that grant had to say. A controller merely WAITING for its
+    // run — hours of `wait`, one every ten seconds — held the only slot the whole
+    // time. Measured: a hundred cadences, a hundred turns to the waiting grant,
+    // and zero Starts for the newer one beside it, which had work ready and never
+    // once got asked.
+    //
+    // So the scan looks for a grant that can actually MOVE. `wait`, `hold` and
+    // `idle` are answers, not transitions: nothing durable changes, so a
+    // controller that can only produce them has no claim on the turn.
+    //
+    // BOUNDED, AND CHEAP TO BE WRONG ABOUT. Reading a grant's facts and asking
+    // the reducer writes nothing — that is the whole point of a pure reducer over
+    // facts gathered elsewhere. So the scan can afford to ask several controllers
+    // what they would do and still perform at most one of the answers.
+    //
+    // THE ONE-TRANSITION RULE IS UNTOUCHED. Several may be asked; exactly one is
+    // carried out, and the rest are forgotten until the next cadence.
+    /**
+     * 🔴 THE PREFERENCE ORDERS THE FRONT OF THE QUEUE; THE ROTATION STILL TURNS
+     * THE REST — AND THE FIRST VERSION OF THIS CODE FROZE THE WHOLE DAEMON.
+     *
+     * MEASURED, by the cycle that attacked this very commit: with a preference of
+     * ANY length the old code pinned `start = 0`, so the scan window became the
+     * first six entries of a fixed order and never moved again. Forty ticks,
+     * forty `hold`s, zero Starts, for ever — and a ONE-ENTRY preference naming a
+     * single blocked goal was enough to do it. The comment above said rotating a
+     * deliberate order "is just discarding it" and was wrong in the way that
+     * matters: rotation is not about fairness between the preferred, it is the
+     * only thing that lets a controller outside the window ever be ASKED.
+     *
+     * ⚠️ SO THE TWO ARE COMPOSED RATHER THAN CHOSEN BETWEEN. The scan order is
+     *
+     *     [ the goals the scheduler named, in ITS order ]
+     *  ++ [ everything else, rotated by one each cadence ]
+     *
+     * The coordinator still gets first look, which is the whole point of asking
+     * it. Nothing outside its answer can starve, because the tail advances every
+     * cadence whatever the head says. And with no preference at all the order is
+     * exactly what it was before this seam existed — the rotated list — so the
+     * unwired path is untouched.
+     *
+     * ⚠️ AND THE PREFERRED BLOCK IS CAPPED. A preference longer than the scan
+     * window would refill the window with preferred entries every tick and
+     * reproduce the freeze by a longer route, so at most half the window is spent
+     * on it. `decideSchedule` never names more goals than there is capacity for,
+     * so in practice this cap is slack; it is here because "in practice" is what
+     * the frozen version also assumed.
+     */
+    const preference = deps.prefer?.() ?? [];
+    const turn = ((deps.rotation?.() ?? 0) % ordered.length + ordered.length) % ordered.length;
+    const preferredFirst = [];
+    const rest = [];
+    if (preference.length > 0) {
+        const rank = (g) => {
+            const at = preference.indexOf(g.goalId);
+            return at === -1 ? -1 : at;
+        };
+        const named = ordered
+            .map((g, i) => ({ g, i, at: rank(g) }))
+            .filter((d) => d.at !== -1)
+            .sort((a, b) => a.at - b.at || a.i - b.i)
+            .slice(0, Math.max(1, Math.floor(exports.MAX_CONTROLLERS_PER_TICK / 2)));
+        const taken = new Set(named.map((d) => d.g.controllerId));
+        preferredFirst.push(...named.map((d) => d.g));
+        rest.push(...ordered.filter((g) => !taken.has(g.controllerId)));
+    }
+    else {
+        rest.push(...ordered);
+    }
+    // The tail rotates every cadence, so every controller outside the preferred
+    // block is reached within `rest.length` ticks whatever the coordinator says.
+    const rotated = rest.length === 0 ? [] : rest.map((_, i) => rest[(turn + i) % rest.length]);
+    const scanOrder = [...preferredFirst, ...rotated];
+    const scan = Math.min(scanOrder.length, exports.MAX_CONTROLLERS_PER_TICK);
+    /**
+     * 🔴 HOW MANY EXECUTIONS ONE CADENCE MAY LAUNCH — AND IT USED TO BE ONE,
+     * WHICH IS NOT PARALLELISM BY ANY READING.
+     *
+     * The one-transition rule is right about TRANSITIONS: reserving an ordinal,
+     * settling a pursuit, projecting a terminal state. Each of those writes
+     * durable state and each deserves to be attributable to a cadence.
+     *
+     * Launching is not one of those. `starter.start` spawns a DETACHED child and
+     * returns without waiting — that is its whole design, so the heartbeat is not
+     * held for hours — so N launches in one cadence produce N processes running
+     * at the same instant, which is the only definition of parallelism that means
+     * anything. Doing them one per cadence would fill N slots in N cadences and
+     * call the queue a fleet.
+     *
+     * ⚠️ ONE STILL, FOR EVERYTHING ELSE. Exactly one non-launch transition per
+     * cadence, unchanged. And the default is one launch too, so a caller that
+     * does not ask for capacity behaves precisely as it always has.
+     *
+     * ⚠️ THE CEILING IS THE CALLER'S, AND IT IS A CEILING RATHER THAN A TARGET.
+     * `launchesPerTick` is `N - active` computed by the daemon from the registry;
+     * this loop stops when the goals run out, which is the common case.
+     */
+    const launchBudget = Math.max(1, deps.launchesPerTick?.() ?? 1);
+    let launched = 0;
+    let firstOutcome = null;
+    let fallback = null;
+    /**
+     * A goal skipped for want of a slot, kept ONLY so the cadence can say so.
+     *
+     * 🔴 IT MUST NOT SHARE `fallback`, AND THAT SHARING DEFEATED THE GUARD
+     * BELOW ENTIRELY.
+     *
+     * MEASURED: the skip did `fallback ??= { grant, action }` and the loop's exit
+     * PERFORMS `fallback` — so the unplaced goal was launched anyway, into the
+     * project's own checkout, which is the exact behaviour the guard exists to
+     * prevent. The guard read as if it worked, the end-to-end run refused with
+     * "a run is already going here", and the two facts never met.
+     */
+    let deferred = null;
+    for (let i = 0; i < scan; i++) {
+        const candidate = scanOrder[i];
+        const facts = await loadFacts(deps, candidate);
+        const action = (0, autonomy_controller_1.decideAutonomyTick)(facts);
+        deps.onDecision?.(candidate.goalId, action.kind);
+        if (movesSomething(action)) {
+            /**
+             * 🔴 A GOAL THE COORDINATOR DID NOT PLACE MUST NOT BE LAUNCHED.
+             *
+             * MEASURED END TO END, and only by the end-to-end harness: with capacity
+             * 2 and three authorized goals, A starts, and the scheduler then emits
+             * ONE more start because one slot is left. The tick's scan still reaches
+             * B and C — they are in the rotation — and with no placement for them the
+             * launcher fell back to its unplaced path: the project's own checkout,
+             * the project's own lease, and a clash with the run already there. Three
+             * cadences, three refusals reading "a run is already going here for goal
+             * gol_A".
+             *
+             * That is the single-run behaviour coming back through the back door.
+             * When a coordinator is deciding, it decides WHO runs; a goal it did not
+             * place has not been refused, it simply has no slot this cadence, and a
+             * later cadence places it when one frees.
+             *
+             * ⚠️ ONLY WHEN A COORDINATOR IS ACTUALLY PLACING. With no `workspaceFor`
+             * at all — every existing caller — nothing is skipped and this behaves
+             * exactly as it always has.
+             */
+            if (action.kind === 'execute-attempt' &&
+                deps.workspaceFor !== undefined &&
+                deps.workspaceFor(candidate.goalId) === undefined) {
+                deferred ??= candidate;
+                continue;
+            }
+            const outcome = { controllerId: candidate.controllerId, ...(await perform(deps, candidate, action)) };
+            // Anything that is not a launch is the tick's one transition, as before.
+            if (action.kind !== 'execute-attempt')
+                return outcome;
+            firstOutcome ??= outcome;
+            launched += 1;
+            if (launched >= launchBudget)
+                return firstOutcome;
+            continue;
+        }
+        // Keep the first non-transition so a tick where nobody can move still
+        // reports something true about the grant whose turn it was.
+        fallback ??= { grant: candidate, action };
+    }
+    /**
+     * ⚠️ THE FIRST LAUNCH IS WHAT THE TICK REPORTS. `TickOutcome` describes ONE
+     * action and every existing reader — the daemon's log, the tests — expects
+     * that shape. Reporting the first is the honest summary of a cadence that
+     * launched several, and changing the shape would rewrite a contract for a
+     * detail the caller does not act on.
+     */
+    if (firstOutcome !== null)
+        return firstOutcome;
+    /**
+     * ⚠️ A DEFERRED GOAL IS REPORTED, NEVER PERFORMED. It has not been refused
+     * and nothing about it has failed; the coordinator simply has no slot for it
+     * this cadence, and a later one places it when a slot frees.
+     */
+    if (fallback === null && deferred !== null) {
+        return {
+            controllerId: deferred.controllerId,
+            action: {
+                kind: 'idle',
+                because: `goal ${deferred.goalId} is authorized but the coordinator has not placed it; waiting for a slot`,
+            },
+        };
+    }
+    const chosen = fallback;
+    return {
+        controllerId: chosen.grant.controllerId,
+        ...(await perform(deps, chosen.grant, chosen.action)),
+    };
+}
+/**
+ * How many controllers one cadence may ASK before giving up on finding work.
+ *
+ * A ceiling rather than "all of them", so a machine holding many grants cannot
+ * turn the autonomy cadence into an unbounded sweep every ten seconds. Six is
+ * comfortably more than the number of goals a person pursues at once and small
+ * enough that the worst tick is still a handful of file reads and one HTTP GET
+ * per candidate.
+ *
+ * Being wrong low is harmless: the rotation moves on, so a controller missed
+ * this cadence is asked on the next one. Being wrong high costs work every ten
+ * seconds for ever.
+ */
+exports.MAX_CONTROLLERS_PER_TICK = 6;
+/**
+ * Whether this action would change something durable.
+ *
+ * The whole fairness rule rests on this distinction, so it is written once,
+ * here, rather than being re-derived at the call site. `wait` and `hold` are
+ * honest answers — something is legitimately in progress, or cannot be acted on
+ * — but nothing about the world changes, so they give up the turn.
+ */
+function movesSomething(action) {
+    switch (action.kind) {
+        case 'reserve-ordinal':
+        case 'execute-attempt':
+        case 'finish-ordinal':
+        case 'terminal':
+        case 'project-terminal':
+        case 'accept-server-ending':
+            return true;
+        case 'wait':
+        case 'hold':
+            return false;
+        default: {
+            const never = action;
+            throw new Error(`no fairness decision for ${String(never)}`);
+        }
+    }
+}
+/**
+ * Everything the reducer is allowed to see, gathered from the authorities that
+ * own it.
+ *
+ * Nothing is derived twice. The attempt history comes from `StartAttempts`, the
+ * spend from `AutonomyStore`, the run's ending from the ledger reader — and
+ * this function's whole job is to put them beside each other.
+ */
+async function loadFacts(deps, grant) {
+    const requestIdFor = (ordinal) => (0, autonomy_store_1.autonomyStartId)(grant.controllerId, ordinal);
+    const base = {
+        controllerId: grant.controllerId,
+        localState: grant.state,
+        expiresAt: grant.expiresAt,
+        maxStarts: grant.maxStarts,
+        now: deps.now(),
+        requestIdFor,
+    };
+    if (grant.state !== 'authorized') {
+        // Over locally. The only question left is whether the server knows, and
+        // asking is cheap compared with leaving a finished pursuit showing as
+        // running on somebody's phone.
+        const remote = await deps.reconcile(grant);
+        return {
+            ...base,
+            unfinished: [],
+            startsConsumed: grant.maxStarts,
+            reconciliation: remote,
+            // Unreachable is not "the server knows". It is "ask again later".
+            serverKnowsItEnded: remote.kind === 'ended' ? true : remote.kind === 'unreachable' ? undefined : false,
+            endingRecorded: grant.projectedAt !== undefined,
+        };
+    }
+    // Read BEFORE anything is decided, and shared by both spending paths. A
+    // person's tap is not about one ordinal; it is about whether the machine
+    // should be going at all.
+    const humanHold = (await deps.humanHold?.()) ?? undefined;
+    const spend = await deps.autonomy.spendOf(grant.controllerId, grant.maxStarts);
+    if (!spend.ok) {
+        // A spend that cannot be read is not a spend of zero. Reconciliation is
+        // skipped: there is nothing this tick could safely do with the answer.
+        //
+        // WEATHER holds — something else had the file for a moment, and the next
+        // tick reads it again. DAMAGE stops: a receipt whose contents contradict
+        // where it sits, or a hole where one was removed, will not improve by being
+        // read again, and a budget that cannot be believed cannot bound anything.
+        return {
+            ...base,
+            unfinished: [],
+            startsConsumed: grant.maxStarts,
+            reconciliation: { kind: 'unreachable', because: spend.because },
+            ...(spend.transient ? {} : { recordsDamaged: spend.because }),
+        };
+    }
+    const { unfinished, startsConsumed } = spend.spend;
+    const ordinal = unfinished[0];
+    const held = humanHold === undefined ? {} : { humanHold };
+    // The server is asked once, and only when the answer could matter. A tick
+    // that is going to wait for a live attempt has nothing to spend and no reason
+    // to make a request.
+    const reconciliation = await deps.reconcile(grant);
+    /**
+     * Asked BESIDE reconciliation, and for the same reason.
+     *
+     * Both answer "may this machine spend anything right now", both are only
+     * true at the instant they were read, and both gate the two spending paths
+     * together. Reading one and not the other would mean a tick that had asked
+     * permission of the grant but not of the person.
+     *
+     * Unconditional for an authorized grant, exactly as reconciliation is. It
+     * could be narrowed to the ticks that can actually spend, and the saving
+     * would be real — but the condition would then live in two places, and the
+     * one that drifts is the one that decides a pursuit may proceed without
+     * having looked.
+     */
+    const gate = await deps.approvalGate?.(grant);
+    const approval = gate === undefined ? {} : { approvalGate: gate };
+    const programme = deps.programme === true ? { programme: true } : {};
+    /**
+     * Read beside the approval and for the same reason: both are authorities that
+     * can refuse a spend, and a tick that asked one but not the other would
+     * proceed without having looked. Unconditional for an authorized grant, so
+     * the condition cannot drift into two places.
+     */
+    const safety = await deps.loopSafety?.(grant);
+    const loopSafety = safety === undefined ? {} : { loopSafety: safety };
+    if (ordinal === undefined) {
+        return { ...base, unfinished, startsConsumed, reconciliation, ...held, ...approval, ...loopSafety, ...programme };
+    }
+    const requestId = requestIdFor(ordinal);
+    const refusal = await deps.refusalOf(requestId);
+    const attempt = await deps.attempts.progress(requestId, {
+        startedRun: await deps.startMarkOf(requestId),
+        refusal: refusal,
+        ordinalReserved: true,
+    });
+    const runEnded = attempt.kind === 'run-started' ? await deps.runEnded(attempt.runId) : undefined;
+    /**
+     * M5-2: the third key, asked only once the Start has refused — before that
+     * there is no branch whose publication could matter — and only of a caller
+     * that can ask it. Whatever the mark named is what is asked about; a mark
+     * that named nothing is asked about nothing, and the controller says so.
+     */
+    const publication = attempt.kind === 'refused' && deps.publicationOf !== undefined
+        ? await deps.publicationOf(refusal?.branch, grant.goalId)
+        : undefined;
+    return {
+        ...base,
+        unfinished,
+        startsConsumed,
+        attempt,
+        ...(runEnded === undefined ? {} : { runEnded }),
+        ...(publication === undefined ? {} : { publication }),
+        reconciliation,
+        ...held,
+        ...approval,
+        ...loopSafety,
+        ...programme,
+    };
+}
+/** Carry out the one action, and nothing beyond it. */
+async function perform(deps, grant, action) {
+    switch (action.kind) {
+        case 'reserve-ordinal': {
+            // Racing daemons converge here through the exclusive receipt: one wins the
+            // ordinal, the other is told, and neither spends twice.
+            const out = await deps.autonomy.consumeStart(grant.controllerId, deps.now());
+            deps.log(out.ok
+                ? `autonomy: reserved Start ${out.ordinal} of ${grant.maxStarts} for goal ${grant.goalId}.`
+                : `autonomy: could not reserve a Start — ${out.because}`);
+            return { action };
+        }
+        case 'execute-attempt': {
+            // SPEND THE TRY FIRST.
+            //
+            // Before the spawn, not after, and this ordering is the whole repair. The
+            // retry budget used to be derived from the receipt the CHILD writes at the
+            // admission seam, so a launch that died before reaching it — missing
+            // binary, argv the CLI rejects, EPERM on the state directory — left no
+            // trace and cost nothing. Measured: five hundred ticks, five hundred
+            // spawns, every one of them calling itself attempt 1.
+            //
+            // Losing the race is not a failure. It means another daemon reserved this
+            // exact try in the same instant; it spawns, we do not, and neither of us
+            // spent two.
+            /**
+             * ⚠️ A CHEAP PRE-CHECK, NOT THE GATE. THE GATE IS IN THE RUN.
+             *
+             * 🔴 IT USED TO RESERVE HERE, AND THAT WOULD HAVE DOUBLE-COUNTED EVERY
+             * START. The canonical admission is `runLoop`'s — the one thing a manual
+             * run, a daemon-spawned Start and a coordinator-placed goal all are — and
+             * a reservation taken here would be held AGAIN there, so one start held
+             * twice its estimate and the machine refused itself at half its ceiling.
+             *
+             * This READS and does not reserve. What it buys is that a start already
+             * obviously over the ceiling costs no spawn, no workspace and none of a
+             * small number of attempts. What it does NOT do is decide, because a
+             * decision taken here and acted on there is two policies pretending to be
+             * one.
+             *
+             * 🔴 THE MONEY CEILING ITSELF IS ENFORCED IN `runLoop`.
+             *
+             * `withinEnvelope` shipped fully specced with no production caller, and
+             * the spend ledger it needed was write-only: nothing anywhere read it, no
+             * config key could construct an `Envelope`, and `grep withinEnvelope(`
+             * returned one `export function` line and zero call sites. A budget over
+             * numbers nobody counts is theatre — `envelope.ts` says so in its own
+             * first paragraph, and was describing itself.
+             *
+             * ⚠️ HERE, BECAUSE THIS IS WHERE THE MACHINE SPENDS WITHOUT ASKING. It is
+             * the one seam that turns a decision into a detached child that will run
+             * for hours; everything upstream is reading files. `looply run` typed by
+             * a person is deliberately NOT bounded by it — that is not the machine
+             * spending on its own, and refusing there would break Simple Mode for a
+             * ceiling written about Autopilot.
+             *
+             * ⚠️ AND BEFORE THE TRY IS SPENT, NOT AFTER. `reserveLaunch` below burns
+             * one of a small number of attempts. A start refused for budget has not
+             * failed at anything and must not cost the pursuit a try.
+             *
+             * ⚠️ NO ENVELOPE, NO CHECK. Absent is what every existing project has,
+             * and it is bounded exactly as it was: by hours, rounds and the queue.
+             */
+            const envelope = deps.envelope?.();
+            if (envelope !== undefined) {
+                /**
+                 * ⚠️ THE SAME ASSUMPTION THE GATE USES, or the pre-check refuses
+                 * things the gate would admit. The round path reports no cost at all;
+                 * without the estimate to stand in for it, ONE round turn makes the
+                 * window unmeasurable and this advisory check locks the machine out
+                 * for the rest of the window — before the canonical gate is even
+                 * consulted.
+                 */
+                const peek = (0, spend_ledger_1.peekEnvelope)(envelope, deps.runsInFlight?.() ?? 0, deps.now(), deps.home, deps.estimateUsd?.());
+                if (!peek.ok) {
+                    deps.log(`autonomy: not starting — ${peek.because}.`);
+                    return { action, started: { kind: 'blocked', reason: peek.because } };
+                }
+            }
+            const reserved = await deps.attempts.reserveLaunch(action.requestId, action.attempt);
+            if (!reserved.ok) {
+                deps.log(`autonomy: Start ${action.ordinal} attempt ${action.attempt} — ${reserved.because}.`);
+                return { action, started: { kind: 'blocked', reason: reserved.because } };
+            }
+            // ALWAYS RECORDED, even if asking throws.
+            //
+            // A launch with no spawn record beside it is the one genuinely unreadable
+            // state — it could be a daemon mid-spawn or a daemon that died between
+            // the two writes, and neither can be told from the other, so it waits.
+            // Leaving the gap open to an ordinary rejection between these two lines
+            // would make that stall reachable without anybody dying: the reserving
+            // daemon would then probe its OWN pid, find itself alive, and wait for
+            // ever on a spawn it already knows never happened.
+            // PROGRAMME MODE (M6-7): the controller let an `approved` decision through.
+            // The Start must carry that approval, reserved once through the same seam
+            // a person's Start uses; if it cannot be reserved now — revoked meanwhile,
+            // taken by another run, the checkout busy — nothing is spent and the tick
+            // holds with the reason. Read again here, not from the tick's facts: the
+            // gate is the server's word and a person may have changed it since.
+            let continuation = {};
+            if (action.fromDecision === true) {
+                if (deps.continueFrom === undefined || deps.approvalGate === undefined) {
+                    const because = 'programme mode has no continuation seam on this machine';
+                    deps.log(`autonomy: Start ${action.ordinal} attempt ${action.attempt} — ${because}; holding.`);
+                    return { action: { kind: 'hold', because } };
+                }
+                const gate = await deps.approvalGate(grant);
+                continuation = await deps.continueFrom(gate, action.requestId, deps.workspaceFor?.(grant.goalId));
+                if (continuation.refuse !== undefined) {
+                    deps.log(`autonomy: Start ${action.ordinal} attempt ${action.attempt} — the approved action could not be continued from: ${continuation.refuse.reason}; holding.`);
+                    return { action: { kind: 'hold', because: continuation.refuse.reason } };
+                }
+                // Named from what the continuation hands back, never from the gate: this
+                // file learns THAT a decision was made, not which (approval-stop.e2e pins it).
+                const named = continuation.governedApprovalId ?? continuation.resumedFromApprovalId ?? '(unnamed)';
+                deps.log(`autonomy: Start ${action.ordinal} — continuing from approval ${named} without another tap (programme mode).`);
+            }
+            let started;
+            try {
+                started = await deps.starter.start({
+                    requestId: action.requestId,
+                    origin: {
+                        kind: 'autonomy',
+                        controllerId: grant.controllerId,
+                        ordinal: action.ordinal,
+                        attempt: action.attempt,
+                    },
+                    goalId: grant.goalId,
+                    goalVersion: grant.goalVersion,
+                    ...(continuation.governedApprovalId === undefined ? {} : { governedApprovalId: continuation.governedApprovalId }),
+                    ...(continuation.resumedFromApprovalId === undefined
+                        ? {}
+                        : { resumedFromApprovalId: continuation.resumedFromApprovalId }),
+                    // Where the coordinator placed this goal. Absent keeps the launcher's
+                    // single-checkout behaviour exactly as it was.
+                    ...(deps.workspaceFor?.(grant.goalId) === undefined
+                        ? {}
+                        : { workspace: deps.workspaceFor(grant.goalId) }),
+                });
+            }
+            catch (e) {
+                await deps.attempts.noteSpawn(action.requestId, action.attempt, { spawned: false });
+                deps.log(`autonomy: Start ${action.ordinal} attempt ${action.attempt} — could not be asked for (${e.message}).`);
+                return { action, started: { kind: 'failed', reason: e.message } };
+            }
+            const result = (0, run_launcher_1.asStartResult)(started);
+            // WHETHER A CHILD EXISTS, written down the moment we are told.
+            //
+            // Without it, a spent try with no claim is unreadable: a spawn that
+            // failed outright and a child a millisecond from claiming look identical,
+            // and the difference decides between trying again and waiting.
+            //
+            // A PID IS THE ONLY HONEST EVIDENCE, and the first version of this asked
+            // the wrong question twice. It read `result.kind !== 'failed'`, but three
+            // of the launcher's exits are PRE-SPAWN — a lease clash, a live-child
+            // clash — and those report `blocked`, so a try that never created
+            // anything was recorded as having produced a child. And it looked for
+            // `started.pid`, which a run never has: a run is held to proof, so a
+            // successful spawn answers `waiting`, not `started`. So the field was
+            // always absent and the branch that exists to probe the child was dead.
+            //
+            // Together those turned R1's retry into a 24-hour stall: no claim, a
+            // spawn record claiming a child, and no pid to probe — which reads as
+            // unprobeable, and unprobeable waits.
+            const spawnedPid = started.started
+                ? started.pid
+                : 'spawnedPid' in started
+                    ? started.spawnedPid
+                    : undefined;
+            await deps.attempts.noteSpawn(action.requestId, action.attempt, {
+                spawned: spawnedPid !== undefined,
+                ...(spawnedPid === undefined ? {} : { pid: spawnedPid }),
+            });
+            // Whatever came back, this tick is over. A `run-started` is not waited
+            // for — the mark holds the runId and a later tick reads it — and a
+            // `blocked` is not a failure to record, just somebody else's turn.
+            if (result.kind === 'run-started') {
+                await deps.autonomy.noteRun(grant.controllerId, action.ordinal, result.runId);
+            }
+            deps.log(`autonomy: Start ${action.ordinal} attempt ${action.attempt} — ${result.kind}.`);
+            return { action, started: result };
+        }
+        case 'finish-ordinal': {
+            await deps.autonomy.finishStart(grant.controllerId, action.ordinal);
+            deps.log(`autonomy: Start ${action.ordinal} is over.`);
+            return { action };
+        }
+        case 'terminal': {
+            // Local terminal truth, written durably, so a restarted daemon stops
+            // without needing the server to tell it again. Projecting it onward is
+            // 6D2F's job; stopping is this slice's.
+            await deps.autonomy.settle(grant.controllerId, action.state);
+            deps.log(`autonomy: ${grant.goalId} — ${action.state}: ${action.because}`);
+            return { action };
+        }
+        case 'accept-server-ending': {
+            // The same mark a successful report writes, for the same reason: this
+            // machine has nothing further to say about this pursuit. Reusing it is
+            // what makes the grant leave the live set and stop taking a turn.
+            await deps.autonomy.markProjected(grant.controllerId, new Date(deps.now()).toISOString());
+            deps.log(`autonomy: ${grant.goalId} — the server already knows it ended as ${action.state}.`);
+            return { action };
+        }
+        case 'project-terminal': {
+            const out = await deps.projectTerminal(grant, action.state, action.because);
+            if (out.ok) {
+                // Only after it got through. A crash between the report and this mark
+                // costs one repeated report, which the server answers idempotently;
+                // marking first would cost the report altogether.
+                await deps.autonomy.markProjected(grant.controllerId, new Date(deps.now()).toISOString());
+            }
+            deps.log(out.ok
+                ? `autonomy: told the server ${grant.goalId} ended as ${action.state}.`
+                : `autonomy: could not report how ${grant.goalId} ended — ${out.because ?? 'no reason given'}`);
+            return { action };
+        }
+        case 'wait':
+        case 'hold':
+            return { action };
+        default: {
+            const never = action;
+            throw new Error(`no way to perform ${String(never)}`);
+        }
+    }
+}
+//# sourceMappingURL=autonomy-tick.js.map

package/dist/autonomy-tick.js.map

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

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function main(argv: string[]): Promise<number>;
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAqwFA,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAiE1D"}