looply-cli 0.0.0-stage → 0.2.0

package/dist/rails-migrations.d.ts

@@ -0,0 +1,75 @@
+import type { MigrationDir, MigrationFile, MigrationPart } from './rails-home';
+/**
+ * THE TWO LEDGERS THAT DECIDE WHETHER A RAIL IS SHUT, MOVED FORWARD ONCE.
+ *
+ * `rails-home.ts` owns the mechanism — exclusive create, target-as-first-source,
+ * marker written last, nothing old deleted. This file owns the only thing that
+ * is specific to each ledger: what "merged" means for it.
+ *
+ * ⚠️ EACH MERGE THROWS RATHER THAN SKIPPING. A source that reads and does not
+ * parse is the fail-closed case, not the tolerable one. The single exception is
+ * a torn FINAL line of an append-only log, which is what a crash mid-append
+ * looks like and which `ExemptionStore.readSpendLog` already skips for the same
+ * reason — discarding every spend on the strength of one truncated line would be
+ * fail-open by another route.
+ */
+/** The legacy whole-map file, and the append-only log that replaced it. */
+export declare const EXEMPTIONS_LEGACY = "exemptions.json";
+export declare const EXEMPTIONS_LOG = "exemptions.spent.jsonl";
+/** The loop-safety history: observations, incidents, and the legacy projection. */
+export declare const SAFETY_LEGACY = "loop-safety.json";
+export declare const SAFETY_EVENTS = "loop-safety-events.jsonl";
+export declare const SAFETY_INCIDENTS = "loop-safety-incidents.jsonl";
+/**
+ * The spend ledger: a SET UNION, and spent in ANY source is spent.
+ *
+ * 🔴 UNION, NOT LAST-WRITER. This is the whole reason the migration is not a
+ * fallback. Workspace A's ledger says grant `g` is spent; workspace B's does
+ * not, because B never offered it. A merge that preferred either side over the
+ * other by position would, half the time, produce a machine that believes `g`
+ * is available. Union is the only combination that cannot lose a spend.
+ *
+ * ⚠️ AND THE FIRST ROUND WINS FOR A KEY SEEN TWICE, matching
+ * `ExemptionStore.record`: "the round recorded is the one that actually used the
+ * door, and overwriting it would make the trailer and this file disagree about
+ * which commit opened it." Sources are therefore passed in the same order
+ * `open()` reads them.
+ */
+export declare function mergeSpendLog(parts: readonly MigrationPart[]): string;
+/**
+ * The safety history: EVERY observation from every source, ordered by `at`.
+ *
+ * 🔴 ORDERED BY THE FIELD, NOT BY THE FILE. The detectors read a sequence: three
+ * identical failure signatures in a row, or an A-B-A-B tree fingerprint. Two
+ * workspaces' histories concatenated end to end produce a sequence that never
+ * happened — A's three failures then B's three, when in fact they interleaved.
+ * The records carry their own `at`, so the true order is recoverable and is used.
+ *
+ * ⚠️ DUPLICATES ARE DROPPED BY IDENTITY, not by position: the same observation
+ * can appear in two sources when a workspace was cut from another's state. Two
+ * identical records are one event that was copied, never two events that agreed.
+ */
+export declare function mergeJsonlByTime(parts: readonly MigrationPart[]): string;
+/**
+ * The legacy whole-document projection is NOT merged forward.
+ *
+ * `loop-safety.json` was a projection of the observations and incidents that the
+ * store rebuilt on every open. Both of its inputs are migrated as append-only
+ * logs above, so carrying the projection too would double every record it holds.
+ * It is left on disk with everything else and never read again.
+ */
+export declare function exemptionMigration(oldStateDirs: readonly string[]): MigrationFile;
+export declare const SAFETY_OVERRIDES = "loop-safety-overrides";
+/**
+ * 🔴 THE OVERRIDE MARKERS MOVE WITH THE INCIDENTS, OR A SPENT RETRY IS LOST.
+ *
+ * `foldInSpentRetries` re-derives "has this incident's one retry been spent"
+ * from these files on every open. They are not a cache of the incidents file —
+ * they are the only record that exists. Leaving them behind means a person who
+ * already spent their retry finds the hold active again, having paid for
+ * nothing; moving them without the incidents means a marker for an incident
+ * nothing can see.
+ */
+export declare function safetyOverridesMigration(oldStateDirs: readonly string[]): MigrationDir;
+export declare function safetyMigrations(oldStateDirs: readonly string[]): MigrationFile[];
+//# sourceMappingURL=rails-migrations.d.ts.map

