@astrosheep/keiyaku 2.9.6 → 2.9.8

package/build/core/bind.js

@@ -3,12 +3,12 @@ import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
 import { activeLedgerRef, appendEntry, appendWithRetry, readLedger } from "./ledger.js";
-import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
-import { assertValidContractId, buildContractId } from "./ids.js";
-import { registerScope, releaseScope } from "./registry.js";
+import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
+import { assertValidContractId, buildContractId, isCommissionId } from "./ids.js";
+import { previewScopeRegistration, registerScope, releaseScope } from "./registry.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { normalizeTargetRef } from "./target-ref.js";
-import { reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
+import { previewTaskBoardForBind, reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
 import { bootstrapEntryDataFromObservation, isBootstrapSuccess, runWorktreeBootstrap, } from "./worktree-bootstrap.js";
 import { contractWorktreePathFromBind, stableRepoRoot } from "./worktree-path.js";
 import { allocateWorktreePlace, cleanupCreatedBindResources, createContractBranch, defaultCreateWorktree, materializeContractView, resolveTreeRoot, } from "./bind-workspace.js";
@@ -138,6 +138,99 @@ export function composeTaskBindDraft(input) {
     }
     return materializeBindDraft(merged);
 }
+async function validateBindAfter(cwd, after) {
+    const unique = new Set();
+    for (const contractId of after) {
+        if (unique.has(contractId)) {
+            throw new FlowError("INVALID_TARGET", `contract ${contractId} selected more than once by --after`);
+        }
+        unique.add(contractId);
+        if (!isCommissionId(contractId)) {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a valid contract id`);
+        }
+        if (!await readLedger(cwd, contractId)) {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} does not exist`);
+        }
+    }
+}
+/**
+ * The common read-only bind admission candidate. Mutation uses this candidate
+ * before task settlement; preview stops after it has observed all admission
+ * facts and rendered the canonical draft.
+ */
+async function admitBindCandidate(input, draft) {
+    const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes: input.randomBytes });
+    await assertValidContractId(input.cwd, id);
+    await validateBindAfter(input.cwd, input.after);
+    const provisionalEntry = makeBindEntry({
+        id,
+        at: new Date(input.nowMs).toISOString(),
+        actor: input.actor,
+        draft,
+        // Preview never writes the task-board commit. The current target head is
+        // sufficient for its read-only provisional entry and worktree coordinate.
+        base: input.base,
+        target: input.target,
+        after: input.after,
+        workspace: input.workspace,
+        place: input.place,
+        bootstrap: input.bootstrapPlan,
+    });
+    const tree = await resolveTreeRoot(input.cwd, input.workspace, id, provisionalEntry);
+    const scopeOverlaps = await previewScopeRegistration(input.cwd, {
+        contractId: id,
+        scope: draft.scope,
+        tree,
+        exclusive: input.exclusive,
+    });
+    return {
+        id,
+        draft,
+        canonicalDraft: renderBindDraft(draft),
+        target: input.target,
+        place: input.workspace === "worktree" ? input.place ?? null : null,
+        workspace: input.workspace,
+        after: input.after,
+        scopeOverlaps,
+    };
+}
+export async function previewBindContract(input) {
+    const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
+    const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
+    const workspace = input.workspace ?? "here";
+    const defaultBranch = await resolveDefaultBranch(input.cwd);
+    if (!defaultBranch) {
+        throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
+    }
+    const target = normalizeTargetRef(defaultBranch.branch);
+    const loadedSettings = await loadKeiyakuSettings(input.cwd);
+    let bootstrapPlan;
+    if (workspace === "worktree") {
+        assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
+        bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
+    }
+    const randomBytes = input.randomBytes?.(0) ?? randomBytesDefault();
+    const place = workspace === "worktree" ? await allocateWorktreePlace(input.cwd, randomBytes) : undefined;
+    const taskAdmission = isTaskBound
+        ? await previewTaskBoardForBind({ cwd: input.cwd, taskIds: input.taskIds })
+        : { tasks: [] };
+    const draft = isTaskBound
+        ? composeTaskBindDraft({ task: taskAdmission.tasks[0], draft: input.draft })
+        : ordinaryDraft;
+    return await admitBindCandidate({
+        cwd: input.cwd,
+        actor: input.actor,
+        nowMs: input.nowMs,
+        after: input.after ?? [],
+        exclusive: input.exclusive,
+        workspace,
+        randomBytes,
+        base: defaultBranch.head,
+        target,
+        bootstrapPlan,
+        place,
+    }, draft);
+}
 export async function bindContract(input) {
     const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
     const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
@@ -161,8 +254,20 @@ export async function bindContract(input) {
         let settlement;
         try {
             const prepare = async (draft) => {
-                const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes });
-                await assertValidContractId(input.cwd, id);
+                const candidate = await admitBindCandidate({
+                    cwd: input.cwd,
+                    actor: input.actor,
+                    nowMs: input.nowMs,
+                    after: input.after ?? [],
+                    exclusive: input.exclusive,
+                    workspace,
+                    randomBytes,
+                    base: defaultBranch.head,
+                    target,
+                    bootstrapPlan,
+                    place,
+                }, draft);
+                const id = candidate.id;
                 const ref = activeLedgerRef(id);
                 return {
                     contractId: id,

package/build/core/call/context.js

@@ -2,7 +2,7 @@ import * as fs from "fs/promises";
 import { FlowError } from "../../flow-error.js";
 import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { createGit, wrapGitError } from "../../git/core.js";
-import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveContractAddress, withResolvedAddress, } from "../addressing.js";
+import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveContractAddress, resolveCallWorktreeAddress, withResolvedAddress, } from "../addressing.js";
 import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { findOpenArcView } from "../arc.js";
 import { readLedger } from "../ledger.js";
@@ -139,7 +139,24 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             },
         }));
     }
