@astrosheep/keiyaku 2.9.6 → 2.9.8

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

@@ -76,6 +76,8 @@ export async function runProjectionGeneration(input) {
     let settled = false;
     let tellObserver;
     let graceTimer;
+    let intentTimer;
+    let handle;
     const clearGraceTimer = () => {
         if (graceTimer === undefined)
             return;
@@ -83,15 +85,19 @@ export async function runProjectionGeneration(input) {
         graceTimer = undefined;
     };
     try {
+        runnerLock = input.runnerLock
+            ?? acquireRunnerLockOrObserveDuplicate(input.projectionDirectory);
+        if (!runnerLock)
+            return { status: "duplicate" };
         const initial = store.readCurrentGeneration();
         if (initial?.launch.executionId !== input.executionId
             || initial.adoption
             || initial.verdict) {
             return { status: "rejected" };
         }
-        runnerLock = acquireRunnerLockOrObserveDuplicate(input.projectionDirectory);
-        if (!runnerLock)
-            return { status: "duplicate" };
+        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() },
@@ -99,11 +105,12 @@ export async function runProjectionGeneration(input) {
         if (adoption.status !== "committed")
             return { status: "rejected" };
         adopted = true;
-        const current = store.readCurrentGeneration();
+        let current = store.readCurrentGeneration();
         if (current?.launch.executionId !== input.executionId) {
             throw new Error("adopted generation stopped being current");
         }
-        // Pre-admission kill: skip provider work and commit killed directly.
+        // 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 });
             if (killed.status !== "committed")
@@ -111,12 +118,61 @@ export async function runProjectionGeneration(input) {
             settled = true;
             return { status: "completed" };
         }
-        const handle = input.execute(current.launch);
-        tellObserver = openProjectionTellObserver(input.projectionDirectory);
+        const prepared = await input.prepareExecution(current.launch);
+        current = store.readCurrentGeneration();
+        if (current?.launch.executionId !== input.executionId) {
+            await prepared.dispose();
+            throw new Error("prepared generation stopped being current");
+        }
+        if (current.killIntent) {
+            await prepared.dispose();
+            const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+            if (killed.status !== "committed")
+                return { status: "rejected" };
+            settled = true;
+            return { status: "completed" };
+        }
+        handle = prepared.start();
+        const settleInterrupted = (facts = {}) => {
+            const transition = 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.
+            });
+            return { status: "completed" };
+        };
+        const settleRunnerOutcome = (execution) => {
+            const transition = 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.
+                });
+            }
+            return { status: "completed" };
+        };
         let gracefulAbortInvoked = false;
         let forceAbortInvoked = false;
         let sawKillIntent = false;