package/dist/rails-migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rails-migrations.d.ts","sourceRoot":"","sources":["../src/rails-migrations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE/E;;;;;;;;;;;;;GAaG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AACnD,eAAO,MAAM,cAAc,2BAA2B,CAAC;AAEvD,mFAAmF;AACnF,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAChD,eAAO,MAAM,aAAa,6BAA6B,CAAC;AACxD,eAAO,MAAM,gBAAgB,gCAAgC,CAAC;AAO9D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CA0CrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAkCxE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CAUjF;AAED,eAAO,MAAM,gBAAgB,0BAA0B,CAAC;AAExD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAKtF;AAED,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,EAAE,CAajF"}

package/dist/rails-migrations.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFETY_OVERRIDES = exports.SAFETY_INCIDENTS = exports.SAFETY_EVENTS = exports.SAFETY_LEGACY = exports.EXEMPTIONS_LOG = exports.EXEMPTIONS_LEGACY = void 0;
+exports.mergeSpendLog = mergeSpendLog;
+exports.mergeJsonlByTime = mergeJsonlByTime;
+exports.exemptionMigration = exemptionMigration;
+exports.safetyOverridesMigration = safetyOverridesMigration;
+exports.safetyMigrations = safetyMigrations;
+const node_path_1 = require("node:path");
+/**
+ * THE TWO LEDGERS THAT DECIDE WHETHER A RAIL IS SHUT, MOVED FORWARD ONCE.
+ *
+ * `rails-home.ts` owns the mechanism — exclusive create, target-as-first-source,
+ * marker written last, nothing old deleted. This file owns the only thing that
+ * is specific to each ledger: what "merged" means for it.
+ *
+ * ⚠️ EACH MERGE THROWS RATHER THAN SKIPPING. A source that reads and does not
+ * parse is the fail-closed case, not the tolerable one. The single exception is
+ * a torn FINAL line of an append-only log, which is what a crash mid-append
+ * looks like and which `ExemptionStore.readSpendLog` already skips for the same
+ * reason — discarding every spend on the strength of one truncated line would be
+ * fail-open by another route.
+ */
+/** The legacy whole-map file, and the append-only log that replaced it. */
+exports.EXEMPTIONS_LEGACY = 'exemptions.json';
+exports.EXEMPTIONS_LOG = 'exemptions.spent.jsonl';
+/** The loop-safety history: observations, incidents, and the legacy projection. */
+exports.SAFETY_LEGACY = 'loop-safety.json';
+exports.SAFETY_EVENTS = 'loop-safety-events.jsonl';
+exports.SAFETY_INCIDENTS = 'loop-safety-incidents.jsonl';
+/** True for the last line of a text that does not end in a newline: a torn append. */
+function isTornTail(text, index, lines) {
+    return index === lines.length - 1 && !text.endsWith('\n');
+}
+/**
+ * The spend ledger: a SET UNION, and spent in ANY source is spent.
+ *
+ * 🔴 UNION, NOT LAST-WRITER. This is the whole reason the migration is not a
+ * fallback. Workspace A's ledger says grant `g` is spent; workspace B's does
+ * not, because B never offered it. A merge that preferred either side over the
+ * other by position would, half the time, produce a machine that believes `g`
+ * is available. Union is the only combination that cannot lose a spend.
+ *
+ * ⚠️ AND THE FIRST ROUND WINS FOR A KEY SEEN TWICE, matching
+ * `ExemptionStore.record`: "the round recorded is the one that actually used the
+ * door, and overwriting it would make the trailer and this file disagree about
+ * which commit opened it." Sources are therefore passed in the same order
+ * `open()` reads them.
+ */
+function mergeSpendLog(parts) {
+    const spent = new Map();
+    const take = (key, round) => {
+        if (typeof key !== 'string' || key === '')
+            return;
+        if (typeof round !== 'number' || !Number.isInteger(round))
+            return;
+        if (!spent.has(key))
+            spent.set(key, round);
+    };
+    for (const part of parts) {
+        if (part.path.endsWith(exports.EXEMPTIONS_LEGACY)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(part.text);
+            }
+            catch {
+                throw new Error(`${part.path} is not readable JSON, so its spends cannot be counted`);
+            }
+            const map = parsed?.spent;
+            if (typeof map !== 'object' || map === null) {
+                throw new Error(`${part.path} is not a spend file, so its spends cannot be counted`);
+            }
+            for (const [key, round] of Object.entries(map))
+                take(key, round);
+            continue;
+        }
+        const lines = part.text.split('\n');
+        lines.forEach((line, i) => {
+            if (line.trim() === '')
+                return;
+            try {
+                const row = JSON.parse(line);
+                take(row.key, row.round);
+            }
+            catch (e) {
+                if (isTornTail(part.text, i, lines))
+                    return;
+                throw new Error(`${part.path} line ${i + 1} is not a spend record`);
+            }
+        });
+    }
+    // Sorted by key so the migrated file is deterministic and diffable. Order
+    // carries no meaning here: `isSpent` asks whether the key is present.
+    return [...spent.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, round]) => `${JSON.stringify({ key, round })}\n`)
+        .join('');
+}
+/**
+ * The safety history: EVERY observation from every source, ordered by `at`.
+ *
+ * 🔴 ORDERED BY THE FIELD, NOT BY THE FILE. The detectors read a sequence: three
+ * identical failure signatures in a row, or an A-B-A-B tree fingerprint. Two
+ * workspaces' histories concatenated end to end produce a sequence that never
+ * happened — A's three failures then B's three, when in fact they interleaved.
+ * The records carry their own `at`, so the true order is recoverable and is used.
+ *
+ * ⚠️ DUPLICATES ARE DROPPED BY IDENTITY, not by position: the same observation
+ * can appear in two sources when a workspace was cut from another's state. Two
+ * identical records are one event that was copied, never two events that agreed.
+ */
+function mergeJsonlByTime(parts) {
+    const rows = [];
+    const seen = new Set();
+    let n = 0;
+    for (const part of parts) {
+        const lines = part.text.split('\n');
+        lines.forEach((line, i) => {
+            const trimmed = line.trim();
+            if (trimmed === '')
+                return;
+            let row;
+            try {
+                row = JSON.parse(trimmed);
+            }
+            catch (e) {
+                if (isTornTail(part.text, i, lines))
+                    return;
+                throw new Error(`${part.path} line ${i + 1} is not a record`);
+            }
+            if (seen.has(trimmed))
+                return;
+            seen.add(trimmed);
+            /**
+             * ⚠️ A RECORD WITH NO TIME SORTS FIRST, NOT LAST. An observation whose
+             * `at` is missing is older than anything that has one — nothing in this
+             * codebase has ever written one without — and putting it last would let a
+             * malformed row displace the most recent real observation, which is the
+             * one every detector looks at.
+             */
+            const at = typeof row.at === 'string' ? row.at : typeof row.triggeredAt === 'string' ? row.triggeredAt : '';
+            rows.push({ at, ordinal: n++, line: trimmed });
+        });
+    }
+    // Stable: equal timestamps keep the order they were read in.
+    rows.sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : a.ordinal - b.ordinal));
+    return rows.map((r) => `${r.line}\n`).join('');
+}
+/**
+ * The legacy whole-document projection is NOT merged forward.
+ *
+ * `loop-safety.json` was a projection of the observations and incidents that the
+ * store rebuilt on every open. Both of its inputs are migrated as append-only
+ * logs above, so carrying the projection too would double every record it holds.
+ * It is left on disk with everything else and never read again.
+ */
+function exemptionMigration(oldStateDirs) {
+    return {
+        name: exports.EXEMPTIONS_LOG,
+        // The legacy map first, then the log, matching the order `open()` reads them.
+        sources: [
+            ...oldStateDirs.map((d) => (0, node_path_1.join)(d, exports.EXEMPTIONS_LEGACY)),
+            ...oldStateDirs.map((d) => (0, node_path_1.join)(d, exports.EXEMPTIONS_LOG)),
+        ],
+        merge: mergeSpendLog,
+    };
+}
+exports.SAFETY_OVERRIDES = 'loop-safety-overrides';
+/**
+ * 🔴 THE OVERRIDE MARKERS MOVE WITH THE INCIDENTS, OR A SPENT RETRY IS LOST.
+ *
+ * `foldInSpentRetries` re-derives "has this incident's one retry been spent"
+ * from these files on every open. They are not a cache of the incidents file —
+ * they are the only record that exists. Leaving them behind means a person who
+ * already spent their retry finds the hold active again, having paid for
+ * nothing; moving them without the incidents means a marker for an incident
+ * nothing can see.
+ */
+function safetyOverridesMigration(oldStateDirs) {
+    return {
+        name: exports.SAFETY_OVERRIDES,
+        sources: oldStateDirs.map((d) => (0, node_path_1.join)(d, exports.SAFETY_OVERRIDES)),
+    };
+}
+function safetyMigrations(oldStateDirs) {
+    return [
+        {
+            name: exports.SAFETY_EVENTS,
+            sources: oldStateDirs.map((d) => (0, node_path_1.join)(d, exports.SAFETY_EVENTS)),
+            merge: mergeJsonlByTime,
+        },
+        {
+            name: exports.SAFETY_INCIDENTS,
+            sources: oldStateDirs.map((d) => (0, node_path_1.join)(d, exports.SAFETY_INCIDENTS)),
+            merge: mergeJsonlByTime,
+        },
+    ];
+}
+//# sourceMappingURL=rails-migrations.js.map