-    if (input.bare || !input.contractId) {
+    if (input.bare) {
+        return {
+            activeKeiyaku: false,
+            effectiveCwd: executionCwd,
+            historyCwd: ledgerCwd,
+            profileCwd: ledgerCwd,
+            projectionCwd: ledgerCwd,
+            address: buildUncommissionedRepositoryAddress({
+                stableRoot: ledgerCwd,
+                workdir: executionCwd,
+                binding: "bare",
+            }),
+        };
+    }
+    const address = input.contractId
+        ? await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource)
+        : await resolveCallWorktreeAddress(ledgerCwd, executionCwd);
+    if (!address) {
         return {
             activeKeiyaku: false,
             effectiveCwd: executionCwd,
@@ -153,7 +170,6 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             }),
         };
     }
-    const address = await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
         const ledger = await readLedger(ledgerCwd, contractId);

package/build/core/call/execution.js

@@ -7,7 +7,7 @@ import { assertProjectionAlias, moveProjectionAlias } from "../projection/index.
 import { projectionDir } from "../projection/index.js";
 import { createProjectionExecutionId } from "../projection/index.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration } from "../projection/index.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "../projection/index.js";
+import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, acquireProjectionRunnerLock, } from "../projection/index.js";
 import { observeProjectionLife } from "../projection/index.js";
 import { mintProjection, mintRepositoryProjection } from "../projection/index.js";
 import { waitForProjection } from "../projection/index.js";
