looply-cli 0.0.0-stage → 0.3.0

package/dist/recovery.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runClosureOnly = runClosureOnly;
+exports.classifyRecovery = classifyRecovery;
+exports.describeRecovery = describeRecovery;
+/**
+ * The half of a repair a process holding no lease may carry out.
+ *
+ * Closing a run is a statement about history: the run stopped, and the ledger is
+ * where that is said. Requeuing an item is a statement about future work, and
+ * the queue belongs to whoever holds the lease — `QueueStore.persist` rewrites
+ * the whole file from its in-memory map, so a second writer does not race an
+ * item, it reverts the entire queue to its own snapshot. The daemon therefore
+ * says what happened and leaves the scheduling to the next run, which does its
+ * own recovery on the way in regardless.
+ */
+function runClosureOnly(r) {
+    return r.kind === 'repairable' ? { ...r, items: [] } : r;
+}
+function classifyRecovery(ev) {
+    const nothingLeftBehind = ev.lease === null && ev.stranded.length === 0;
+    if (nothingLeftBehind)
+        return { kind: 'none' };
+    // A dirty tree is the case that must never be guessed at. It may hold a
+    // crashed agent's half-finished edit, or an hour of somebody's own work, and
+    // there is no evidence anywhere that distinguishes them. Blocking costs a
+    // person one command; guessing wrong costs them the work.
+    if (ev.changedPaths.length > 0) {
+        return {
+            kind: 'blocked',
+            lease: ev.lease,
+            reason: `the working tree has ${ev.changedPaths.length} uncommitted change(s) and a previous run did not finish. ` +
+                'looply cannot tell whose changes those are, so it will not touch them. ' +
+                'Commit or stash them, then run again.',
+        };
+    }
+    // The branch moved somewhere the dead run never knew about. Recovery has no
+    // business switching branches under somebody, and reasoning about a run whose
+    // tree is now a different tree would be guesswork.
+    const leftByTheDeadRun = ev.lease !== null &&
+        ev.currentBranch === '(detached)' &&
+        ev.judging?.runId === ev.lease.runId &&
+        ev.headSha !== undefined &&
+        ev.judging.sha === ev.headSha;
+    if (ev.lease && !leftByTheDeadRun && ev.currentBranch !== ev.lease.branch && ev.currentBranch !== ev.lease.baseBranch) {
+        return {
+            kind: 'blocked',
+            lease: ev.lease,
+            reason: `a previous run was working on ${ev.lease.branch} but this checkout is now on ${ev.currentBranch}. ` +
+                'Switch back to finish recovering it, or delete .looply/state/run.lease.json to abandon it.',
+        };
+    }
+    // The tree is clean, so nothing can be lost by deciding. Each stranded item
+    // is judged on whether its work actually landed.
+    const items = ev.stranded.map((item) => {
+        // Checked, not worked: nothing was committed for it and no round began.
+        if (item.state === 'verifying') {
+            return {
+                itemId: item.id,
+                action: 'unverify',
+                reason: 'the run stopped while this item was being checked, before any round began',
+            };
+        }
+        // A round commits with the item's title as the subject, and only after the
+        // commit permit passed — the gate's required steps and, when proof is on, a
+        // proven verdict. So a matching commit at HEAD is downstream of the two-key
+        // rule rather than a way around it: it is evidence the round finished, not
+        // a claim that it should have.
+        if (ev.headSubject !== null && ev.headSubject.split('\n')[0]?.trim() === item.title.trim()) {
+            return {
+                itemId: item.id,
+                action: 'done',
+                reason: 'its commit is at HEAD — the round finished and only the bookkeeping was lost',
+            };
+        }
+        return {
+            itemId: item.id,
+            action: 'requeue',
+            reason: 'the run stopped before this round finished, and nothing was committed for it',
+        };
+    });
+    return {
+        kind: 'repairable',
+        lease: ev.lease,
+        items,
+        closeRun: ev.lease?.runId ?? null,
+    };
+}
+/** One line a person can act on, for the log and for the alert. */
+function describeRecovery(r) {
+    switch (r.kind) {
+        case 'none':
+            return 'nothing to recover';
+        case 'blocked':
+            return r.reason;
+        case 'repairable': {
+            const requeued = r.items.filter((i) => i.action === 'requeue').length;
+            const done = r.items.filter((i) => i.action === 'done').length;
+            const unverified = r.items.filter((i) => i.action === 'unverify').length;
+            const parts = [
+                r.closeRun ? `closed ${r.closeRun}, which stopped without saying so` : null,
+                requeued ? `${requeued} item(s) put back in the queue` : null,
+                unverified ? `${unverified} item(s) put back to be checked again` : null,
+                done ? `${done} item(s) marked done — their work had already landed` : null,
+            ].filter(Boolean);
+            return parts.length ? `recovered a previous run: ${parts.join('; ')}` : 'nothing to recover';
+        }
+    }
+}
+//# sourceMappingURL=recovery.js.map