package/dist/rails-migrations.js.map

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

package/dist/rails-stores.d.ts

@@ -0,0 +1,49 @@
+import { ExemptionStore } from './exemption-store';
+import { LoopSafetyStore } from './loop-safety-store';
+import { type LedgerFs } from './ledger-store';
+import { type MigrationFs } from './rails-home';
+/**
+ * THE TWO RAILS STORES, POINTED AT THEIR MACHINE-LEVEL HOME.
+ *
+ * These are the only constructors production code should use. A bare
+ * `new ExemptionStore(dir, fs)` is still what every test builds — the store
+ * knows nothing about where it lives, which is what keeps it testable — but a
+ * production caller that picked its own directory is exactly how the ledger
+ * ended up inside the repository in the first place.
+ *
+ * ⚠️ THE MIGRATION IS PART OF OPENING, NOT A SEPARATE STEP SOMEBODY MUST
+ * REMEMBER. It is handed to the store as a closure and runs before the store's
+ * first read, so there is no window in which a caller has an open store that has
+ * not yet moved its history forward. A migration that refuses leaves the store
+ * unreadable, which for both of these means every rail stays shut.
+ */
+/** Where the migration reads from and writes to, so a test can supply its own. */
+export interface RailsDeps {
+    readonly fs?: LedgerFs;
+    readonly migrationFs?: MigrationFs;
+    readonly home?: string;
+    readonly now?: () => number;
+    /** Records why a migration refused. Production prints it; tests collect it. */
+    readonly onRefusal?: (because: string) => void;
+}
+/**
+ * The exemption spend ledger.
+ *
+ * 🔴 A SINGLE-USE GRANT IS SINGLE-USE ACROSS THE MACHINE. Phase 1 made it
+ * single-use across the WORKSPACES of one checkout by moving this to the project
+ * state directory; this moves it out of the repository, where ordinary
+ * housekeeping — a re-clone, a `git clean -xfd`, deleting a finished checkout —
+ * cannot quietly turn a spent grant back into an unspent one.
+ */
+export declare function railsExemptionStore(cwd: string, deps?: RailsDeps): ExemptionStore;
+/**
+ * The loop-safety history.
+ *
+ * 🔴 A HOLD MEANS THE SAME THING ON A BUSY MACHINE AS ON AN IDLE ONE. The
+ * detectors count observations, so a history split across N places is N
+ * histories, and `repeated_failure` needs three failures in EACH — the exact
+ * silent safety-disablement the detectors exist to prevent, recreated by a
+ * different route.
+ */
+export declare function railsSafetyStore(cwd: string, deps?: RailsDeps): LoopSafetyStore;
+//# sourceMappingURL=rails-stores.d.ts.map

