looply-cli 0.0.0-stage → 0.2.0

package/dist/queue-view.d.ts

@@ -0,0 +1,20 @@
+import type { Item } from '@looply/core';
+/** `path:line` for the first piece of evidence, which is where a round starts. */
+export declare function whereOf(item: Pick<Item, 'evidence'>): string | null;
+/**
+ * Why this item is where it is, in a few words.
+ *
+ * An item sitting in a non-pickable state without a reason beside it is the
+ * thing that makes a queue feel arbitrary — and the reason is always recorded,
+ * so there is no excuse for not printing it.
+ */
+export declare function reasonOf(item: Item): string | null;
+export interface QueueViewOptions {
+    /** Show every state, not just the ones worth acting on. */
+    all?: boolean;
+    width?: number;
+}
+export declare function renderQueue(items: readonly Item[], opts?: QueueViewOptions): string[];
+/** The one-line answer `looply stop` gives, which depends on what is running. */
+export declare function stopMessage(runLive: boolean, kind: 'pause' | 'stop' | 'resume'): string;
+//# sourceMappingURL=queue-view.d.ts.map

package/dist/queue-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-view.d.ts","sourceRoot":"","sources":["../src/queue-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAa,MAAM,cAAc,CAAC;AAqDpD,kFAAkF;AAClF,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,MAAM,GAAG,IAAI,CAInE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAKlD;AAED,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,IAAI,GAAE,gBAAqB,GAAG,MAAM,EAAE,CAkDzF;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAgCvF"}

