@astrosheep/keiyaku 2.9.6 → 2.9.7

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, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
+import { ProjectionGenerationStoreError, VERDICTS, assertExecutionId, assertIsoTimestamp, assertNonNegativeSafeInteger, assertPositiveSafeInteger, cloneFacts, validateAdoptionFacts, validateInterruptIntentFacts, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
 function committed(records) {
     return { status: "committed", records };
 }
@@ -51,10 +51,32 @@ export function requestKillIfOpen(database, readOnly, input) {
             return rejected("already-terminal", current);
         if (current.killIntent)
             return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
         const facts = validateKillIntentFacts({ operatorAction: "kill", killedAt }, "kill-intent facts");
         return committed([appendRecord(database, "kill-intent", executionId, facts, history.records.length + 1)]);
     });
 }
+export function requestInterruptIfOpen(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const interruptedAt = assertIsoTimestamp(input.interruptedAt, "interruptedAt");
+    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.killIntent)
+            return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
+        const facts = validateInterruptIntentFacts({ interruptedAt }, "interrupt-intent facts");
+        return committed([appendRecord(database, "interrupt-intent", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function runnerKilledIfRequested(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const callerFacts = cloneFacts(input.facts ?? {}, "killed verdict facts");
@@ -87,6 +109,84 @@ export function runnerKilledIfRequested(database, readOnly, input) {
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
 }
+export function runnerInterruptedIfRequested(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const callerFacts = cloneFacts(input.facts ?? {}, "interrupted verdict facts");
+    for (const reserved of ["state", "interruptIntentSeq", "interruptedAt", "terminalAt"]) {
+        if (reserved in callerFacts) {
+            throw new ProjectionGenerationStoreError(`interrupted verdict facts.${reserved} is reserved`);
+        }
+    }
+    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.interruptIntent)
+            return rejected("kill-not-requested", current);
+        const facts = validateVerdictFacts({
+            ...callerFacts,
+            state: "interrupted",
+            interruptIntentSeq: current.interruptIntent.seq,
+            interruptedAt: current.interruptIntent.facts.interruptedAt,
+            ...(terminalAt ? { terminalAt } : {}),
+        }, "interrupted verdict facts");
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
+/** Publish a stopped provider outcome while atomically honoring any stop intent that won first. */
+export function runnerVerdictIfOpen(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    if (!VERDICTS.has(input.verdict))
+        throw new ProjectionGenerationStoreError(`unknown verdict '${String(input.verdict)}'`);
+    if (input.verdict === "killed" || input.verdict === "interrupted" || input.verdict === "launch-failed" || input.verdict === "lost-runner") {
+        throw new ProjectionGenerationStoreError(`runner outcome verdict '${input.verdict}' is not publishable`);
+    }
+    const callerFacts = cloneFacts(input.facts ?? {}, "runner verdict 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 !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        let facts;
+        if (current.interruptIntent) {
+            const { state: _state, interruptIntentSeq: _seq, interruptedAt: _at, terminalAt: _terminal, ...rest } = callerFacts;
+            facts = validateVerdictFacts({
+                ...rest,
+                state: "interrupted",
+                interruptIntentSeq: current.interruptIntent.seq,
+                interruptedAt: current.interruptIntent.facts.interruptedAt,
+                terminalAt,
+            }, "runner interrupted verdict facts");
+        }
+        else if (current.killIntent && !(input.verdict === "failed" && callerFacts.operatorAction === "kill")) {
+            const { state: _state, killIntentSeq: _seq, killedAt: _at, terminalAt: _terminal, ...rest } = callerFacts;
+            facts = validateVerdictFacts({
+                ...rest,
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                terminalAt,
+            }, "runner killed verdict facts");
+        }
+        else {
+            facts = validateVerdictFacts({ ...callerFacts, state: input.verdict, terminalAt }, "runner verdict facts");
+        }
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function settleKillIfRunnerDead(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released runner-lock evidence");
@@ -128,8 +228,8 @@ export function verdictIfOpen(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     if (!VERDICTS.has(input.verdict))
         throw new ProjectionGenerationStoreError(`unknown verdict '${String(input.verdict)}'`);
-    if (input.verdict === "killed") {
-        throw new ProjectionGenerationStoreError("verdict 'killed' is reserved to runnerKilledIfRequested and settleKillIfRunnerDead");
+    if (input.verdict === "killed" || input.verdict === "interrupted") {
+        throw new ProjectionGenerationStoreError(`verdict '${input.verdict}' is reserved to its runner-owned transition`);
     }
     return writeTransition(database, readOnly, () => {
         const history = readValidatedHistory(database);
@@ -259,6 +359,8 @@ export function handoff(database, readOnly, input) {
             return rejected("already-terminal", current);
         if (current.killIntent)
             return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
         if (!current.adoption)
             return rejected("not-adopted", current);
         if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {

package/build/core/projection/index.js

@@ -9,7 +9,7 @@ export { assertProjectionAlias, isProjectionAlias, moveProjectionAlias, projecti
 export { resolveProjectionCoordinate } from "./projection-coordinate.js";
 export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionRoot, readProjectionEvents, } from "./projection-core.js";
 export { readProjectionIdentity } from "./projection-identity.js";
-export { killProjectionGeneration } from "./projection-kill.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";
@@ -24,4 +24,4 @@ export { projectionGenerationRunnerArgv, spawnProjectionGenerationRunner, } from
 export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
 export { executeProjectionGeneration } from "./generation/projection-generation-execution.js";
 export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";
-export { claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";
+export { claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readPendingTellWindow, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";

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

@@ -5,7 +5,7 @@ import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "../atomic-publish.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 export { isTellCausallyConsumed, } from "./tell/model.js";
-export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
+export { claimAllInbox, claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
 export const PROJECTION_ID_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*\/[0-9a-f]{8}$/;

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

@@ -1,5 +1,36 @@
 import { openProjectionGenerationStore } from "./generation/store.js";
 import { observeProjectionRunnerLock } 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);
+    try {
+        for (;;) {
+            const current = store.readCurrentGeneration();
+            if (!current)
+                return { status: "already-closed" };
+            if (current.verdict)
+                return { status: "already-closed", executionId: current.launch.executionId };
+            const executionId = current.launch.executionId;
+            if (!current.adoption || observeProjectionRunnerLock(projectionDirectory).state !== "held") {
+                return { status: "already-closed", executionId };
+            }
+            const request = store.requestInterruptIfOpen({
+                executionId,
+                interruptedAt: new Date(nowMs).toISOString(),
+            });
+            if (request.status === "committed")
+                return { status: "accepted", executionId };
+            if (request.reason === "not-current")
+                continue;
+            if (request.reason === "interrupt-requested")
+                return { status: "accepted", executionId };
+            return { status: "already-closed", executionId };
+        }
+    }
+    finally {
+        store.close();
+    }
+}
 function settleReleasedLeash(store, projectionDirectory, executionId) {
     const observation = observeProjectionRunnerLock(projectionDirectory);
     if (observation.state === "held" || observation.state === "unknown") {

package/build/core/projection/projection-life-protocol.js

@@ -4,6 +4,7 @@ export const GENERATION_VERDICT_STATES = [
     "launch-failed",
     "lost-runner",
     "dismissed",
+    "interrupted",
     "killed",
 ];
 function asLaunch(record) {
@@ -21,6 +22,11 @@ function asKillIntent(record) {
         ? record
         : undefined;
 }
+function asInterruptIntent(record) {
+    return record.kind === "interrupt-intent"
+        ? record
+        : undefined;
+}
 function asVerdict(record) {
     return record.kind === "verdict"
         ? record
@@ -41,18 +47,21 @@ export function selectCurrentGeneration(records) {
         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 ??= asAdoption(record);
         killIntent ??= asKillIntent(record);
+        interruptIntent ??= asInterruptIntent(record);
         verdict ??= asVerdict(record);
     }
     return {
         launch,
         ...(adoption ? { adoption } : {}),
         ...(killIntent ? { killIntent } : {}),
+        ...(interruptIntent ? { interruptIntent } : {}),
         ...(verdict ? { verdict } : {}),
     };
 }
@@ -67,6 +76,7 @@ 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":

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

@@ -7,10 +7,12 @@ import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
 import { extractTerminalTimestamp } from "./generation/model.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./projection-life-protocol.js";
-import { readProjectionTellCounts } from "./tell/store.js";
+import { deriveProjectionLife } from "./projection-life-protocol.js";
+import { readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
 import { projectTerminalFailure, } from "./projection-terminal-failure.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "../stored-agent-event.js";
+import { tellProjection } from "./projection-wake.js";
+import { FlowError } from "../../flow-error.js";
 /** Return the commission-bound projection IDs visible at one admission instant. */
 export async function snapshotCommissionProjectionIds(cwd, commissionId) {
     const root = await projectionRoot(cwd);
@@ -73,10 +75,6 @@ const WAIT_POLL_MS = 100;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function waitingTellCount(projectionDirectory) {
-    const counts = readProjectionTellCounts(projectionDirectory);
-    return counts.inbox + counts.inflight + counts.submitted + counts.delivered;
-}
 function latestValidEventAgeMs(events, nowMs) {
     let latest;
     for (const event of events) {
@@ -125,7 +123,7 @@ function outcomeText(current) {
     return undefined;
 }
 function buildSnapshot(input) {
-    const { projectionDirectory, pact, phase, current, events, malformedEvents, nowMs } = input;
+    const { projectionDirectory, pact, phase, current, events, malformedEvents, nowMs, tells } = input;
     const anchorAt = current?.verdict ? timestampFact(current, nowMs) : new Date(nowMs).toISOString();
     const anchorMs = Date.parse(anchorAt);
     const mintedAtMs = Date.parse(pact.mintedAt);
@@ -142,7 +140,7 @@ function buildSnapshot(input) {
             ? Math.max(0, anchorMs - mintedAtMs)
             : 0,
         ...(activityAgeMs !== undefined ? { activityAgeMs } : {}),
-        tellsWaiting: waitingTellCount(projectionDirectory),
+        tells,
         activity: foldPublicProjectionActivity(events),
         ...(invalidActivity ? { eventDiagnostics: [invalidActivity] } : {}),
         workspaceRoot: pact.workspaceRoot,
@@ -168,25 +166,64 @@ export async function waitForProjection(input) {
     }
     const deadline = input.deadlineMs
         ?? (input.timeoutMs === undefined ? undefined : now() + input.timeoutMs);
+    const wakeProjection = input.wakeProjection ?? ((directory, id) => tellProjection(directory, id));
+    const readContinuationSnapshot = input.readContinuationSnapshot ?? readProjectionGenerationContinuationSnapshot;
+    let wakeAttempted = false;
     for (;;) {
         input.signal?.throwIfAborted();
         const observedAtMs = now();
-        const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
+        const continuation = readContinuationSnapshot(input.projectionDirectory, 10);
+        const current = continuation.current;
+        let life = deriveProjectionLife({
+            records: continuation.records,
             nowMs: observedAtMs,
             startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
         });
-        const current = observation.compatibility === "current" && observation.records
-            ? selectCurrentGeneration(observation.records)
-            : null;
-        const life = observation.compatibility === "current"
-            ? observation.life
-            : { phase: "unknown", diagnostic: observation.diagnostic };
+        if (current && !current.verdict && current.adoption) {
+            const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
+                nowMs: observedAtMs,
+                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+            });
+            if (observation.compatibility === "incompatible") {
+                life = { phase: "unknown", diagnostic: observation.diagnostic };
+            }
+            else if ((observation.records?.at(-1)?.seq ?? 0) !== continuation.generationSequence) {
+                continue;
+            }
+            else {
+                life = observation.life;
+            }
+        }
+        if (!wakeAttempted
+            && current
+            && life.phase !== "active"
+            && life.phase !== "minting"
+            && life.phase !== "quiescent"
+            && life.phase !== "unknown"
+            && continuation.requiresWake) {
+            wakeAttempted = true;
+            try {
+                const wakeState = await wakeProjection(input.projectionDirectory, `${pact.akuma}/${path.basename(input.projectionDirectory)}`);
+                if (wakeState === "active" || wakeState === "woken")
+                    continue;
+            }
+            catch (error) {
+                if (!(error instanceof FlowError) || error.code !== "PROJECTION_WAKE_FAILED")
+                    throw error;
+                // The wake path persisted any launch/adoption failure. Refresh once so
+                // this invocation reports that typed truth without retrying in a loop.
+                continue;
+            }
+        }
         const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
         const terminal = verdict !== undefined;
         const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);
         const terminalWithinDeadline = terminal && (input.deadlineMs === undefined
             || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < input.deadlineMs));
         if (terminalWithinDeadline || (deadline !== undefined && observedAtMs >= deadline)) {
+            const revalidated = readContinuationSnapshot(input.projectionDirectory, 10);
+            if (revalidated.generationSequence !== continuation.generationSequence)
+                continue;
             const stored = current
                 ? readGenerationEvents(input.projectionDirectory, current.launch.executionId)
                 : [];
@@ -199,6 +236,7 @@ export async function waitForProjection(input) {
                 events,
                 malformedEvents: malformed,
                 nowMs: observedAtMs,
+                tells: revalidated.tells,
             });
             if (terminalWithinDeadline && current) {
                 const text = outcomeText(current);

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

@@ -2,13 +2,42 @@ import { FlowError } from "../../flow-error.js";
 import { parseResolvedAkumaLaunchSnapshot } from "../../agents/launch-snapshot/model.js";
 import { isRecoverableSessionEnvelope } from "../../agents/harness/index.js";
 import { ProjectionStateError } from "../atomic-publish.js";
-import { applyContinuationEffort, snapshotPendingTells, } from "./generation/projection-generation-continuation.js";
+import { applyContinuationEffort, readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
 import { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
 import { PROJECTION_ADOPTION_POLL_MS, PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
 import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 import { setTimeout as delay } from "node:timers/promises";
+/** Persist an asynchronous interrupt wake failure at the generation boundary. */
+export function recordInterruptWakeFailure(projectionDirectory, cause, nowMs = Date.now()) {
+    const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
+    const current = continuation.current;
+    if (!current || !current.verdict || current.verdict.facts.state !== "interrupted")
+        return;
+    const snapshot = continuation.successor;
+    const executionId = createProjectionExecutionId(nowMs);
+    const facts = successorFacts(current, snapshot, nowMs, false);
+    const store = openProjectionGenerationStore(projectionDirectory);
+    try {
+        const launch = store.launchIfSettled({ executionId, facts });
+        if (launch.status !== "committed")
+            return;
+        store.verdictIfOpen({
+            executionId,
+            verdict: "launch-failed",
+            facts: {
+                stage: "interrupt-wake",
+                cause,
+                tellRetained: true,
+                terminalAt: new Date(nowMs).toISOString(),
+            },
+        });
+    }
+    finally {
+        store.close();
+    }
+}
 function incompatibleProjectionError(projectionId) {
     const subject = projectionId ? `Projection '${projectionId}'` : "Projection";
     return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; keiyaku status --all can inspect it, but tell cannot change it.`);
@@ -148,12 +177,15 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         if (life.phase === "unknown") {
             return "pending";
         }
-        const current = readCurrentGeneration(projectionDirectory);
+        const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
+        const current = continuation.current;
         if (!current)
             return "pending";
         if (current.killIntent && !current.verdict)
             return "pending";
-        const snapshot = snapshotPendingTells(projectionDirectory);
+        if (!continuation.requiresWake)
+            return "pending";
+        const snapshot = continuation.successor;
         const successorExecutionId = createProjectionExecutionId(nowMs);
         let facts;
         try {

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

@@ -42,6 +42,24 @@ export function withRead(projectionDirectory, read) {
         database.close();
     }
 }
+export function withReadSnapshot(projectionDirectory, read) {
+    const database = openDatabase(projectionDirectory, true);
+    try {
+        database.exec("BEGIN");
+        try {
+            const result = read(database);
+            database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            rollbackQuietly(database);
+            throw error;
+        }
+    }
+    finally {
+        database.close();
+    }
+}
 export function withWrite(projectionDirectory, write) {
     const database = openDatabase(projectionDirectory, false);
     try {

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

@@ -6,6 +6,7 @@ export const PROJECTION_TELL_STATES = [
     "consumed",
     "delivered",
 ];
+export const PENDING_PROJECTION_TELL_STATES = ["inbox", "inflight", "submitted"];
 export function requireExecutionId(value) {
     if (typeof value !== "string" || value.trim() === "") {
         throw new ProjectionStateError("submitted tell executionId must be a non-empty string");