cool-workflow 0.1.80 → 0.1.81

package/dist/run-registry.js

@@ -34,51 +34,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunRegistry = exports.DEFAULT_RUN_REGISTRY_POLICY = exports.RUN_REGISTRY_SCHEMA_VERSION = void 0;
+exports.formatQueueList = exports.formatHistory = exports.formatResume = exports.formatGcVerify = exports.formatGcRun = exports.formatGcPlan = exports.formatRunShow = exports.formatRunSearch = exports.formatRegistryReport = exports.RunRegistry = exports.RUN_REGISTRY_SCHEMA_VERSION = exports.DEFAULT_RUN_REGISTRY_POLICY = exports.isRunLifecycleState = exports.compareQueue = void 0;
 exports.resolveCwHome = resolveCwHome;
 exports.deriveLifecycle = deriveLifecycle;
-exports.compareQueue = compareQueue;
-exports.isRunLifecycleState = isRunLifecycleState;
-exports.formatRegistryReport = formatRegistryReport;
-exports.formatRunSearch = formatRunSearch;
-exports.formatRunShow = formatRunShow;
-exports.formatGcPlan = formatGcPlan;
-exports.formatGcRun = formatGcRun;
-exports.formatGcVerify = formatGcVerify;
-exports.formatResume = formatResume;
-exports.formatHistory = formatHistory;
-exports.formatQueueList = formatQueueList;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const state_1 = require("./state");
-const reclamation_1 = require("./reclamation");
-exports.RUN_REGISTRY_SCHEMA_VERSION = 1;
-const LIFECYCLE_STATES = [
-    "queued",
-    "running",
-    "blocked",
-    "completed",
-    "failed",
-    "archived",
-    "reclaimed"
-];
-// POLICY defaults. Configurable; never baked into the index. archiveOlderThanDays
-// = 0 disables retention archiving (explicit selection still works). The v0.1.39
-// reclamation knobs all default to RECLAIM NOTHING (back-compatible, opt-in).
-exports.DEFAULT_RUN_REGISTRY_POLICY = {
-    schemaVersion: 1,
-    archiveOlderThanDays: 0,
-    archiveStates: ["completed", "failed"],
-    defaultQueuePriority: 100,
-    reclaimAfterArchiveDays: 0,
-    reclaimStates: ["completed", "failed"],
-    keepSnapshots: false,
-    keepScratch: false,
-    maxReclaimRuns: 0,
-    maxReclaimBytes: 0
-};
+// planReclamation/runReclamation/verifyReclamation/ReclamationError moved with the
+// GC cluster into ./run-registry/gc (FreeBSD-audit R2 deep).
+const compare_1 = require("./compare");
+const derive_1 = require("./run-registry/derive");
+Object.defineProperty(exports, "compareQueue", { enumerable: true, get: function () { return derive_1.compareQueue; } });
+Object.defineProperty(exports, "isRunLifecycleState", { enumerable: true, get: function () { return derive_1.isRunLifecycleState; } });
+const gc_1 = require("./run-registry/gc");
+const queue_1 = require("./run-registry/queue");
+const policy_1 = require("./run-registry/policy");
+Object.defineProperty(exports, "DEFAULT_RUN_REGISTRY_POLICY", { enumerable: true, get: function () { return policy_1.DEFAULT_RUN_REGISTRY_POLICY; } });
+Object.defineProperty(exports, "RUN_REGISTRY_SCHEMA_VERSION", { enumerable: true, get: function () { return policy_1.RUN_REGISTRY_SCHEMA_VERSION; } });
 // ---------------------------------------------------------------------------
 // Home registry location (EXPLICIT, INSPECTABLE STATE)
 // ---------------------------------------------------------------------------
@@ -109,16 +83,16 @@ function fingerprintRun(run) {
         `loopStage:${run.loopStage}`,
         `schema:${run.schemaVersion}`
     ];
-    for (const task of [...run.tasks].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const task of [...run.tasks].sort((a, b) => (0, compare_1.compareBytes)(a.id, b.id))) {
         parts.push(`task:${task.id}:${task.status}`);
     }
-    for (const commit of [...run.commits].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const commit of [...run.commits].sort((a, b) => (0, compare_1.compareBytes)(a.id, b.id))) {
         parts.push(`commit:${commit.id}:${commit.verifierGated ? "gated" : "checkpoint"}`);
     }
-    for (const phase of [...run.phases].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const phase of [...run.phases].sort((a, b) => (0, compare_1.compareBytes)(a.id, b.id))) {
         parts.push(`phase:${phase.id}:${phase.status}`);
     }
