looply-cli 0.0.0-stage → 0.2.0

package/dist/command-runner.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeCommandRunner = void 0;
+exports.makeCommandRunner = makeCommandRunner;
+exports.nodeSpawn = nodeSpawn;
+exports.nodeKillTree = nodeKillTree;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const untrusted_exec_1 = require("./untrusted-exec");
+function makeCommandRunner(deps) {
+    return (cmd, timeoutMs) => new Promise((resolve) => {
+        const started = Date.now();
+        const chunks = [];
+        let settled = false;
+        let timer;
+        const finish = (ok, timedOut) => {
+            // First outcome wins: exit-after-kill and error-then-exit must not
+            // resolve twice or report a second, contradictory result.
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            resolve({ ok, timedOut, ms: Date.now() - started, output: chunks.join('') });
+        };
+        const handle = deps.spawn(cmd);
+        handle.onOutput((c) => chunks.push(c));
+        handle.onError((err) => {
+            // Kept in the output so a missing tool reads differently in the log
+            // from a failing test (DESIGN §12 case 6).
+            chunks.push(err.message);
+            finish(false, false);
+        });
+        handle.onExit((code) => finish(code === 0, false));
+        timer = setTimeout(() => {
+            if (settled)
+                return;
+            if (handle.pid !== undefined)
+                deps.killTree(handle.pid);
+            // Resolve now rather than waiting for the exit event: a process that
+            // survives the kill is exactly the hang the timeout exists to escape.
+            finish(false, true);
+        }, timeoutMs);
+    });
+}
+function nodeSpawn(cmd) {
+    // `detached` puts the child in its own process group on POSIX so `kill(-pid)`
+    // reaches the whole tree; on Windows it would open a new console instead, and
+    // taskkill walks the tree by itself.
+    const child = (0, node_child_process_1.spawn)(cmd, {
+        shell: true,
+        detached: process.platform !== 'win32',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+        pid: child.pid,
+        onExit: (cb) => child.on('exit', (code) => cb(code)),
+        onError: (cb) => child.on('error', cb),
+        onOutput: (cb) => {
+            child.stdout?.on('data', (d) => cb(d.toString('utf8')));
+            child.stderr?.on('data', (d) => cb(d.toString('utf8')));
+        },
+    };
+}
+function nodeKillTree(pid) {
+    if (process.platform === 'win32') {
+        /**
+         * 🔴 ABSOLUTE, AND FROM A CWD LOOPLY OWNS. This was `spawnSync('taskkill',
+         * …)` with neither.
+         *
+         * Windows resolves a bare program name from the CURRENT DIRECTORY before
+         * PATH, and the current directory here is the project — the one place a
+         * contained agent is granted write. So a repository holding a
+         * `taskkill.exe` had it executed, uncontained and with the runner's own
+         * privileges, by the very code whose job is to stop a command that has
+         * overrun its timeout. It is the same hole `gitBinary` was written for; the
+         * name is different and the consequence is identical.
+         *
+         * `model-transport`'s killer already resolved this way. Two spellings of
+         * the same rule, and only one of them was safe.
+         */
+        const system32 = (0, node_path_1.join)((0, untrusted_exec_1.systemRoot)(), 'System32');
+        (0, node_child_process_1.spawnSync)((0, node_path_1.join)(system32, 'taskkill.exe'), ['/pid', String(pid), '/T', '/F'], {
+            cwd: system32,
+            windowsHide: true,
+        });
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        // The group may already be gone, or the child never got its own group
+        // (spawn raced the kill); fall back to the single pid before giving up.
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            /* already dead — the goal state */
+        }
+    }
+}
+/** The runner the gate executor should be handed in real use. */
+exports.nodeCommandRunner = makeCommandRunner({
+    spawn: nodeSpawn,
+    killTree: nodeKillTree,
+});
+//# sourceMappingURL=command-runner.js.map

package/dist/command-runner.js.map

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

package/dist/compatible-sets.d.ts