package/dist/rails-stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rails-stores.d.ts","sourceRoot":"","sources":["../src/rails-stores.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAgB,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG7D,OAAO,EAKL,KAAK,WAAW,EAEjB,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;;GAcG;AAEH,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD;AAuBD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,SAAc,GAAG,cAAc,CAIrF;AAiDD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,SAAc,GAAG,eAAe,CAOnF"}

package/dist/rails-stores.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.railsExemptionStore = railsExemptionStore;
+exports.railsSafetyStore = railsSafetyStore;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const exemption_store_1 = require("./exemption-store");
+const loop_safety_store_1 = require("./loop-safety-store");
+const ledger_store_1 = require("./ledger-store");
+const git_driver_1 = require("./git-driver");
+const workspace_1 = require("./workspace");
+const rails_home_1 = require("./rails-home");
+const rails_migrations_1 = require("./rails-migrations");
+async function move(cwd, which, deps) {
+    const home = deps.home ?? (0, node_os_1.homedir)();
+    const fs = deps.migrationFs ?? rails_home_1.nodeMigrationFs;
+    const dir = (0, rails_home_1.railsDir)(cwd, home);
+    const olds = await (0, rails_home_1.legacyStateDirs)({
+        projectState: (0, git_driver_1.projectStateDir)(cwd),
+        workspacesRoot: (0, workspace_1.workspacesRoot)(cwd, home),
+        fs,
+    });
+    const files = which === 'exemptions' ? [(0, rails_migrations_1.exemptionMigration)(olds)] : (0, rails_migrations_1.safetyMigrations)(olds);
+    // The override markers travel WITH the incidents. See safetyOverridesMigration.
+    const dirs = which === 'exemptions' ? [] : [(0, rails_migrations_1.safetyOverridesMigration)(olds)];
+    const out = await (0, rails_home_1.copyForwardOnce)({ dir, files, dirs, fs, who: which, now: deps.now });
+    if (!out.ok && deps.onRefusal !== undefined)
+        deps.onRefusal(out.because);
+    return out;
+}
+/**
+ * The exemption spend ledger.
+ *
+ * 🔴 A SINGLE-USE GRANT IS SINGLE-USE ACROSS THE MACHINE. Phase 1 made it
+ * single-use across the WORKSPACES of one checkout by moving this to the project
+ * state directory; this moves it out of the repository, where ordinary
+ * housekeeping — a re-clone, a `git clean -xfd`, deleting a finished checkout —
+ * cannot quietly turn a spent grant back into an unspent one.
+ */
+function railsExemptionStore(cwd, deps = {}) {
+    return new exemption_store_1.ExemptionStore((0, rails_home_1.railsDir)(cwd, deps.home ?? (0, node_os_1.homedir)()), deps.fs ?? ledger_store_1.nodeLedgerFs, () => move(cwd, 'exemptions', withVoice(deps, 'exemptions', cwd, deps.home ?? (0, node_os_1.homedir)())));
+}
+/**
+ * 🔴 A REFUSAL THAT NOBODY PRINTS IS A SILENT FAILURE, AND BOTH OF THESE FAIL
+ * CLOSED — so the person sees a machine that has stopped doing something, with
+ * nothing said about why.
+ *
+ * `onRefusal` existed and no production caller passed one. An exemption store
+ * that refuses answers `isSpent` true for EVERY grant, so a person's granted
+ * exemption simply stops working; a safety store that refuses leaves `safety =
+ * null`, and the hold fence is skipped entirely. Either is worth a line.
+ */
+function withVoice(deps, which, cwd, home) {
+    if (deps.onRefusal !== undefined)
+        return deps;
+    return {
+        ...deps,
+        onRefusal: (because) => {
+            process.stderr.write(`rails   : the ${which} ledger could not be moved — ${because}\n`);
+            /**
+             * 🔴 AND A DURABLE ONE, BECAUSE stderr IS `/dev/null` FOR THE PROCESS
+             * THAT MOST NEEDS TO BE HEARD.
+             *
+             * MEASURED: `run-launcher` spawns every daemon-launched run with
+             * `detached: true, stdio: 'ignore'`. The same child, under `pipe`,
+             * delivers both refusal lines; under `ignore` it delivers nothing at all
+             * while the store state is identically `unreadable`. So an overnight run
+             * whose exemption ledger has silently shut every rail says nothing,
+             * anywhere, ever.
+             *
+             * `bin.ts` already knows this hazard and names it for `RunRefused` —
+             * "the daemon that spawned this cannot [hear], because it spawns with
+             * `stdio: 'ignore'` on a detached child, so the words go nowhere" — and
+             * answers it with a durable mark beside the stream. This is that.
+             */
+            try {
+                const dir = (0, rails_home_1.railsDir)(cwd, home);
+                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+                (0, node_fs_1.appendFileSync)((0, node_path_1.join)(dir, 'refusals.jsonl'), `\n${JSON.stringify({ which, because, pid: process.pid, at: new Date().toISOString() })}\n`, 'utf8');
+            }
+            catch {
+                /* a refusal we cannot write down is still a refusal we printed */
+            }
+        },
+    };
+}
+/**
+ * The loop-safety history.
+ *
+ * 🔴 A HOLD MEANS THE SAME THING ON A BUSY MACHINE AS ON AN IDLE ONE. The
+ * detectors count observations, so a history split across N places is N
+ * histories, and `repeated_failure` needs three failures in EACH — the exact
+ * silent safety-disablement the detectors exist to prevent, recreated by a
+ * different route.
+ */
+function railsSafetyStore(cwd, deps = {}) {
+    return new loop_safety_store_1.LoopSafetyStore((0, rails_home_1.railsDir)(cwd, deps.home ?? (0, node_os_1.homedir)()), loop_safety_store_1.nodeSafetyFs, deps.now ?? (() => Date.now()), () => move(cwd, 'safety', withVoice(deps, 'loop-safety', cwd, deps.home ?? (0, node_os_1.homedir)())));
+}
+//# sourceMappingURL=rails-stores.js.map