-        const observeKillBoundary = () => {
+        let sawInterruptIntent = false;
+        const observeStopBoundary = () => {
             try {
                 if (!tellObserver.hasDataVersionChanged())
                     return;
@@ -125,9 +181,10 @@ export async function runProjectionGeneration(input) {
                     return;
                 if (live.verdict)
                     return;
-                if (!live.killIntent)
+                sawKillIntent = live.killIntent !== undefined;
+                sawInterruptIntent = live.interruptIntent !== undefined;
+                if (!sawKillIntent && !sawInterruptIntent)
                     return;
-                sawKillIntent = true;
                 if (gracefulAbortInvoked)
                     return;
                 gracefulAbortInvoked = true;
@@ -153,12 +210,12 @@ export async function runProjectionGeneration(input) {
         const outcomeWatch = handle.outcome.then((execution) => {
             outcomeBox.status = "fulfilled";
             outcomeBox.execution = execution;
-            observeKillBoundary();
+            observeStopBoundary();
             bumpActivity();
         }, (error) => {
             outcomeBox.status = "rejected";
             outcomeBox.error = error;
-            observeKillBoundary();
+            observeStopBoundary();
             bumpActivity();
         });
         // Always rejection-observe so abandon paths never surface unhandled rejections.
@@ -168,7 +225,7 @@ export async function runProjectionGeneration(input) {
                 for await (const _event of handle.events) {
                     if (forceAbortInvoked)
                         return;
-                    observeKillBoundary();
+                    observeStopBoundary();
                     bumpActivity();
                 }
             }
@@ -178,10 +235,17 @@ export async function runProjectionGeneration(input) {
             bumpActivity();
         })();
         observeAbandoned(eventDrain);
-        while (outcomeBox.status === "pending" && !sawKillIntent) {
+        // 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();
         }
-        if (sawKillIntent) {
+        if (sawKillIntent || sawInterruptIntent) {
             // Grace race: outcome settlement inside the window is stop proof.
             if (outcomeBox.status === "pending") {
                 const graceExpired = new Promise((resolve) => {
@@ -201,6 +265,16 @@ export async function runProjectionGeneration(input) {
                 const facts = killOutcome.status === "fulfilled"
                     ? nonReservedRunnerKillFacts(killOutcome.execution.facts)
                     : undefined;
+                if (sawInterruptIntent && killOutcome.status === "fulfilled" && killOutcome.execution.verdict === "interrupted") {
+                    return settleInterrupted(facts);
+                }
+                if (sawInterruptIntent) {
+                    if (killOutcome.status === "fulfilled")
+                        return settleRunnerOutcome(killOutcome.execution);
+                    if (killOutcome.status === "rejected")
+                        throw killOutcome.error;
+                    throw new Error("interrupt outcome did not establish provider stop");
+                }
                 const killed = store.runnerKilledIfRequested({
                     executionId: input.executionId,
                     ...(facts && Object.keys(facts).length > 0 ? { facts } : {}),
@@ -214,6 +288,8 @@ export async function runProjectionGeneration(input) {
             forceAbortInvoked = true;
             try {
                 await handle.abort("force");
+                if (sawInterruptIntent)
+                    return settleInterrupted();
                 const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
                 if (killed.status !== "committed")
                     return { status: "rejected" };
@@ -225,7 +301,7 @@ export async function runProjectionGeneration(input) {
                     executionId: input.executionId,
                     verdict: "failed",
                     facts: {
-                        operatorAction: "kill",
+                        ...(sawKillIntent ? { operatorAction: "kill" } : {}),
                         diagnostic: "escalation-failed",
                         detail: errorDetail(error),
                         failedAt: new Date(now()).toISOString(),
@@ -261,83 +337,86 @@ export async function runProjectionGeneration(input) {
         const tellFence = normalizeTellFence(pending.tellIds);
         if (tellFence.length > 0) {
             const successorExecutionId = createProjectionExecutionId(now());
-            const transition = store.handoff({
-                executionId: input.executionId,
-                completionFacts: execution.facts,
-                successorExecutionId,
-                successorFacts: successorLaunchFacts(current.launch, execution.facts, pending.effort, now),
-                tellFence,
-            });
-            if (transition.status !== "committed")
+            const successorFacts = successorLaunchFacts(current.launch, execution.facts, pending.effort, now);
+            let transitionReason;
+            if (!input.startSuccessor)
                 return { status: "rejected" };
-            settled = true;
-            // Handoff makes the predecessor terminal before life authority moves.
-            // A held projection lock must always mean that a current runner exists,
-            // so release it before the successor makes its one-shot acquisition.
-            runnerLock.close();
-            runnerLock = undefined;
             try {
-                input.spawnSuccessor?.(successorExecutionId);
+                const successorOwnership = runnerLock;
+                await input.startSuccessor(successorExecutionId, () => {
+                    const transition = store.handoff({
+                        executionId: input.executionId,
+                        completionFacts: execution.facts,
+                        successorExecutionId,
+                        successorFacts,
+                        tellFence,
+                    });
+                    if (transition.status !== "committed") {
+                        transitionReason = transition.reason;
+                        return false;
+                    }
+                    settled = true;
+                    return true;
+                }, successorOwnership);
+                runnerLock = undefined;
             }
-            catch (error) {
-                store.verdictIfOpen({
-                    executionId: successorExecutionId,
-                    verdict: "launch-failed",
-                    facts: {
-                        stage: "spawn",
-                        detail: `successor runner spawn failed: ${errorDetail(error)}`,
-                        terminalAt: new Date(now()).toISOString(),
-                    },
-                });
+            catch {
+                if (settled)
+                    return { status: "handed-off", successorExecutionId };
+                return settleRunnerOutcome(execution);
             }
-            return { status: "handed-off", successorExecutionId };
-        }
-        const verdict = store.verdictIfOpen({
-            executionId: input.executionId,
-            verdict: execution.verdict,
-            facts: execution.facts,
-        });
-        if (verdict.status !== "committed") {
-            // Kill intent may commit after the last outcome-boundary observation and
-            // before this transaction. The settled outcome is already stop proof.
-            if (verdict.reason === "kill-requested") {
-                const facts = nonReservedRunnerKillFacts(execution.facts);
-                const killed = store.runnerKilledIfRequested({
-                    executionId: input.executionId,
-                    ...(Object.keys(facts).length > 0 ? { facts } : {}),
-                });
-                if (killed.status !== "committed")
+            if (!settled) {
+                if (transitionReason !== "kill-requested" && transitionReason !== "interrupt-requested") {
                     return { status: "rejected" };
-                settled = true;
-                return { status: "completed" };
+                }
+            }
+            else {
+                return { status: "handed-off", successorExecutionId };
             }
-            return { status: "rejected" };
         }
-        settled = true;
-        return { status: "completed" };
+        return settleRunnerOutcome(execution);
     }
     catch (error) {
         if (adopted && !settled) {
-            store.verdictIfOpen({
+            let cleanupError;
+            if (handle) {
+                try {
+                    await handle.abort("force");
+                }
+                catch (failure) {
+                    cleanupError = failure;
+                }
+            }
+            const live = store.readCurrentGeneration();
+            const detail = error instanceof Error ? error.message : String(error);
+            store.runnerVerdictIfOpen({
                 executionId: input.executionId,
                 verdict: "failed",
                 facts: {
                     failedAt: new Date(now()).toISOString(),
-                    detail: error instanceof Error ? error.message : String(error),
+                    detail,
+                    ...(cleanupError ? {
+                        ...(live?.killIntent ? { operatorAction: "kill" } : {}),
+                        diagnostic: "cleanup-escalation-failed",
+                        cleanupDetail: errorDetail(cleanupError),
+                    } : {}),
                     error: {
                         version: OUTCOME_ERROR_VERSION,
                         code: "SUBAGENT_EXEC_ERROR",
-                        message: error instanceof Error ? error.message : String(error),
+                        message: detail,
                         timeoutMs: null,
                         exitCode: null,
                     },
                 },
+                terminalAt: new Date(now()).toISOString(),
             });
         }
         throw error;
     }
     finally {
         clearGraceTimer();
+        if (intentTimer !== undefined)
+            clearInterval(intentTimer);
         try {
             tellObserver?.close();
         }

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

@@ -1,15 +1,97 @@
-import { executeProjectionGeneration } from "./projection-generation-execution.js";
-import { spawnProjectionGenerationRunner } from "./projection-generation-process.js";
+import { prepareProjectionGenerationExecution } from "./projection-generation-execution.js";
+import { PROJECTION_RUNNER_BOOTSTRAP_ENV, } from "./projection-generation-process.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";
-export async function runProjectionGenerationRuntime(projectionDirectory, executionId) {
-    await runProjectionGeneration({
-        projectionDirectory,
-        executionId,
-        execute: (launch) => executeProjectionGeneration(projectionDirectory, launch),
-        snapshotPendingTells: () => snapshotPendingTells(projectionDirectory),
-        spawnSuccessor: (successorExecutionId) => {
-            spawnProjectionGenerationRunner(projectionDirectory, successorExecutionId);
-        },
+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);
     });
 }
+export async function wakeProjectionAfterInterrupt(projectionDirectory, wake = tellProjection) {
+    const pact = readProjectionIdentity(projectionDirectory);
+    try {
+        await wake(projectionDirectory, `${pact.akuma}/${path.basename(projectionDirectory)}`, undefined);
+    }
+    catch (error) {
+        persistInterruptWakeFailure(projectionDirectory, error);
+        throw error;
+    }
+}
+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;
+    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,
+            prepareExecution: (launch) => prepareProjectionGenerationExecution(projectionDirectory, launch),
+            snapshotPendingTells: () => snapshotPendingTells(projectionDirectory),
+            startSuccessor: async (successorExecutionId, commitLaunch, launchOwnership) => {
+                const started = await startProjectionGeneration(projectionDirectory, successorExecutionId, {
+                    commitLaunch,
+                    launchOwnership,
+                });
+                if (started.status === "failed")
+                    throw new Error(started.detail);
+            },
+            wakeAfterInterrupt: () => wakeProjectionAfterInterrupt(projectionDirectory),
+        });
+    }
+    finally {
+        runnerLock?.close();
+        transferTarget?.close();
+    }
+}

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

@@ -1,4 +1,4 @@
-import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, closeDatabase, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, } from "./database.js";
+import { PROJECTION_GENERATION_SCHEMA_VERSION, PROJECTION_GENERATION_STORE_FILE, assertDatabaseOpen, beginGenerationWriteTransaction, closeDatabase, commitGenerationWriteTransaction, openMutableDatabase, openReadOnlyDatabase, readValidatedHistory, rollbackGenerationWriteTransaction, } 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, };
@@ -21,8 +21,18 @@ export class ProjectionGenerationStore {
         return new ProjectionGenerationStore(databasePath, database, true);
     }
     close() {
+        rollbackGenerationWriteTransaction(this.#database);
         closeDatabase(this.#database);
     }
+    beginWriteTransaction() {
+        beginGenerationWriteTransaction(this.#database, this.readOnly);
+    }
+    commitWriteTransaction() {
+        commitGenerationWriteTransaction(this.#database);
+    }
+    rollbackWriteTransaction() {
+        rollbackGenerationWriteTransaction(this.#database);
+    }
     readRecords() {
         assertDatabaseOpen(this.#database);
         return readValidatedHistory(this.#database).records;
@@ -40,15 +50,27 @@ export class ProjectionGenerationStore {
     launchIfSettled(input) {
         return transitions.launchIfSettled(this.#database, this.readOnly, input);
     }
+    failInterruptWakeIfSettled(input) {
+        return transitions.failInterruptWakeIfSettled(this.#database, this.readOnly, input);
+    }
     adoptionIfCurrent(input) {
         return transitions.adoptionIfCurrent(this.#database, this.readOnly, input);
     }
     requestKillIfOpen(input) {
         return transitions.requestKillIfOpen(this.#database, this.readOnly, input);
     }
+    requestInterruptIfOpen(input) {
+        return transitions.requestInterruptIfOpen(this.#database, this.readOnly, input);
+    }
     runnerKilledIfRequested(input) {
         return transitions.runnerKilledIfRequested(this.#database, this.readOnly, input);
     }
+    runnerInterruptedIfRequested(input) {
+        return transitions.runnerInterruptedIfRequested(this.#database, this.readOnly, input);
+    }
+    runnerVerdictIfOpen(input) {
+        return transitions.runnerVerdictIfOpen(this.#database, this.readOnly, input);
+    }
     settleKillIfRunnerDead(input) {
         return transitions.settleKillIfRunnerDead(this.#database, this.readOnly, input);
     }
@@ -58,6 +80,9 @@ export class ProjectionGenerationStore {
     supersedeStartupTimeout(input) {
         return transitions.supersedeStartupTimeout(this.#database, this.readOnly, input);
     }
+    settleStartupFailure(input) {
+        return transitions.settleStartupFailure(this.#database, this.readOnly, input);
+    }
     replaceDeadRunner(input) {
         return transitions.replaceDeadRunner(this.#database, this.readOnly, input);
     }