@@ -0,0 +1,67 @@
+import { type CompatibleSet, type RepoRevision } from '@looply/core';
+import type { LedgerFs } from './ledger-store';
+import { AppendOnlyStore } from './record-store';
+/**
+ * THE COMPATIBLE-REVISION RECORDS — `.looply/state/compatible-sets.jsonl`.
+ *
+ * 🔴 EVERY LINE IS AN IMMUTABLE FACT, AND THE SET IS A FOLD OVER THEM.
+ *
+ * The first shape of this rewrote a set's state each time a repository
+ * published, with the latest line winning. `AppendOnlyStore` refuses that
+ * outright — *"written once. Appending an id already on record is a programming
+ * error, not a second answer"* — and it is right: a store whose records
+ * supersede each other cannot say what happened, only what is currently
+ * believed, and what happened is the entire point of a resumable publication.
+ *
+ * So there are two kinds of line, each written once:
+ *
+ *   accepted   somebody accepted these revisions TOGETHER. One per set.
+ *   published  one repository published that set. One per (set, repository),
+ *              which is exactly the granularity a non-atomic publication
+ *              advances in.
+ *
+ * `setFrom` folds them back into the `CompatibleSet` the pure decision takes.
+ * An interrupted publication leaves the accepted line plus however many
+ * published lines got written — which is a resumable state by construction,
+ * not by care.
+ */
+export type CompatibleRecord = {
+    readonly id: string;
+    readonly kind: 'accepted';
+    readonly setId: string;
+    readonly at: string;
+    readonly revisions: readonly RepoRevision[];
+} | {
+    readonly id: string;
+    readonly kind: 'published';
+    readonly setId: string;
+    readonly at: string;
+    readonly repo: string;
+};
+/** The id a publication line is written under — one per (set, repository). */
+export declare function publishedId(setId: string, repo: string): string;
+export declare class CompatibleSetStore extends AppendOnlyStore<CompatibleRecord> {
+    constructor(stateDir: string, fs: LedgerFs);
+}
+export declare function isRepoRevision(v: unknown): v is RepoRevision;
+export declare function isCompatibleRecord(v: unknown): v is CompatibleRecord;
+/**
+ * Fold the records for one set back into the set.
+ *
+ * ⚠️ NULL WHEN NOTHING ACCEPTED IT. A publication line without its acceptance is
+ * not half a set — it is a record about something nobody agreed to, and
+ * inventing a set around it would be the caller's guess wearing the store's
+ * authority.
+ */
+export declare function setFrom(records: readonly CompatibleRecord[], setId: string): CompatibleSet | null;
+/**
+ * The most recently accepted set, which is the one a bare `looply repos` asks
+ * about.
+ *
+ * ⚠️ BY ACCEPTANCE TIME, NOT BY FILE ORDER. A publication line for an older set
+ * can be appended after a newer set was accepted — that is exactly what
+ * finishing an interrupted publication looks like — and taking the last line in
+ * the file would then answer about the wrong set.
+ */
+export declare function newestSetId(records: readonly CompatibleRecord[]): string | null;
+//# sourceMappingURL=compatible-sets.d.ts.map

package/dist/compatible-sets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatible-sets.d.ts","sourceRoot":"","sources":["../src/compatible-sets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,gBAAgB,GACxB;IACE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;CAC7C,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEN,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,qBAAa,kBAAmB,SAAQ,eAAe,CAAC,gBAAgB,CAAC;gBAC3D,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;CAG3C;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,YAAY,CAI5D;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,gBAAgB,CAOpE;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAYjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,GAAG,IAAI,CAO/E"}

