@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/projection/tell/launch-store.js

@@ -0,0 +1,244 @@
+import { ProjectionStateError } from "../../atomic-publish.js";
+import { withRead, withWrite } from "./database.js";
+import { parseFence, requireExecutionId, submittedFromRow } from "./model.js";
+function selectTell(database, tellId) {
+    return database.prepare(`
+    SELECT tell_id, text, created_at, effort, state, execution_id, fence_json, replayed_from_json
+    FROM projection_tells WHERE tell_id = ?
+  `).get(tellId);
+}
+export function claimFencedTells(projectionDirectory, fence, executionId) {
+    const owner = requireExecutionId(executionId);
+    return withWrite(projectionDirectory, (database) => {
+        const claimed = [];
+        const seen = new Set();
+        for (const tellId of fence) {
+            if (seen.has(tellId))
+                throw new ProjectionStateError(`duplicate tell in generation fence: ${tellId}`);
+            seen.add(tellId);
+            const row = selectTell(database, tellId);
+            if (!row)
+                throw new ProjectionStateError(`generation tell fence member is missing: ${tellId}`);
+            if (row.state === "inbox") {
+                database.prepare(`
+          UPDATE projection_tells
+          SET state = 'inflight'
+          WHERE tell_id = ? AND state = 'inbox'
+        `).run(tellId);
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state === "inflight") {
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state === "submitted" || row.state === "seen") {
+                const submitted = submittedFromRow(row);
+                if (submitted.executionId === owner) {
+                    throw new ProjectionStateError(`submitted tell belongs to current execution: ${tellId}`);
+                }
+                const replayedFrom = [
+                    ...(submitted.replayedFrom ?? []),
+                    { executionId: submitted.executionId, fence: submitted.fence },
+                ];
+                const result = database.prepare(`
+          UPDATE projection_tells
+          SET
+            state = 'inflight',
+            execution_id = NULL,
+            fence_json = NULL,
+            replayed_from_json = ?
+          WHERE tell_id = ? AND state = ?
+        `).run(JSON.stringify(replayedFrom), tellId, row.state);
+                if (Number(result.changes) !== 1) {
+                    throw new ProjectionStateError(`generation tell fence member changed while claiming: ${tellId}`);
+                }
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state === "consumed" && row.execution_id === owner)
+                continue;
+            throw new ProjectionStateError(`generation tell fence member is not claimable: ${tellId}`);
+        }
+        return claimed;
+    });
+}
+/**
+ * The generation launch reducer: one heart transaction validates the frozen
+ * fence, claims exactly its non-consumed members, and establishes the matching
+ * immutable reservation before any provider can start.
+ */
+export function claimAndReserveFencedTells(projectionDirectory, fence, executionId) {
+    const owner = requireExecutionId(executionId);
+    return withWrite(projectionDirectory, (database) => {
+        const seen = new Set();
+        for (const tellId of fence) {
+            if (seen.has(tellId))
+                throw new ProjectionStateError(`duplicate tell in generation fence: ${tellId}`);
+            seen.add(tellId);
+        }
+        const existing = database.prepare(`
+      SELECT tell_id FROM projection_tell_launch_batches
+      WHERE execution_id = ? ORDER BY tell_id
+    `).all(owner);
+        const reservationExists = database.prepare(`
+      SELECT 1 FROM projection_tell_launch_admissions WHERE execution_id = ?
+    `).get(owner) !== undefined;
+        if (reservationExists) {
+            const requested = [...seen].sort();
+            const reserved = existing.map((row) => row.tell_id);
+            if (reserved.length !== requested.length || reserved.some((tellId, index) => tellId !== requested[index])) {
+                throw new ProjectionStateError(`launch batch conflict for execution '${owner}'`);
+            }
+            // A retry is an insert-or-verify of immutable membership. Receipt stages
+            // may already have advanced, so it must not re-run claim validation.
+            return reserved;
+        }
+        const claimed = [];
+        for (const tellId of fence) {
+            const row = selectTell(database, tellId);
+            if (!row)
+                throw new ProjectionStateError(`generation tell fence member is missing: ${tellId}`);
+            if (row.state === "inbox") {
+                database.prepare(`UPDATE projection_tells SET state = 'inflight' WHERE tell_id = ? AND state = 'inbox'`).run(tellId);
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state === "inflight") {
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state === "submitted" || row.state === "seen") {
+                const submitted = submittedFromRow(row);
+                if (submitted.executionId === owner)
+                    throw new ProjectionStateError(`submitted tell belongs to current execution: ${tellId}`);
+                const replayedFrom = [...(submitted.replayedFrom ?? []), { executionId: submitted.executionId, fence: submitted.fence }];
+                const result = database.prepare(`
+          UPDATE projection_tells
+          SET state = 'inflight', execution_id = NULL, fence_json = NULL, replayed_from_json = ?
+          WHERE tell_id = ? AND state = ?
+        `).run(JSON.stringify(replayedFrom), tellId, row.state);
+                if (Number(result.changes) !== 1)
+                    throw new ProjectionStateError(`generation tell fence member changed while claiming: ${tellId}`);
+                claimed.push(tellId);
+                continue;
+            }
+            if (row.state !== "consumed" || row.execution_id !== owner) {
+                throw new ProjectionStateError(`generation tell fence member is not claimable: ${tellId}`);
+            }
+        }
+        database.prepare(`INSERT INTO projection_tell_launch_admissions (execution_id) VALUES (?)`).run(owner);
+        for (const tellId of claimed) {
+            database.prepare(`INSERT INTO projection_tell_launch_batches (execution_id, tell_id) VALUES (?, ?)`).run(owner, tellId);
+        }
+        return claimed;
+    });
+}
+/**
+ * Atomically bind an adapter-owned native coordinate to a pre-existing launch
+ * reservation. Heart never derives a coordinate from later activity.
+ */
+export function bindTellLaunchReservation(projectionDirectory, admission) {
+    const executionId = requireExecutionId(admission.executionId);
+    const fence = parseFence(admission.fence);
+    withWrite(projectionDirectory, (database) => {
+        const unique = new Set();
+        for (const tellId of admission.tellIds) {
+            if (unique.has(tellId))
+                throw new ProjectionStateError(`duplicate tell in launch batch: ${tellId}`);
+            unique.add(tellId);
+        }
+        const established = database.prepare(`
+      SELECT 1 FROM projection_tell_launch_admissions WHERE execution_id = ?
+    `).get(executionId) !== undefined;
+        const existing = database.prepare(`
+      SELECT tell_id FROM projection_tell_launch_batches
+      WHERE execution_id = ? ORDER BY tell_id
+    `).all(executionId);
+        const requested = [...unique].sort();
+        if (!established) {
+            throw new ProjectionStateError(`launch admission has no reservation for execution '${executionId}'`);
+        }
+        const admitted = existing.map((row) => row.tell_id);
+        if (admitted.length !== requested.length || admitted.some((tellId, index) => tellId !== requested[index])) {
+            throw new ProjectionStateError(`launch batch conflict for execution '${executionId}'`);
+        }
+        database.prepare(`
+      INSERT INTO projection_tell_launch_coordinates (execution_id, fence_json)
+      VALUES (?, ?)
+      ON CONFLICT(execution_id, fence_json) DO NOTHING
+    `).run(executionId, JSON.stringify(fence));
+        for (const tellId of unique) {
+            const row = selectTell(database, tellId);
+            if (!row)
+                throw new ProjectionStateError(`tell '${tellId}' does not exist`);
+            if (row.state === "inflight") {
+                database.prepare(`
+          UPDATE projection_tells SET state = 'submitted', execution_id = ?, fence_json = ?
+          WHERE tell_id = ? AND state = 'inflight'
+        `).run(executionId, JSON.stringify(fence), tellId);
+            }
+            else if (row.execution_id !== executionId || !["submitted", "seen", "consumed"].includes(row.state)) {
+                throw new ProjectionStateError(`launch batch tell changed while admitting: ${tellId}`);
+            }
+        }
+    });
+}
+export function listTellLaunchBatch(projectionDirectory, executionId) {
+    const owner = requireExecutionId(executionId);
+    return withRead(projectionDirectory, (database) => database.prepare(`
+      SELECT tell_id FROM projection_tell_launch_batches
+      WHERE execution_id = ?
+      ORDER BY tell_id
+    `).all(owner).map((row) => row.tell_id));
+}
+export function listTellLaunchAdmissions(projectionDirectory, executionId) {
+    const owner = requireExecutionId(executionId);
+    return withRead(projectionDirectory, (database) => {
+        const tells = database.prepare(`
+      SELECT tell_id FROM projection_tell_launch_batches
+      WHERE execution_id = ? ORDER BY tell_id
+    `).all(owner);
+        return database.prepare(`
+      SELECT fence_json FROM projection_tell_launch_coordinates
+      WHERE execution_id = ? ORDER BY fence_json
+    `).all(owner).map((row) => ({
+            fence: parseFence(JSON.parse(row.fence_json)),
+            tellIds: tells.map((tell) => tell.tell_id),
+        }));
+    });
+}
+export function isTellLaunchAdmissionMember(projectionDirectory, executionId, tellId) {
+    const owner = requireExecutionId(executionId);
+    return withRead(projectionDirectory, (database) => database.prepare(`
+    SELECT 1 FROM projection_tell_launch_batches
+    WHERE execution_id = ? AND tell_id = ?
+  `).get(owner, tellId) !== undefined);
+}
+export function markTellSubmitted(projectionDirectory, tellId, fields) {
+    const executionId = requireExecutionId(fields.executionId);
+    const fence = parseFence(fields.fence);
+    const replayedFrom = (fields.replayedFrom ?? []).map((entry) => ({
+        executionId: requireExecutionId(entry.executionId),
+        fence: parseFence(entry.fence),
+    }));
+    withWrite(projectionDirectory, (database) => {
+        const row = selectTell(database, tellId);
+        if (!row)
+            throw new ProjectionStateError(`tell '${tellId}' does not exist`);
+        if (row.state === "submitted")
+            return;
+        if (row.state !== "inflight") {
+            throw new ProjectionStateError(`tell '${tellId}' is not inflight`);
+        }
+        database.prepare(`
+      UPDATE projection_tells
+      SET
+        state = 'submitted',
+        execution_id = ?,
+        fence_json = ?,
+        replayed_from_json = COALESCE(?, replayed_from_json)
+      WHERE tell_id = ? AND state = 'inflight'
+    `).run(executionId, JSON.stringify(fence), replayedFrom.length > 0 ? JSON.stringify(replayedFrom) : null, tellId);
+    });
+}

