@astrosheep/keiyaku 2.9.6 → 2.9.8

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

@@ -1,22 +1,87 @@
 import { ProjectionStateError } from "../../atomic-publish.js";
 import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../../../agents/launch-snapshot/model.js";
-import { listTellIds, readTellOriginal, readTellSubmitted, } from "../projection-core.js";
-export function snapshotPendingTells(projectionDirectory) {
-    const pending = ["inbox", "inflight", "submitted"]
-        .flatMap((layer) => listTellIds(projectionDirectory, layer)
-        .map((tellId) => ({ layer, tellId })))
-        .sort((left, right) => left.tellId.localeCompare(right.tellId));
+import { listTellMetadataFromDatabase, readPendingTellWindowFromDatabase, } from "../tell/store.js";
+import { PENDING_PROJECTION_TELL_STATES } from "../tell/model.js";
+import { readValidatedHistory, withGenerationReadSnapshot } from "./database.js";
+function retainedFenceFor(current) {
+    return current?.verdict?.facts.state === "launch-failed"
+        ? current.launch.facts.tellFence ?? []
+        : [];
+}
+function interruptedForReplay(current) {
+    return current?.verdict?.facts.state === "interrupted";
+}
+function snapshotTells(database, layers, admit) {
+    const pending = listTellMetadataFromDatabase(database, layers)
+        .filter((item) => admit?.({
+        layer: item.state,
+        tellId: item.tellId,
+        ...(item.executionId ? { executionId: item.executionId } : {}),
+    }) ?? true);
     const effort = pending.reduce((selected, item) => {
-        const tell = item.layer === "submitted"
-            ? readTellSubmitted(projectionDirectory, item.tellId)
-            : readTellOriginal(projectionDirectory, item.layer, item.tellId);
-        return tell.effort ?? selected;
+        return item.effort ?? selected;
     }, undefined);
     return {
         tellIds: pending.map((item) => item.tellId),
         ...(effort ? { effort } : {}),
     };
 }
+/** Ordinary completed-generation handoff retains only tells not yet delivered. */
+export function snapshotPendingTells(projectionDirectory) {
+    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
+}
+/** Interrupted generations replay pending mail and their own delivered tells. */
+export function snapshotInterruptTells(projectionDirectory, executionId) {
+    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], (item) => item.layer !== "delivered" || item.executionId === executionId));
+}
+/** Retry ordinary pending mail plus exactly the durable fence of a failed launch. */
+export function snapshotRetainedSuccessorTells(projectionDirectory, retainedFence) {
+    const retained = new Set(retainedFence);
+    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], ({ layer, tellId }) => layer !== "delivered" || retained.has(tellId)));
+}
+/** Build the durable successor fence only after continuation is admitted. */
+export function snapshotProjectionContinuationTells(projectionDirectory, current) {
+    const snapshot = readProjectionGenerationContinuationSnapshot(projectionDirectory, 0);
+    if (snapshot.current?.launch.executionId !== current?.launch.executionId) {
+        throw new ProjectionStateError("projection generation changed while selecting continuation tells");
+    }
+    return snapshot.successor;
+}
+function readContinuationFromDatabase(database, current, limit = 10) {
+    const tells = readPendingTellWindowFromDatabase(database, limit);
+    const retainedFence = retainedFenceFor(current);
+    const successor = interruptedForReplay(current)
+        ? snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], (item) => item.layer !== "delivered" || item.executionId === current.launch.executionId)
+        : retainedFence.length > 0
+            ? snapshotTells(database, [...PENDING_PROJECTION_TELL_STATES, "delivered"], ({ layer, tellId }) => layer !== "delivered" || retainedFence.includes(tellId))
+            : snapshotTells(database, PENDING_PROJECTION_TELL_STATES);
+    return {
+        tells,
+        successor,
+        requiresWake: successor.tellIds.length > 0,
+    };
+}
+/** One heart snapshot owns generation selection and all continuation facts. */
+export function readProjectionGenerationContinuationSnapshot(projectionDirectory, limit = 10) {
+    return withGenerationReadSnapshot(projectionDirectory, (database) => {
+        const { records, current } = readValidatedHistory(database);
+        const continuation = readContinuationFromDatabase(database, current, limit);
+        return {
+            records,
+            current,
+            generationSequence: records.at(-1)?.seq ?? 0,
+            ...continuation,
+        };
+    });
+}
+/** One continuation eligibility fact shared by tell, wait, and wake. */
+export function readProjectionContinuation(projectionDirectory, current, limit = 10) {
+    const snapshot = readProjectionGenerationContinuationSnapshot(projectionDirectory, limit);
+    if (snapshot.current?.launch.executionId !== current?.launch.executionId) {
+        throw new ProjectionStateError("projection generation changed while reading continuation");
+    }
+    return snapshot;
+}
 export function applyContinuationEffort(inputs, effort) {
     if (!effort)
         return inputs;

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

@@ -2,7 +2,7 @@ import { initializeConfig } from "../../../config/env.js";
 import { buildCallTerms } from "../../../agents/call-terms.js";
 import { parseResolvedAkumaLaunchSnapshot } from "../../../agents/launch-snapshot/model.js";
 import { revive, call, } from "../../../agents/harness/index.js";
-import { claimFencedTells, demoteSubmittedTellsForReplay, readTellOriginal, readProjectionEvents, } from "../projection-core.js";
+import { claimFencedTells, readTellOriginal, readProjectionEvents, } from "../projection-core.js";
 import { createProjectionExecutionObserver, renderProjectionTellFrame, } from "../projection-execution-observer.js";
 import { readProjectionIdentity } from "../projection-identity.js";
 import { selectValidStoredAgentEvents } from "../../stored-agent-event.js";
@@ -136,11 +136,10 @@ async function completionFacts(projectionDirectory, executionId, inputs, outcome
  * Construct the public Projection once and expose a provider-neutral execution
  * handle. Provider adapters and harness public types are unchanged.
  */
-export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
+export function prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts = {}) {
     const inputs = parseLaunchInputs(launch);
     initializeConfig(process.env, inputs.cwd);
     const executionId = launch.executionId;
-    demoteSubmittedTellsForReplay(projectionDirectory, executionId);
     const initialTellIds = claimFencedTells(projectionDirectory, launch.facts.tellFence ?? [], executionId);
     const tellPrompt = initialTellIds.map((tellId) => {
         const tell = readTellOriginal(projectionDirectory, "inflight", tellId);
@@ -161,41 +160,51 @@ export function executeProjectionGeneration(projectionDirectory, launch, provide
         executionId,
         initialTellIds,
     });
-    let projection;
-    try {
-        projection = inputs.session
-            ? revive({
-                ...terms,
-                session: inputs.session,
-                resumePath: inputs.resumePath ?? projectionDirectory,
-            }, { observer: observerController.observer })
-            : call(terms, { observer: observerController.observer });
-    }
-    catch (error) {
-        void observerController.close();
-        throw error;
-    }
-    const outcome = projection.outcome.then(async (result) => {
-        try {
+    return {
+        start() {
+            let projection;
+            try {
+                projection = inputs.session
+                    ? revive({
+                        ...terms,
+                        session: inputs.session,
+                        resumePath: inputs.resumePath ?? projectionDirectory,
+                    }, { observer: observerController.observer })
+                    : call(terms, { observer: observerController.observer });
+            }
+            catch (error) {
+                void observerController.close();
+                throw error;
+            }
+            const outcome = projection.outcome.then(async (result) => {
+                try {
+                    return {
+                        verdict: result.status === "completed"
+                            ? "completed"
+                            : result.status === "dismissed"
+                                ? "dismissed"
+                                : result.status === "interrupted"
+                                    ? "interrupted"
+                                    : "failed",
+                        facts: await completionFacts(projectionDirectory, executionId, inputs, result),
+                    };
+                }
+                finally {
+                    await observerController.close();
+                }
+            }, async (error) => {
+                await observerController.close();
+                throw error;
+            });
             return {
-                verdict: result.status === "completed"
-                    ? "completed"
-                    : result.status === "dismissed"
-                        ? "dismissed"
-                        : "failed",
-                facts: await completionFacts(projectionDirectory, executionId, inputs, result),
+                events: projection.events,
+                outcome,
+                abort: (mode) => projection.abort(mode),
             };
-        }
-        finally {
-            await observerController.close();
-        }
-    }, async (error) => {
-        await observerController.close();
-        throw error;
-    });
-    return {
-        events: projection.events,
-        outcome,
-        abort: (mode) => projection.abort(mode),
+        },
+        dispose: () => observerController.close(),
     };
 }
+export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
+    return prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts).start();
+}

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

@@ -1,37 +1,179 @@
 import { setTimeout as delay } from "node:timers/promises";
 import { openProjectionGenerationStore } from "./store.js";
 import { spawnProjectionGenerationRunner, } from "./projection-generation-process.js";
+import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "../projection-runner-lock.js";
 export const PROJECTION_ADOPTION_TIMEOUT_MS = 4_000;
 export const PROJECTION_ADOPTION_POLL_MS = 20;
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function recordLaunchFailure(projectionDirectory, executionId, detail, stage, terminalAt) {
+function recordDeadStartup(projectionDirectory, executionId, detail, stage, terminalAt) {
     const store = openProjectionGenerationStore(projectionDirectory);
     try {
-        return store.verdictIfOpen({
+        return store.settleStartupFailure({
             executionId,
-            verdict: "launch-failed",
-            facts: { stage, detail, ...(terminalAt ? { terminalAt } : {}) },
+            releasedLockEvidence: { stage, detail },
+            diagnostic: { stage, detail },
+            terminalAt,
         }).status === "committed";
     }
     finally {
         store.close();
     }
 }
+function observeBootstrapMessages(child, executionId) {
+    const seen = new Set();
+    const waiters = new Map();
+    let failure;
+    const onMessage = (value) => {
+        const message = value;
+        if (message.executionId !== executionId)
+            return;
+        if (message.kind !== "leash-inherited" && message.kind !== "leash-acquired")
+            return;
+        seen.add(message.kind);
+        const waiter = waiters.get(message.kind);
+        if (waiter) {
+            waiter.resolve();
+            waiters.delete(message.kind);
+        }
+    };
+    const onError = (error) => {
+        failure = error;
+        for (const waiter of waiters.values())
+            waiter.reject(error);
+        waiters.clear();
+    };
+    const onExit = () => onError(new Error("runner exited during bootstrap"));
+    child.on("message", onMessage);
+    child.on("error", onError);
+    child.on("exit", onExit);
+    return {
+        waitFor(kind) {
+            if (seen.has(kind))
+                return Promise.resolve();
+            if (failure)
+                return Promise.reject(failure);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    waiters.delete(kind);
+                    reject(failure ?? new Error(`runner did not report ${kind} before startup timeout`));
+                }, PROJECTION_ADOPTION_TIMEOUT_MS);
+                waiters.set(kind, {
+                    resolve: () => {
+                        clearTimeout(timer);
+                        waiters.delete(kind);
+                        resolve();
+                    },
+                    reject: (error) => {
+                        clearTimeout(timer);
+                        waiters.delete(kind);
+                        reject(error);
+                    },
+                });
+            });
+        },
+        close() {
+            child.off("message", onMessage);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        },
+    };
+}
+function sendBootstrapCommand(child, command) {
+    return new Promise((resolve, reject) => {
+        if (!child.send || !child.connected) {
+            reject(new Error("runner bootstrap channel is unavailable"));
+            return;
+        }
+        child.send(command, (error) => error ? reject(error) : resolve());
+    });
+}
 /** Spawn one committed launch and return only after its exact adoption row. */
 export async function startProjectionGeneration(projectionDirectory, executionId, dependencies = {}) {
     const now = dependencies.now ?? Date.now;
     const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
+    const launcherAcquiredOwnership = dependencies.launchOwnership === undefined;
+    let launchOwnership;
+    try {
+        launchOwnership = dependencies.launchOwnership
+            ?? acquireProjectionRunnerLock(projectionDirectory);
+    }
+    catch (error) {
+        if (observeProjectionRunnerLock(projectionDirectory).state === "held") {
+            return { status: "pending" };
+        }
+        return {
+            status: "failed",
+            cause: "adoption",
+            detail: `runner construction failed: ${errorDetail(error)}`,
+        };
+    }
+    let launchCommitted = false;
+    let childPromoted = false;
     let child;
     try {
         child = spawnProjectionGenerationRunner(projectionDirectory, executionId, dependencies);
     }
     catch (error) {
         const detail = `runner spawn failed: ${errorDetail(error)}`;
-        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
+        recordDeadStartup(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
+        launchOwnership.close();
         return { status: "failed", cause: "spawn", detail };
     }
+    const bootstrap = observeBootstrapMessages(child, executionId);
+    try {
+        await bootstrap.waitFor("leash-inherited");
+        if (dependencies.commitLaunch && !dependencies.commitLaunch()) {
+            await sendBootstrapCommand(child, { kind: "launch-rejected", executionId });
+            if (launcherAcquiredOwnership)
+                launchOwnership.close();
+            return { status: "failed", cause: "adoption", detail: "generation launch transaction was rejected" };
+        }
+        launchCommitted = true;
+        launchOwnership.releaseReservationForTransfer();
+        await sendBootstrapCommand(child, { kind: "promote-leash", executionId });
+        await bootstrap.waitFor("leash-acquired");
+        childPromoted = true;
+        await sendBootstrapCommand(child, { kind: "launch-committed", executionId });
+        try {
+            launchOwnership.close();
+        }
+        catch {
+            // The promoted child owns lifecycle truth; parent guard cleanup is diagnostic only.
+        }
+    }
+    catch (error) {
+        void sendBootstrapCommand(child, { kind: "launch-rejected", executionId }).catch(() => { });
+        if (childPromoted) {
+            try {
+                launchOwnership.close();
+            }
+            catch { }
+            return { status: "pending", child };
+        }
+        if (!launchCommitted) {
+            launchOwnership.close();
+            return { status: "failed", cause: "adoption", detail: `runner construction failed: ${errorDetail(error)}` };
+        }
+        try {
+            launchOwnership.reclaimReservation();
+        }
+        catch {
+            launchOwnership.close();
+            return { status: "pending", child };
+        }
+        try {
+            recordDeadStartup(projectionDirectory, executionId, `runner construction failed: ${errorDetail(error)}`, "adoption", new Date(now()).toISOString());
+        }
+        finally {
+            launchOwnership.close();
+        }
+        return { status: "failed", cause: "adoption", detail: `runner construction failed: ${errorDetail(error)}` };
+    }
+    finally {
+        bootstrap.close();
+    }
     const deadline = now() + PROJECTION_ADOPTION_TIMEOUT_MS;
     for (;;) {
         const observedAt = now();
@@ -74,19 +216,5 @@ export async function startProjectionGeneration(projectionDirectory, executionId
     finally {
         store.close();
     }
-    const detail = "runner did not commit adoption before startup timeout";
-    if (!recordLaunchFailure(projectionDirectory, executionId, detail, "adoption", new Date(now()).toISOString())) {
-        const raced = openProjectionGenerationStore(projectionDirectory);
-        try {
-            const current = raced.readCurrentGeneration();
-            if (current?.launch.executionId === executionId && current.adoption) {
-                return { status: "adopted", child };
-            }
-        }
-        finally {
-            raced.close();
-        }
-    }
-    child.kill("SIGTERM");
-    return { status: "failed", cause: "adoption", detail };
+    return { status: "pending", child };
 }

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

@@ -17,6 +17,7 @@ export function projectionGenerationRunnerArgv(projectionDirectory, executionId)
         executionId,
     ];
 }
+export const PROJECTION_RUNNER_BOOTSTRAP_ENV = "KEIYAKU_PROJECTION_RUNNER_BOOTSTRAP";
 export function spawnProjectionGenerationRunner(projectionDirectory, executionId, dependencies = {}) {
     const spawn = dependencies.spawn ?? nodeSpawn;
     const openSync = dependencies.openSync ?? fs.openSync;
@@ -30,7 +31,8 @@ export function spawnProjectionGenerationRunner(projectionDirectory, executionId
     try {
         const child = spawn(command, args, {
             detached: true,
-            stdio: ["ignore", logFd, logFd],
+            stdio: ["ignore", logFd, logFd, "ipc"],
+            env: { ...process.env, [PROJECTION_RUNNER_BOOTSTRAP_ENV]: "1" },
         });
         if (child.pid === undefined) {
             throw new Error("projection runner did not expose a process id");