package/dist/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":";;AA4DA,wCAEC;AA+DD,4CA0EC;AAGD,4CAmBC;AA5KD;;;;;;;;;;GAUG;AACH,SAAgB,cAAc,CAAC,CAAW;IACxC,OAAO,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,CAAC;AA+DD,SAAgB,gBAAgB,CAAC,EAAoB;IACnD,MAAM,iBAAiB,GAAG,EAAE,CAAC,KAAK,KAAK,IAAI,IAAI,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;IACxE,IAAI,iBAAiB;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAE/C,wEAAwE;IACxE,6EAA6E;IAC7E,0EAA0E;IAC1E,0DAA0D;IAC1D,IAAI,EAAE,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/B,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,EAAE,CAAC,KAAK;YACf,MAAM,EACJ,wBAAwB,EAAE,CAAC,YAAY,CAAC,MAAM,4DAA4D;gBAC1G,yEAAyE;gBACzE,uCAAuC;SAC1C,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,8EAA8E;IAC9E,mDAAmD;IACnD,MAAM,gBAAgB,GACpB,EAAE,CAAC,KAAK,KAAK,IAAI;QACjB,EAAE,CAAC,aAAa,KAAK,YAAY;QACjC,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK;QACpC,EAAE,CAAC,OAAO,KAAK,SAAS;QACxB,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,OAAO,CAAC;IAChC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,aAAa,KAAK,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,aAAa,KAAK,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QACtH,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,EAAE,CAAC,KAAK;YACf,MAAM,EACJ,iCAAiC,EAAE,CAAC,KAAK,CAAC,MAAM,gCAAgC,EAAE,CAAC,aAAa,IAAI;gBACpG,4FAA4F;SAC/F,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,iDAAiD;IACjD,MAAM,KAAK,GAAiB,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACnD,wEAAwE;QACxE,IAAI,IAAI,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;YAC/B,OAAO;gBACL,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,MAAM,EAAE,UAAU;gBAClB,MAAM,EAAE,2EAA2E;aACpF,CAAC;QACJ,CAAC;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,4EAA4E;QAC5E,2EAA2E;QAC3E,+BAA+B;QAC/B,IAAI,EAAE,CAAC,WAAW,KAAK,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YAC3F,OAAO;gBACL,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,MAAM,EAAE,MAAM;gBACd,MAAM,EAAE,8EAA8E;aACvF,CAAC;QACJ,CAAC;QACD,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,EAAE;YACf,MAAM,EAAE,SAAS;YACjB,MAAM,EAAE,8EAA8E;SACvF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,EAAE,CAAC,KAAK;QACf,KAAK;QACL,QAAQ,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,IAAI,IAAI;KAClC,CAAC;AACJ,CAAC;AAED,mEAAmE;AACnE,SAAgB,gBAAgB,CAAC,CAAW;IAC1C,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,MAAM;YACT,OAAO,oBAAoB,CAAC;QAC9B,KAAK,SAAS;YACZ,OAAO,CAAC,CAAC,MAAM,CAAC;QAClB,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,MAAM,CAAC;YACtE,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,MAAM,CAAC;YAC/D,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,MAAM,CAAC;YACzE,MAAM,KAAK,GAAG;gBACZ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,QAAQ,mCAAmC,CAAC,CAAC,CAAC,IAAI;gBAC3E,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,gCAAgC,CAAC,CAAC,CAAC,IAAI;gBAC7D,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,uCAAuC,CAAC,CAAC,CAAC,IAAI;gBACxE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,sDAAsD,CAAC,CAAC,CAAC,IAAI;aAC5E,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAClB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,6BAA6B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,oBAAoB,CAAC;QAC/F,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/redraw.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Redrawing a block of terminal output in place.
+ *
+ * `looply pair` reissues its code on a fixed interval (`DEFAULT_REISSUE_MS`,
+ * currently 150s) and used to print a whole
+ * new box underneath the last one. After two minutes the terminal held a stack
+ * of five pairing codes, all but the newest expired, with nothing to say which
+ * was which — and the natural thing to do is read whichever one your eye lands
+ * on. That produced "the code is invalid no matter what I do", because it
+ * usually was: the server was right every time.
+ *
+ * So the block is drawn once and then overwritten. Exactly one code is ever on
+ * screen, and it is always the live one.
+ *
+ * Falls back to plain appending when stdout is not a terminal — a redirected or
+ * piped log wants every frame in order, and cursor escapes in a file are noise.
+ */
+export interface RedrawSink {
+    write(s: string): void;
+    isTty: boolean;
+}
+export declare function nodeRedrawSink(): RedrawSink;
+export declare class Redrawer {
+    private readonly sink;
+    private lines;
+    constructor(sink: RedrawSink);
+    /** Replace whatever this drew last time with `block`. */
+    draw(block: string): void;
+    /** Leave the last block on screen and stop owning it. */
+    release(): void;
+}
+/** How many terminal rows a block occupies once written with a trailing newline. */
+export declare function countLines(block: string): number;
+//# sourceMappingURL=redraw.d.ts.map