package/dist/rails-stores.js.map

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

package/dist/reaper.d.ts

@@ -0,0 +1,69 @@
+import { GitDriver } from './git-driver';
+import { RunRegistry, type ProbeFn } from './workspace';
+/**
+ * THE MACHINE RETIRES WHAT IT MADE — when the project asked (M4-4).
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Since M4-1 the daemon can make checkouts, and nothing removed them: idle ones
+ * accumulated up to `machine.max_workspaces` until a person ran the manual
+ * reap. With `machine.reap_provisioned: true` the daemon retires, at most ONE
+ * per cadence, after the tick, a checkout that meets ALL of:
+ *
+ *   1. IT MADE IT — the provisioner leaves `provisioned.json` in the checkout's
+ *      state dir; a checkout a person cut carries none and is never touched;
+ *   2. NOTHING RUNS THERE — `abandonedWorkspaces` lists it (no record claims
+ *      it, no live lease, no live creation marker), or its only record is of a
+ *      run that has DIED (an orphan the manual command retires the same way);
+ *   3. IT HAS BEEN IDLE for at least `machine.idle_checkout_minutes`, measured
+ *      from the newest of the marker and anything written to its state dir;
+ *   4. THE MANUAL COMMAND'S OWN FUNCTIONS AGREE — `reapAbandoned` /
+ *      `reapWorkspace`: not busy, not quarantined, no residue (uncommitted or
+ *      untracked work keeps it, with the reason), records retained, then
+ *      `git worktree remove` and prune.
+ *
+ * 🔴 NEVER A CHECKOUT THAT IS ABOUT TO BE USED. The daemon hands over the
+ * paths it placed a goal into this cadence and last (a launch is not an
+ * arrival: the run has not written its lease yet) and the one it provisioned
+ * this cadence; none of those is a candidate. And an orphan's checkout that a
+ * LIVE run now occupies is not touched either — the dead record is somebody
+ * else's leftover, the checkout is in use.
+ *
+ * ⚠️ AND IT KNOWS NOTHING ABOUT GOALS. A checkout is a checkout.
+ */
+export declare const PROVISIONED_MARKER = "provisioned.json";
+export interface ProvisionedMarker {
+    readonly by: 'daemon';
+    readonly at: string;
+    readonly pid: number;
+}
+/** Written by the provisioner once the checkout is complete: the fact that the machine made it. */
+export declare function writeProvisionedMarker(stateDir: string, at: string, pid: number): void;
+export declare function provisionedByDaemon(checkout: string): ProvisionedMarker | null;
+/** Minutes since anything last happened in the checkout: the marker, or the newest entry of its state dir. */
+export declare function idleMinutesOf(checkout: string, marker: ProvisionedMarker, now: number): number;
+export type ReapOutcome = 'retired' | 'kept' | 'none';
+export interface ReapDeps {
+    readonly cwd: string;
+    readonly registry: RunRegistry;
+    readonly git: GitDriver;
+    readonly now: () => number;
+    readonly idleMinutes: number;
+    readonly probe?: ProbeFn;
+    readonly log: (line: string) => void;
+    /** Checkouts the daemon placed into or made this cadence (or last): never candidates. */
+    readonly exclude?: readonly string[];
+    /** Whose home the workspaces root lives under; the user's unless a caller says otherwise. */
+    readonly home?: string;
+}
+/** One cadence's reaping: the first eligible checkout in path order, and only one. */
+export declare function reapOneProvisioned(deps: ReapDeps): Promise<ReapOutcome>;
+/** The daemon's reaper: built only behind `machine.reap_provisioned`; a failure is a log line, never a stopped daemon. */
+export declare function nodeReaper(cwd: string, projectState: string, opts: {
+    readonly idleMinutes: number;
+    readonly log: (line: string) => void;
+    readonly now?: () => number;
+    readonly home?: string;
+}): (exclude?: readonly string[]) => Promise<ReapOutcome | 'failed'>;
+/** For `looply runs` and tests: is there a marker at all? */
+export declare function hasProvisionedMarker(checkout: string): boolean;
+//# sourceMappingURL=reaper.d.ts.map

package/dist/reaper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reaper.d.ts","sourceRoot":"","sources":["../src/reaper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAA0B,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,WAAW,EAA8E,KAAK,OAAO,EAAkB,MAAM,aAAa,CAAC;AAEpJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,kBAAkB,qBAAqB,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,mGAAmG;AACnG,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAKtF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAO9E;AAED,8GAA8G;AAC9G,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAe9F;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,yFAAyF;IACzF,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD,sFAAsF;AACtF,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAyC7E;AAED,0HAA0H;AAC1H,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAChI,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,GAAG,QAAQ,CAAC,CAkBlE;AAED,6DAA6D;AAC7D,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE9D"}