package/dist/compatible-sets.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompatibleSetStore = void 0;
+exports.publishedId = publishedId;
+exports.isRepoRevision = isRepoRevision;
+exports.isCompatibleRecord = isCompatibleRecord;
+exports.setFrom = setFrom;
+exports.newestSetId = newestSetId;
+const core_1 = require("@looply/core");
+const record_store_1 = require("./record-store");
+/** The id a publication line is written under — one per (set, repository). */
+function publishedId(setId, repo) {
+    return `${setId}:${repo}`;
+}
+class CompatibleSetStore extends record_store_1.AppendOnlyStore {
+    constructor(stateDir, fs) {
+        super(stateDir, 'compatible-sets.jsonl', isCompatibleRecord, fs);
+    }
+}
+exports.CompatibleSetStore = CompatibleSetStore;
+function isRepoRevision(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    return typeof o['repo'] === 'string' && typeof o['sha'] === 'string';
+}
+function isCompatibleRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    if (typeof o['id'] !== 'string' || typeof o['setId'] !== 'string' || typeof o['at'] !== 'string')
+        return false;
+    if (o['kind'] === 'accepted')
+        return Array.isArray(o['revisions']) && o['revisions'].every(isRepoRevision);
+    if (o['kind'] === 'published')
+        return typeof o['repo'] === 'string';
+    return false;
+}
+/**
+ * Fold the records for one set back into the set.
+ *
+ * ⚠️ NULL WHEN NOTHING ACCEPTED IT. A publication line without its acceptance is
+ * not half a set — it is a record about something nobody agreed to, and
+ * inventing a set around it would be the caller's guess wearing the store's
+ * authority.
+ */
+function setFrom(records, setId) {
+    const accepted = records.find((r) => r.kind === 'accepted' && r.setId === setId);
+    if (accepted === undefined || accepted.kind !== 'accepted')
+        return null;
+    let set = { id: setId, at: accepted.at, revisions: accepted.revisions, published: [] };
+    // `recordPublished` is the pure step, reused rather than re-implemented: it is
+    // idempotent, and a line naming a repository the set does not name folds to
+    // nothing rather than throwing — which leaves that repository reading `to
+    // publish`, the direction a corrupt record is safe to be wrong in.
+    for (const r of records) {
+        if (r.kind === 'published' && r.setId === setId)
+            set = (0, core_1.recordPublished)(set, r.repo);
+    }
+    return set;
+}
+/**
+ * The most recently accepted set, which is the one a bare `looply repos` asks
+ * about.
+ *
+ * ⚠️ BY ACCEPTANCE TIME, NOT BY FILE ORDER. A publication line for an older set
+ * can be appended after a newer set was accepted — that is exactly what
+ * finishing an interrupted publication looks like — and taking the last line in
+ * the file would then answer about the wrong set.
+ */
+function newestSetId(records) {
+    let best = null;
+    for (const r of records) {
+        if (r.kind !== 'accepted')
+            continue;
+        if (best === null || r.at > best.at)
+            best = { setId: r.setId, at: r.at };
+    }
+    return best === null ? null : best.setId;
+}
+//# sourceMappingURL=compatible-sets.js.map

package/dist/compatible-sets.js.map

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

package/dist/compile-check.d.ts

@@ -0,0 +1,31 @@
+import { type StepVerdict } from '@looply/core';
+import type { CitationReaders } from './citation-readers';
+import type { PlanStep } from './goal-compile';
+/**
+ * THE COMPILER'S ANSWER IS CHECKED BEFORE IT BECOMES WORK (M3-2, audit D-02).
+ *
+ * Every evidence entry of every step is re-read at the committed tree the plan
+ * was made against, through the readers the composition root injects — a path
+ * for its presence, a line for its presence, a quote for being on that line
+ * (or, with no line given, on some line of the file). `judgeStep` in core
+ * decides; this file only fetches and sorts. A refused step is kept with its
+ * facts so the log and the record can show the claim beside what is there.
+ *
+ * 🔴 PURE OF GIT, FS AND THE MODEL: readers in, verdicts out. With no tree
+ * (`null`) nothing can be re-read, and a step that cites anything is refused —
+ * an unreadable citation is not a satisfied one.
+ */
+export interface CheckedStep {
+    readonly step: PlanStep;
+    readonly facts: readonly (string | null)[];
+    readonly verdict: StepVerdict;
+}
+export interface CheckedPlan {
+    readonly admitted: PlanStep[];
+    readonly refused: CheckedStep[];
+    readonly treeSha: string | null;
+}
+export declare function checkCompiledPlan(steps: readonly PlanStep[], readers: CitationReaders, treeSha: string | null): Promise<CheckedPlan>;
+/** The log line: the step by its title, the claim and the fact in the judge's words. */
+export declare function describeRefusal(c: CheckedStep): string;
+//# sourceMappingURL=compile-check.d.ts.map

package/dist/compile-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-check.d.ts","sourceRoot":"","sources":["../src/compile-check.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AASD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAW1I;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAEtD"}