package/dist/redraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redraw.d.ts","sourceRoot":"","sources":["../src/redraw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,wBAAgB,cAAc,IAAI,UAAU,CAK3C;AAED,qBAAa,QAAQ;IAGP,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,KAAK,CAAK;gBAEW,IAAI,EAAE,UAAU;IAE7C,yDAAyD;IACzD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAWzB,yDAAyD;IACzD,OAAO,IAAI,IAAI;CAGhB;AAED,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD"}

package/dist/redraw.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Redrawing a block of terminal output in place.
+ *
+ * `looply pair` reissues its code on a fixed interval (`DEFAULT_REISSUE_MS`,
+ * currently 150s) and used to print a whole
+ * new box underneath the last one. After two minutes the terminal held a stack
+ * of five pairing codes, all but the newest expired, with nothing to say which
+ * was which — and the natural thing to do is read whichever one your eye lands
+ * on. That produced "the code is invalid no matter what I do", because it
+ * usually was: the server was right every time.
+ *
+ * So the block is drawn once and then overwritten. Exactly one code is ever on
+ * screen, and it is always the live one.
+ *
+ * Falls back to plain appending when stdout is not a terminal — a redirected or
+ * piped log wants every frame in order, and cursor escapes in a file are noise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redrawer = void 0;
+exports.nodeRedrawSink = nodeRedrawSink;
+exports.countLines = countLines;
+const ESC = String.fromCharCode(27);
+/** Move the cursor up n rows. */
+const up = (n) => ESC + '[' + n + 'A';
+/** Erase from the cursor to the end of the screen. */
+const CLEAR_DOWN = ESC + '[0J';
+function nodeRedrawSink() {
+    return {
+        write: (s) => void process.stdout.write(s),
+        isTty: process.stdout.isTTY === true,
+    };
+}
+class Redrawer {
+    sink;
+    lines = 0;
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** Replace whatever this drew last time with `block`. */
+    draw(block) {
+        if (this.sink.isTty && this.lines > 0) {
+            // Up over the previous block, then clear to the end of the screen: the
+            // new block may be shorter than the old one, and leaving the tail behind
+            // is how half of an expired code stays on screen under the live one.
+            this.sink.write(up(this.lines) + CLEAR_DOWN);
+        }
+        this.sink.write(block.endsWith('\n') ? block : block + '\n');
+        this.lines = countLines(block);
+    }
+    /** Leave the last block on screen and stop owning it. */
+    release() {
+        this.lines = 0;
+    }
+}
+exports.Redrawer = Redrawer;
+/** How many terminal rows a block occupies once written with a trailing newline. */
+function countLines(block) {
+    const body = block.endsWith('\n') ? block.slice(0, -1) : block;
+    return body.split('\n').length;
+}
+//# sourceMappingURL=redraw.js.map