-    for (const fb of [...(run.feedback || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    for (const fb of [...(run.feedback || [])].sort((a, b) => (0, compare_1.compareBytes)(a.id, b.id))) {
         parts.push(`feedback:${fb.id}:${fb.status}`);
     }
     return fingerprintStrings(parts);
@@ -182,6 +156,8 @@ class RunRegistry {
     repoRegistryDir(repo) {
         return node_path_1.default.join(repo, ".cw", "registry");
     }
+    // Public so the carved queue cluster (run-registry/queue.ts) can resolve the
+    // home-registry dir without reaching into private state (QueueHost).
     homeRegistryDir() {
         return node_path_1.default.join(this.homeRoot, "registry");
     }
@@ -216,6 +192,11 @@ class RunRegistry {
             provenance: this.loadProvenanceOverlay(repo)
         };
     }
+    /** Default queue priority from POLICY (QueueHost). Exposed so the carved queue
+     *  cluster never re-derives policy. */
+    get defaultQueuePriority() {
+        return policy_1.DEFAULT_RUN_REGISTRY_POLICY.defaultQueuePriority;
+    }
     // ---- home registry files ------------------------------------------------
     reposFilePath() {
         return node_path_1.default.join(this.homeRegistryDir(), "repos.json");
@@ -252,28 +233,17 @@ class RunRegistry {
             const already = current.repos.some((entry) => node_path_1.default.resolve(entry.root) === resolved);
             if (!already)
                 current.repos.push({ root: resolved, addedAt: new Date().toISOString() });
-            current.repos.sort((a, b) => a.root.localeCompare(b.root));
+            current.repos.sort((a, b) => (0, compare_1.compareBytes)(a.root, b.root));
             (0, state_1.writeJson)(file, current, { durable: true });
             return { registered: !already, repos: current.repos.map((entry) => entry.root) };
         });
     }
-    queueFilePath() {
-        return node_path_1.default.join(this.homeRegistryDir(), "queue.json");
-    }
+    // Queue file helpers + queueAdd/List/Show/Drain now live in ./run-registry/queue
+    // (FreeBSD-audit R2 deep). These remain as thin delegators; `this` satisfies the
+    // QueueHost contract structurally (repoRoot, defaultQueuePriority,
+    // homeRegistryDir, registerRepo).
     loadQueue() {
-        const file = this.queueFilePath();
-        if (!node_fs_1.default.existsSync(file))
-            return [];
-        try {
-            const parsed = (0, state_1.readJson)(file);
-            return Array.isArray(parsed.entries) ? parsed.entries : [];
-        }
-        catch {
-            return [];
-        }
-    }
-    saveQueue(entries) {
-        (0, state_1.writeJson)(this.queueFilePath(), { schemaVersion: 1, entries }, { durable: true });
+        return (0, queue_1.loadQueue)(this);
     }
     // Public queue accessors for the v0.1.37 control-plane scheduler (it operates ON
     // this queue store via pure functions in scheduling.ts; the queue file is never
@@ -283,7 +253,7 @@ class RunRegistry {
         return this.loadQueue();
     }
     saveQueueEntries(entries) {
-        this.saveQueue(entries);
+        (0, queue_1.saveQueue)(this, entries);
     }
     schedulingPolicyPath() {
         return node_path_1.default.join(this.homeRegistryDir(), "scheduling-policy.json");
@@ -313,7 +283,7 @@ class RunRegistry {
         // Run Retention & Provable Reclamation (v0.1.39): the per-run reclaimed.json
         // overlay (if any) raises the disk-tier above `archived` and downgrades the
         // capability. Derived from source, never invented.
-        const reclaim = loadReclaimedFromDir(runDir);
+        const reclaim = (0, derive_1.loadReclaimedFromDir)(runDir);
         const lastTombstone = reclaim.tombstones[reclaim.tombstones.length - 1];
         const tier = lastTombstone ? "reclaimed" : archive ? "archived" : "live";
         const capability = lastTombstone ? lastTombstone.capability : "re-runnable";
@@ -356,8 +326,8 @@ class RunRegistry {
             commitCount: (run.commits || []).length,
             verifierGatedCommitCount: li.verifierGatedCommits,
             openFeedbackCount: li.openFeedback,
-            backends: distinctBackends(run),
-            inputsDigest: digestInputs(run.inputs),
+            backends: (0, derive_1.distinctBackends)(run),
+            inputsDigest: (0, derive_1.digestInputs)(run.inputs),
             sourceFingerprint: fingerprintRun(run),
             freshness: "valid",
             provenance
@@ -379,7 +349,7 @@ class RunRegistry {
             if (record)
                 records.push(record);
         }
-        return records.sort(compareRecords);
+        return records.sort(derive_1.compareRecords);
     }
     // ---- index construction (current truth) ---------------------------------
     /** Build the CURRENT index fresh from source for the requested scope. This is
@@ -389,7 +359,7 @@ class RunRegistry {
         const records = [];
         for (const repo of repos)
             records.push(...this.scanRepo(repo));
-        records.sort(compareRecords);
+        records.sort(derive_1.compareRecords);
         const queue = scope === "home" ? this.loadQueue() : this.loadQueue().filter((q) => node_path_1.default.resolve(q.repo) === this.repoRoot);
         const sourceFingerprint = fingerprintStrings([
             ...repos.map((r) => `repo:${r}`),
@@ -404,7 +374,7 @@ class RunRegistry {
             repos,
             records,
             queue,
-            counts: countRecords(records)
+            counts: (0, derive_1.countRecords)(records)
         };
     }
     persistedIndexPath(scope) {
@@ -496,20 +466,20 @@ class RunRegistry {
         const index = this.buildIndex(scope);
         const report = this.report(scope, index);
         const query = {
-            text: optionalLower(raw.text),
-            app: optionalLower(raw.app),
+            text: (0, derive_1.optionalLower)(raw.text),
+            app: (0, derive_1.optionalLower)(raw.app),
             status: raw.status,
             repo: raw.repo ? node_path_1.default.resolve(raw.repo) : undefined,
             since: raw.since,
             until: raw.until,
             includeArchived: raw.includeArchived ?? true,
-            offset: clampInt(raw.offset, 0, 0),
-            limit: clampInt(raw.limit, 50, 1)
+            offset: (0, derive_1.clampInt)(raw.offset, 0, 0),
+            limit: (0, derive_1.clampInt)(raw.limit, 50, 1)
         };
-        let records = index.records.filter((record) => matchesQuery(record, query));
+        let records = index.records.filter((record) => (0, derive_1.matchesQuery)(record, query));
         if (!query.includeArchived)
             records = records.filter((record) => !record.archived);
-        records.sort(compareRecords);
+        records.sort(derive_1.compareRecords);
         const total = records.length;
         const page = records.slice(query.offset, query.offset + query.limit);
         return {
@@ -568,6 +538,8 @@ class RunRegistry {
             nextAction: "node scripts/cw.js registry refresh" + (scope === "home" ? " --scope home" : "")
         };
     }
+    // Public so the carved gc cluster (run-registry/gc.ts) can resolve a run
+    // repo-first without reaching into private state (GcHost).
     locate(runId, scope) {
         // Current repo first (least astonishment: cwd wins).
         const here = this.deriveRecordForRun(this.repoRoot, runId);
@@ -599,6 +571,8 @@ class RunRegistry {
         }
         return undefined;
     }
+    // Public so the carved gc cluster (run-registry/gc.ts) can load source state
+    // for a resolved run without reaching into private state (GcHost).
     loadRun(repo, runId) {
         const statePath = node_path_1.default.join(this.repoRunsDir(repo), runId, "state.json");
         if (!node_fs_1.default.existsSync(statePath))
@@ -618,7 +592,7 @@ class RunRegistry {
         }
         const record = located.record;
         const run = this.loadRun(record.repo, runId);
-        const limit = clampInt(options.limit, 5, 1);
+        const limit = (0, derive_1.clampInt)(options.limit, 5, 1);
         const nextTasks = (run.tasks || [])
             .filter((t) => t.status === "pending" || t.status === "running")
             .slice(0, limit)
@@ -699,7 +673,7 @@ class RunRegistry {
     /** Apply a retention POLICY: archive eligible runs older than the window. The
      *  window/states are policy inputs, never baked into the index. Returns the set
      *  archived; archives are overlay marks, so nothing is destroyed. */
-    archiveByPolicy(policy = exports.DEFAULT_RUN_REGISTRY_POLICY, options = {}) {
+    archiveByPolicy(policy = policy_1.DEFAULT_RUN_REGISTRY_POLICY, options = {}) {
         const scope = options.scope || "home";
         if (!policy.archiveOlderThanDays || policy.archiveOlderThanDays <= 0) {
             return { policy, archived: [], eligible: 0 };
@@ -720,227 +694,29 @@ class RunRegistry {
     // dry-run (frees nothing); `gc run` executes the write-ahead reclamation
     // transaction (skeleton → tombstone → fsync → free); `gc verify` re-proves a
     // reclaimed run independently. Eligibility is explicit and fail-closed.
+    // Implementations live in ./run-registry/gc (FreeBSD-audit R2 deep); these are
+    // thin delegators preserving the public surface. `this` satisfies GcHost
+    // (buildIndex, locate, loadRun).
     /** Resolve the effective reclamation policy (defaults reclaim NOTHING). */
     reclamationPolicy(overrides = {}) {
-        return { ...exports.DEFAULT_RUN_REGISTRY_POLICY, ...overrides };
-    }
-    /** Fail-closed eligibility: terminal AND archived AND no open feedback AND past
-     *  retention. Returns the matching refusal code, or null when eligible. Reads
-     *  the live-source-derived record; order yields distinct, stable codes. */
-    reclaimEligibility(record, policy, nowMs) {
-        if (record.tier === "reclaimed")
-            return "already-reclaimed";
-        const terminalStates = policy.reclaimStates && policy.reclaimStates.length ? policy.reclaimStates : ["completed", "failed"];
-        if (record.derivedLifecycle !== "completed" && record.derivedLifecycle !== "failed")
-            return "non-terminal";
-        if (!terminalStates.includes(record.derivedLifecycle))
-            return "non-terminal";
-        if (record.openFeedbackCount > 0)
-            return "open-feedback";
-        if (!record.archived)
-            return "not-archived";
-        const days = policy.reclaimAfterArchiveDays ?? 0;
-        if (days > 0) {
-            const archivedAtMs = record.archivedAt ? Date.parse(record.archivedAt) : NaN;
-            if (!Number.isFinite(archivedAtMs))
-                return "within-retention";
-            if (archivedAtMs > nowMs - days * 24 * 60 * 60 * 1000)
-                return "within-retention";
-        }
-        return null;
-    }
-    /** Resolve a single run to a one-element record list via locate() (repo-first),
-     *  avoiding a full-registry scan for single-run gc plan/run. */
-    recordsForRunId(runId, scope) {
-        const located = this.locate(runId, scope);
-        return located ? [located.record] : [];
+        return (0, gc_1.reclamationPolicy)(overrides);
     }
     /** Dry-run: compute eligible runs, per-kind bytes that WOULD be freed, and the
      *  capability downgrade. Frees NOTHING. */
     gcPlan(options = {}) {
-        const scope = options.scope || "home";
-        const policy = this.reclamationPolicy(options.policy);
-        const nowIso = options.now || new Date().toISOString();
-        const nowMs = Date.parse(nowIso);
-        // Fast, deterministic single-run path: resolve just that run via locate()
-        // (repo-first) so a home-scope plan never re-scans the whole registry.
-        const records = options.runId ? this.recordsForRunId(options.runId, scope) : this.buildIndex(scope).records;
-        const entries = [];
-        let bytesToFree = 0;
-        let eligibleCount = 0;
-        for (const record of records) {
-            const refusal = this.reclaimEligibility(record, policy, nowMs);
-            let plan;
-            try {
-                const run = this.loadRun(record.repo, record.runId);
-                plan = (0, reclamation_1.planReclamation)(run, { keepScratch: policy.keepScratch, keepSnapshots: policy.keepSnapshots });
-            }
-            catch {
-                entries.push({
-                    runId: record.runId,
-                    repo: record.repo,
-                    eligible: false,
-                    reason: "unreadable",
-                    tier: record.tier || "live",
-                    capability: record.capability || "re-runnable",
-                    capabilityReason: record.capabilityReason || "live-full",
-                    bytesToFree: 0,
-                    byKind: {},
-                    freeable: []
-                });
-                continue;
-            }
-            const eligible = refusal === null;
-            const entry = {
-                runId: record.runId,
-                repo: record.repo,
-                eligible,
-                reason: eligible ? "eligible" : refusal,
-                tier: record.tier || "live",
-                capability: plan.capability,
-                capabilityReason: plan.capabilityReason,
-                bytesToFree: eligible ? plan.bytesToFree : 0,
-                byKind: eligible ? plan.byKind : {},
-                freeable: eligible ? plan.freeable.map((f) => ({ path: f.path, kind: f.kind, bytes: f.bytes })) : []
-            };
-            entries.push(entry);
-            if (eligible) {
-                eligibleCount += 1;
-                bytesToFree += plan.bytesToFree;
-            }
-        }
-        return {
-            schemaVersion: 1,
-            scope,
-            generatedAt: nowIso,
-            policy: {
-                reclaimAfterArchiveDays: policy.reclaimAfterArchiveDays ?? 0,
-                keepSnapshots: Boolean(policy.keepSnapshots),
-                keepScratch: Boolean(policy.keepScratch),
-                reclaimStates: policy.reclaimStates && policy.reclaimStates.length ? policy.reclaimStates : ["completed", "failed"]
-            },
-            total: entries.length,
-            eligibleCount,
-            bytesToFree,
-            entries,
-            nextAction: eligibleCount ? "node scripts/cw.js gc run" : "node scripts/cw.js run search"
-        };
+        return (0, gc_1.gcPlan)(this, options);
     }
     /** Execute the write-ahead reclamation transaction for eligible runs. Bounded
      *  (`maxReclaimRuns` / `maxReclaimBytes`), fail-closed on any incomplete
      *  skeleton. Produces a tombstone and frees the bulk. */
     gcRun(options = {}) {
-        const scope = options.scope || "home";
-        const policy = this.reclamationPolicy(options.policy);
-        const nowIso = options.now || new Date().toISOString();
-        const nowMs = Date.parse(nowIso);
-        const records = options.runId ? this.recordsForRunId(options.runId, scope) : this.buildIndex(scope).records;
-        const maxRuns = options.limit ?? (policy.maxReclaimRuns || 0);
-        const maxBytes = policy.maxReclaimBytes || 0;
-        const reclaimed = [];
-        const refused = [];
-        let totalBytesFreed = 0;
-        for (const record of records) {
-            const refusal = this.reclaimEligibility(record, policy, nowMs);
-            if (refusal) {
-                refused.push({ runId: record.runId, code: refusal });
-                continue;
-            }
-            if (maxRuns > 0 && reclaimed.length >= maxRuns)
-                break;
-            let run;
-            try {
-                run = this.loadRun(record.repo, record.runId);
-            }
-            catch {
-                refused.push({ runId: record.runId, code: "unreadable" });
-                continue;
-            }
-            try {
-                const result = (0, reclamation_1.runReclamation)(run, {
-                    now: nowIso,
-                    actor: options.actor,
-                    policy: { reclaimAfterArchiveDays: policy.reclaimAfterArchiveDays, keepScratch: policy.keepScratch, keepSnapshots: policy.keepSnapshots },
-                    reclaimPolicy: { keepScratch: policy.keepScratch, keepSnapshots: policy.keepSnapshots }
-                });
-                // No post-free saveCheckpoint: runReclamation now DURABLY persists the
-                // result-node re-point inside the transaction (before any byte is freed),
-                // so state.json can never reference a freed path even on a crash here.
-                reclaimed.push({
-                    runId: record.runId,
-                    bytesFreed: result.bytesFreed,
-                    tombstoneHash: result.tombstone.tombstoneHash,
-                    capability: result.tombstone.capability,
-                    capabilityReason: result.tombstone.capabilityReason
-                });
-                totalBytesFreed += result.bytesFreed;
-                if (maxBytes > 0 && totalBytesFreed >= maxBytes)
-                    break;
-            }
-            catch (error) {
-                if (error instanceof reclamation_1.ReclamationError)
-                    refused.push({ runId: record.runId, code: error.code });
-                else
-                    throw error;
-            }
-        }
-        return {
-            schemaVersion: 1,
-            scope,
-            generatedAt: nowIso,
-            dryRun: false,
-            reclaimed,
-            refused,
-            totalBytesFreed,
-            nextAction: reclaimed.length ? "node scripts/cw.js gc verify <run-id>" : "node scripts/cw.js gc plan"
-        };
+        return (0, gc_1.gcRun)(this, options);
     }
     /** Re-prove a reclaimed run: skeleton schema-complete, tombstone chain
      *  recomputed-and-untampered, each reconstructable artifact re-derived from its
      *  RETAINED inputs to its expectDigest, and eligible-when-reclaimed. */
     gcVerify(runId, options = {}) {
-        const scope = options.scope || "home";
-        const located = this.locate(runId, scope);
-        if (!located) {
-            return {
-                schemaVersion: 1,
-                runId,
-                reclaimed: false,
-                verified: false,
-                tier: "live",
-                capability: "re-runnable",
-                chainLength: 0,
-                checks: [{ name: "located", pass: false, code: "not-reclaimed", detail: "run source not found" }],
-                nextAction: "node scripts/cw.js registry refresh" + (scope === "home" ? " --scope home" : "")
-            };
-        }
-        const run = this.loadRun(located.record.repo, runId);
-        const result = (0, reclamation_1.verifyReclamation)(run);
-        const checks = result.checks.map((c) => ({ name: c.name, pass: c.pass, code: c.code, detail: c.detail }));
-        // Eligible-when-reclaimed: each tombstone must have sealed a terminal verdict.
-        let eligibleWhenReclaimed = result.reclaimed;
-        for (const tombstone of result.tombstones) {
-            const terminal = tombstone.skeleton.finalVerdict?.terminal === true;
-            if (!terminal) {
-                eligibleWhenReclaimed = false;
-                checks.push({ name: `eligible-when-reclaimed:${tombstone.tombstoneId}`, pass: false, code: "ineligible-when-reclaimed", detail: "non-terminal verdict sealed" });
-            }
-        }
-        const last = result.tombstones[result.tombstones.length - 1];
-        const verified = result.verified && eligibleWhenReclaimed;
-        return {
-            schemaVersion: 1,
-            runId,
-            reclaimed: result.reclaimed,
-            verified,
-            tier: located.record.tier || (result.reclaimed ? "reclaimed" : "live"),
-            capability: located.record.capability || "re-runnable",
-            capabilityReason: located.record.capabilityReason,
-            tombstoneHash: last?.tombstoneHash,
-            chainLength: result.tombstones.length,
-            checks,
-            nextAction: verified ? "node scripts/cw.js run show " + runId : "node scripts/cw.js gc plan"
-        };
+        return (0, gc_1.gcVerify)(this, runId, options);
     }
     // ---- rerun (NEW run linked to the original; original preserved) ---------
     rerun(runId, options = {}) {
@@ -992,88 +768,34 @@ class RunRegistry {
         };
     }
     // ---- queue (durable, ordered; drained by the host) ----------------------
+    // Implementations live in ./run-registry/queue (FreeBSD-audit R2 deep); these
+    // are thin delegators preserving the public surface. `this` satisfies QueueHost.
     queueAdd(options = {}) {
-        const repo = options.repo ? node_path_1.default.resolve(options.repo) : this.repoRoot;
-        // Cross-process read-modify-write on the home queue: lock so a concurrently
-        // added task can never vanish (v0.1.40, P1-D).
-        return (0, state_1.withFileLock)(this.queueFilePath(), () => {
-            const entries = this.loadQueue();
-            const entry = {
-                schemaVersion: 1,
-                id: options.id || queueId(),
-                runId: options.runId,
-                appId: options.appId,
-                workflowId: options.workflowId,
-                repo,
-                priority: Number.isFinite(options.priority) ? Number(options.priority) : exports.DEFAULT_RUN_REGISTRY_POLICY.defaultQueuePriority,
-                enqueuedAt: new Date().toISOString(),
-                status: "pending",
-                inputs: options.inputs,
-                note: options.note
-            };
-            entries.push(entry);
-            this.registerRepo(repo);
-            this.saveQueue(entries);
-            return entry;
-        });
+        return (0, queue_1.queueAdd)(this, options);
     }
     queueList(options = {}) {
-        let entries = this.loadQueue();
-        if (options.status)
-            entries = entries.filter((e) => e.status === options.status);
-        if (options.repo) {
-            const repo = node_path_1.default.resolve(options.repo);
-            entries = entries.filter((e) => node_path_1.default.resolve(e.repo) === repo);
-        }
-        entries = [...entries].sort(compareQueue);
-        return { schemaVersion: 1, total: entries.length, entries };
+        return (0, queue_1.queueList)(this, options);
     }
     queueShow(id) {
-        const entry = this.loadQueue().find((e) => e.id === id);
-        if (!entry)
-            throw new Error(`Queue entry not found: ${id}`);
-        return entry;
+        return (0, queue_1.queueShow)(this, id);
     }
-    /** Drain the next N ready/pending entries in policy order, marking them drained.
-     *  CW records readiness/order; the HOST still executes the workers. */
     queueDrain(options = {}) {
-        const limit = clampInt(options.limit, 1, 1);
-        const repoFilter = options.repo ? node_path_1.default.resolve(options.repo) : undefined;
-        // Lock the drain RMW so two hosts can never double-drain the same entry
-        // (v0.1.40, P1-D — the scheduling kernel's concurrency ceiling now holds
-        // across processes, not just within one).
-        return (0, state_1.withFileLock)(this.queueFilePath(), () => {
-            const entries = this.loadQueue();
-            const drainable = entries
-                .filter((e) => e.status === "pending" || e.status === "ready")
-                .filter((e) => !repoFilter || node_path_1.default.resolve(e.repo) === repoFilter)
-                .sort(compareQueue);
-            const drained = [];
-            const drainedAt = new Date().toISOString();
-            for (const entry of drainable.slice(0, limit)) {
-                entry.status = "drained";
-                entry.drainedAt = drainedAt;
-                drained.push(entry);
-            }
-            this.saveQueue(entries);
-            const remaining = entries.filter((e) => e.status === "pending" || e.status === "ready").length;
-            return { schemaVersion: 1, drained, remaining };
-        });
+        return (0, queue_1.queueDrain)(this, options);
     }
     // ---- cross-repo history (unified timeline) ------------------------------
     history(options = {}) {
         const scope = options.scope || "home";
         const index = this.buildIndex(scope);
         const report = this.report(scope, index);
-        const app = optionalLower(options.app);
-        const limit = clampInt(options.limit, 50, 1);
-        const offset = clampInt(options.offset, 0, 0);
+        const app = (0, derive_1.optionalLower)(options.app);
+        const limit = (0, derive_1.clampInt)(options.limit, 50, 1);
+        const offset = (0, derive_1.clampInt)(options.offset, 0, 0);
         let records = index.records;
         if (app)
             records = records.filter((r) => (r.appId || r.workflowId || "").toLowerCase().includes(app));
         if (options.status)
             records = records.filter((r) => r.lifecycle === options.status || r.derivedLifecycle === options.status);
-        const ordered = [...records].sort(compareHistory);
+        const ordered = [...records].sort(derive_1.compareHistory);
         const total = ordered.length;
         const page = ordered.slice(offset, offset + limit);
         const entries = page.map((r) => ({
@@ -1102,253 +824,16 @@ class RunRegistry {
     }
 }
 exports.RunRegistry = RunRegistry;
-// ---------------------------------------------------------------------------
-// pure helpers
-// ---------------------------------------------------------------------------
-function compareRecords(a, b) {
-    if (a.createdAt !== b.createdAt)
-        return a.createdAt < b.createdAt ? -1 : 1;
-    return a.runId.localeCompare(b.runId);
-}
-function compareHistory(a, b) {
-    // Newest first.
-    if (a.createdAt !== b.createdAt)
-        return a.createdAt < b.createdAt ? 1 : -1;
-    return a.runId.localeCompare(b.runId);
-}
-function compareQueue(a, b) {
-    if (a.priority !== b.priority)
-        return a.priority - b.priority;
-    if (a.enqueuedAt !== b.enqueuedAt)
-        return a.enqueuedAt < b.enqueuedAt ? -1 : 1;
-    return a.id.localeCompare(b.id);
-}
-function matchesQuery(record, query) {
-    if (query.app && !(record.appId || record.workflowId || "").toLowerCase().includes(query.app))
-        return false;
-    if (query.status && record.lifecycle !== query.status && record.derivedLifecycle !== query.status)
-        return false;
-    if (query.repo && node_path_1.default.resolve(record.repo) !== query.repo)
-        return false;
-    if (query.since && record.createdAt < query.since)
-        return false;
-    if (query.until && record.createdAt > query.until)
-        return false;
-    if (query.text) {
-        const haystack = [
-            record.runId,
-            record.appId,
-            record.workflowId,
-            record.title,
-            record.repo,
-            record.lifecycle,
-            record.loopStage,
-            record.inputsDigest
-        ]
-            .filter(Boolean)
-            .join(" ")
-            .toLowerCase();
-        if (!haystack.includes(query.text))
-            return false;
-    }
-    return true;
-}
-/** Bounded, deterministic stringification of run inputs for free-text search.
- *  Descriptive intent keys (question, prompt, ...) come first so they survive
- *  truncation; the rest follow alphabetically. Deterministic and compact. */
-const DIGEST_PRIORITY_KEYS = ["question", "prompt", "task", "summary", "title", "objective", "focus", "topic"];
-/** Distinct execution backends used by a run's dispatches/tasks, recomputed from
- *  source state. Sorted; empty for pre-v0.1.29 / default-only runs that never
- *  recorded a backend. The registry stays backend-agnostic — this is metadata. */
-function distinctBackends(run) {
-    const backends = new Set();
-    for (const dispatch of run.dispatches || []) {
-        if (dispatch.backendId)
-            backends.add(dispatch.backendId);
-    }
-    for (const task of run.tasks || []) {
-        if (task.backendId)
-            backends.add(task.backendId);
-    }
-    return [...backends].sort();
-}
-function digestInputs(inputs) {
-    if (!inputs || typeof inputs !== "object")
-        return undefined;
-    const keys = Object.keys(inputs);
-    const ordered = [
-        ...DIGEST_PRIORITY_KEYS.filter((k) => keys.includes(k)),
-        ...keys.filter((k) => !DIGEST_PRIORITY_KEYS.includes(k)).sort()
-    ];
-    const parts = [];
-    for (const key of ordered) {
-        const value = inputs[key];
-        if (value === undefined || value === null)
-            continue;
-        const rendered = Array.isArray(value) ? value.join(",") : typeof value === "object" ? JSON.stringify(value) : String(value);
-        parts.push(`${key}=${rendered}`);
-    }
-    const joined = parts.join(" ").replace(/\s+/g, " ").trim();
-    return joined.length > 360 ? `${joined.slice(0, 357)}...` : joined;
-}
-function countRecords(records) {
-    const counts = {
-        total: records.length,
-        queued: 0,
-        running: 0,
-        blocked: 0,
-        completed: 0,
-        failed: 0,
-        archived: 0,
-        reclaimed: 0
-    };
-    for (const record of records) {
-        counts[record.lifecycle] = (counts[record.lifecycle] || 0) + 1;
-    }
-    return counts;
-}
-function optionalLower(value) {
-    if (value === undefined || value === null || value === "")
-        return undefined;
-    return String(value).toLowerCase();
-}
-function clampInt(value, fallback, min) {
-    const n = Number(value);
-    if (!Number.isFinite(n))
-        return fallback;
-    return Math.max(min, Math.floor(n));
-}
-let queueCounter = 0;
-function queueId() {
-    queueCounter += 1;
-    const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
-    return `q-${stamp}-${String(queueCounter).padStart(3, "0")}`;
-}
-function isRunLifecycleState(value) {
-    return typeof value === "string" && LIFECYCLE_STATES.includes(value);
-}
-/** Read a run dir's `reclaimed.json` overlay (v0.1.39). Fail-closed to an empty
- *  chain on absence/corruption — a malformed overlay must never brick the run. */
-function loadReclaimedFromDir(runDir) {
-    const file = node_path_1.default.join(runDir, "reclaimed.json");
-    if (!node_fs_1.default.existsSync(file))
-        return { schemaVersion: 1, runId: "", tombstones: [] };
-    try {
-        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
-        return { schemaVersion: 1, runId: parsed.runId || "", tombstones: Array.isArray(parsed.tombstones) ? parsed.tombstones : [] };
-    }
-    catch {
-        return { schemaVersion: 1, runId: "", tombstones: [] };
-    }
-}
-// ---------------------------------------------------------------------------
-// Human formatting (CLI-only; never affects --json / MCP payloads)
-// ---------------------------------------------------------------------------
-function countsLine(counts) {
-    return `total=${counts.total} queued=${counts.queued} running=${counts.running} blocked=${counts.blocked} completed=${counts.completed} failed=${counts.failed} archived=${counts.archived} reclaimed=${counts.reclaimed}`;
-}
-function recordLine(record) {
-    const flags = [record.archived ? "archived" : "", record.provenance?.rerunOf ? `rerunOf=${record.provenance.rerunOf}` : ""].filter(Boolean).join(" ");
-    return `  [${record.lifecycle}] ${record.runId} (${record.appId || record.workflowId}) ${record.loopStage}${flags ? ` {${flags}}` : ""}`;
-}
-function formatRegistryReport(report) {
-    const lines = [];
-    lines.push(`Run Registry (${report.scope}): ${report.root}`);
-    lines.push(`Freshness: ${report.freshness.status}${report.freshness.staleRuns.length ? ` (stale: ${report.freshness.staleRuns.join(", ")})` : ""}${report.freshness.missingRuns.length ? ` (missing: ${report.freshness.missingRuns.join(", ")})` : ""}`);
-    lines.push(`Repos: ${report.index.repos.length}`);
-    lines.push(countsLine(report.counts));
-    if (report.freshness.status !== "valid")
-        lines.push(`Next Action: ${report.nextAction}`);
-    return lines.join("\n");
-}
-function formatRunSearch(result) {
-    const lines = [];
-    lines.push(`Run Search (${result.scope}): ${result.total} match(es), showing ${result.records.length} [offset ${result.offset}] freshness=${result.freshness}`);
-    for (const record of result.records)
-        lines.push(recordLine(record));
-    if (!result.records.length)
-        lines.push("  (no matching runs)");
-    return lines.join("\n");
-}
-function formatRunShow(result) {
-    if (!result.found) {
-        return `Run ${result.runId}: MISSING (source state.json absent — fail closed). Next: ${result.nextAction}`;
-    }
-    const r = result.record;
-    const lines = [
-        `Run ${r.runId} [${r.lifecycle}] (derived: ${r.derivedLifecycle})`,
-        `  app=${r.appId || r.workflowId} loopStage=${r.loopStage} repo=${r.repo}`,
-        `  tasks: total=${r.tasks.total} pending=${r.tasks.pending} running=${r.tasks.running} failed=${r.tasks.failed} completed=${r.tasks.completed}`,
-        `  commits=${r.commitCount} (verifier-gated=${r.verifierGatedCommitCount}) openFeedback=${r.openFeedbackCount}`
-    ];
-    if (r.provenance?.rerunOf)
-        lines.push(`  provenance: rerunOf=${r.provenance.rerunOf} gen=${r.provenance.generation} origin=${r.provenance.originRunId}`);
-    if (r.tier && r.tier !== "live") {
-        lines.push(`  tier=${r.tier} capability=${r.capability} reason=${r.capabilityReason}${r.reclaimedBytes ? ` bytesFreed=${r.reclaimedBytes}` : ""}${r.tombstoneHash ? ` tombstone=${r.tombstoneHash.slice(0, 19)}` : ""}`);
-    }
-    return lines.join("\n");
-}
-function formatGcPlan(result) {
-    const lines = [
-        `GC Plan (${result.scope}): ${result.eligibleCount}/${result.total} eligible, ${result.bytesToFree} byte(s) would be freed [DRY-RUN, frees nothing]`,
-        `  policy: reclaimAfterArchiveDays=${result.policy.reclaimAfterArchiveDays} keepScratch=${result.policy.keepScratch} keepSnapshots=${result.policy.keepSnapshots}`
-    ];
-    for (const entry of result.entries) {
-        if (entry.eligible) {
-            const kinds = Object.entries(entry.byKind).map(([k, v]) => `${k}=${v}`).join(" ");
-            lines.push(`  [eligible] ${entry.runId} -> ${entry.capability} (${entry.capabilityReason}) ${entry.bytesToFree}B {${kinds}}`);
-        }
-        else {
-            lines.push(`  [skip:${entry.reason}] ${entry.runId} (tier=${entry.tier})`);
-        }
-    }
-    if (!result.entries.length)
-        lines.push("  (no runs in scope)");
-    return lines.join("\n");
-}
-function formatGcRun(result) {
-    const lines = [`GC Run (${result.scope}): reclaimed ${result.reclaimed.length} run(s), freed ${result.totalBytesFreed} byte(s)`];
-    for (const r of result.reclaimed)
-        lines.push(`  [reclaimed] ${r.runId} -> ${r.capability} (${r.capabilityReason}) ${r.bytesFreed}B tombstone=${r.tombstoneHash.slice(0, 19)}`);
-    for (const r of result.refused)
-        lines.push(`  [refused:${r.code}] ${r.runId}`);
-    if (!result.reclaimed.length && !result.refused.length)
-        lines.push("  (nothing eligible)");
-    return lines.join("\n");
-}
-function formatGcVerify(result) {
-    const lines = [
-        `GC Verify ${result.runId}: reclaimed=${result.reclaimed} verified=${result.verified} tier=${result.tier} capability=${result.capability}${result.tombstoneHash ? ` tombstone=${result.tombstoneHash.slice(0, 19)}` : ""}`
-    ];
-    for (const check of result.checks)
-        lines.push(`  ${check.pass ? "PASS" : "FAIL"} ${check.name}${check.code ? ` [${check.code}]` : ""}${check.detail ? ` (${check.detail})` : ""}`);
-    return lines.join("\n");
-}
-function formatResume(result) {
-    const lines = [
-        `Resume ${result.runId} [${result.lifecycle}] loopStage=${result.loopStage} (resolved from ${result.resolvedFrom}, ${result.freshness})`,
-        `  resumable=${result.resumable} nextTasks=${result.nextTasks.length}`
-    ];
-    for (const action of result.nextActions)
-        lines.push(`  -> ${action.command}\n     ${action.reason}`);
-    return lines.join("\n");
-}
-function formatHistory(result) {
-    const lines = [];
-    lines.push(`Run History (${result.scope}): ${result.total} run(s) across ${result.repos.length} repo(s), freshness=${result.freshness}`);
-    for (const entry of result.entries) {
-        lines.push(`  ${entry.createdAt} [${entry.lifecycle}] ${entry.runId} (${entry.appId || entry.workflowId})${entry.provenance?.rerunOf ? ` rerunOf=${entry.provenance.rerunOf}` : ""}`);
-    }
-    if (!result.entries.length)
-        lines.push("  (no runs)");
-    return lines.join("\n");
-}
-function formatQueueList(result) {
-    const lines = [`Run Queue: ${result.total} entry(ies) [priority asc]`];
-    for (const entry of result.entries) {
-        lines.push(`  #${entry.priority} ${entry.id} [${entry.status}] ${entry.appId || entry.workflowId || entry.runId || "?"} repo=${entry.repo}${entry.note ? ` note=${entry.note}` : ""}`);
-    }
-    if (!result.entries.length)
-        lines.push("  (queue empty)");
-    return lines.join("\n");
-}
+// Human formatting (CLI-only) now lives in ./run-registry/format.ts (FreeBSD-
+// audit R2: rendering carved out of the registry class). Re-exported so that
+// importers of "./run-registry" see an unchanged surface.
+var format_1 = require("./run-registry/format");
+Object.defineProperty(exports, "formatRegistryReport", { enumerable: true, get: function () { return format_1.formatRegistryReport; } });
+Object.defineProperty(exports, "formatRunSearch", { enumerable: true, get: function () { return format_1.formatRunSearch; } });
+Object.defineProperty(exports, "formatRunShow", { enumerable: true, get: function () { return format_1.formatRunShow; } });
+Object.defineProperty(exports, "formatGcPlan", { enumerable: true, get: function () { return format_1.formatGcPlan; } });
+Object.defineProperty(exports, "formatGcRun", { enumerable: true, get: function () { return format_1.formatGcRun; } });
+Object.defineProperty(exports, "formatGcVerify", { enumerable: true, get: function () { return format_1.formatGcVerify; } });
+Object.defineProperty(exports, "formatResume", { enumerable: true, get: function () { return format_1.formatResume; } });
+Object.defineProperty(exports, "formatHistory", { enumerable: true, get: function () { return format_1.formatHistory; } });
+Object.defineProperty(exports, "formatQueueList", { enumerable: true, get: function () { return format_1.formatQueueList; } });