package/dist/queue-view.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereOf = whereOf;
+exports.reasonOf = reasonOf;
+exports.renderQueue = renderQueue;
+exports.stopMessage = stopMessage;
+const ui_1 = require("./ui");
+/**
+ * `looply queue` — everything waiting, and why.
+ *
+ * Rendering is pure and takes items, so what the terminal shows is testable
+ * without a filesystem. The point of the screen is the *why*: a queue of
+ * fifteen items where twelve are stale, blocked or duplicates is a queue with
+ * three items, and a count alone hides that.
+ */
+/** Triage order: what you can work on, then what needs you, then what is done. */
+const ORDER = [
+    'ready',
+    'in_progress',
+    'verifying',
+    'draft',
+    'blocked',
+    'split',
+    'duplicate',
+    'stale',
+    'done',
+    'closed',
+];
+const HEADINGS = {
+    ready: 'ready to pick',
+    // Only true while a runner is alive. After a crash the item sits here with
+    // nothing working on it, which is precisely when the old wording misled.
+    in_progress: 'picked up by a run — recovered automatically if that run died',
+    verifying: 'being checked',
+    draft: 'not checked yet — a run confirms these before picking',
+    blocked: 'blocked — needs you',
+    split: 'too big — needs breaking up',
+    duplicate: 'merged into another item',
+    stale: 'already fixed, so nothing to do',
+    done: 'kept',
+    closed: 'closed without landing',
+};
+function tone(state) {
+    if (state === 'ready' || state === 'done')
+        return ui_1.volt;
+    if (state === 'in_progress' || state === 'verifying')
+        return ui_1.white;
+    if (state === 'blocked' || state === 'split')
+        return ui_1.amber;
+    if (state === 'closed')
+        return ui_1.red;
+    return ui_1.grey;
+}
+function clip(s, n) {
+    return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
+}
+/** `path:line` for the first piece of evidence, which is where a round starts. */
+function whereOf(item) {
+    const first = item.evidence[0];
+    if (!first)
+        return null;
+    return first.line ? `${first.path}:${first.line}` : first.path;
+}
+/**
+ * Why this item is where it is, in a few words.
+ *
+ * An item sitting in a non-pickable state without a reason beside it is the
+ * thing that makes a queue feel arbitrary — and the reason is always recorded,
+ * so there is no excuse for not printing it.
+ */
+function reasonOf(item) {
+    if (item.state === 'blocked' && item.blockedReason)
+        return item.blockedReason;
+    if (item.state === 'duplicate' && item.duplicateOf)
+        return `duplicate of ${item.duplicateOf}`;
+    if (item.lastFailure)
+        return `last attempt: ${item.lastFailure}`;
+    return null;
+}
+function renderQueue(items, opts = {}) {
+    const width = opts.width ?? 78;
+    const out = [];
+    if (items.length === 0) {
+        return ['', `  ${(0, ui_1.grey)('the queue is empty.')}`, '', `  ${(0, ui_1.dim)('looply scan')}  ${(0, ui_1.grey)('reads the code and fills it')}`, ''];
+    }
+    // Everything past `done` is history: shown on request, never by default, or
+    // a queue that has been worked for a night buries its own live items.
+    const shown = opts.all ? ORDER : ORDER.filter((s) => s !== 'done' && s !== 'closed' && s !== 'stale' && s !== 'duplicate');
+    out.push('');
+    let printed = 0;
+    for (const state of shown) {
+        const group = items.filter((i) => i.state === state);
+        if (!group.length)
+            continue;
+        const paint = tone(state);
+        out.push(`  ${paint(String(group.length).padStart(2))} ${paint(HEADINGS[state])}`);
+        for (const item of group) {
+            printed += 1;
+            out.push(`     ${(0, ui_1.grey)(item.id.slice(0, 12))}  ${clip(item.title, width - 20)}`);
+            const where = whereOf(item);
+            const reason = reasonOf(item);
+            const meta = [];
+            if (where)
+                meta.push(where);
+            if (item.attempts > 0)
+                meta.push(`${item.attempts} attempt${item.attempts === 1 ? '' : 's'}`);
+            if (meta.length)
+                out.push(`     ${(0, ui_1.dim)(' '.repeat(12))}  ${(0, ui_1.dim)(meta.join('  ·  '))}`);
+            if (reason)
+                out.push(`     ${(0, ui_1.dim)(' '.repeat(12))}  ${paint(clip(reason, width - 20))}`);
+        }
+        out.push('');
+    }
+    const hidden = items.length - printed;
+    if (hidden > 0 && !opts.all) {
+        out.push(`  ${(0, ui_1.grey)(`${hidden} more already dealt with`)} ${(0, ui_1.dim)('— looply queue --all')}`);
+        out.push('');
+    }
+    const ready = items.filter((i) => i.state === 'ready').length;
+    const drafts = items.filter((i) => i.state === 'draft').length;
+    if (ready === 0 && drafts > 0) {
+        out.push(`  ${(0, ui_1.grey)('nothing is pickable yet.')} ${(0, ui_1.dim)('looply verify')} ${(0, ui_1.grey)('checks the drafts against the code.')}`);
+        out.push('');
+    }
+    return out;
+}
+/** The one-line answer `looply stop` gives, which depends on what is running. */
+function stopMessage(runLive, kind) {
+    if (!runLive) {
+        /**
+         * 🔴 "NOTHING TO RESUME" WAS FALSE, AND IT WAS THE FALSE HALF OF A
+         * DEADLOCK.
+         *
+         * The old comment here said nothing is written because "a run clears any
+         * pending request as it starts". That is true of a RUN and says nothing
+         * about the DAEMON, which reads the same project `control.json` to decide
+         * whether a person has asked the machine to hold — and holds. So a pause
+         * that outlived its run held the machine, and the command named after
+         * releasing it printed this line and wrote nothing.
+         *
+         * `stop` keeps the old answer, because it addresses a run and there is no
+         * run. The other two address a standing hold, which exists whether or not
+         * anything is running.
+         */
+        if (kind === 'stop')
+            return `${(0, ui_1.bad)('no run is going')} — nothing to stop.`;
+        return kind === 'pause'
+            ? `${(0, ui_1.volt)('holding')} — no run is going, and the machine will not start one until you resume.`
+            : `${(0, ui_1.volt)('hold cleared')} — no run is going; the machine may start one again.`;
+    }
+    /**
+     * ⚠️ `resume` SAYS SOMETHING DIFFERENT, because it is the only one of the
+     * three that does not make the run wait. Reusing the pause wording would tell
+     * a person the round in flight finishes first, which is true and completely
+     * beside the point of what they just asked for.
+     */
+    if (kind === 'resume')
+        return `${(0, ui_1.volt)('resuming')} — the run carries on from its next round.`;
+    return kind === 'stop'
+        ? `${(0, ui_1.volt)('stopping')} — the round in flight finishes first, then the run ends.`
+        : `${(0, ui_1.volt)('pausing')} — the round in flight finishes first, then the run holds.`;
+}
+//# sourceMappingURL=queue-view.js.map