package/build/core/projection/tell/model.js

@@ -3,10 +3,10 @@ export const PROJECTION_TELL_STATES = [
     "inbox",
     "inflight",
     "submitted",
+    "seen",
     "consumed",
-    "delivered",
 ];
-export const PENDING_PROJECTION_TELL_STATES = ["inbox", "inflight", "submitted"];
+export const PENDING_PROJECTION_TELL_STATES = ["inbox", "inflight", "submitted", "seen"];
 export function requireExecutionId(value) {
     if (typeof value !== "string" || value.trim() === "") {
         throw new ProjectionStateError("submitted tell executionId must be a non-empty string");
@@ -63,7 +63,7 @@ export function originalFromRow(row) {
     };
 }
 export function submittedFromRow(row) {
-    if (row.state !== "submitted" && row.state !== "consumed" && row.state !== "delivered") {
+    if (row.state !== "submitted" && row.state !== "seen" && row.state !== "consumed") {
         throw new ProjectionStateError(`tell '${row.tell_id}' is not submitted`);
     }
     if (row.execution_id === null || row.fence_json === null) {

package/build/core/projection/tell/store.js

@@ -1,6 +1,7 @@
 import { ProjectionStateError, randomHex8 } from "../../atomic-publish.js";
 import { withRead, withReadSnapshot, withWrite } from "./database.js";
 import { assertTellIdRandomHex, originalFromRow, PENDING_PROJECTION_TELL_STATES, parseFence, requireExecutionId, submittedFromRow, } from "./model.js";
+export { bindTellLaunchReservation, claimAndReserveFencedTells, claimFencedTells, isTellLaunchAdmissionMember, listTellLaunchAdmissions, listTellLaunchBatch, markTellSubmitted, } from "./launch-store.js";
 function selectTell(database, tellId) {
     return database.prepare(`
     SELECT
@@ -11,8 +12,7 @@ function selectTell(database, tellId) {
       state,
       execution_id,
       fence_json,
-      replayed_from_json,
-      delivered_at
+      replayed_from_json
     FROM projection_tells
     WHERE tell_id = ?
   `).get(tellId);
@@ -62,40 +62,13 @@ export function readPendingTellWindowFromDatabase(database, limit) {
     LIMIT ?
   `).all(...PENDING_PROJECTION_TELL_STATES, limit);
     return {
-        totals: { undelivered: Number(total.count) },
+        totals: { pending: Number(total.count) },
         window: rows.map((row) => ({ tellId: row.tell_id, text: row.text, createdAt: row.created_at, state: row.state })),
     };
 }
 export function readPendingTellWindow(projectionDirectory, limit) {
     return withReadSnapshot(projectionDirectory, (database) => readPendingTellWindowFromDatabase(database, limit));
 }
-/** Whether a failed successor fence still retains delivered mail for replay. */
-export function hasRetainedDeliveredTellFromDatabase(database, retainedFence) {
-    if (retainedFence.length === 0)
-        return false;
-    const statement = database.prepare(`
-    SELECT 1
-    FROM projection_tells
-    WHERE tell_id = ? AND state = 'delivered'
-    LIMIT 1
-  `);
-    return retainedFence.some((tellId) => statement.get(tellId) !== undefined);
-}
-export function hasRetainedDeliveredTell(projectionDirectory, retainedFence) {
-    return withRead(projectionDirectory, (database) => hasRetainedDeliveredTellFromDatabase(database, retainedFence));
-}
-/** Whether interrupted replay has any delivered tell left to return to inbox. */
-export function hasDeliveredTellFromDatabase(database, executionId) {
-    return database.prepare(`
-    SELECT 1
-    FROM projection_tells
-    WHERE state = 'delivered' AND execution_id = ?
-    LIMIT 1
-  `).get(executionId) !== undefined;
-}
-export function hasDeliveredTell(projectionDirectory, executionId) {
-    return withRead(projectionDirectory, (database) => hasDeliveredTellFromDatabase(database, executionId));
-}
 export function readTellOriginal(projectionDirectory, state, tellId) {
     return withRead(projectionDirectory, (database) => {
         const row = selectTell(database, tellId);
@@ -160,100 +133,79 @@ export function claimAllInbox(projectionDirectory) {
         return rows.map((row) => row.tell_id);
     });
 }
-export function claimFencedTells(projectionDirectory, fence, executionId) {
-    const owner = requireExecutionId(executionId);
-    return withWrite(projectionDirectory, (database) => {
-        const claimed = [];
-        const seen = new Set();
-        for (const tellId of fence) {
-            if (seen.has(tellId))
-                throw new ProjectionStateError(`duplicate tell in generation fence: ${tellId}`);
-            seen.add(tellId);
-            const row = selectTell(database, tellId);
-            if (!row)
-                throw new ProjectionStateError(`generation tell fence member is missing: ${tellId}`);
-            if (row.state === "inbox") {
-                database.prepare(`
-          UPDATE projection_tells
-          SET state = 'inflight'
-          WHERE tell_id = ? AND state = 'inbox'
-        `).run(tellId);
-                claimed.push(tellId);
-                continue;
-            }
-            if (row.state === "inflight") {
-                claimed.push(tellId);
-                continue;
-            }
-            if (row.state === "submitted" || row.state === "delivered") {
-                const submitted = submittedFromRow(row);
-                if (submitted.executionId === owner) {
-                    throw new ProjectionStateError(`submitted tell belongs to current execution: ${tellId}`);
-                }
-                const replayedFrom = [
-                    ...(submitted.replayedFrom ?? []),
-                    { executionId: submitted.executionId, fence: submitted.fence },
-                ];
-                const result = database.prepare(`
-          UPDATE projection_tells
-          SET
-            state = 'inflight',
-            execution_id = NULL,
-            fence_json = NULL,
-            replayed_from_json = ?,
-            delivered_at = NULL
-          WHERE tell_id = ? AND state = ?
-        `).run(JSON.stringify(replayedFrom), tellId, row.state);
-                if (Number(result.changes) !== 1) {
-                    throw new ProjectionStateError(`generation tell fence member changed while claiming: ${tellId}`);
-                }
-                claimed.push(tellId);
-                continue;
-            }
-            if (row.state === "consumed" && row.execution_id === owner)
-                continue;
-            throw new ProjectionStateError(`generation tell fence member is not claimable: ${tellId}`);
-        }
-        return claimed;
-    });
+function receiptTimestamp() {
+    return new Date().toISOString();
 }
-export function markTellSubmitted(projectionDirectory, tellId, fields) {
-    const executionId = requireExecutionId(fields.executionId);
-    const fence = parseFence(fields.fence);
-    const replayedFrom = (fields.replayedFrom ?? []).map((entry) => ({
-        executionId: requireExecutionId(entry.executionId),
-        fence: parseFence(entry.fence),
-    }));
+/** Reduce persisted native evidence through the one monotonic heart-stage algebra. */
+function recordTellReceiptFromDatabase(database, receipt) {
+    const executionId = requireExecutionId(receipt.executionId);
+    const fence = receipt.fence ? parseFence(receipt.fence) : undefined;
+    const receivedAt = receipt.receivedAt ?? receiptTimestamp();
+    const row = selectTell(database, receipt.tellId);
+    if (!row || row.execution_id !== executionId)
+        return false;
+    const inserted = database.prepare(`
+    INSERT INTO projection_tell_receipts (
+      tell_id, execution_id, stage, correlation_kind, fence_json, received_at
+    ) VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(tell_id, execution_id, stage) DO NOTHING
+  `).run(receipt.tellId, executionId, receipt.stage, receipt.correlation, fence ? JSON.stringify(fence) : null, receivedAt);
+    const receipts = database.prepare(`
+    SELECT stage FROM projection_tell_receipts
+    WHERE tell_id = ? AND execution_id = ?
+  `).all(receipt.tellId, executionId);
+    const stages = new Set(receipts.map((entry) => entry.stage));
+    let state = row.state;
+    let advanced = false;
+    if (state === "submitted" && stages.has("seen")) {
+        database.prepare(`UPDATE projection_tells SET state = 'seen' WHERE tell_id = ? AND state = 'submitted'`)
+            .run(receipt.tellId);
+        state = "seen";
+        advanced = true;
+    }
+    if (state === "seen" && stages.has("consumed")) {
+        database.prepare(`UPDATE projection_tells SET state = 'consumed' WHERE tell_id = ? AND state = 'seen'`)
+            .run(receipt.tellId);
+        advanced = true;
+    }
+    return Number(inserted.changes) === 1 || advanced;
+}
+/**
+ * Persist a provider-native receipt and advance the mailbox only when the
+ * receipt proves the next monotonic heart stage. Event-ledger persistence is
+ * deliberately not part of this transaction.
+ */
+export function recordTellReceipt(projectionDirectory, receipt) {
+    return withWrite(projectionDirectory, (database) => recordTellReceiptFromDatabase(database, receipt));
+}
+/** Persist the execution's native receipt strength independently of AgentEvent storage. */
+export function recordTellReceiptCapabilities(projectionDirectory, executionId, capabilities) {
+    const owner = requireExecutionId(executionId);
     withWrite(projectionDirectory, (database) => {
-        const row = selectTell(database, tellId);
-        if (!row)
-            throw new ProjectionStateError(`tell '${tellId}' does not exist`);
-        if (row.state === "submitted")
+        const existing = database.prepare(`
+      SELECT seen, consumed FROM projection_tell_receipt_capabilities
+      WHERE execution_id = ?
+    `).get(owner);
+        if (existing) {
+            if (existing.seen !== capabilities.seen || existing.consumed !== capabilities.consumed) {
+                throw new ProjectionStateError(`tell receipt capabilities conflict for execution '${owner}'`);
+            }
             return;
-        if (row.state !== "inflight") {
-            throw new ProjectionStateError(`tell '${tellId}' is not inflight`);
         }
         database.prepare(`
-      UPDATE projection_tells
-      SET
-        state = 'submitted',
-        execution_id = ?,
-        fence_json = ?,
-        replayed_from_json = COALESCE(?, replayed_from_json)
-      WHERE tell_id = ? AND state = 'inflight'
-    `).run(executionId, JSON.stringify(fence), replayedFrom.length > 0 ? JSON.stringify(replayedFrom) : null, tellId);
+      INSERT INTO projection_tell_receipt_capabilities (execution_id, seen, consumed)
+      VALUES (?, ?, ?)
+    `).run(owner, capabilities.seen, capabilities.consumed);
     });
 }
-export function markTellConsumed(projectionDirectory, tellId) {
-    withWrite(projectionDirectory, (database) => {
-        const result = database.prepare(`
-      UPDATE projection_tells
-      SET state = 'consumed', delivered_at = NULL
-      WHERE tell_id = ? AND state IN ('submitted', 'delivered')
-    `).run(tellId);
-        if (Number(result.changes) !== 1) {
-            throw new ProjectionStateError(`tell '${tellId}' is not submitted or delivered`);
-        }
+export function readTellReceiptCapabilities(projectionDirectory, executionId) {
+    const owner = requireExecutionId(executionId);
+    return withRead(projectionDirectory, (database) => {
+        const row = database.prepare(`
+      SELECT seen, consumed FROM projection_tell_receipt_capabilities
+      WHERE execution_id = ?
+    `).get(owner);
+        return row && { seen: row.seen, consumed: row.consumed };
     });
 }
 export function readProjectionTellCounts(projectionDirectory) {
@@ -262,8 +214,8 @@ export function readProjectionTellCounts(projectionDirectory) {
             inbox: 0,
             inflight: 0,
             submitted: 0,
+            seen: 0,
             consumed: 0,
-            delivered: 0,
         };
         const rows = database.prepare(`
       SELECT state, COUNT(*) AS count

package/build/core/registry.js

@@ -1,71 +1,30 @@
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
-import { readLedger } from "./ledger.js";
-import { appendRefLogWithRetry, readRefLog } from "./ref-log.js";
 import { patternsOverlap, scopePathEvidence } from "./scope.js";
-import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
-export const REGISTRY_REF = "refs/keiyaku/registry";
+import { readRepositoryLifecycle } from "./repository-ledger/read-model.js";
 export const SCOPE_OVERLAP_PATH_PREVIEW_LIMIT = 10;
-function parseRegistryEntry(message) {
-    const body = message.slice(message.indexOf("\n\n") + 2).trim();
-    const parsed = JSON.parse(body);
-    if (parsed.v !== 1 || !parsed.contract || !["register", "release", "repair"].includes(parsed.kind)) {
-        throw new FlowError("INTERNAL_STATE", `invalid registry entry for ${REGISTRY_REF}`);
-    }
-    return parsed;
-}
-function registrySubject(entry) {
-    return `keiyaku registry: ${entry.kind} ${entry.contract}`;
-}
-async function isActiveNonTerminal(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger)
-        return false;
-    const state = deriveContractState(ledger.entries);
-    return state.state !== "corrupt" && !isTerminalState(state);
-}
-async function activeRegistrations(cwd, entries) {
-    const released = new Set(entries.filter((entry) => entry.kind === "release").map((entry) => entry.contract));
-    const registrations = new Map();
-    for (const entry of entries) {
-        if (entry.kind === "register" && !released.has(entry.contract)) {
-            registrations.set(entry.contract, { scope: entry.scope, tree: entry.tree });
-        }
-    }
-    const active = [];
-    for (const [contract, registration] of registrations) {
-        if (await isActiveNonTerminal(cwd, contract))
-            active.push({ contract, scope: registration.scope, tree: registration.tree });
-    }
-    return active;
+function activeRegistrations(read) {
+    return read.contracts
+        .filter((model) => !["claimed", "forfeited"].includes(model.phase))
+        .map((model) => ({ contract: model.contract, scope: [...model.effectiveScope] }));
 }
-async function trackedRepositoryPaths(cwd) {
+async function trackedRepositoryPaths(cwd, tree) {
     try {
-        return (await createGit(cwd).raw(["ls-files", "-z"]))
+        return (await createGit(cwd).raw(["ls-tree", "-r", "-z", "--name-only", tree]))
             .split("\0")
             .filter(Boolean)
             .sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     }
     catch (error) {
-        throw wrapGitError("ls-files -z", error, cwd);
+        throw wrapGitError(`ls-tree ${tree}`, error, cwd);
     }
 }
-async function scopeRegistrationAdmission(cwd, input, entries, trackedPaths) {
+async function scopeRegistrationAdmission(cwd, input, read, trackedPaths) {
     const nextOverlaps = [];
-    const active = await activeRegistrations(cwd, entries);
-    if (input.exclusive && active.length > 0) {
-        const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
-        throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
-    }
+    const active = activeRegistrations(read);
     for (const existing of active) {
         if (existing.contract === input.contractId)
             continue;
-        if (existing.tree === input.tree) {
-            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
-                `tree is already occupied by active contract ${existing.contract}`,
-                `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
-            ].join(" "));
-        }
         const [nextEvidence, existingEvidence] = await Promise.all([
             scopePathEvidence(cwd, input.scope, trackedPaths),
             scopePathEvidence(cwd, existing.scope, trackedPaths),
@@ -121,44 +80,20 @@ async function scopeRegistrationAdmission(cwd, input, entries, trackedPaths) {
     }
     return nextOverlaps;
 }
-/** Read-only bind admission: validate exclusivity and classify scope overlap. */
-export async function previewScopeRegistration(cwd, input) {
-    const [entries, trackedPaths] = await Promise.all([
-        readRefLog(cwd, REGISTRY_REF, parseRegistryEntry),
-        trackedRepositoryPaths(cwd),
-    ]);
-    return await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
+function refuseExclusiveOverlap(contractId, overlaps) {
+    const occupants = [...new Set(overlaps.map((overlap) => overlap.contracts[1]))].sort();
+    throw new FlowError("INVALID_TARGET", `exclusive bind ${contractId} overlaps active contract${occupants.length === 1 ? "" : "s"}: ${occupants.join(", ")}`);
 }
-export async function registerScope(cwd, input) {
-    let overlaps = [];
-    const trackedPaths = await trackedRepositoryPaths(cwd);
-    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
-        overlaps = await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
-        return {
-            v: 1,
-            kind: "register",
-            contract: input.contractId,
-            at: input.at,
-            actor: input.actor,
-            scope: input.scope,
-            tree: input.tree,
-        };
-    });
-    if (!result.ok)
-        throw new FlowError("INTERNAL_STATE", `failed to register scope for ${input.contractId}: ${result.reason}`);
-    return { head: result.head, overlaps };
+/** Bind admission against one immutable repository fold and candidate Git tree. */
+export async function admitScopeRegistration(cwd, input, read) {
+    const overlaps = await scopeRegistrationAdmission(cwd, input, read, await trackedRepositoryPaths(cwd, input.tree));
+    if (input.exclusive && overlaps.length > 0)
+        refuseExclusiveOverlap(input.contractId, overlaps);
+    return overlaps;
 }
-export async function releaseScope(cwd, input) {
-    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, (entries) => {
-        const hasActiveRegistration = entries.some((entry) => entry.kind === "register" && entry.contract === input.contractId);
-        const alreadyReleased = entries.some((entry) => entry.kind === "release" && entry.contract === input.contractId);
-        if (!hasActiveRegistration || alreadyReleased)
-            return null;
-        return { v: 1, kind: "release", contract: input.contractId, at: input.at, actor: input.actor };
-    });
-    if (!result.ok && result.reason !== "aborted") {
-        throw new FlowError("INTERNAL_STATE", `failed to release scope for ${input.contractId}: ${result.reason}`);
-    }
+/** Read-only preview observes the repository once and shares mutation admission. */
+export async function previewScopeRegistration(cwd, input) {
+    return await admitScopeRegistration(cwd, input, await readRepositoryLifecycle(cwd));
 }
 export function bindScope(entry) {
     return entry.data.scope;