@astrosheep/keiyaku 2.9.7 → 2.9.8

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

@@ -77,6 +77,7 @@ export async function runProjectionGeneration(input) {
     let tellObserver;
     let graceTimer;
     let intentTimer;
+    let handle;
     const clearGraceTimer = () => {
         if (graceTimer === undefined)
             return;
@@ -84,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() },
@@ -100,12 +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 retains its established settlement law. Interrupt
-        // intent must enter provider execution so only an actual stop can settle it.
+        // 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")
@@ -113,8 +118,21 @@ 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,
@@ -319,39 +337,40 @@ 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") {
-                if (transition.reason !== "kill-requested" && transition.reason !== "interrupt-requested") {
+            const successorFacts = successorLaunchFacts(current.launch, execution.facts, pending.effort, now);
+            let transitionReason;
+            if (!input.startSuccessor)
+                return { status: "rejected" };
+            try {
+                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 {
+                if (settled)
+                    return { status: "handed-off", successorExecutionId };
+                return settleRunnerOutcome(execution);
+            }
+            if (!settled) {
+                if (transitionReason !== "kill-requested" && transitionReason !== "interrupt-requested") {
                     return { status: "rejected" };
                 }
             }
             else {
-                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);
-                }
-                catch (error) {
-                    store.verdictIfOpen({
-                        executionId: successorExecutionId,
-                        verdict: "launch-failed",
-                        facts: {
-                            stage: "spawn",
-                            detail: `successor runner spawn failed: ${errorDetail(error)}`,
-                            terminalAt: new Date(now()).toISOString(),
-                        },
-                    });
-                }
                 return { status: "handed-off", successorExecutionId };
             }
         }
@@ -359,20 +378,37 @@ export async function runProjectionGeneration(input) {
     }
     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;

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

@@ -1,34 +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";
-import { recordInterruptWakeFailure, tellProjection } from "../projection-wake.js";
+import { persistInterruptWakeFailure, tellProjection } from "../projection-wake.js";
 import { readProjectionIdentity } from "../projection-identity.js";
-import { FlowError } from "../../../flow-error.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) {
-        const cause = error instanceof FlowError
-            && error.facts?.kind === "projection_wake_failure"
-            ? error.facts.cause
-            : "spawn";
-        recordInterruptWakeFailure(projectionDirectory, cause);
+        persistInterruptWakeFailure(projectionDirectory, error);
         throw error;
     }
 }
 export async function runProjectionGenerationRuntime(projectionDirectory, executionId) {
-    await runProjectionGeneration({
-        projectionDirectory,
-        executionId,
-        execute: (launch) => executeProjectionGeneration(projectionDirectory, launch),
-        snapshotPendingTells: () => snapshotPendingTells(projectionDirectory),
-        spawnSuccessor: (successorExecutionId) => {
-            spawnProjectionGenerationRunner(projectionDirectory, successorExecutionId);
-        },
-        wakeAfterInterrupt: () => wakeProjectionAfterInterrupt(projectionDirectory),
-    });
+    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,6 +50,9 @@ 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);
     }
@@ -67,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);
     }

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

@@ -1,5 +1,5 @@
 import { appendRecord, readValidatedHistory, writeTransition, } from "./database.js";
-import { ProjectionGenerationStoreError, VERDICTS, assertExecutionId, assertIsoTimestamp, assertNonNegativeSafeInteger, assertPositiveSafeInteger, cloneFacts, validateAdoptionFacts, validateInterruptIntentFacts, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
+import { ProjectionGenerationStoreError, VERDICTS, assertExecutionId, assertIsoTimestamp, cloneFacts, validateAdoptionFacts, validateInterruptIntentFacts, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
 function committed(records) {
     return { status: "committed", records };
 }
@@ -20,6 +20,38 @@ export function launchIfSettled(database, readOnly, input) {
         return committed([appendRecord(database, "launch", executionId, facts, history.records.length + 1)]);
     });
 }