package/dist/queue-view.js.map

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

package/dist/queue-write-lease.d.ts

@@ -0,0 +1,106 @@
+import { type LeaseState } from './run-lease';
+/**
+ * WRITING `queue.json` WHILE A RUN IS GOING CORRUPTS IT, AND BOTH COMMANDS DID.
+ *
+ * 🔴 THE MECHANISM, WHICH IS NOT A NARROW RACE.
+ *
+ * `QueueStore` reads disk exactly once, in `open()`, and answers every later
+ * question from an in-memory map. `persist()` is `writeList(this.list())` — the
+ * WHOLE map, temp-then-renamed over the file. A run opens the queue at its
+ * first second and holds that map for hours.
+ *
+ * So `looply scan` inserting five items during a run is not a torn write that a
+ * lock would fix. The scan's five items land on disk, and then the run's very
+ * next `persist()` writes its own hours-old snapshot over them. The items are
+ * gone, nothing errors, and the scan reported success.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE FIRST VERSION OF THIS FILE TOOK THE RUN LEASE, AND THAT WAS WRONG IN
+ * THREE MEASURED WAYS. THE FIX IS TO OBSERVE IT AND NEVER TAKE IT.
+ *
+ * It called `RunLeaseStore.acquire` with a minted runId and
+ * `branch: '(a scan)'`. That lease is read by five other things, and it lied to
+ * all of them:
+ *
+ *   1. `classifyRecovery` blocks whenever the checkout's branch differs from
+ *      the lease's — and a real branch can never equal `(a scan)`. So a
+ *      Ctrl-C'd verify (no signal handler runs the `finally`; a pass can last
+ *      half an hour) wedged EVERY later `looply run` in that checkout behind
+ *      "a previous run was working on (a verify pass)", and drove a daemon to
+ *      spawn a doomed run every poll for the full one-hour redelivery window.
+ *   2. `refuseStart` compares what the lease says it is working on against
+ *      what the Start asks for. A scan lease says nothing, so a bound Start
+ *      from a phone was acked TERMINALLY refused, with a sentence naming a
+ *      run that does not exist — advice neither `looply stop` nor `looply
+ *      runs` can act on.
+ *   3. `acquire` TAKES OVER a dead lease. A crashed run's lease is the only
+ *      durable record that the run needs closing, and a scan silently consumed
+ *      it, after which nothing ever emits `run.ended` and the server's Run row
+ *      stays open for ever — the exact harm `daemon-recovery.ts` exists to
+ *      prevent.
+ *
+ * None of that was necessary. What these commands actually need is two things,
+ * and neither is the run lease:
+ *
+ *   - REFUSE WHILE A RUN IS LIVE. That is a READ of the run lease. Reading it
+ *     tells nothing a lie and destroys nothing.
+ *   - DO NOT COLLIDE WITH ANOTHER SCAN. That is a lock of their own, in their
+ *     own file, that no run-lease consumer has ever heard of.
+ */
+export declare class QueueBusy extends Error {
+    readonly what: string;
+    readonly because: string;
+    constructor(what: string, because: string);
+}
+/**
+ * One sentence a person can act on.
+ *
+ * ⚠️ COMPOSED HERE RATHER THAN IN `describeLease`, which four other call sites
+ * consume verbatim — widening it to name `acquiredAt` would change all of their
+ * messages too. And `ambiguous` may carry NO lease at all (an unreadable file,
+ * a foreign host), which is exactly the case a person most needs a clear
+ * sentence for and the one an `err.state.lease` reference prints `undefined` in.
+ */
+export declare function refusalFor(what: string, state: LeaseState, stateDir?: string): string;
+export interface QueueLease {
+    /** Give it back. Safe to call twice. */
+    release(): Promise<void>;
+}
+/**
+ * Take the right to write `queue.json` in this checkout.
+ *
+ * ⚠️ CALLED AT THE WRITE, NOT AT THE TOP OF THE COMMAND. `looply scan --dry-run`
+ * "answers a question and changes nothing" by its own contract, and a lock taken
+ * on entry would make it refusable while a run is going — turning a read-only
+ * question into one that needs the machine to be idle.
+ *
+ * ⚠️ THE EXECUTION DIRECTORY, NEVER THE PROJECT'S. A lock at the project state
+ * directory would be one lock for N worktrees, which is the opposite of the
+ * Phase 1 model: two people scanning two different workspaces must not block
+ * each other.
+ */
+/**
+ * Is a queue write in progress in this checkout?
+ *
+ * 🔴 THE LOCK WAS ONE-SIDED, AND A MEASUREMENT SHOWED WHAT THAT COSTS.
+ *
+ * Scan and verify took it; nothing else had heard of it. So a run started
+ * DURING a verify pass — by the daemon's poll, by a phone Start, by a second
+ * terminal, all of which consult only the run lease, which is free — acquired
+ * the lease, re-opened the queue, and wrote its hours-old snapshot back over
+ * every verdict the pass produced from that moment on. Measured: two items
+ * confirmed by the pass, one silently reverted to `draft` by the run, no error
+ * on either side, and the agent time that produced the verdict gone.
+ *
+ * `verify` is the worse half, because it holds the lock for the WHOLE pass —
+ * uncapped without `--max`, at up to five minutes a draft — which is precisely
+ * why it takes the lock early.
+ */
+export declare function queueWriteInProgress(cwd: string): {
+    readonly busy: false;
+} | {
+    readonly busy: true;
+    readonly because: string;
+};
+export declare function takeQueueWriteLease(cwd: string, what: string): Promise<QueueLease>;
+//# sourceMappingURL=queue-write-lease.d.ts.map