package/dist/redraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redraw.js","sourceRoot":"","sources":["../src/redraw.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAaH,wCAKC;AA0BD,gCAGC;AA7CD,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;AACpC,iCAAiC;AACjC,MAAM,EAAE,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACtD,sDAAsD;AACtD,MAAM,UAAU,GAAG,GAAG,GAAG,KAAK,CAAC;AAO/B,SAAgB,cAAc;IAC5B,OAAO;QACL,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI;KACrC,CAAC;AACJ,CAAC;AAED,MAAa,QAAQ;IAGU;IAFrB,KAAK,GAAG,CAAC,CAAC;IAElB,YAA6B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEjD,yDAAyD;IACzD,IAAI,CAAC,KAAa;QAChB,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACtC,uEAAuE;YACvE,yEAAyE;YACzE,qEAAqE;YACrE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;QAC7D,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,yDAAyD;IACzD,OAAO;QACL,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;IACjB,CAAC;CACF;AArBD,4BAqBC;AAED,oFAAoF;AACpF,SAAgB,UAAU,CAAC,KAAa;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/D,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;AACjC,CAAC"}

package/dist/rejected-evidence.d.ts

@@ -0,0 +1,255 @@
+import type { GateStepResult, GateVerdict, ProofVerdict } from '@looply/core';
+import type { ImplementerResult } from './agent-driver';
+import { type AbortResult, type GateStepDiagnostic } from './gate';
+/**
+ * WHAT A REJECTED CANDIDATE LEAVES BEHIND.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE PREVIOUS TRIAL DISCARDED A ROUND AND KEPT NOTHING. Looply wrote a
+ * change, ran its typecheck, saw red, and did the right thing: `git reset
+ * --hard`. What survived was `testsAdded: 8` and `outputDigest: 38faf4ea…`.
+ * Which files it wrote, what it wrote, and WHY the typecheck refused it were
+ * all gone — the ledger held a hash of the reason, and the reset destroyed the
+ * only copy of the work. A repair could not have been attempted by anyone,
+ * machine or person, because there was nothing to repair from.
+ *
+ * This module is the fix: before the tree is reset, the candidate and the
+ * verdict against it are written where the reset cannot reach.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHERE, AND WHY THERE.
+ *
+ * Under `projectStateDir` — `.looply/state/rejected/<runId>/…` for an ordinary
+ * checkout. `GitDriver.discard()` is `reset --hard` + `clean -fd -e .looply`;
+ * the state directory is untracked and explicitly spared, so it is the one
+ * place in the tree a discard leaves alone. It is also `protectedPaths` for the
+ * contained tool bridge, so a worker cannot read or edit its own evidence: what
+ * a repair attempt is told about a previous rejection reaches it through the
+ * prompt, bounded, from the runner.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT IS KEPT, AND WHAT IS NOT.
+ *
+ * Kept: identity (run, round, attempt, item), the base the candidate was
+ * written against, the changed-file manifest, the patch, each gate step's
+ * command, exit status and interleaved output, the implementer's structured
+ * result and a bounded transcript. Every text is bounded and every cut is
+ * announced — in the text and in a flag beside it.
+ *
+ * ⚠️ NOT KEPT: the patch of a candidate the RAILS aborted. An abort means the
+ * change touched a path the project forbade — a production config, a
+ * credential file, whatever the rails name — and retaining its content would
+ * copy exactly the thing the rail exists to keep out of the record. The
+ * manifest still names the paths; the reason says why the patch is withheld.
+ *
+ * ⚠️ AND NOTHING OUTSIDE THE ROUND'S OWN CHANGE. The patch is `git diff HEAD`
+ * of the project tree with `.looply` excluded; no operator file, no home
+ * directory, no environment reaches this. The runner hands over what it has
+ * and this writes it — it reads nothing on its own.
+ */
+/** Bound on the retained patch. A candidate larger than this is kept truncated and flagged. */
+export declare const REJECTED_PATCH_MAX_BYTES: number;
+/** Bound on the implementer's transcript kept beside the patch. */
+export declare const REJECTED_TRANSCRIPT_MAX_CHARS: number;
+export interface RejectedAttemptInput {
+    run: {
+        runId: string;
+        projectId: string;
+        lane: string;
+        branch: string;
+    };
+    round: number;
+    attempt: number;
+    itemId: string;
+    itemTitle: string;
+    /** HEAD when the candidate was written — what the patch applies to. */
+    baseSha: string;
+    /** The reason the round carried on the item, verbatim. */
+    why: string;
+    /** Where in the round the rejection happened. */
+    stage: 'implementer' | 'gate' | 'commit' | 'proof';
+    gate?: {
+        verdict: GateVerdict;
+        steps: readonly GateStepResult[];
+        diagnostics: readonly GateStepDiagnostic[];
+        abort?: AbortResult;
+    };
+    proof?: {
+        verdict: ProofVerdict;
+        reason: string;
+        confidence: number;
+    };
+    implementer?: {
+        result: ImplementerResult | null;
+        abandoned: string | null;
+        transcript: string;
+    };
+    manifest: ReadonlyArray<{
+        path: string;
+        status: string;
+    }>;
+    /** null when the runner could not produce one; see `patchWithheld`. */
+    patch: {
+        text: string;
+        bytes: number;
+        truncated: boolean;
+    } | null;
+    /** Why there is no patch, when there is none. */
+    patchWithheld?: string;
+}
+export interface RetainedRejection {
+    retained: true;
+    /** Relative to the project root when inside it; absolute otherwise. */
+    path: string;
+    absolutePath: string;
+    files: string[];
+    patchFile: string | null;
+    patchSha256: string | null;
+}
+export type RetainOutcome = RetainedRejection | {
+    retained: false;
+    because: string;
+};
+/**
+ * A restarted run asking about the last rejection of an item it is about to
+ * attempt again — and everything the answer must agree with before it is used.
+ */
+export interface RehydrateQuery {
+    itemId: string;
+    projectId: string;
+    lane: string;
+    /** The run that is asking. Its OWN rejections are held in memory, never read back from here. */
+    runId: string;
+    /** `Item.attempts`: execution attempts already spent. */
+    attemptsSpent: number;
+    /** `Item.lastFailure`: the reason the last discard wrote onto the item. */
+    lastFailure: string | undefined;
+}
+export type RehydrateOutcome = {
+    found: true;
+    input: RejectedAttemptInput;
+    outcome: RetainedRejection;
+}
+/** `because: null` is "nothing is retained for this item" — an absence, not a refusal. */
+ | {
+    found: false;
+    because: string | null;
+};
+export interface RejectedEvidenceSink {
+    retain(input: RejectedAttemptInput): Promise<RetainOutcome>;
+    /**
+     * THE LAST REJECTION OF AN ITEM, READ BACK AFTER THE RUN THAT MADE IT ENDED.
+     *
+     * 🔴 WITHOUT THIS A RESTART ERASED THE REPAIR. The runner held an item's last
+     * rejection in memory only, so a run that stopped — or died — between a
+     * rejected round and the attempt that would repair it handed the next run
+     * nothing but `lastFailure`: one line, no diagnostics, no candidate. The
+     * evidence was sitting on disk the whole time, retained for exactly this.
+     *
+     * ⚠️ ADMITTED ONLY WHEN IT IS PROVABLY THIS ITEM'S LAST WORD. Each check below
+     * refuses by name, and a refusal leaves the attempt exactly as it was before
+     * this existed — briefed from `lastFailure`, starting from the base:
+     *   - it is this item's, in this project and this lane;
+     *   - it was written by an EARLIER run, never the asking one;
+     *   - CONTINUITY: its attempt is the item's spent count AND its reason is the
+     *     item's `lastFailure` — `discardAndRequeue` writes both from the same
+     *     values it retains, so any later touch to the item breaks the match;
+     *   - INTEGRITY: the patch — the only part written back into the tree — hashes
+     *     to the sha256 recorded when it was kept, and every step output it cites
+     *     is present.
+     * Base, scope and rails are then checked by `prepareRepair` exactly as for a
+     * rejection this run saw, because a restored candidate is a restored
+     * candidate whichever run retained it.
+     *
+     * Optional: a sink without it means a restarted run repairs from
+     * `lastFailure` alone, which is the behaviour before this existed.
+     */
+    latestFor?(query: RehydrateQuery): Promise<RehydrateOutcome>;
+}
+/** The record written as `record.json` — everything except the large texts, which sit beside it. */
+export interface RejectedAttemptRecord {
+    schema: 'looply.rejected-attempt/1';
+    retainedAt: string;
+    run: RejectedAttemptInput['run'];
+    round: number;
+    attempt: number;
+    item: {
+        id: string;
+        title: string;
+    };
+    base: {
+        sha: string;
+    };
+    candidate: {
+        manifest: ReadonlyArray<{
+            path: string;
+            status: string;
+        }>;
+        patchFile: string | null;
+        patchSha256: string | null;
+        patchBytes: number | null;
+        patchTruncated: boolean | null;
+        patchWithheld: string | null;
+    };
+    rejection: {
+        stage: RejectedAttemptInput['stage'];
+        why: string;
+    };
+    gate: {
+        verdict: GateVerdict;
+        /** Which steps appear on the ledger, including skips. */
+        steps: readonly GateStepResult[];
+        /** Each executed step, with its output in the named file. */
+        executed: Array<{
+            step: string;
+            command: string;
+            cwd: string;
+            exitCode: number | null;
+            timedOut: boolean;
+            unavailable: boolean;
+            classification: GateStepDiagnostic['classification'];
+            ms: number;
+            outputFile: string;
+            outputChars: number;
+            outputTruncated: boolean;
+            /** The runner reports stdout and stderr as one interleaved stream. */
+            streams: 'combined';
+        }>;
+        abort: AbortResult | null;
+    } | null;
+    proof: RejectedAttemptInput['proof'] | null;
+    implementer: {
+        result: ImplementerResult | null;
+        abandoned: string | null;
+        transcriptFile: string | null;
+        transcriptChars: number | null;
+        transcriptTruncated: boolean | null;
+    } | null;
+}
+export interface RejectedEvidenceDeps {
+    /** Where to write. Defaults to `projectStateDir(projectDir)`. */
+    stateDir?: string;
+    now?: () => number;
+    /** Overridable so a test can make the write fail. */
+    fs?: {
+        mkdirSync(path: string, opts: {
+            recursive: true;
+        }): unknown;
+        writeFileSync(path: string, data: string, encoding: 'utf8'): void;
+    };
+    /** Overridable so a test can make a read fail. Defaults to node:fs. */
+    read?: {
+        existsSync(path: string): boolean;
+        readdirSync(path: string): string[];
+        readFileSync(path: string, encoding: 'utf8'): string;
+    };
+}
+export declare function makeRejectedEvidenceStore(projectDir: string, deps?: RejectedEvidenceDeps): RejectedEvidenceSink;
+/**
+ * The path a report prints: relative to the project when the state directory
+ * lives inside it, absolute when it does not (a linked worktree keeps its state
+ * under the daemon's home). Forward slashes either way — it is a pointer for a
+ * person and for the app, not a path for a shell.
+ */
+export declare function evidencePath(projectDir: string, dir: string): string;
+//# sourceMappingURL=rejected-evidence.d.ts.map

package/dist/rejected-evidence.d.ts.map

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