@@ -60,13 +60,29 @@ export function outcomeFromGeneration(current) {
     return restoreOutcome(record);
 }
 export async function executeSubagent(agentName, prompt, cwd, options) {
-    const { projection: projectionCoordinate, launchSnapshot } = await buildCallConfig(agentName, prompt, cwd, options);
+    const { projection: projectionCoordinate, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
     if (!projectionCoordinate) {
         throw new FlowError("INTERNAL_STATE", "durable execution requires a projection coordinate");
     }
-    const launched = await startProjectionGeneration(projectionCoordinate.dir, projectionCoordinate.executionId);
-    if (launched.status === "failed") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.detail);
+    const launchOwnership = acquireProjectionRunnerLock(projectionCoordinate.dir);
+    const launched = await startProjectionGeneration(projectionCoordinate.dir, projectionCoordinate.executionId, {
+        commitLaunch: () => {
+            const store = openProjectionGenerationStore(projectionCoordinate.dir);
+            try {
+                return store.launchIfSettled({ executionId: projectionCoordinate.executionId, facts: launchFacts }).status === "committed";
+            }
+            finally {
+                store.close();
+            }
+        },
+        launchOwnership,
+    });
+    launchOwnership.close();
+    if (launched.status !== "adopted") {
+        const detail = launched.status === "pending"
+            ? "runner retained startup ownership without adopting before the bounded launch wait"
+            : launched.detail;
+        throw new FlowError("SUBAGENT_EXEC_ERROR", detail);
     }
     const joined = await waitForProjection({
         projectionDirectory: projectionCoordinate.dir,
@@ -111,13 +127,28 @@ export async function executeSubagent(agentName, prompt, cwd, options) {
     throw new FlowError("INTERNAL_STATE", "Unhandled subagent outcome state.");
 }
 export async function launchSubagentGeneration(agentName, prompt, cwd, options) {
-    const { projection, launchSnapshot } = await buildCallConfig(agentName, prompt, cwd, options);
+    const { projection, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
     if (!projection) {
         throw new FlowError("INTERNAL_STATE", "durable launch requires a projection coordinate");
     }
-    const launched = await startProjectionGeneration(projection.dir, projection.executionId);
-    if (launched.status === "failed") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.detail);
+    const launchOwnership = acquireProjectionRunnerLock(projection.dir);
+    const launched = await startProjectionGeneration(projection.dir, projection.executionId, {
+        commitLaunch: () => {
+            const store = openProjectionGenerationStore(projection.dir);
+            try {
+                return store.launchIfSettled({ executionId: projection.executionId, facts: launchFacts }).status === "committed";
+            }
+            finally {
+                store.close();
+            }
+        },
+        launchOwnership,
+    });
+    launchOwnership.close();
+    if (launched.status !== "adopted") {
+        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.status === "pending"
+            ? "runner retained startup ownership without adopting before the bounded launch wait"
+            : launched.detail);
     }
     return { projection, launchSnapshot };
 }
@@ -173,16 +204,6 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
                 } : {}),
             },
         }));
-        const store = openProjectionGenerationStore(minted.dir);
-        try {
-            const launch = store.launchIfSettled({ executionId, facts: launchFacts });
-            if (launch.status !== "committed") {
-                throw new FlowError("INTERNAL_STATE", `initial generation launch rejected: ${launch.reason}`);
-            }
-        }
-        finally {
-            store.close();
-        }
         const previousAliasTarget = options.alias === undefined
             ? undefined
             : await moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
@@ -202,6 +223,7 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
             id: minted.id,
             dir: minted.dir,
             executionId,
+            launchFacts,
             ...(options.alias ? { alias: options.alias } : {}),
             ...(previousAliasTargetStillRunning ? { previousAliasTarget: previousAliasTargetStillRunning } : {}),
         };
@@ -209,9 +231,10 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
     // Every public launch has one durable projection object. Repository-free
     // authority changes the storage owner, not whether the object exists; mint
     // failure is therefore a launch failure rather than an in-process fallback.
-    const projectionCoordinate = await publishProjection();
+    const { launchFacts, ...projectionCoordinate } = await publishProjection();
     return {
         projection: projectionCoordinate,
         launchSnapshot,
+        launchFacts,
     };
 }

package/build/core/draft.js

@@ -204,7 +204,7 @@ export function renderMissingBindSectionsTemplate(missing) {
             continue;
         }
         if (section === "scope") {
-            lines.push("## Scope", "```", "<pattern>", "<another-pattern>", "```");
+            lines.push("## Scope", "~~~", "<pattern>", "<another-pattern>", "~~~");
             continue;
         }
         lines.push("## Checks", "- <verification>");

package/build/core/ledger-batch.js