package/dist/queue-write-lease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-write-lease.d.ts","sourceRoot":"","sources":["../src/queue-write-lease.ts"],"names":[],"mappings":"AAIA,OAAO,EAAyC,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAEhC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM;gBADf,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM;CAK3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAyBrF;AAED,MAAM,WAAW,UAAU;IACzB,wCAAwC;IACxC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAoBD;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,GACV;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAmB9E;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAoHxF"}

package/dist/queue-write-lease.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueBusy = void 0;
+exports.refusalFor = refusalFor;
+exports.queueWriteInProgress = queueWriteInProgress;
+exports.takeQueueWriteLease = takeQueueWriteLease;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const git_driver_1 = require("./git-driver");
+const run_lease_1 = require("./run-lease");
+/**
+ * WRITING `queue.json` WHILE A RUN IS GOING CORRUPTS IT, AND BOTH COMMANDS DID.
+ *
+ * 🔴 THE MECHANISM, WHICH IS NOT A NARROW RACE.
+ *
+ * `QueueStore` reads disk exactly once, in `open()`, and answers every later
+ * question from an in-memory map. `persist()` is `writeList(this.list())` — the
+ * WHOLE map, temp-then-renamed over the file. A run opens the queue at its
+ * first second and holds that map for hours.
+ *
+ * So `looply scan` inserting five items during a run is not a torn write that a
+ * lock would fix. The scan's five items land on disk, and then the run's very
+ * next `persist()` writes its own hours-old snapshot over them. The items are
+ * gone, nothing errors, and the scan reported success.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE FIRST VERSION OF THIS FILE TOOK THE RUN LEASE, AND THAT WAS WRONG IN
+ * THREE MEASURED WAYS. THE FIX IS TO OBSERVE IT AND NEVER TAKE IT.
+ *
+ * It called `RunLeaseStore.acquire` with a minted runId and
+ * `branch: '(a scan)'`. That lease is read by five other things, and it lied to
+ * all of them:
+ *
+ *   1. `classifyRecovery` blocks whenever the checkout's branch differs from
+ *      the lease's — and a real branch can never equal `(a scan)`. So a
+ *      Ctrl-C'd verify (no signal handler runs the `finally`; a pass can last
+ *      half an hour) wedged EVERY later `looply run` in that checkout behind
+ *      "a previous run was working on (a verify pass)", and drove a daemon to
+ *      spawn a doomed run every poll for the full one-hour redelivery window.
+ *   2. `refuseStart` compares what the lease says it is working on against
+ *      what the Start asks for. A scan lease says nothing, so a bound Start
+ *      from a phone was acked TERMINALLY refused, with a sentence naming a
+ *      run that does not exist — advice neither `looply stop` nor `looply
+ *      runs` can act on.
+ *   3. `acquire` TAKES OVER a dead lease. A crashed run's lease is the only
+ *      durable record that the run needs closing, and a scan silently consumed
+ *      it, after which nothing ever emits `run.ended` and the server's Run row
+ *      stays open for ever — the exact harm `daemon-recovery.ts` exists to
+ *      prevent.
+ *
+ * None of that was necessary. What these commands actually need is two things,
+ * and neither is the run lease:
+ *
+ *   - REFUSE WHILE A RUN IS LIVE. That is a READ of the run lease. Reading it
+ *     tells nothing a lie and destroys nothing.
+ *   - DO NOT COLLIDE WITH ANOTHER SCAN. That is a lock of their own, in their
+ *     own file, that no run-lease consumer has ever heard of.
+ */
+class QueueBusy extends Error {
+    what;
+    because;
+    constructor(what, because) {
+        super(because);
+        this.what = what;
+        this.because = because;
+        this.name = 'QueueBusy';
+    }
+}
+exports.QueueBusy = QueueBusy;
+/**
+ * One sentence a person can act on.
+ *
+ * ⚠️ COMPOSED HERE RATHER THAN IN `describeLease`, which four other call sites
+ * consume verbatim — widening it to name `acquiredAt` would change all of their
+ * messages too. And `ambiguous` may carry NO lease at all (an unreadable file,
+ * a foreign host), which is exactly the case a person most needs a clear
+ * sentence for and the one an `err.state.lease` reference prints `undefined` in.
+ */
+function refusalFor(what, state, stateDir) {
+    if (state.kind === 'active') {
+        return (`a run is working in this checkout — ${state.lease.runId} (pid ${state.lease.pid}, ` +
+            `branch ${state.lease.branch}) since ${state.lease.acquiredAt}. ${what} would write ` +
+            'queue.json, and that run holds the whole queue in memory, so its next round would ' +
+            'write its own copy back over yours. Wait for it, or `looply stop` it, then try again.');
+    }
+    if (state.kind === 'ambiguous') {
+        return (`cannot tell whether a run is working in this checkout: ${state.reason}. ` +
+            `${what} would write queue.json, and guessing wrong loses somebody's work — so this ` +
+            'refuses rather than guesses. ' +
+            /**
+             * ⚠️ IT NAMES THE FILE. The first version sent the person to `looply runs`,
+             * which reads the registry and the workspaces root and never looks at the
+             * current checkout's lease — so in Simple Mode it answered "nothing
+             * running, and nothing left behind" about the very file that was refusing
+             * them, and there was no next step.
+             */
+            `The file is ${stateDir === undefined ? 'run.lease.json' : (0, node_path_1.join)(stateDir, 'run.lease.json')}.`);
+    }
+    return `${what} could not take this checkout's write lease`;
+}
+function readClaim(path) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+        if (typeof parsed.pid !== 'number' || typeof parsed.host !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Take the right to write `queue.json` in this checkout.
+ *
+ * ⚠️ CALLED AT THE WRITE, NOT AT THE TOP OF THE COMMAND. `looply scan --dry-run`
+ * "answers a question and changes nothing" by its own contract, and a lock taken
+ * on entry would make it refusable while a run is going — turning a read-only
+ * question into one that needs the machine to be idle.
+ *
+ * ⚠️ THE EXECUTION DIRECTORY, NEVER THE PROJECT'S. A lock at the project state
+ * directory would be one lock for N worktrees, which is the opposite of the
+ * Phase 1 model: two people scanning two different workspaces must not block
+ * each other.
+ */
+/**
+ * Is a queue write in progress in this checkout?
+ *
+ * 🔴 THE LOCK WAS ONE-SIDED, AND A MEASUREMENT SHOWED WHAT THAT COSTS.
+ *
+ * Scan and verify took it; nothing else had heard of it. So a run started
+ * DURING a verify pass — by the daemon's poll, by a phone Start, by a second
+ * terminal, all of which consult only the run lease, which is free — acquired
+ * the lease, re-opened the queue, and wrote its hours-old snapshot back over
+ * every verdict the pass produced from that moment on. Measured: two items
+ * confirmed by the pass, one silently reverted to `draft` by the run, no error
+ * on either side, and the agent time that produced the verdict gone.
+ *
+ * `verify` is the worse half, because it holds the lock for the WHOLE pass —
+ * uncapped without `--max`, at up to five minutes a draft — which is precisely
+ * why it takes the lock early.
+ */
+function queueWriteInProgress(cwd) {
+    const lock = (0, node_path_1.join)((0, git_driver_1.executionStateDir)(cwd), 'queue.write.lock');
+    if (!(0, node_fs_1.existsSync)(lock))
+        return { busy: false };
+    const held = readClaim(lock);
+    if (held === null) {
+        return { busy: true, because: `a queue write is in progress and its claim cannot be read (${lock})` };
+    }
+    /**
+     * ⚠️ ONLY A LIVE, SAME-HOST HOLDER BLOCKS. A dead one is left for the next
+     * scan or verify to break — a run has no business breaking a lock it does
+     * not take, and refusing on a stale one would wedge the central command.
+     */
+    if (held.host !== (0, node_os_1.hostname)() || (0, run_lease_1.nodeProbe)(held.pid) !== 'alive')
+        return { busy: false };
+    return {
+        busy: true,
+        because: `${held.what} is writing this checkout's queue (pid ${held.pid}, since ${held.at}). ` +
+            'A run holds the whole queue in memory and would write its own copy back over that work',
+    };
+}
+async function takeQueueWriteLease(cwd, what) {
+    const stateDir = (0, git_driver_1.executionStateDir)(cwd);
+    const lock = (0, node_path_1.join)(stateDir, 'queue.write.lock');
+    /**
+     * 🔴 THE RUN LEASE IS READ AND NEVER TAKEN. See the header. `inspect()` has no
+     * side effect: it does not claim, it does not reap a dead lease, and it leaves
+     * a crashed run's evidence exactly where recovery needs to find it.
+     */
+    const runLease = new run_lease_1.RunLeaseStore(stateDir, run_lease_1.nodeLeaseFs);
+    const before = await runLease.inspect();
+    if (before.kind === 'active' || before.kind === 'ambiguous') {
+        throw new QueueBusy(what, refusalFor(what, before, stateDir));
+    }
+    (0, node_fs_1.mkdirSync)(stateDir, { recursive: true });
+    const mine = { pid: process.pid, host: (0, node_os_1.hostname)(), what, at: new Date().toISOString() };
+    const body = `${JSON.stringify(mine, null, 2)}\n`;
+    const claim = () => {
+        try {
+            (0, node_fs_1.writeFileSync)(lock, body, { encoding: 'utf8', flag: 'wx' });
+            return true;
+        }
+        catch (e) {
+            const code = e.code;
+            // Windows answers EPERM rather than EEXIST against a pending-delete file.
+            if (code === 'EEXIST' || code === 'EPERM')
+                return false;
+            throw e;
+        }
+    };
+    if (!claim()) {
+        /**
+         * ⚠️ A LOCK WHOSE OWNER IS GONE IS BROKEN, NOT OBEYED — and broken by
+         * CONTENT MATCH, which is the discipline Phase 1 settled on after measuring
+         * what removing a token by path does: a process that had already lost its
+         * claim deleted the winner's, and four processes then held one lock.
+         *
+         * A lock from ANOTHER HOST is never broken. This file lives in a checkout
+         * that could be on a network share, and a pid means nothing across machines.
+         */
+        const held = readClaim(lock);
+        /**
+         * ⚠️ GUARDED. An ENOENT between the `existsSync` and the read — which is
+         * exactly what a competing process doing this same dead-lock break causes —
+         * used to throw a raw filesystem error out of here, past `bin.ts`'s
+         * QueueBusy handling, printing an internal path and exiting 1 instead of 2.
+         */
+        let raw;
+        try {
+            raw = (0, node_fs_1.readFileSync)(lock, 'utf8');
+        }
+        catch {
+            raw = null;
+        }
+        const dead = held !== null && held.host === (0, node_os_1.hostname)() && (0, run_lease_1.nodeProbe)(held.pid) === 'dead';
+        if (!dead || raw === null) {
+            /**
+             * ⚠️ IT NAMES THE FILE. A lock left by a crashed command whose pid has
+             * since been recycled — or belongs to another user, so the probe answers
+             * `unknown` — refuses every later scan and verify in that checkout for
+             * ever, in the present tense, about a month-old file. Since those two are
+             * the only ways items enter and get confirmed, that checkout can never
+             * take on new work again; and `looply runs`, `--reap`, `doctor` and
+             * `status` all say there is nothing left behind. The remedy is deleting
+             * one file, so the sentence says which.
+             */
+            throw new QueueBusy(what, (held === null
+                ? `another command is writing this checkout's queue, and this cannot read its claim`
+                : `${held.what} is writing this checkout's queue (pid ${held.pid} on ${held.host}, since ${held.at})`) +
+                `. If nothing is, delete ${lock}`);
+        }
+        try {
+            if ((0, node_fs_1.readFileSync)(lock, 'utf8') === raw)
+                (0, node_fs_1.unlinkSync)(lock);
+        }
+        catch {
+            /* somebody else got there; the claim below will say so */
+        }
+        if (!claim()) {
+            throw new QueueBusy(what, `another command took this checkout's queue write lock first (${lock})`);
+        }
+    }
+    /**
+     * 🔴 RE-READ THE RUN LEASE AFTER CLAIMING. Between the first read and the
+     * claim a run can have started: it takes the run lease, sees no reason to
+     * care about this lock, and opens the queue. Checking once would let the scan
+     * write into exactly the window it exists to avoid.
+     *
+     * ⚠️ AND IT GIVES THE LOCK BACK BEFORE REFUSING, or a refusal would leave the
+     * checkout locked by a command that did nothing.
+     */
+    const after = await runLease.inspect();
+    if (after.kind === 'active' || after.kind === 'ambiguous') {
+        try {
+            if ((0, node_fs_1.readFileSync)(lock, 'utf8') === body)
+                (0, node_fs_1.unlinkSync)(lock);
+        }
+        catch {
+            /* already gone */
+        }
+        throw new QueueBusy(what, refusalFor(what, after, stateDir));
+    }
+    let given = false;
+    return {
+        release: async () => {
+            if (given)
+                return;
+            given = true;
+            try {
+                // Only ours: the same compare-before-remove rule as above.
+                if ((0, node_fs_1.readFileSync)(lock, 'utf8') === body)
+                    (0, node_fs_1.unlinkSync)(lock);
+            }
+            catch {
+                /* already gone, or somebody broke it because we looked dead */
+            }
+        },
+    };
+}
+//# sourceMappingURL=queue-write-lease.js.map

package/dist/queue-write-lease.js.map

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