+/** Persist an asynchronous interrupt wake rejection as one closed successor. */
+export function failInterruptWakeIfSettled(database, readOnly, input) {
+    const predecessorExecutionId = assertExecutionId(input.predecessorExecutionId);
+    const successorExecutionId = assertExecutionId(input.successorExecutionId);
+    const successorFacts = validateLaunchFacts(input.successorFacts, "interrupt wake successor launch facts");
+    const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== predecessorExecutionId)
+            return rejected("not-current", current);
+        if (current.verdict?.facts.state !== "interrupted") {
+            return rejected(current.verdict ? "already-terminal" : "current-generation-open", current);
+        }
+        if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {
+            return rejected("execution-id-already-used", current);
+        }
+        const verdictFacts = validateVerdictFacts({
+            state: "launch-failed",
+            cause: input.cause,
+            tellRetained: true,
+            terminalAt,
+        }, "interrupt wake failure verdict facts");
+        const firstSeq = history.records.length + 1;
+        return committed([
+            appendRecord(database, "launch", successorExecutionId, successorFacts, firstSeq),
+            appendRecord(database, "verdict", successorExecutionId, verdictFacts, firstSeq + 1),
+        ]);
+    });
+}
 export function adoptionIfCurrent(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const facts = validateAdoptionFacts(input.facts, "adoption facts");
@@ -240,15 +272,15 @@ export function verdictIfOpen(database, readOnly, input) {
             return rejected("not-current", current);
         if (current.verdict)
             return rejected("already-terminal", current);
+        if (input.verdict === "launch-failed" && current.adoption) {
+            return rejected("already-adopted", current);
+        }
         if (current.killIntent) {
             const killEscalationFailed = input.verdict === "failed"
                 && input.facts?.operatorAction === "kill";
             if (!killEscalationFailed)
                 return rejected("kill-requested", current);
         }
-        if (input.verdict === "launch-failed" && current.adoption) {
-            return rejected("already-adopted", current);
-        }
         const facts = validateVerdictFacts({ ...(input.facts ?? {}), state: input.verdict, ...(input.terminalAt ? { terminalAt: assertIsoTimestamp(input.terminalAt, "terminalAt") } : {}) }, "verdict facts");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
@@ -256,8 +288,10 @@ export function verdictIfOpen(database, readOnly, input) {
 export function supersedeStartupTimeout(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const successorExecutionId = assertExecutionId(input.successorExecutionId);
-    const observedAtMs = assertNonNegativeSafeInteger(input.observedAtMs, "observedAtMs");
-    const startupTimeoutMs = assertPositiveSafeInteger(input.startupTimeoutMs, "startupTimeoutMs");
+    const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released startup-lock evidence");
+    if (Object.keys(releasedLockEvidence).length === 0) {
+        throw new ProjectionGenerationStoreError("released startup-lock evidence must not be empty");
+    }
     const diagnostic = cloneFacts(input.diagnostic, "startup-timeout diagnostic");
     const successorFacts = validateLaunchFacts(input.successorFacts, "successor launch facts");
     const terminalAt = input.terminalAt === undefined
@@ -272,19 +306,24 @@ export function supersedeStartupTimeout(database, readOnly, input) {
             return rejected("not-current", current);
         if (current.verdict)
             return rejected("already-terminal", current);
-        if (current.killIntent)
-            return rejected("kill-requested", current);
         if (current.adoption)
             return rejected("already-adopted", current);
+        if (current.killIntent) {
+            const verdictFacts = validateVerdictFacts({
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                releasedLockEvidence,
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup-timeout killed verdict facts");
+            return committed([appendRecord(database, "verdict", executionId, verdictFacts, history.records.length + 1)]);
+        }
         if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {
             return rejected("execution-id-already-used", current);
         }
-        const launchedAtMs = Date.parse(current.launch.facts.createdAt);
-        if (observedAtMs - launchedAtMs < startupTimeoutMs) {
-            return rejected("startup-timeout-not-elapsed", current);
-        }
         const verdictFactsBase = {
             ...diagnostic,
+            releasedLockEvidence,
             state: "launch-failed",
             ...(terminalAt === undefined ? {} : { terminalAt }),
         };
@@ -296,6 +335,44 @@ export function supersedeStartupTimeout(database, readOnly, input) {
         ]);
     });
 }
+export function settleStartupFailure(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released startup-lock evidence");
+    if (Object.keys(releasedLockEvidence).length === 0) {
+        throw new ProjectionGenerationStoreError("released startup-lock evidence must not be empty");
+    }
+    const diagnostic = cloneFacts(input.diagnostic, "startup failure diagnostic");
+    const terminalAt = input.terminalAt === undefined
+        ? undefined
+        : assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        if (current.adoption)
+            return rejected("already-adopted", current);
+        const facts = current.killIntent
+            ? validateVerdictFacts({
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                releasedLockEvidence,
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup failure killed verdict facts")
+            : validateVerdictFacts({
+                ...diagnostic,
+                releasedLockEvidence,
+                state: "launch-failed",
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup failure verdict facts");
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function replaceDeadRunner(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const successorExecutionId = assertExecutionId(input.successorExecutionId);

package/build/core/projection/index.js

@@ -12,8 +12,8 @@ export { readProjectionIdentity } from "./projection-identity.js";
 export { interruptProjectionGeneration, killProjectionGeneration } from "./projection-kill.js";
 export { observeProjectionLife, observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 export { mintProjection, mintRepositoryProjection, ProjectionMintCollisionError, } from "./projection-mint.js";
-export { acquireProjectionRunnerLock, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
-export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readProjectionStatusBoard, } from "./projection-status.js";
+export { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, acquireProjectionRunnerTransferTarget, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
+export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readAkumaNonterminalProjectionStatus, readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "./projection-status.js";
 export { projectTerminalFailure, } from "./projection-terminal-failure.js";
 export { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet, } from "./projection-wait.js";
 export { assertTellEffortSupported, assertProjectionTellable, tellProjection, } from "./projection-wake.js";
@@ -22,6 +22,6 @@ export { createProjectionExecutionId } from "./generation/projection-generation-
 export { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
 export { projectionGenerationRunnerArgv, spawnProjectionGenerationRunner, } from "./generation/projection-generation-process.js";
 export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
-export { executeProjectionGeneration } from "./generation/projection-generation-execution.js";
+export { executeProjectionGeneration, prepareProjectionGenerationExecution, } from "./generation/projection-generation-execution.js";
 export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";
 export { claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readPendingTellWindow, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";

package/build/core/projection/projection-kill.js

@@ -1,5 +1,5 @@
 import { openProjectionGenerationStore } from "./generation/store.js";
-import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+import { acquireProjectionRunnerSettlementLock, observeProjectionRunnerLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.js";
 /** The runner observes this durable intent and owns native termination. */
 export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.now()) {
     const store = openProjectionGenerationStore(projectionDirectory);
@@ -32,18 +32,30 @@ export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.
     }
 }
 function settleReleasedLeash(store, projectionDirectory, executionId) {
-    const observation = observeProjectionRunnerLock(projectionDirectory);
-    if (observation.state === "held" || observation.state === "unknown") {
+    const current = store.readCurrentGeneration();
+    if (current?.launch.executionId !== executionId
+        || current.verdict) {
         return { status: "accepted", executionId };
     }
-    // Positive released-leash evidence only; settlement race still reports accepted.
-    store.settleKillIfRunnerDead({
-        executionId,
-        releasedLockEvidence: {
-            state: "released",
+    let deathEvidence;
+    try {
+        deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
+    }
+    catch (error) {
+        if (error instanceof ProjectionRunnerLockUnavailableError) {
+            return { status: "accepted", executionId };
+        }
+        return { status: "accepted", executionId };
+    }
+    try {
+        store.settleKillIfRunnerDead({
             executionId,
-        },
-    });
+            releasedLockEvidence: { state: "acquired", executionId },
+        });
+    }
+    finally {
+        deathEvidence.close();
+    }
     return { status: "accepted", executionId };
 }
 /**