package/dist/compile-check.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCompiledPlan = checkCompiledPlan;
+exports.describeRefusal = describeRefusal;
+const core_1 = require("@looply/core");
+async function readEvidence(e, readers, treeSha) {
+    if (treeSha === null)
+        return null;
+    if (e.line !== undefined)
+        return readers.file(e.path, e.line, treeSha);
+    if (e.quote !== undefined && e.quote.trim() !== '')
+        return readers.find(e.path, e.quote, treeSha);
+    return readers.path(e.path, treeSha);
+}
+async function checkCompiledPlan(steps, readers, treeSha) {
+    const admitted = [];
+    const refused = [];
+    for (const step of steps) {
+        const facts = [];
+        for (const e of step.evidence)
+            facts.push(await readEvidence(e, readers, treeSha));
+        const verdict = (0, core_1.judgeStep)(step, facts);
+        if (verdict.ok)
+            admitted.push(step);
+        else
+            refused.push({ step, facts, verdict });
+    }
+    return { admitted, refused, treeSha };
+}
+/** The log line: the step by its title, the claim and the fact in the judge's words. */
+function describeRefusal(c) {
+    return `step ${JSON.stringify(c.step.title)} refused — ${c.verdict.ok ? 'admitted' : c.verdict.because}`;
+}
+//# sourceMappingURL=compile-check.js.map

package/dist/compile-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-check.js","sourceRoot":"","sources":["../src/compile-check.ts"],"names":[],"mappings":";;AAqCA,8CAWC;AAGD,0CAEC;AArDD,uCAA0E;AA8B1E,KAAK,UAAU,YAAY,CAAC,CAAW,EAAE,OAAwB,EAAE,OAAsB;IACvF,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACvE,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAClG,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC;AAEM,KAAK,UAAU,iBAAiB,CAAC,KAA0B,EAAE,OAAwB,EAAE,OAAsB;IAClH,MAAM,QAAQ,GAAe,EAAE,CAAC;IAChC,MAAM,OAAO,GAAkB,EAAE,CAAC;IAClC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAsB,EAAE,CAAC;QACpC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,KAAK,CAAC,IAAI,CAAC,MAAM,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QACnF,MAAM,OAAO,GAAG,IAAA,gBAAS,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACvC,IAAI,OAAO,CAAC,EAAE;YAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;YAC/B,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AACxC,CAAC;AAED,wFAAwF;AACxF,SAAgB,eAAe,CAAC,CAAc;IAC5C,OAAO,QAAQ,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;AAC3G,CAAC"}

package/dist/compile-store.d.ts

@@ -0,0 +1,16 @@
+import { type CompileRecord } from '@looply/core';
+import type { LedgerFs } from './ledger-store';
+import { AppendOnlyStore } from './record-store';
+/**
+ * THE COMPILE RECORDS ON DISK — `.looply/state/compiles.jsonl`, beside the
+ * ledger of the checkout the compile happened in.
+ *
+ * One line per compile attempt (an EVENT, not a memo — the same question may
+ * be put again after a timeout): who was asked, with what (a digest), at which
+ * tree, what came back, how many steps were admitted and which were refused
+ * with the reason. Written before any step becomes an item.
+ */
+export declare class CompileStore extends AppendOnlyStore<CompileRecord> {
+    constructor(stateDir: string, fs: LedgerFs);
+}
+//# sourceMappingURL=compile-store.d.ts.map

package/dist/compile-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-store.d.ts","sourceRoot":"","sources":["../src/compile-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,eAAe,CAAC,aAAa,CAAC;gBAClD,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;CAG3C"}

package/dist/compile-store.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompileStore = void 0;
+const core_1 = require("@looply/core");
+const record_store_1 = require("./record-store");
+/**
+ * THE COMPILE RECORDS ON DISK — `.looply/state/compiles.jsonl`, beside the
+ * ledger of the checkout the compile happened in.
+ *
+ * One line per compile attempt (an EVENT, not a memo — the same question may
+ * be put again after a timeout): who was asked, with what (a digest), at which
+ * tree, what came back, how many steps were admitted and which were refused
+ * with the reason. Written before any step becomes an item.
+ */
+class CompileStore extends record_store_1.AppendOnlyStore {
+    constructor(stateDir, fs) {
+        super(stateDir, 'compiles.jsonl', core_1.isCompileRecord, fs);
+    }
+}
+exports.CompileStore = CompileStore;
+//# sourceMappingURL=compile-store.js.map

