@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,489 +0,0 @@
-import { openProjectionGenerationStore, } from "./store.js";
-import { acquireRunnerLease, observeRunnerLease, } from "../../run-control/runner-lease.js";
-import { beginConnectionBoundRunnerClose } from "../../run-control/connection-bound-close.js";
-import { createProjectionExecutionId, projectionRunnerLeasePath } from "./projection-generation-identity.js";
-import { applyContinuationEffort, } from "./projection-generation-continuation.js";
-import { openProjectionTellObserver } from "./database.js";
-import { OUTCOME_ERROR_VERSION } from "../../../agents/types.js";
-import { openProjectionGenerationDoorbell, } from "./projection-generation-doorbell.js";
-/** Private runner-side kill grace. Not a setting, env, parameter, or export. */
-const KILL_GRACE_MS = 5000;
-function successorLaunchFacts(launch, completionFacts, effort, now) {
-    const { tellFence: _tellFence, ...inherited } = launch.facts;
-    const rawInputs = launch.facts.inputs;
-    const inputs = rawInputs
-        && typeof rawInputs === "object"
-        && !Array.isArray(rawInputs)
-        ? rawInputs
-        : {};
-    // Revive source identity is launch-local; never inherit it onto a tell handoff successor.
-    const { sourceArtifactId: _sourceArtifactId, ...inheritedInputs } = inputs;
-    return {
-        ...inherited,
-        createdAt: new Date(now()).toISOString(),
-        launchedBy: "sweep-wake",
-        parentExecutionId: launch.executionId,
-        inputs: applyContinuationEffort({
-            ...inheritedInputs,
-            ...(completionFacts.session ? { session: completionFacts.session } : {}),
-            ...(typeof completionFacts.responsePath === "string"
-                ? { resumePath: completionFacts.responsePath }
-                : {}),
-        }, effort),
-    };
-}
-function normalizeTellFence(tellIds) {
-    return [...new Set(tellIds)].sort();
-}
-function errorDetail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function nonReservedRunnerKillFacts(facts) {
-    const { state: _state, killIntentSeq: _killIntentSeq, killedAt: _killedAt, ...rest } = facts;
-    return rest;
-}
-function readOutcomeState(state) {
-    if (state.status === "fulfilled") {
-        return { status: "fulfilled", execution: state.execution };
-    }
-    if (state.status === "rejected") {
-        return { status: "rejected", error: state.error };
-    }
-    return { status: "pending" };
-}
-function acquireRunnerLockOrObserveDuplicate(projectionDirectory) {
-    try {
-        return acquireRunnerLease(projectionRunnerLeasePath(projectionDirectory));
-    }
-    catch (error) {
-        if (observeRunnerLease(projectionRunnerLeasePath(projectionDirectory)).state === "held") {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function observeAbandoned(promise) {
-    void promise.then(() => { }, () => { });
-}
-/**
- * Own one exact generation from kernel-lock acquisition through its terminal
- * transaction. Provider execution is injected so this actor never depends on
- * harness, catalog, renderer, or mailbox storage details.
- */
-export async function runProjectionGeneration(input) {
-    const now = input.now ?? Date.now;
-    const store = openProjectionGenerationStore(input.projectionDirectory);
-    let runnerLock;
-    let adopted = false;
-    let settled = false;
-    let tellObserver;
-    let doorbell;
-    let graceTimer;
-    let handle;
-    let gracefulAbortInvoked = false;
-    let forceAbortInvoked = false;
-    let sawKillIntent = false;
-    let sawInterruptIntent = false;
-    let wakeAfterLockRelease = false;
-    let pullStopIntent;
-    let notifyMainWait;
-    const commitTerminal = (stage) => {
-        if (!runnerLock)
-            throw new Error("runner lease is not held");
-        const close = beginConnectionBoundRunnerClose(store.connectionForRunnerClose(), runnerLock);
-        try {
-            const transition = stage();
-            if (transition.status !== "committed") {
-                close.rollback();
-                return transition;
-            }
-            close.commit();
-            runnerLock = undefined;
-            return transition;
-        }
-        catch (error) {
-            if (close.leaseOwnership === "retained")
-                close.rollback();
-            else
-                runnerLock = undefined;
-            throw error;
-        }
-    };
-    const clearGraceTimer = () => {
-        if (graceTimer === undefined)
-            return;
-        clearTimeout(graceTimer);
-        graceTimer = undefined;
-    };
-    try {
-        runnerLock = input.runnerLock
-            ?? acquireRunnerLockOrObserveDuplicate(input.projectionDirectory);
-        if (!runnerLock)
-            return { status: "duplicate" };
-        tellObserver = openProjectionTellObserver(input.projectionDirectory);
-        // Establish the version fence before the listener becomes reachable. The
-        // forced pull below still sees intent committed before listener startup.
-        tellObserver.hasDataVersionChanged();
-        pullStopIntent = (force = false) => {
-            try {
-                if (!force && !tellObserver.hasDataVersionChanged())
-                    return undefined;
-                const live = store.readCurrentGeneration();
-                if (live?.launch.executionId !== input.executionId || live?.verdict)
-                    return live;
-                sawKillIntent = live.killIntent !== undefined;
-                sawInterruptIntent = live.interruptIntent !== undefined;
-                if (!sawKillIntent && !sawInterruptIntent)
-                    return live;
-                if (gracefulAbortInvoked || !handle)
-                    return live;
-                gracefulAbortInvoked = true;
-                void handle.abort("graceful").catch(() => {
-                    // A failed native stop does not alter durable intent truth.
-                });
-                return live;
-            }
-            catch {
-                // Observation failure is unknown, never evidence about the provider.
-                return undefined;
-            }
-        };
-        doorbell = await openProjectionGenerationDoorbell({
-            identity: store.readIdentity(),
-            executionId: input.executionId,
-            onRing: () => {
-                pullStopIntent?.(true);
-                notifyMainWait?.();
-            },
-        });
-        // This is the one baseline heart pull after listener registration. It
-        // covers intent committed while the listener did not yet exist.
-        const initial = pullStopIntent(true);
-        if (initial?.launch.executionId !== input.executionId
-            || initial.adoption
-            || initial.verdict) {
-            return { status: "rejected" };
-        }
-        const adoption = store.adoptionIfCurrent({
-            executionId: input.executionId,
-            facts: { adoptedAt: new Date(now()).toISOString() },
-        });
-        if (adoption.status !== "committed")
-            return { status: "rejected" };
-        adopted = true;
-        let current = store.readCurrentGeneration();
-        if (current?.launch.executionId !== input.executionId) {
-            throw new Error("adopted generation stopped being current");
-        }
-        // Adoption is the provider-admission boundary. A kill that committed first
-        // settles without constructing a provider execution.
-        if (current.killIntent) {
-            const killed = commitTerminal(() => store.runnerKilledIfRequested({
-                executionId: input.executionId,
-                terminalAt: new Date(now()).toISOString(),
-            }));
-            if (killed.status !== "committed")
-                return { status: "rejected" };
-            settled = true;
-            return { status: "completed" };
-        }
-        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 = commitTerminal(() => store.runnerKilledIfRequested({
-                executionId: input.executionId,
-                terminalAt: new Date(now()).toISOString(),
-            }));
-            if (killed.status !== "committed")
-                return { status: "rejected" };
-            settled = true;
-            return { status: "completed" };
-        }
-        handle = prepared.start();
-        const settleInterrupted = (facts = {}) => {
-            pullStopIntent?.(true);
-            const transition = commitTerminal(() => store.runnerInterruptedIfRequested({
-                executionId: input.executionId,
-                facts,
-                terminalAt: new Date(now()).toISOString(),
-            }));
-            if (transition.status !== "committed")
-                return { status: "rejected" };
-            settled = true;
-            wakeAfterLockRelease = true;
-            return { status: "completed" };
-        };
-        const settleRunnerOutcome = (execution) => {
-            pullStopIntent?.(true);
-            const transition = commitTerminal(() => store.runnerVerdictIfOpen({
-                executionId: input.executionId,
-                verdict: execution.verdict,
-                facts: execution.facts,
-                terminalAt: new Date(now()).toISOString(),
-            }));
-            if (transition.status !== "committed")
-                return { status: "rejected" };
-            settled = true;
-            if (transition.records[0]?.facts.state === "interrupted") {
-                wakeAfterLockRelease = true;
-            }
-            return { status: "completed" };
-        };
-        const observeStopBoundary = () => { pullStopIntent?.(); };
-        // Mutable box so async settlement is readable without control-flow narrowing traps.
-        const outcomeBox = { status: "pending" };
-        let resolveActivity;
-        const activityChanged = () => new Promise((resolve) => {
-            resolveActivity = resolve;
-        });
-        const bumpActivity = () => {
-            const resolve = resolveActivity;
-            resolveActivity = undefined;
-            resolve?.();
-        };
-        notifyMainWait = bumpActivity;
-        const outcomeWatch = handle.outcome.then((execution) => {
-            outcomeBox.status = "fulfilled";
-            outcomeBox.execution = execution;
-            observeStopBoundary();
-            bumpActivity();
-        }, (error) => {
-            outcomeBox.status = "rejected";
-            outcomeBox.error = error;
-            observeStopBoundary();
-            bumpActivity();
-        });
-        // Always rejection-observe so abandon paths never surface unhandled rejections.
-        observeAbandoned(outcomeWatch);
-        const eventDrainState = { closed: false };
-        const eventDrain = (async () => {
-            try {
-                for await (const _event of handle.events) {
-                    if (forceAbortInvoked)
-                        return;
-                    observeStopBoundary();
-                    bumpActivity();
-                }
-            }
-            catch {
-                // Public event delivery is observation-only; outcome owns terminal truth.
-            }
-            finally {
-                eventDrainState.closed = true;
-                bumpActivity();
-            }
-        })();
-        observeAbandoned(eventDrain);
-        while (outcomeBox.status === "pending" && !sawKillIntent && !sawInterruptIntent) {
-            const wakeSources = [outcomeWatch, activityChanged()];
-            if (!eventDrainState.closed)
-                wakeSources.push(eventDrain);
-            await Promise.race(wakeSources);
-            observeStopBoundary();
-        }
-        if (sawKillIntent || sawInterruptIntent) {
-            // Grace race: outcome settlement inside the window is stop proof.
-            if (outcomeBox.status === "pending") {
-                const graceExpired = new Promise((resolve) => {
-                    graceTimer = setTimeout(() => {
-                        graceTimer = undefined;
-                        resolve("timeout");
-                    }, KILL_GRACE_MS);
-                });
-                await Promise.race([
-                    outcomeWatch.then(() => "outcome"),
-                    graceExpired,
-                ]);
-                clearGraceTimer();
-            }
-            const killOutcome = readOutcomeState(outcomeBox);
-            if (killOutcome.status !== "pending") {
-                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 = commitTerminal(() => store.runnerKilledIfRequested({
-                    executionId: input.executionId,
-                    ...(facts && Object.keys(facts).length > 0 ? { facts } : {}),
-                    terminalAt: new Date(now()).toISOString(),
-                }));
-                if (killed.status !== "committed")
-                    return { status: "rejected" };
-                settled = true;
-                return { status: "completed" };
-            }
-            // Force escalation: resolution is stop proof; rejection is kill failure.
-            forceAbortInvoked = true;
-            try {
-                await handle.abort("force");
-                if (sawInterruptIntent)
-                    return settleInterrupted();
-                const killed = commitTerminal(() => store.runnerKilledIfRequested({
-                    executionId: input.executionId,
-                    terminalAt: new Date(now()).toISOString(),
-                }));
-                if (killed.status !== "committed")
-                    return { status: "rejected" };
-                settled = true;
-                return { status: "completed" };
-            }
-            catch (error) {
-                const failed = commitTerminal(() => store.verdictIfOpen({
-                    executionId: input.executionId,
-                    verdict: "failed",
-                    facts: {
-                        ...(sawKillIntent ? { operatorAction: "kill" } : {}),
-                        diagnostic: "escalation-failed",
-                        detail: errorDetail(error),
-                        failedAt: new Date(now()).toISOString(),
-                        error: {
-                            version: OUTCOME_ERROR_VERSION,
-                            code: "SUBAGENT_EXEC_ERROR",
-                            message: errorDetail(error),
-                            timeoutMs: null,
-                            exitCode: null,
-                        },
-                    },
-                }));
-                // Durably completed after the failed verdict; outer catch must not overwrite.
-                settled = true;
-                if (failed.status !== "committed")
-                    return { status: "rejected" };
-                return { status: "completed" };
-            }
-        }
-        // No kill intent: ordinary outcome, then pending-tell handoff or verdict.
-        await outcomeWatch;
-        const ordinaryOutcome = readOutcomeState(outcomeBox);
-        if (ordinaryOutcome.status === "rejected") {
-            throw ordinaryOutcome.error;
-        }
-        if (ordinaryOutcome.status !== "fulfilled") {
-            throw new Error("projection generation outcome did not settle");
-        }
-        const execution = ordinaryOutcome.execution;
-        const pending = execution.verdict === "completed"
-            ? input.snapshotPendingTells()
-            : { tellIds: [] };
-        const tellFence = normalizeTellFence(pending.tellIds);
-        if (tellFence.length > 0) {
-            const successorExecutionId = createProjectionExecutionId(now());
-            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, () => {
-                    pullStopIntent?.(true);
-                    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 {
-                return { status: "handed-off", successorExecutionId };
-            }
-        }
-        return settleRunnerOutcome(execution);
-    }
-    catch (error) {
-        if (adopted && !settled && runnerLock) {
-            let cleanupError;
-            if (handle) {
-                try {
-                    await handle.abort("force");
-                }
-                catch (failure) {
-                    cleanupError = failure;
-                }
-            }
-            pullStopIntent?.(true);
-            const live = store.readCurrentGeneration();
-            const detail = error instanceof Error ? error.message : String(error);
-            const failed = commitTerminal(() => store.runnerVerdictIfOpen({
-                executionId: input.executionId,
-                verdict: "failed",
-                facts: {
-                    failedAt: new Date(now()).toISOString(),
-                    detail,
-                    ...(cleanupError ? {
-                        ...(live?.killIntent ? { operatorAction: "kill" } : {}),
-                        diagnostic: "cleanup-escalation-failed",
-                        cleanupDetail: errorDetail(cleanupError),
-                    } : {}),
-                    error: {
-                        version: OUTCOME_ERROR_VERSION,
-                        code: "SUBAGENT_EXEC_ERROR",
-                        message: detail,
-                        timeoutMs: null,
-                        exitCode: null,
-                    },
-                },
-                terminalAt: new Date(now()).toISOString(),
-            }));
-            settled = failed.status === "committed";
-        }
-        throw error;
-    }
-    finally {
-        clearGraceTimer();
-        try {
-            tellObserver?.close();
-        }
-        catch {
-            // Observer cleanup cannot reopen life or product authority.
-        }
-        try {
-            await doorbell?.close();
-        }
-        finally {
-            try {
-                runnerLock?.close();
-            }
-            finally {
-                store.close();
-            }
-        }
-        if (wakeAfterLockRelease) {
-            void input.wakeAfterInterrupt?.().catch(() => {
-                // A later tell retries the ordinary wake path after its durable failure.
-            });
-        }
-    }
-}

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

@@ -1,46 +0,0 @@
-import { prepareProjectionGenerationExecution } from "./projection-generation-execution.js";
-import { receiveDetachedLease, } from "../../run-control/index.js";
-import { runProjectionGeneration } from "./projection-generation-runner.js";
-import { startProjectionGeneration } from "./projection-generation-launcher.js";
-import { snapshotPendingTells } from "./projection-generation-continuation.js";
-import { persistInterruptWakeFailure, tellProjection } from "../projection-wake.js";
-import { readProjectionIdentity } from "../projection-identity.js";
-import * as path from "node:path";
-import { projectionRunnerLeasePath } from "./projection-generation-identity.js";
-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) {
-    const transfer = await receiveDetachedLease({
-        coordinate: executionId,
-        leasePath: projectionRunnerLeasePath(projectionDirectory),
-    });
-    if (transfer.status === "rejected")
-        return;
-    try {
-        await runProjectionGeneration({
-            projectionDirectory,
-            executionId,
-            runnerLock: transfer.lease,
-            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 { /* execution owns and closes the transferred lease */ }
-}

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

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