@@ -0,0 +1,194 @@
+import { wrapGitError, runGitProcess } from "../git/core.js";
+import { GitStreamingBatchFramingError, GitStreamingBatchResponseEndedError, openGitStreamingBatch, } from "../git/streaming-batch.js";
+import { parseLedgerEntryCommitMessage } from "./entry.js";
+import { ACTIVE_LEDGER_REF_PREFIX, activeLedgerRef, } from "./ledger.js";
+const MAX_LEDGER_COMMIT_BYTES = 1024 * 1024;
+async function runLedgerGit(cwd, args) {
+    const result = await runGitProcess(cwd, args);
+    if (result.error || result.status !== 0) {
+        throw wrapGitError(args.join(" "), {
+            message: result.error?.message
+                ?? `git exited with status ${result.status ?? "unknown"}`,
+            stderr: result.stderr,
+            stdout: result.stdout,
+        }, cwd);
+    }
+    return Buffer.from(result.stdout, "utf8");
+}
+async function queryBatchObject(batch, expression) {
+    const record = await batch.request(expression, {
+        maxContentBytes: MAX_LEDGER_COMMIT_BYTES,
+    });
+    if (record.kind === "missing")
+        return null;
+    if (record.kind === "ambiguous") {
+        throw new Error(`[git cat-file ${expression}] object is ambiguous`);
+    }
+    return {
+        oid: record.record.oid,
+        type: record.record.type,
+        content: record.record.content,
+    };
+}
+function parseCommitObject(object) {
+    if (object.type !== "commit") {
+        throw new Error(`git cat-file expected commit ${object.oid}, received ${object.type}`);
+    }
+    const content = object.content.toString("utf8");
+    const messageStart = content.indexOf("\n\n");
+    if (messageStart < 0)
+        throw new Error(`git commit ${object.oid} has no message separator`);
+    const parents = [];
+    for (const line of content.slice(0, messageStart).split("\n")) {
+        if (!line.startsWith("parent "))
+            continue;
+        const parent = line.slice("parent ".length);
+        if (!/^[0-9a-f]{40,64}$/.test(parent)) {
+            throw new Error(`git commit ${object.oid} has an invalid parent header`);
+        }
+        parents.push(parent);
+    }
+    return { oid: object.oid, parents, message: content.slice(messageStart + 2) };
+}
+function parseLedgerRefs(output) {
+    return output
+        .toString("utf8")
+        .split(/\r?\n/)
+        .filter((ref) => ref.startsWith(ACTIVE_LEDGER_REF_PREFIX))
+        .map((ref) => ({ contractId: ref.slice(ACTIVE_LEDGER_REF_PREFIX.length), ref }));
+}
+async function readLedgerFromBatch(batch, ref, commits) {
+    const headObject = await queryBatchObject(batch, `${ref.ref}^{commit}`);
+    if (!headObject)
+        return null;
+    const head = parseCommitObject(headObject);
+    commits.set(head.oid, Promise.resolve(head));
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = async (oid) => {
+        if (visited.has(oid))
+            return;
+        if (visiting.has(oid))
+            throw new Error(`git ledger ancestry contains a cycle at ${oid}`);
+        visiting.add(oid);
+        let pending = commits.get(oid);
+        if (!pending) {
+            pending = queryBatchObject(batch, oid).then((object) => {
+                if (!object)
+                    throw new Error(`[git cat-file ${oid}] object is missing`);
+                return parseCommitObject(object);
+            });
+            commits.set(oid, pending);
+        }
+        const commit = await pending;
+        for (const parent of commit.parents)
+            await visit(parent);
+        visiting.delete(oid);
+        visited.add(oid);
+        ordered.push(commit);
+    };
+    await visit(head.oid);
+    return {
+        contractId: ref.contractId,
+        ref: ref.ref,
+        head: head.oid,
+        entries: ordered.map((commit) => parseLedgerEntryCommitMessage(commit.message)),
+    };
+}
+async function closeBatch(cwd, batch) {
+    const close = await batch.close();
+    if (!close.aborted && (close.timedOut || close.signal || close.code !== 0)) {
+        throw wrapGitError("cat-file --batch", {
+            message: close.timedOut
+                ? "git timed out"
+                : close.signal
+                    ? `git exited from signal ${close.signal}`
+                    : `git exited with status ${close.code ?? "unknown"}`,
+            stderr: close.stderr.toString("utf8"),
+        }, cwd);
+    }
+}
+async function readLedgerRefs(cwd, refs) {
+    if (refs.length === 0)
+        return [];
+    const batch = openGitStreamingBatch(cwd);
+    const commits = new Map();
+    const results = [];
+    let readError;
+    try {
+        for (let index = 0; index < refs.length; index += 1) {
+            const ref = refs[index];
+            try {
+                const ledger = await readLedgerFromBatch(batch, ref, commits);
+                if (ledger)
+                    results.push(ledger);
+                else
+                    results.push({ id: ref.contractId, error: new Error(`ledger ref disappeared: ${ref.ref}`) });
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error : new Error(String(error));
+                results.push({ id: ref.contractId, error: diagnostic });
+                if (error instanceof GitStreamingBatchFramingError
+                    || error instanceof GitStreamingBatchResponseEndedError) {
+                    const isolationReason = error instanceof GitStreamingBatchResponseEndedError
+                        ? "response ended"
+                        : "malformed frame";
+                    for (const pending of refs.slice(index + 1)) {
+                        results.push({
+                            id: pending.contractId,
+                            error: new Error(`git cat-file batch terminated after ${isolationReason}: ${diagnostic.message}`),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        await closeBatch(cwd, batch);
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return results;
+}
+/** Read every ledger with two Git processes regardless of ledger or entry count. */
+export async function readAllLedgerSnapshots(cwd) {
+    const refOutput = await runLedgerGit(cwd, [
+        "for-each-ref",
+        "--sort=refname",
+        "--format=%(refname)",
+        ACTIVE_LEDGER_REF_PREFIX,
+    ]);
+    return readLedgerRefs(cwd, parseLedgerRefs(refOutput));
+}
+/** Read one exact ledger with one Git process and without enumerating other refs. */
+export async function readLedgerSnapshot(cwd, contractId) {
+    const ref = activeLedgerRef(contractId);
+    const batch = openGitStreamingBatch(cwd);
+    let ledger = null;
+    let readError;
+    try {
+        ledger = await readLedgerFromBatch(batch, { contractId, ref }, new Map());
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        await closeBatch(cwd, batch);
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return ledger;
+}

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

@@ -4,7 +4,7 @@ import { DatabaseSync } from "node:sqlite";
 import { configureHeartBusyTimeout } from "../heart.js";
 import { ProjectionGenerationStoreError, parseStoredRow, validateHistory, } from "./model.js";
 export const PROJECTION_GENERATION_STORE_FILE = "heart";
-export const PROJECTION_GENERATION_SCHEMA_VERSION = 2;
+export const PROJECTION_GENERATION_SCHEMA_VERSION = 3;
 const SCHEMA_TABLE_SQL = `
   CREATE TABLE generation_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
@@ -14,7 +14,7 @@ const SCHEMA_TABLE_SQL = `
 const RECORD_TABLE_SQL = `
   CREATE TABLE generation_records (
     seq INTEGER PRIMARY KEY CHECK (seq > 0),
-    kind TEXT NOT NULL CHECK (kind IN ('launch', 'adoption', 'kill-intent', 'verdict')),
+    kind TEXT NOT NULL CHECK (kind IN ('launch', 'adoption', 'kill-intent', 'interrupt-intent', 'verdict')),
     execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
     facts_json TEXT NOT NULL CHECK (json_valid(facts_json))
   ) STRICT
@@ -250,6 +250,25 @@ export function openReadOnlyDatabase(projectionDirectory) {
         throw projectionGenerationStoreReadError(databasePath, error);
     }
 }
+/** Read the validated heart through one consistent SQLite snapshot. */
+export function withGenerationReadSnapshot(projectionDirectory, read) {
+    const { database } = openReadOnlyDatabase(projectionDirectory);
+    try {
+        database.exec("BEGIN");
+        try {
+            const result = read(database);
+            database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            rollbackQuietly(database);
+            throw error;
+        }
+    }
+    finally {
+        closeDatabase(database);
+    }
+}
 export function assertDatabaseOpen(database) {
     if (closedDatabases.has(database))
         throw new ProjectionGenerationStoreError("projection generation store is closed");
@@ -276,6 +295,8 @@ export function writeTransition(database, readOnly, run) {
     if (readOnly) {
         throw new ProjectionGenerationStoreError("projection generation store is read-only");
     }
+    if (database.isTransaction)
+        return run();
     database.exec("BEGIN IMMEDIATE");
     try {
         const result = run();
@@ -287,6 +308,26 @@ export function writeTransition(database, readOnly, run) {
         throw error;
     }
 }
+export function beginGenerationWriteTransaction(database, readOnly) {
+    assertDatabaseOpen(database);
+    if (readOnly)
+        throw new ProjectionGenerationStoreError("projection generation store is read-only");
+    if (database.isTransaction)
+        throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
+    database.exec("BEGIN IMMEDIATE");
+}
+export function commitGenerationWriteTransaction(database) {
+    assertDatabaseOpen(database);
+    if (!database.isTransaction)
+        throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
+    database.exec("COMMIT");
+}
+export function rollbackGenerationWriteTransaction(database) {
+    assertDatabaseOpen(database);
+    if (!database.isTransaction)
+        return;
+    rollbackQuietly(database);
+}
 export function closeDatabase(database) {
     if (closedDatabases.has(database))
         return;

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

@@ -133,6 +133,16 @@ export function validateKillIntentFacts(value, location) {
         throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
     return facts;
 }
+export function validateInterruptIntentFacts(value, location) {
+    const facts = cloneFacts(value, location);
+    facts.interruptedAt = assertIsoTimestamp(facts.interruptedAt, `${location}.interruptedAt`);
+    if ("operatorAction" in facts) {
+        throw new ProjectionGenerationStoreError(`${location}.operatorAction is not part of interrupt-intent`);
+    }
+    if ("state" in facts)
+        throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
+    return facts;
+}
 export function validateVerdictFacts(value, location) {
     const facts = cloneFacts(value, location);
     if (typeof facts.state !== "string" || !VERDICTS.has(facts.state)) {
@@ -182,6 +192,7 @@ export function parseStoredRow(row) {
     if (row.kind !== "launch"
         && row.kind !== "adoption"
         && row.kind !== "kill-intent"
+        && row.kind !== "interrupt-intent"
         && row.kind !== "verdict") {
         throw new ProjectionGenerationStoreError(`generation row ${seq} has unknown kind '${row.kind}'`);
     }
@@ -200,7 +211,9 @@ export function parseStoredRow(row) {
             ? validateAdoptionFacts(decoded, location)
             : row.kind === "kill-intent"
                 ? validateKillIntentFacts(decoded, location)
-                : validateVerdictFacts(decoded, location);
+                : row.kind === "interrupt-intent"
+                    ? validateInterruptIntentFacts(decoded, location)
+                    : validateVerdictFacts(decoded, location);
     return { seq, kind: row.kind, executionId, facts };
 }
 export function validateHistory(records) {
@@ -237,13 +250,21 @@ export function validateHistory(records) {
             continue;
         }
         if (record.kind === "kill-intent") {
-            if (current.killIntent)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates kill-intent`);
+            if (current.killIntent || current.interruptIntent)
+                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates generation stop intent`);
             if (current.verdict)
                 throw new ProjectionGenerationStoreError(`generation row ${record.seq} records kill-intent after verdict`);
             current.killIntent = record;
             continue;
         }
+        if (record.kind === "interrupt-intent") {
+            if (current.killIntent || current.interruptIntent)
+                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates generation stop intent`);
+            if (current.verdict)
+                throw new ProjectionGenerationStoreError(`generation row ${record.seq} records interrupt-intent after verdict`);
+            current.interruptIntent = record;
+            continue;
+        }
         if (current.verdict)
             throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates verdict`);
         current.verdict = record;