package/dist/compile-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-store.js","sourceRoot":"","sources":["../src/compile-store.ts"],"names":[],"mappings":";;;AAAA,uCAAmE;AAEnE,iDAAiD;AAEjD;;;;;;;;GAQG;AACH,MAAa,YAAa,SAAQ,8BAA8B;IAC9D,YAAY,QAAgB,EAAE,EAAY;QACxC,KAAK,CAAC,QAAQ,EAAE,gBAAgB,EAAE,sBAAe,EAAE,EAAE,CAAC,CAAC;IACzD,CAAC;CACF;AAJD,oCAIC"}

package/dist/completion.d.ts

@@ -0,0 +1,106 @@
+import { type IntegrationAttempt } from './integration-runtime';
+import type { IntegratedReceipt } from '@looply/core';
+import type { LaneCoverage } from './lane-coverage';
+/**
+ * THE THIRD KEY (M5-2).
+ *
+ * A Start ends `goal_satisfied` when two keys turn inside the run: the
+ * evaluator's verdict and the machine's own evidence. Both are about the run's
+ * checkout. Whether the LANE ever took the work was nobody's key — the commits
+ * sat on `looply/run-…` and "satisfied" meant "the run said so", while a
+ * second branch the lane refused converged only through a person's hands.
+ * With the daemon integrating for itself (M5-1) there is a third fact to read
+ * before a grant closes: has `looply/integration` published that branch?
+ *
+ * This file answers that one question, for one branch, from the two sources
+ * the lane already keeps — its attempt log and the repository — and takes no
+ * position on what the answer means for a grant. That is the controller's
+ * decision (`decideControllerRefusal` with the facts), fixed by its own spec.
+ */
+export type Publication = 
+/**
+ * The lane holds the branch's work: an attempt on record published it, or its
+ * tip is already inside the lane.
+ *
+ * `reviewOwed` is present when the attempt that published it owes an
+ * evaluator verdict — the model's judgement did not carry across a replay.
+ * It is a FACT ABOUT THE PUBLICATION, carried here so the controller can
+ * decide what it means for a grant; this type takes no position on that.
+ */
+{
+    readonly kind: 'published';
+    readonly branch: string;
+    readonly sha: string;
+    readonly reviewOwed?: {
+        readonly reason: 'revalidate' | 'unmeasurable';
+        readonly because: string;
+    };
+    /**
+     * WHICH SOURCE REQUIREMENTS THIS INTEGRATED REVISION WAS FOUND TO MEET.
+     *
+     * Another FACT ABOUT THE PUBLICATION, carried for the same reason
+     * `reviewOwed` is: the controller decides what it means for a grant, and
+     * this type takes no position. Absent for every project that holds no
+     * claims, which is most of them.
+     */
+    readonly requirements?: IntegratedReceipt;
+    /** The goal the publishing attempt was for, when the lane recorded one. */
+    readonly goalId?: string;
+    /**
+     * Programme mode: strict coverage of the pursuit's goal, judged on the integration
+     * tip (`withLaneCoverage`). Another FACT; the controller decides what it means.
+     */
+    readonly coverage?: LaneCoverage;
+    /**
+     * F27: a goal-met Start JUDGED exactly this commit, so the verdict `reviewOwed` names was
+     * taken. Present only beside `reviewOwed`, and only when the commit matches.
+     */
+    readonly reviewTakenAt?: string;
+    /** F27: a new Start here judges the tree the lane holds, so buying one can move a hold. */
+    readonly rejudge?: true;
+}
+/** The branch exists, is not in the lane, and the lane has not answered for its current tip. */
+ | {
+    readonly kind: 'pending';
+    readonly branch: string;
+}
+/** The lane answered for this tip and did not publish. `rebase` when its answer was `needs-rebase`. */
+ | {
+    readonly kind: 'refused';
+    readonly branch: string;
+    readonly because: string;
+    readonly rebase: boolean;
+    readonly rejudge?: true;
+}
+/** No branch was named, or the one named is not in the repository and nothing on record published it. */
+ | {
+    readonly kind: 'unknown';
+    readonly branch?: string;
+};
+/** The branch as the repository has it now: its tip, and whether the lane already contains that tip. */
+export interface BranchStanding {
+    readonly sha: string;
+    readonly inLane: boolean;
+}
+/**
+ * Pure over what was read. The attempt log is append-only, so among several
+ * records for one branch the LAST is the lane's latest word; a record for a
+ * tip that has since moved is not an answer about the tip that exists.
+ */
+export declare function publicationOf(attempts: readonly IntegrationAttempt[], branch: string | undefined, standing: BranchStanding | null, 
+/** F27: the commits a goal-met Start judged for this branch (`judgedAt` on its delivery records). */
+judged?: readonly string[]): Publication;
+/**
+ * The daemon's reader: the lane's log beside the repository, re-read on every
+ * ask because both are written by other processes between cadences.
+ *
+ * ⚠️ A QUESTION THIS CADENCE COULD NOT ANSWER IS NOT AN ANSWER. Anything that
+ * throws — a repository mid-operation, a log mid-write — comes back `unknown`,
+ * which holds; it can never close a grant.
+ */
+export declare function nodePublication(cwd: string, 
+/** F27: `rejudge` — this daemon runs a programme whose Starts judge the tree the lane holds. */
+opts?: {
+    readonly rejudge?: boolean;
+}): (branch: string | undefined) => Promise<Publication>;
+//# sourceMappingURL=completion.d.ts.map

