@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,443 +0,0 @@
-import { openProjectionGenerationStore, } from "./store.js";
-import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "../projection-runner-lock.js";
-import { createProjectionExecutionId } from "./projection-generation-identity.js";
-import { applyContinuationEffort, } from "./projection-generation-continuation.js";
-import { openProjectionTellObserver } from "../tell/database.js";
-import { OUTCOME_ERROR_VERSION } from "../../../agents/types.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 acquireProjectionRunnerLock(projectionDirectory);
-    }
-    catch (error) {
-        if (observeProjectionRunnerLock(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 graceTimer;
-    let intentTimer;
-    let handle;
-    const clearGraceTimer = () => {
-        if (graceTimer === undefined)
-            return;
-        clearTimeout(graceTimer);
-        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" };
-        }
-        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() },
-        });
-        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 = 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 = 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 = {}) => {
-            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;
-        let sawInterruptIntent = false;
-        const observeStopBoundary = () => {
-            try {
-                if (!tellObserver.hasDataVersionChanged())
-                    return;
-                const live = store.readCurrentGeneration();
-                if (live?.launch.executionId !== input.executionId)
-                    return;
-                if (live.verdict)
-                    return;
-                sawKillIntent = live.killIntent !== undefined;
-                sawInterruptIntent = live.interruptIntent !== undefined;
-                if (!sawKillIntent && !sawInterruptIntent)
-                    return;
-                if (gracefulAbortInvoked)
-                    return;
-                gracefulAbortInvoked = true;
-                void handle.abort("graceful").catch(() => {
-                    // Abort observation failures fail closed for this boundary.
-                });
-            }
-            catch {
-                // Observation failures fail closed and must not change provider outcome.
-            }
-        };
-        // 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?.();
-        };
-        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 eventDrain = (async () => {
-            try {
-                for await (const _event of handle.events) {
-                    if (forceAbortInvoked)
-                        return;
-                    observeStopBoundary();
-                    bumpActivity();
-                }
-            }
-            catch {
-                // Event-stream failures fail closed for observation; abandon quietly.
-            }
-            bumpActivity();
-        })();
-        observeAbandoned(eventDrain);
-        // 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 || 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 = 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 = 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 = 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, () => {
-                    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) {
-            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,
-                    ...(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(),
-            });
-        }
-        throw error;
-    }
-    finally {
-        clearGraceTimer();
-        if (intentTimer !== undefined)
-            clearInterval(intentTimer);
-        try {
-            tellObserver?.close();
-        }
-        catch {
-            // Observer cleanup cannot reopen life or product authority.
-        }
-        try {
-            runnerLock?.close();
-        }
-        finally {
-            store.close();
-        }
-    }
-}

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

@@ -1,97 +0,0 @@
-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 { 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,98 +0,0 @@
-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, };
-export { GENERATION_VERDICT_STATES, isIncompatibleProjectionGenerationStoreError, ProjectionGenerationStoreError, } from "./model.js";
-export class ProjectionGenerationStore {
-    databasePath;
-    readOnly;
-    #database;
-    constructor(databasePath, database, readOnly) {
-        this.databasePath = databasePath;
-        this.#database = database;
-        this.readOnly = readOnly;
-    }
-    static open(projectionDirectory) {
-        const { databasePath, database } = openMutableDatabase(projectionDirectory);
-        return new ProjectionGenerationStore(databasePath, database, false);
-    }
-    static openReadOnly(projectionDirectory) {
-        const { databasePath, database } = openReadOnlyDatabase(projectionDirectory);
-        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;
-    }
-    readCurrentGeneration() {
-        assertDatabaseOpen(this.#database);
-        return readValidatedHistory(this.#database).current;
-    }
-    initializeIdentity(identity) {
-        initializeProjectionIdentity(this.#database, this.databasePath, this.readOnly, identity);
-    }
-    readIdentity() {
-        return readProjectionIdentity(this.#database, this.databasePath);
-    }
-    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);
-    }
-    verdictIfOpen(input) {
-        return transitions.verdictIfOpen(this.#database, this.readOnly, input);
-    }
-    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);
-    }
-    handoff(input) {
-        return transitions.handoff(this.#database, this.readOnly, input);
-    }
-}
-export function openProjectionGenerationStore(projectionDirectory) {
-    return ProjectionGenerationStore.open(projectionDirectory);
-}
-export function openProjectionGenerationStoreReadOnly(projectionDirectory) {
-    return ProjectionGenerationStore.openReadOnly(projectionDirectory);
-}