@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/projection/generation/projection-generation-runner.js

@@ -1,9 +1,11 @@
 import { openProjectionGenerationStore, } from "./store.js";
-import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "../projection-runner-lock.js";
-import { createProjectionExecutionId } from "./projection-generation-identity.js";
+import { acquireRunnerLease, observeRunnerLease, } from "../../run-control/runner-lease.js";
+import { beginConnectionBoundRunnerClose } from "../../run-control/connection-bound-close.js";
+import { createProjectionExecutionId, projectionRunnerLeasePath } from "./projection-generation-identity.js";
 import { applyContinuationEffort, } from "./projection-generation-continuation.js";
-import { openProjectionTellObserver } from "../tell/database.js";
+import { openProjectionTellObserver } from "./database.js";
 import { OUTCOME_ERROR_VERSION } from "../../../agents/types.js";
+import { openProjectionGenerationDoorbell, } from "./projection-generation-doorbell.js";
 /** Private runner-side kill grace. Not a setting, env, parameter, or export. */
 const KILL_GRACE_MS = 5000;
 function successorLaunchFacts(launch, completionFacts, effort, now) {
@@ -51,10 +53,10 @@ function readOutcomeState(state) {
 }
 function acquireRunnerLockOrObserveDuplicate(projectionDirectory) {
     try {
-        return acquireProjectionRunnerLock(projectionDirectory);
+        return acquireRunnerLease(projectionRunnerLeasePath(projectionDirectory));
     }
     catch (error) {
-        if (observeProjectionRunnerLock(projectionDirectory).state === "held") {
+        if (observeRunnerLease(projectionRunnerLeasePath(projectionDirectory)).state === "held") {
             return undefined;
         }
         throw error;
@@ -75,9 +77,38 @@ export async function runProjectionGeneration(input) {
     let adopted = false;
     let settled = false;
     let tellObserver;
+    let doorbell;
     let graceTimer;
-    let intentTimer;
     let handle;
+    let gracefulAbortInvoked = false;
+    let forceAbortInvoked = false;
+    let sawKillIntent = false;
+    let sawInterruptIntent = false;
+    let wakeAfterLockRelease = false;
+    let pullStopIntent;
+    let notifyMainWait;
+    const commitTerminal = (stage) => {
+        if (!runnerLock)
+            throw new Error("runner lease is not held");
+        const close = beginConnectionBoundRunnerClose(store.connectionForRunnerClose(), runnerLock);
+        try {
+            const transition = stage();
+            if (transition.status !== "committed") {
+                close.rollback();
+                return transition;
+            }
+            close.commit();
+            runnerLock = undefined;
+            return transition;
+        }
+        catch (error) {
+            if (close.leaseOwnership === "retained")
+                close.rollback();
+            else
+                runnerLock = undefined;
+            throw error;
+        }
+    };
     const clearGraceTimer = () => {
         if (graceTimer === undefined)
             return;
@@ -89,15 +120,50 @@ export async function runProjectionGeneration(input) {
             ?? acquireRunnerLockOrObserveDuplicate(input.projectionDirectory);
         if (!runnerLock)
             return { status: "duplicate" };
-        const initial = store.readCurrentGeneration();
+        tellObserver = openProjectionTellObserver(input.projectionDirectory);
+        // Establish the version fence before the listener becomes reachable. The
+        // forced pull below still sees intent committed before listener startup.
+        tellObserver.hasDataVersionChanged();
+        pullStopIntent = (force = false) => {
+            try {
+                if (!force && !tellObserver.hasDataVersionChanged())
+                    return undefined;
+                const live = store.readCurrentGeneration();
+                if (live?.launch.executionId !== input.executionId || live?.verdict)
+                    return live;
+                sawKillIntent = live.killIntent !== undefined;
+                sawInterruptIntent = live.interruptIntent !== undefined;
+                if (!sawKillIntent && !sawInterruptIntent)
+                    return live;
+                if (gracefulAbortInvoked || !handle)
+                    return live;
+                gracefulAbortInvoked = true;
+                void handle.abort("graceful").catch(() => {
+                    // A failed native stop does not alter durable intent truth.
+                });
+                return live;
+            }
+            catch {
+                // Observation failure is unknown, never evidence about the provider.
+                return undefined;
+            }
+        };
+        doorbell = await openProjectionGenerationDoorbell({
+            identity: store.readIdentity(),
+            executionId: input.executionId,
+            onRing: () => {
+                pullStopIntent?.(true);
+                notifyMainWait?.();
+            },
+        });
+        // This is the one baseline heart pull after listener registration. It
+        // covers intent committed while the listener did not yet exist.
+        const initial = pullStopIntent(true);
         if (initial?.launch.executionId !== input.executionId
             || initial.adoption
             || initial.verdict) {
             return { status: "rejected" };
         }
-        tellObserver = openProjectionTellObserver(input.projectionDirectory);
-        // Prime before adoption so a concurrent stop write cannot become the baseline.
-        tellObserver.hasDataVersionChanged();
         const adoption = store.adoptionIfCurrent({
             executionId: input.executionId,
             facts: { adoptedAt: new Date(now()).toISOString() },
@@ -112,7 +178,10 @@ export async function runProjectionGeneration(input) {
         // Adoption is the provider-admission boundary. A kill that committed first
         // settles without constructing a provider execution.
         if (current.killIntent) {
-            const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+            const killed = commitTerminal(() => store.runnerKilledIfRequested({
+                executionId: input.executionId,
+                terminalAt: new Date(now()).toISOString(),
+            }));
             if (killed.status !== "committed")
                 return { status: "rejected" };
             settled = true;
@@ -126,7 +195,10 @@ export async function runProjectionGeneration(input) {
         }
         if (current.killIntent) {
             await prepared.dispose();
-            const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+            const killed = commitTerminal(() => store.runnerKilledIfRequested({
+                executionId: input.executionId,
+                terminalAt: new Date(now()).toISOString(),
+            }));
             if (killed.status !== "committed")
                 return { status: "rejected" };
             settled = true;
@@ -134,68 +206,35 @@ export async function runProjectionGeneration(input) {
         }
         handle = prepared.start();
         const settleInterrupted = (facts = {}) => {
-            const transition = store.runnerInterruptedIfRequested({
+            pullStopIntent?.(true);
+            const transition = commitTerminal(() => store.runnerInterruptedIfRequested({
                 executionId: input.executionId,
                 facts,
                 terminalAt: new Date(now()).toISOString(),
-            });
+            }));
             if (transition.status !== "committed")
                 return { status: "rejected" };
             settled = true;
-            runnerLock.close();
-            runnerLock = undefined;
-            void input.wakeAfterInterrupt?.().catch(() => {
-                // The ordinary wake path persists its typed failure. A later tell can retry.
-            });
+            wakeAfterLockRelease = true;
             return { status: "completed" };
         };
         const settleRunnerOutcome = (execution) => {
-            const transition = store.runnerVerdictIfOpen({
+            pullStopIntent?.(true);
+            const transition = commitTerminal(() => store.runnerVerdictIfOpen({
                 executionId: input.executionId,
                 verdict: execution.verdict,
                 facts: execution.facts,
                 terminalAt: new Date(now()).toISOString(),
-            });
+            }));
             if (transition.status !== "committed")
                 return { status: "rejected" };
             settled = true;
             if (transition.records[0]?.facts.state === "interrupted") {
-                runnerLock.close();
-                runnerLock = undefined;
-                void input.wakeAfterInterrupt?.().catch(() => {
-                    // The ordinary wake path persists its typed failure. A later observer retries.
-                });
+                wakeAfterLockRelease = true;
             }
             return { status: "completed" };
         };
-        let gracefulAbortInvoked = false;
-        let forceAbortInvoked = false;
-        let sawKillIntent = false;
-        let sawInterruptIntent = false;
-        const observeStopBoundary = () => {
-            try {
-                if (!tellObserver.hasDataVersionChanged())
-                    return;
-                const live = store.readCurrentGeneration();
-                if (live?.launch.executionId !== input.executionId)
-                    return;
-                if (live.verdict)
-                    return;
-                sawKillIntent = live.killIntent !== undefined;
-                sawInterruptIntent = live.interruptIntent !== undefined;
-                if (!sawKillIntent && !sawInterruptIntent)
-                    return;
-                if (gracefulAbortInvoked)
-                    return;
-                gracefulAbortInvoked = true;
-                void handle.abort("graceful").catch(() => {
-                    // Abort observation failures fail closed for this boundary.
-                });
-            }
-            catch {
-                // Observation failures fail closed and must not change provider outcome.
-            }
-        };
+        const observeStopBoundary = () => { pullStopIntent?.(); };
         // Mutable box so async settlement is readable without control-flow narrowing traps.
         const outcomeBox = { status: "pending" };
         let resolveActivity;
@@ -207,6 +246,7 @@ export async function runProjectionGeneration(input) {
             resolveActivity = undefined;
             resolve?.();
         };
+        notifyMainWait = bumpActivity;
         const outcomeWatch = handle.outcome.then((execution) => {
             outcomeBox.status = "fulfilled";
             outcomeBox.execution = execution;
@@ -220,6 +260,7 @@ export async function runProjectionGeneration(input) {
         });
         // Always rejection-observe so abandon paths never surface unhandled rejections.
         observeAbandoned(outcomeWatch);
+        const eventDrainState = { closed: false };
         const eventDrain = (async () => {
             try {
                 for await (const _event of handle.events) {
@@ -230,20 +271,20 @@ export async function runProjectionGeneration(input) {
                 }
             }
             catch {
-                // Event-stream failures fail closed for observation; abandon quietly.
+                // Public event delivery is observation-only; outcome owns terminal truth.
+            }
+            finally {
+                eventDrainState.closed = true;
+                bumpActivity();
             }
-            bumpActivity();
         })();
         observeAbandoned(eventDrain);
-        // A provider may be silently executing when an operator interrupts it.
-        // The durable observer is the sole stop-intent authority in that interval.
-        intentTimer = setInterval(() => {
-            observeStopBoundary();
-            bumpActivity();
-        }, 100);
-        intentTimer.unref?.();
         while (outcomeBox.status === "pending" && !sawKillIntent && !sawInterruptIntent) {
-            await activityChanged();
+            const wakeSources = [outcomeWatch, activityChanged()];
+            if (!eventDrainState.closed)
+                wakeSources.push(eventDrain);
+            await Promise.race(wakeSources);
+            observeStopBoundary();
         }
         if (sawKillIntent || sawInterruptIntent) {
             // Grace race: outcome settlement inside the window is stop proof.
@@ -275,10 +316,11 @@ export async function runProjectionGeneration(input) {
                         throw killOutcome.error;
                     throw new Error("interrupt outcome did not establish provider stop");
                 }
-                const killed = store.runnerKilledIfRequested({
+                const killed = commitTerminal(() => store.runnerKilledIfRequested({
                     executionId: input.executionId,
                     ...(facts && Object.keys(facts).length > 0 ? { facts } : {}),
-                });
+                    terminalAt: new Date(now()).toISOString(),
+                }));
                 if (killed.status !== "committed")
                     return { status: "rejected" };
                 settled = true;
@@ -290,14 +332,17 @@ export async function runProjectionGeneration(input) {
                 await handle.abort("force");
                 if (sawInterruptIntent)
                     return settleInterrupted();
-                const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+                const killed = commitTerminal(() => store.runnerKilledIfRequested({
+                    executionId: input.executionId,
+                    terminalAt: new Date(now()).toISOString(),
+                }));
                 if (killed.status !== "committed")
                     return { status: "rejected" };
                 settled = true;
                 return { status: "completed" };
             }
             catch (error) {
-                const failed = store.verdictIfOpen({
+                const failed = commitTerminal(() => store.verdictIfOpen({
                     executionId: input.executionId,
                     verdict: "failed",
                     facts: {
@@ -313,7 +358,7 @@ export async function runProjectionGeneration(input) {
                             exitCode: null,
                         },
                     },
-                });
+                }));
                 // Durably completed after the failed verdict; outer catch must not overwrite.
                 settled = true;
                 if (failed.status !== "committed")
@@ -344,6 +389,7 @@ export async function runProjectionGeneration(input) {
             try {
                 const successorOwnership = runnerLock;
                 await input.startSuccessor(successorExecutionId, () => {
+                    pullStopIntent?.(true);
                     const transition = store.handoff({
                         executionId: input.executionId,
                         completionFacts: execution.facts,
@@ -377,7 +423,7 @@ export async function runProjectionGeneration(input) {
         return settleRunnerOutcome(execution);
     }
     catch (error) {
-        if (adopted && !settled) {
+        if (adopted && !settled && runnerLock) {
             let cleanupError;
             if (handle) {
                 try {
@@ -387,9 +433,10 @@ export async function runProjectionGeneration(input) {
                     cleanupError = failure;
                 }
             }
+            pullStopIntent?.(true);
             const live = store.readCurrentGeneration();
             const detail = error instanceof Error ? error.message : String(error);
-            store.runnerVerdictIfOpen({
+            const failed = commitTerminal(() => store.runnerVerdictIfOpen({
                 executionId: input.executionId,
                 verdict: "failed",
                 facts: {
@@ -409,14 +456,13 @@ export async function runProjectionGeneration(input) {
                     },
                 },
                 terminalAt: new Date(now()).toISOString(),
-            });
+            }));
+            settled = failed.status === "committed";
         }
         throw error;
     }
     finally {
         clearGraceTimer();
-        if (intentTimer !== undefined)
-            clearInterval(intentTimer);
         try {
             tellObserver?.close();
         }
@@ -424,10 +470,20 @@ export async function runProjectionGeneration(input) {
             // Observer cleanup cannot reopen life or product authority.
         }
         try {
-            runnerLock?.close();
+            await doorbell?.close();
         }
         finally {
-            store.close();
+            try {
+                runnerLock?.close();
+            }
+            finally {
+                store.close();
+            }
+        }
+        if (wakeAfterLockRelease) {
+            void input.wakeAfterInterrupt?.().catch(() => {
+                // A later tell retries the ordinary wake path after its durable failure.
+            });
         }
     }
 }

package/build/core/projection/generation/projection-generation-runtime.js

@@ -1,47 +1,12 @@
 import { prepareProjectionGenerationExecution } from "./projection-generation-execution.js";
-import { PROJECTION_RUNNER_BOOTSTRAP_ENV, } from "./projection-generation-process.js";
+import { receiveDetachedLease, } from "../../run-control/index.js";
 import { runProjectionGeneration } from "./projection-generation-runner.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
 import { startProjectionGeneration } from "./projection-generation-launcher.js";
 import { snapshotPendingTells } from "./projection-generation-continuation.js";
 import { persistInterruptWakeFailure, tellProjection } from "../projection-wake.js";
 import { readProjectionIdentity } from "../projection-identity.js";
 import * as path from "node:path";
-import { acquireProjectionRunnerTransferTarget } from "../projection-runner-lock.js";
-function sendBootstrapMessage(message) {
-    return new Promise((resolve, reject) => {
-        if (!process.send || !process.connected) {
-            reject(new Error("projection runner bootstrap channel is unavailable"));
-            return;
-        }
-        process.send(message, (error) => error ? reject(error) : resolve());
-    });
-}
-function waitForLaunchCommand(executionId, expected) {
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            process.off("message", onMessage);
-            process.off("disconnect", onDisconnect);
-        };
-        const onDisconnect = () => {
-            cleanup();
-            reject(new Error("projection runner bootstrap channel disconnected before launch authorization"));
-        };
-        const onMessage = (value) => {
-            const command = value;
-            if (command.executionId !== executionId)
-                return;
-            if (expected === "promote-leash" && command.kind !== "promote-leash" && command.kind !== "launch-rejected")
-                return;
-            if (expected === "launch-authority" && command.kind !== "launch-committed" && command.kind !== "launch-rejected")
-                return;
-            cleanup();
-            resolve(command);
-        };
-        process.on("message", onMessage);
-        process.on("disconnect", onDisconnect);
-    });
-}
+import { projectionRunnerLeasePath } from "./projection-generation-identity.js";
 export async function wakeProjectionAfterInterrupt(projectionDirectory, wake = tellProjection) {
     const pact = readProjectionIdentity(projectionDirectory);
     try {
@@ -53,30 +18,17 @@ export async function wakeProjectionAfterInterrupt(projectionDirectory, wake = t
     }
 }
 export async function runProjectionGenerationRuntime(projectionDirectory, executionId) {
-    if (process.env[PROJECTION_RUNNER_BOOTSTRAP_ENV] !== "1") {
-        throw new Error("projection runner was not spawned with inherited leash coordination");
-    }
-    let runnerLock;
-    let transferTarget;
+    const transfer = await receiveDetachedLease({
+        coordinate: executionId,
+        leasePath: projectionRunnerLeasePath(projectionDirectory),
+    });
+    if (transfer.status === "rejected")
+        return;
     try {
-        transferTarget = acquireProjectionRunnerTransferTarget(projectionDirectory, process.platform, PROJECTION_ADOPTION_TIMEOUT_MS);
-        await sendBootstrapMessage({ kind: "leash-inherited", executionId });
-        const promotion = await waitForLaunchCommand(executionId, "promote-leash");
-        if (promotion.kind === "launch-rejected")
-            return;
-        runnerLock = transferTarget.promote();
-        transferTarget = undefined;
-        await sendBootstrapMessage({ kind: "leash-acquired", executionId });
-        const command = await waitForLaunchCommand(executionId, "launch-authority");
-        if (command.kind === "launch-rejected")
-            return;
-        process.disconnect?.();
-        const ownedLock = runnerLock;
-        runnerLock = undefined;
         await runProjectionGeneration({
             projectionDirectory,
             executionId,
-            runnerLock: ownedLock,
+            runnerLock: transfer.lease,
             prepareExecution: (launch) => prepareProjectionGenerationExecution(projectionDirectory, launch),
             snapshotPendingTells: () => snapshotPendingTells(projectionDirectory),
             startSuccessor: async (successorExecutionId, commitLaunch, launchOwnership) => {
@@ -90,8 +42,5 @@ export async function runProjectionGenerationRuntime(projectionDirectory, execut
             wakeAfterInterrupt: () => wakeProjectionAfterInterrupt(projectionDirectory),
         });
     }
-    finally {
-        runnerLock?.close();
-        transferTarget?.close();
-    }
+    finally { /* execution owns and closes the transferred lease */ }
 }

package/build/core/projection/generation/protocol.js

@@ -0,0 +1,68 @@
+import { GENERATION_VERDICT_STATES, } from "./model.js";
+function recordOfKind(record, kind) {
+    return record.kind === kind ? record : undefined;
+}
+/** Select the newest generation by its Projection ledger sequence. */
+export function selectCurrentGeneration(records) {
+    let launch;
+    for (const record of records)
+        launch = recordOfKind(record, "launch") ?? launch;
+    if (!launch)
+        return null;
+    let adoption;
+    let killIntent;
+    let interruptIntent;
+    let verdict;
+    for (const record of records) {
+        if (record.seq <= launch.seq || record.executionId !== launch.executionId)
+            continue;
+        adoption ??= recordOfKind(record, "adoption");
+        killIntent ??= recordOfKind(record, "kill-intent");
+        interruptIntent ??= recordOfKind(record, "interrupt-intent");
+        verdict ??= recordOfKind(record, "verdict");
+    }
+    return { launch, ...(adoption ? { adoption } : {}), ...(killIntent ? { killIntent } : {}), ...(interruptIntent ? { interruptIntent } : {}), ...(verdict ? { verdict } : {}) };
+}
+function verdictState(record) {
+    const state = record?.facts.state;
+    return typeof state === "string" && GENERATION_VERDICT_STATES.includes(state)
+        ? state
+        : undefined;
+}
+function phaseForVerdict(state) {
+    switch (state) {
+        case "completed": return "done";
+        case "dismissed": return "dismissed";
+        case "interrupted": return "done";
+        case "killed": return "killed";
+        case "lost-runner": return "lost";
+        case "failed":
+        case "launch-failed": return "failed";
+    }
+}
+export function deriveProjectionLife(input) {
+    const chain = selectCurrentGeneration(input.records);
+    if (!chain)
+        return { phase: "quiescent" };
+    const executionId = chain.launch.executionId;
+    if (chain.verdict) {
+        const state = verdictState(chain.verdict);
+        return state
+            ? { phase: phaseForVerdict(state), executionId, verdict: state }
+            : { phase: "unknown", executionId, diagnostic: "current generation has an invalid verdict" };
+    }
+    if (!chain.adoption) {
+        switch (input.runnerLease) {
+            case "held": return { phase: "minting", executionId };
+            case "released": return { phase: "lost", executionId, diagnostic: "startup owner died before adoption" };
+            case "unknown":
+            case undefined: return { phase: "unknown", executionId, diagnostic: "runner lease could not be determined" };
+        }
+    }
+    switch (input.runnerLease) {
+        case "held": return { phase: "active", executionId };
+        case "released": return { phase: "lost", executionId };
+        case "unknown":
+        case undefined: return { phase: "unknown", executionId, diagnostic: "runner lease could not be determined" };
+    }
+}

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

@@ -1,4 +1,4 @@
-import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, beginGenerationWriteTransaction, closeDatabase, commitGenerationWriteTransaction, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, rollbackGenerationWriteTransaction, } from "./database.js";
+import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, closeDatabase, connectionBoundGenerationStore, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, } from "./database.js";
 import { initializeIdentity as initializeProjectionIdentity, readIdentity as readProjectionIdentity, } from "./identity.js";
 import * as transitions from "./transitions.js";
 export { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, };
@@ -7,10 +7,12 @@ export class ProjectionGenerationStore {
     databasePath;
     readOnly;
     #database;
+    #generationStore;
     constructor(databasePath, database, readOnly) {
         this.databasePath = databasePath;
         this.#database = database;
         this.readOnly = readOnly;
+        this.#generationStore = connectionBoundGenerationStore(database, readOnly);
     }
     static open(projectionDirectory) {
         const { databasePath, database } = openMutableDatabase(projectionDirectory);
@@ -21,25 +23,33 @@ export class ProjectionGenerationStore {
         return new ProjectionGenerationStore(databasePath, database, true);
     }
     close() {
-        rollbackGenerationWriteTransaction(this.#database);
+        assertDatabaseOpen(this.#database);
+        this.#generationStore.rollbackWriteTransaction();
         closeDatabase(this.#database);
     }
     beginWriteTransaction() {
-        beginGenerationWriteTransaction(this.#database, this.readOnly);
+        assertDatabaseOpen(this.#database);
+        this.#generationStore.beginWriteTransaction();
     }
     commitWriteTransaction() {
-        commitGenerationWriteTransaction(this.#database);
+        assertDatabaseOpen(this.#database);
+        this.#generationStore.commitWriteTransaction();
     }
     rollbackWriteTransaction() {
-        rollbackGenerationWriteTransaction(this.#database);
+        assertDatabaseOpen(this.#database);
+        this.#generationStore.rollbackWriteTransaction();
+    }
+    connectionForRunnerClose() {
+        assertDatabaseOpen(this.#database);
+        return this.#database;
     }
     readRecords() {
         assertDatabaseOpen(this.#database);
-        return readValidatedHistory(this.#database).records;
+        return readValidatedHistory(this.#database, this.readOnly).records;
     }
     readCurrentGeneration() {
         assertDatabaseOpen(this.#database);
-        return readValidatedHistory(this.#database).current;
+        return readValidatedHistory(this.#database, this.readOnly).current;
     }
     initializeIdentity(identity) {
         initializeProjectionIdentity(this.#database, this.databasePath, this.readOnly, identity);