package/dist/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../src/completion.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,WAAW;AACrB;;;;;;;;GAQG;AACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACnG;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAC1C,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;CACzB;AACH,gGAAgG;GAC9F;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACvD,uGAAuG;GACrG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CAAE;AACpI,yGAAyG;GACvG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,wGAAwG;AACxG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAKD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,cAAc,GAAG,IAAI;AAC/B,qGAAqG;AACrG,MAAM,GAAE,SAAS,MAAM,EAAO,GAC7B,WAAW,CAiEb;AAYD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM;AACX,gGAAgG;AAChG,IAAI,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC,WAAW,CAAC,CAqBtD"}

package/dist/completion.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicationOf = publicationOf;
+exports.nodePublication = nodePublication;
+const git_driver_1 = require("./git-driver");
+const integration_1 = require("./integration");
+const integration_runtime_1 = require("./integration-runtime");
+const lane_claims_1 = require("./lane-claims");
+/** How much of the lane's reason a hold repeats. A hold is read in a log line, not a report. */
+const MAX_REASON = 500;
+/**
+ * Pure over what was read. The attempt log is append-only, so among several
+ * records for one branch the LAST is the lane's latest word; a record for a
+ * tip that has since moved is not an answer about the tip that exists.
+ */
+function publicationOf(attempts, branch, standing, 
+/** F27: the commits a goal-met Start judged for this branch (`judgedAt` on its delivery records). */
+judged = []) {
+    if (branch === undefined)
+        return { kind: 'unknown' };
+    const mine = attempts.filter((a) => a.branch === branch);
+    const published = latest(mine.filter((a) => a.published !== undefined));
+    if (published?.published !== undefined) {
+        return {
+            kind: 'published',
+            branch,
+            sha: published.published.to,
+            ...(published.reviewOwed === undefined ? {} : { reviewOwed: published.reviewOwed }),
+            ...(published.reviewOwed !== undefined && judged.includes(published.published.to) ? { reviewTakenAt: published.published.to } : {}),
+            ...(published.requirements === undefined ? {} : { requirements: published.requirements }),
+            ...(published.goalId === undefined ? {} : { goalId: published.goalId }),
+        };
+    }
+    /**
+     * 🔴 A REPLAYED BRANCH IS ANSWERED BY ITS REPLAY (F21).
+     *
+     * The lane cannot fast-forward a branch whose base moved, so it carries the
+     * change onto the new base as `looply/replay-…` and publishes THAT. The run
+     * branch's own attempt stays `needs-rebase` — so this answered `refused`, a
+     * rebase, and the controller bought a new Start every cadence for work that was
+     * already integrated, until the grant was spent. Measured by reading
+     * (live2/CLOSURE-CHAIN-MAP.md B8): whichever of two concurrent goals lands second
+     * is always replayed. The replay's answer — published, refused or not yet
+     * offered — is this branch's answer.
+     *
+     * ⚠️ ONLY FOR THE TIP THAT WAS CARRIED. A branch that moved since is a new
+     * candidate, and the old replay says nothing about it. One hop: replays are
+     * never offered as run branches, so they are never replayed again.
+     */
+    const carried = latest(mine.filter((a) => a.replayedAs !== undefined && (standing === null || a.commitSha === standing.sha)));
+    if (carried?.replayedAs !== undefined) {
+        const replay = carried.replayedAs;
+        const theirs = attempts.filter((a) => a.branch === replay);
+        const landed = latest(theirs.filter((a) => a.published !== undefined));
+        if (landed?.published !== undefined) {
+            return {
+                kind: 'published',
+                branch: replay,
+                sha: landed.published.to,
+                ...(landed.reviewOwed === undefined ? {} : { reviewOwed: landed.reviewOwed }),
+                ...(landed.reviewOwed !== undefined && judged.includes(landed.published.to) ? { reviewTakenAt: landed.published.to } : {}),
+                ...(landed.requirements === undefined ? {} : { requirements: landed.requirements }),
+                ...(landed.goalId === undefined ? {} : { goalId: landed.goalId }),
+            };
+        }
+        const last = latest(theirs);
+        if (last === undefined)
+            return { kind: 'pending', branch: replay };
+        return { kind: 'refused', branch: replay, because: reasonOf(last), rebase: last.verdict === 'needs-rebase' };
+    }
+    if (standing === null)
+        return { kind: 'unknown', branch };
+    /**
+     * ⚠️ NO OBLIGATION IS REPORTED FOR A TIP THAT IS SIMPLY INSIDE THE LANE.
+     *
+     * This branch answers from the REPOSITORY, not from an attempt: the tip is
+     * already contained, and no attempt on record published it. There is nothing
+     * to read an obligation off, and inventing an absence would be the same
+     * mistake as inventing a presence. A tip that got there through an attempt is
+     * answered by the branch above, which does carry it.
+     */
+    if (standing.inLane)
+        return { kind: 'published', branch, sha: standing.sha };
+    const answered = latest(mine.filter((a) => a.commitSha === standing.sha || a.candidateSha === standing.sha));
+    if (answered === undefined)
+        return { kind: 'pending', branch };
+    return { kind: 'refused', branch, because: reasonOf(answered), rebase: answered.verdict === 'needs-rebase' };
+}
+function latest(list) {
+    return list.length === 0 ? undefined : list[list.length - 1];
+}
+function reasonOf(a) {
+    if (a.because !== undefined)
+        return a.because.slice(0, MAX_REASON);
+    const red = (a.checks ?? []).filter((c) => !c.ok).map((c) => `${c.name}: ${c.detail}`);
+    return (red.length > 0 ? `the gate was red — ${red.join('; ')}` : `the lane's verdict was ${a.verdict}`).slice(0, MAX_REASON);
+}
+/**
+ * The daemon's reader: the lane's log beside the repository, re-read on every
+ * ask because both are written by other processes between cadences.
+ *
+ * ⚠️ A QUESTION THIS CADENCE COULD NOT ANSWER IS NOT AN ANSWER. Anything that
+ * throws — a repository mid-operation, a log mid-write — comes back `unknown`,
+ * which holds; it can never close a grant.
+ */
+function nodePublication(cwd, 
+/** F27: `rejudge` — this daemon runs a programme whose Starts judge the tree the lane holds. */
+opts = {}) {
+    const git = new git_driver_1.GitDriver((0, git_driver_1.nodeGitExec)(cwd));
+    const mark = (p) => opts.rejudge === true && (p.kind === 'published' || p.kind === 'refused') ? { ...p, rejudge: true } : p;
+    return async (branch) => {
+        if (branch === undefined)
+            return publicationOf([], undefined, null);
+        try {
+            const attempts = (0, integration_runtime_1.readAttempts)(cwd);
+            // F27: the commits a goal-met Start judged for this branch — where an owed verdict was taken.
+            const judged = (0, lane_claims_1.readLaneClaims)(cwd).flatMap((r) => r.kind === 'delivery' && r.branch === branch && r.judgedAt !== undefined ? [r.judgedAt] : []);
+            if (!(await git.refExists(branch)))
+                return mark(publicationOf(attempts, branch, null, judged));
+            const sha = await git.mergeBase(branch, branch);
+            if (sha === null)
+                return mark(publicationOf(attempts, branch, null, judged));
+            const inLane = (await git.refExists(integration_1.INTEGRATION_BRANCH)) && (await git.mergeBase(integration_1.INTEGRATION_BRANCH, branch)) === sha;
+            return mark(publicationOf(attempts, branch, { sha, inLane }, judged));
+        }
+        catch {
+            return { kind: 'unknown', branch };
+        }
+    };
+}
+//# sourceMappingURL=completion.js.map