@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/petition-preview.js

@@ -0,0 +1,97 @@
+import { createOathGate } from "./petition-claim-gates.js";
+import { assertPetitionArcReady, assertPetitionFresh, assertPetitionable, loadPetitionPreflightContext, } from "./petition.js";
+import { petitionSealSource, previewSeal } from "./seal.js";
+export const PETITION_PREVIEW_GATE_NAMES = [
+    "contract",
+    "freshness",
+    "arc",
+    "state",
+    "seal",
+    "oath",
+    "verification",
+    "review",
+];
+function failureDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function gate(name, evaluate) {
+    try {
+        await evaluate();
+        return { name, result: "pass" };
+    }
+    catch (error) {
+        return { name, result: "failed", detail: failureDetail(error) };
+    }
+}
+function sealPathDetail(paths) {
+    return `${paths.length} ${paths.length === 1 ? "file" : "files"} · ${paths.length > 0 ? paths.join(", ") : "(none)"}`;
+}
+const notEvaluated = (name) => ({
+    name,
+    result: "not_evaluated",
+});
+/**
+ * Build a petition preflight without crossing any settlement or provider boundary.
+ * Loading the addressed contract is construction: failure there leaves no truthful
+ * target/source coordinate and therefore propagates as dry-run exit 2.
+ */
+export async function previewPetition(input) {
+    const context = await loadPetitionPreflightContext(input.cwd, input.contractId);
+    const gates = [{ name: "contract", result: "pass" }];
+    const freshness = await gate("freshness", async () => {
+        await assertPetitionFresh(input.cwd, input.contractId, context.ledger.entries, context.base);
+    });
+    gates.push(freshness);
+    const arc = freshness.result === "pass"
+        ? await gate("arc", async () => {
+            await assertPetitionArcReady(context.deliveryCwd, input.contractId, context.ledger.entries);
+        })
+        : notEvaluated("arc");
+    gates.push(arc);
+    const state = await gate("state", () => {
+        assertPetitionable(input.contractId, context.ledger.entries);
+    });
+    gates.push(state);
+    let seal;
+    if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
+        try {
+            const sealPreview = await previewSeal(context.deliveryCwd, context.ledger.entries, "HEAD", input.waivePaths);
+            seal = { name: "seal", result: "pass", detail: sealPathDetail(sealPreview.paths) };
+        }
+        catch (error) {
+            seal = { name: "seal", result: "failed", detail: failureDetail(error) };
+        }
+    }
+    else {
+        seal = notEvaluated("seal");
+    }
+    gates.push(seal);
+    const oathOwner = createOathGate();
+    const oath = await gate("oath", async () => {
+        const result = await oathOwner.evaluate({
+            cwd: input.cwd,
+            contractId: input.contractId,
+            input: {
+                cwd: input.cwd,
+                contractId: input.contractId,
+                intent: "CLAIM",
+                title: `Petition ${input.contractId}`,
+                plea: `Settle contract ${input.contractId} through the petition pipeline.`,
+                oath: input.oath,
+            },
+            verificationCommands: [],
+            baseBranch: context.target.branch,
+            reviewNumber: 0,
+        });
+        if (!result.pass)
+            throw new Error(result.message);
+    });
+    gates.push(oath, notEvaluated("verification"), notEvaluated("review"));
+    return {
+        contract: input.contractId,
+        target: context.target.ref,
+        arc: { source: petitionSealSource(context.ledger.entries) },
+        gates,
+        verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
+    };
+}

package/build/core/petition-run.js

@@ -1,8 +1,9 @@
-import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
+import { assertSettingsKnobUsable } from "../config/settings/disease.js";
+import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
 import { readCurrentContractContext } from "./context.js";
 import { readLedger } from "./ledger.js";
-import { commissionTarget } from "./status.js";
+import { commissionTarget } from "./status/drift.js";
 import { getCurrentBranch, isGitRepo } from "../git/branches.js";
 import { claimKeiyaku } from "./petition-claim.js";
 import { forfeitKeiyaku } from "./petition-forfeit.js";

package/build/core/petition.js

@@ -2,9 +2,10 @@ import { FlowError } from "../flow-error.js";
 import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
 import { parseCommandMarkdown } from "./command-io.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { allocateSettlementSeat, queueMembership, readQueueReadModel } from "./queue_v2.js";
-import { findOpenArc, receiptsAfterFence, sealOpenArc } from "./seal.js";
-import { commissionTarget, deriveContractState, latestBase } from "./status.js";
+import { allocateSettlementSeat, queueMembership, readQueueReadModel } from "./queue.js";
+import { findOpenArc, getMaxArc, receiptsAfterFence, sealCurrentArc } from "./seal.js";
+import { deriveContractState } from "./status/lifecycle.js";
+import { commissionTarget, latestBase } from "./status/drift.js";
 import { findContractWorktreePath } from "./worktree-path.js";
 async function resolveCommit(cwd, ref) {
     const git = createGit(cwd);
@@ -17,7 +18,26 @@ async function resolveCommit(cwd, ref) {
         throw wrapGitError(`rev-parse ${ref}`, error, cwd);
     }
 }
-async function assertFresh(cwd, contractId, entries, base) {
+export async function loadPetitionPreflightContext(cwd, contractId) {
+    const ledger = await readLedger(cwd, contractId);
+    if (!ledger) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
+    }
+    const base = latestBase(ledger.entries);
+    if (!base)
+        throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
+    const target = commissionTarget(ledger.entries);
+    if (!target) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} missing commission target`);
+    }
+    return {
+        ledger,
+        deliveryCwd: (await findContractWorktreePath(cwd, contractId)) ?? cwd,
+        base,
+        target,
+    };
+}
+export async function assertPetitionFresh(cwd, contractId, entries, base) {
     const target = commissionTarget(entries);
     if (!target) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} missing commission target`);
@@ -30,31 +50,28 @@ async function assertFresh(cwd, contractId, entries, base) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} must renew onto ${target.branch} before petition`, { hints: [`keiyaku @${contractId} renew — renews delivery before petition`] });
     }
 }
-function assertPetitionable(contractId, entries) {
+export async function assertPetitionArcReady(deliveryCwd, contractId, entries) {
+    if (getMaxArc(entries) <= 0 || findOpenArc(entries))
+        return;
+    const loose = await receiptsAfterFence(deliveryCwd, entries);
+    if (loose.length > 0) {
+        throw new FlowError("NO_OPEN_ARC", `${loose.length} commits after fence have no arc to receipt them`, { hints: [`keiyaku @${contractId} arc — opens a new arc to receipt them, then petition`] });
+    }
+}
+export function assertPetitionable(contractId, entries) {
     const state = deriveContractState(entries);
-    if (state.state !== "active") {
+    // bound is legal for derived a0 (sealCurrentArc appends seal 0 before petition).
+    if (state.state !== "active" && state.state !== "bound") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition from state ${state.state}`);
     }
 }
 export async function petitionContract(input) {
     const at = new Date(input.nowMs).toISOString();
-    const ledger = await readLedger(input.cwd, input.contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
-    }
-    const deliveryCwd = (await findContractWorktreePath(input.cwd, input.contractId)) ?? input.cwd;
-    const base = latestBase(ledger.entries);
-    if (!base)
-        throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
-    await assertFresh(input.cwd, input.contractId, ledger.entries, base);
-    if (!findOpenArc(ledger.entries)) {
-        const loose = await receiptsAfterFence(deliveryCwd, ledger.entries);
-        if (loose.length > 0) {
-            throw new FlowError("NO_OPEN_ARC", `${loose.length} commits after fence have no arc to receipt them`, { hints: [`keiyaku @${input.contractId} arc — opens a new arc to receipt them, then petition`] });
-        }
-    }
+    const { ledger, deliveryCwd, base, target } = await loadPetitionPreflightContext(input.cwd, input.contractId);
+    await assertPetitionFresh(input.cwd, input.contractId, ledger.entries, base);
+    await assertPetitionArcReady(deliveryCwd, input.contractId, ledger.entries);
     assertPetitionable(input.contractId, ledger.entries);
-    const sealed = await sealOpenArc({
+    const sealed = await sealCurrentArc({
         cwd: deliveryCwd,
         renderCwd: deliveryCwd,
         contractId: input.contractId,
@@ -62,10 +79,6 @@ export async function petitionContract(input) {
         nowMs: input.nowMs,
         waivePaths: input.intent === "claim" ? input.waivePaths : undefined,
     });
-    const target = commissionTarget(ledger.entries);
-    if (!target) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} missing commission target`);
-    }
     const allocated = await allocateSettlementSeat(input.cwd, {
         target: target.ref,
         actor: input.actor,

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

@@ -0,0 +1,306 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+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;
+const SCHEMA_TABLE_SQL = `
+  CREATE TABLE generation_schema (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = ${PROJECTION_GENERATION_SCHEMA_VERSION})
+  ) STRICT
+`;
+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')),
+    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
+    facts_json TEXT NOT NULL CHECK (json_valid(facts_json))
+  ) STRICT
+`;
+const IDENTITY_TABLE_SQL = `
+  CREATE TABLE projection_identity (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = 1),
+    pid INTEGER NOT NULL CHECK (pid >= 0),
+    akuma TEXT NOT NULL CHECK (length(trim(akuma)) > 0),
+    provider TEXT NOT NULL CHECK (length(trim(provider)) > 0),
+    authority_json TEXT NOT NULL CHECK (json_valid(authority_json)),
+    binding_json TEXT NOT NULL CHECK (json_valid(binding_json)),
+    minted_at TEXT NOT NULL CHECK (length(trim(minted_at)) > 0),
+    workspace_root TEXT NOT NULL CHECK (length(trim(workspace_root)) > 0),
+    effective_policy_json TEXT CHECK (
+      effective_policy_json IS NULL OR json_valid(effective_policy_json)
+    )
+  ) STRICT
+`;
+const TELL_TABLE_SQL = `
+  CREATE TABLE projection_tells (
+    tell_id TEXT PRIMARY KEY CHECK (length(trim(tell_id)) > 0),
+    text TEXT NOT NULL,
+    created_at TEXT NOT NULL CHECK (length(trim(created_at)) > 0),
+    effort TEXT CHECK (effort IS NULL OR length(trim(effort)) > 0),
+    state TEXT NOT NULL CHECK (
+      state IN ('inbox', 'inflight', 'submitted', 'consumed', 'delivered')
+    ),
+    execution_id TEXT CHECK (
+      execution_id IS NULL OR length(trim(execution_id)) > 0
+    ),
+    fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
+    replayed_from_json TEXT CHECK (
+      replayed_from_json IS NULL OR json_valid(replayed_from_json)
+    ),
+    delivered_at TEXT CHECK (
+      delivered_at IS NULL OR length(trim(delivered_at)) > 0
+    )
+  ) STRICT
+`;
+const closedDatabases = new WeakSet();
+function pragmaNumber(database, pragma) {
+    const row = database.prepare(`PRAGMA ${pragma}`).get();
+    const value = row ? Object.values(row)[0] : undefined;
+    if (typeof value !== "number" && typeof value !== "bigint") {
+        throw new ProjectionGenerationStoreError(`PRAGMA ${pragma} returned an invalid value`);
+    }
+    return Number(value);
+}
+export function rollbackQuietly(database) {
+    try {
+        database.exec("ROLLBACK");
+    }
+    catch {
+        // Preserve the transition or schema failure that caused the rollback.
+    }
+}
+function validateSchemaShape(database) {
+    const version = pragmaNumber(database, "user_version");
+    if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
+        throw new ProjectionGenerationStoreError(`projection generation schema version ${version} is not supported; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
+    }
+    const objects = database.prepare(`
+    SELECT name, type
+    FROM sqlite_schema
+    WHERE name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all();
+    const signature = objects.map((object) => `${object.type}:${object.name}`).join(",");
+    if (signature !== "table:generation_records,table:generation_schema,table:projection_identity,table:projection_tells") {
+        throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`);
+    }
+    const metadata = database.prepare("SELECT singleton, version FROM generation_schema").all();
+    if (metadata.length !== 1 || Number(metadata[0].singleton) !== 1 || Number(metadata[0].version) !== PROJECTION_GENERATION_SCHEMA_VERSION) {
+        throw new ProjectionGenerationStoreError("projection generation schema metadata is malformed");
+    }
+    const recordColumns = database.prepare("PRAGMA table_info(generation_records)").all();
+    const columnSignature = recordColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (columnSignature !== "seq:INTEGER:0:1,kind:TEXT:1:0,execution_id:TEXT:1:0,facts_json:TEXT:1:0") {
+        throw new ProjectionGenerationStoreError("projection generation record schema is malformed");
+    }
+    const identityColumns = database.prepare("PRAGMA table_info(projection_identity)").all();
+    const identitySignature = identityColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (identitySignature !== "singleton:INTEGER:0:1,version:INTEGER:1:0,pid:INTEGER:1:0,akuma:TEXT:1:0,provider:TEXT:1:0,authority_json:TEXT:1:0,binding_json:TEXT:1:0,minted_at:TEXT:1:0,workspace_root:TEXT:1:0,effective_policy_json:TEXT:0:0") {
+        throw new ProjectionGenerationStoreError("projection identity schema is malformed");
+    }
+    const tellColumns = database.prepare("PRAGMA table_info(projection_tells)").all();
+    const tellSignature = tellColumns
+        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
+        .join(",");
+    if (tellSignature !== "tell_id:TEXT:1:1,text:TEXT:1:0,created_at:TEXT:1:0,effort:TEXT:0:0,state:TEXT:1:0,execution_id:TEXT:0:0,fence_json:TEXT:0:0,replayed_from_json:TEXT:0:0,delivered_at:TEXT:0:0") {
+        throw new ProjectionGenerationStoreError("projection tell schema is malformed");
+    }
+    const quickCheck = database.prepare("PRAGMA quick_check").get();
+    if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
+        throw new ProjectionGenerationStoreError("projection generation database failed quick_check");
+    }
+}
+function initializeOrValidateSchema(database) {
+    database.exec("BEGIN EXCLUSIVE");
+    try {
+        const version = pragmaNumber(database, "user_version");
+        const objects = database.prepare(`
+      SELECT name, type
+      FROM sqlite_schema
+      WHERE name NOT LIKE 'sqlite_%'
+      ORDER BY name
+    `).all();
+        if (version === 0 && objects.length === 0) {
+            database.exec(SCHEMA_TABLE_SQL);
+            database.exec(RECORD_TABLE_SQL);
+            database.exec(IDENTITY_TABLE_SQL);
+            database.exec(TELL_TABLE_SQL);
+            database.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
+                .run(PROJECTION_GENERATION_SCHEMA_VERSION);
+            database.exec(`PRAGMA user_version = ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
+        }
+        else if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
+            throw new ProjectionGenerationStoreError(`projection generation schema version ${version} is not supported; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
+        }
+        validateSchemaShape(database);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        rollbackQuietly(database);
+        throw error;
+    }
+}
+export function openMutableDatabase(projectionDirectory) {
+    const stat = fs.statSync(projectionDirectory);
+    if (!stat.isDirectory())
+        throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
+    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+    let database;
+    try {
+        database = new DatabaseSync(databasePath, {
+            enableForeignKeyConstraints: true,
+            enableDoubleQuotedStringLiterals: false,
+            allowExtension: false,
+        });
+        configureHeartBusyTimeout(database);
+        // Rollback journal keeps observers genuinely read-only. A read-only WAL
+        // connection creates/updates -wal and -shm coordination files, while
+        // immutable WAL reads can miss concurrently committed facts.
+        database.exec("PRAGMA journal_mode = DELETE");
+        database.exec("PRAGMA synchronous = FULL");
+        database.exec("PRAGMA foreign_keys = ON");
+        database.exec("PRAGMA trusted_schema = OFF");
+    }
+    catch (error) {
+        try {
+            database?.close();
+        }
+        catch { /* preserve the open/configuration failure */ }
+        throw new ProjectionGenerationStoreError(`cannot open projection generation store at ${databasePath}`, { cause: error });
+    }
+    try {
+        initializeOrValidateSchema(database);
+        readValidatedHistory(database);
+        return { databasePath, database };
+    }
+    catch (error) {
+        database.close();
+        if (error instanceof ProjectionGenerationStoreError)
+            throw error;
+        throw new ProjectionGenerationStoreError(`invalid projection generation store at ${databasePath}`, { cause: error });
+    }
+}
+export function openReadOnlyDatabase(projectionDirectory) {
+    const stat = fs.statSync(projectionDirectory);
+    if (!stat.isDirectory())
+        throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
+    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+    try {
+        if (!fs.lstatSync(databasePath).isFile()) {
+            throw new ProjectionGenerationStoreError("projection generation store must be a regular file");
+        }
+    }
+    catch (error) {
+        if (error instanceof ProjectionGenerationStoreError)
+            throw error;
+        throw new ProjectionGenerationStoreError(`projection generation store does not exist at ${databasePath}`, { cause: error });
+    }
+    let database;
+    try {
+        database = new DatabaseSync(databasePath, {
+            readOnly: true,
+            enableDoubleQuotedStringLiterals: false,
+            allowExtension: false,
+        });
+        configureHeartBusyTimeout(database);
+        validateSchemaShape(database);
+        readValidatedHistory(database);
+        return { databasePath, database };
+    }
+    catch (error) {
+        try {
+            database?.close();
+        }
+        catch { /* preserve the read/open failure */ }
+        if (error instanceof ProjectionGenerationStoreError)
+            throw error;
+        throw new ProjectionGenerationStoreError(`cannot read projection generation store at ${databasePath}`, { cause: error });
+    }
+}
+export function assertDatabaseOpen(database) {
+    if (closedDatabases.has(database))
+        throw new ProjectionGenerationStoreError("projection generation store is closed");
+}
+export function readValidatedHistory(database) {
+    const rows = database.prepare(`
+    SELECT seq, kind, execution_id, facts_json
+    FROM generation_records
+    ORDER BY seq
+  `).all();
+    const records = rows.map(parseStoredRow);
+    return { records, current: validateHistory(records) };
+}
+export function appendRecord(database, kind, executionId, facts, seq) {
+    const encoded = JSON.stringify(facts);
+    database.prepare(`
+    INSERT INTO generation_records (seq, kind, execution_id, facts_json)
+    VALUES (?, ?, ?, ?)
+  `).run(seq, kind, executionId, encoded);
+    return { seq, kind, executionId, facts: JSON.parse(encoded) };
+}
+export function writeTransition(database, readOnly, run) {
+    assertDatabaseOpen(database);
+    if (readOnly) {
+        throw new ProjectionGenerationStoreError("projection generation store is read-only");
+    }
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const result = run();
+        database.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        rollbackQuietly(database);
+        throw error;
+    }
+}
+export function closeDatabase(database) {
+    if (closedDatabases.has(database))
+        return;
+    closedDatabases.add(database);
+    database.close();
+}
+/**
+ * Discovery-only predicate: a readable regular heart whose PRAGMA user_version
+ * is exactly 1 is recognized historical residue. Never opens through the store
+ * class, never mutates, and any observation failure returns false so callers
+ * proceed into the strict current-schema reader.
+ */
+export function isProjectionGenerationSchemaV1Residue(projectionDirectory) {
+    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+    let database;
+    let residue = false;
+    try {
+        if (!fs.lstatSync(databasePath).isFile())
+            return false;
+        database = new DatabaseSync(databasePath, {
+            readOnly: true,
+            enableDoubleQuotedStringLiterals: false,
+            allowExtension: false,
+        });
+        configureHeartBusyTimeout(database);
+        residue = pragmaNumber(database, "user_version") === 1;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (database) {
+            try {
+                database.close();
+            }
+            catch {
+                residue = false;
+            }
+        }
+    }
+    return residue;
+}

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

@@ -0,0 +1,84 @@
+import { parseExecutionPact, } from "../../execution-pact.js";
+import { assertDatabaseOpen, rollbackQuietly, } from "./database.js";
+import { ProjectionGenerationStoreError } from "./model.js";
+export function initializeIdentity(database, databasePath, readOnly, identity) {
+    assertDatabaseOpen(database);
+    if (readOnly) {
+        throw new ProjectionGenerationStoreError("projection identity store is read-only");
+    }
+    const validated = parseExecutionPact(identity, `${databasePath}#projection_identity`);
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const existing = database.prepare("SELECT COUNT(*) AS count FROM projection_identity").get();
+        if (Number(existing?.count ?? 0) !== 0) {
+            throw new ProjectionGenerationStoreError("projection identity is already initialized");
+        }
+        database.prepare(`
+      INSERT INTO projection_identity (
+        singleton,
+        version,
+        pid,
+        akuma,
+        provider,
+        authority_json,
+        binding_json,
+        minted_at,
+        workspace_root,
+        effective_policy_json
+      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(validated.version, validated.pid, validated.akuma, validated.provider, JSON.stringify(validated.authority), JSON.stringify(validated.binding), validated.mintedAt, validated.workspaceRoot, validated.effectivePolicy === undefined
+            ? null
+            : JSON.stringify(validated.effectivePolicy));
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        rollbackQuietly(database);
+        throw error;
+    }
+}
+export function readIdentity(database, databasePath) {
+    assertDatabaseOpen(database);
+    const rows = database.prepare(`
+    SELECT
+      version,
+      pid,
+      akuma,
+      provider,
+      authority_json,
+      binding_json,
+      minted_at,
+      workspace_root,
+      effective_policy_json
+    FROM projection_identity
+  `).all();
+    if (rows.length !== 1) {
+        throw new ProjectionGenerationStoreError(`projection identity row count must be 1, found ${rows.length}`);
+    }
+    const row = rows[0];
+    let authority;
+    let binding;
+    let effectivePolicy;
+    try {
+        authority = JSON.parse(row.authority_json);
+        binding = JSON.parse(row.binding_json);
+        effectivePolicy = row.effective_policy_json === null
+            ? undefined
+            : JSON.parse(row.effective_policy_json);
+    }
+    catch (error) {
+        throw new ProjectionGenerationStoreError("projection identity contains malformed JSON", {
+            cause: error,
+        });
+    }
+    return parseExecutionPact({
+        version: Number(row.version),
+        pid: Number(row.pid),
+        akuma: row.akuma,
+        provider: row.provider,
+        authority,
+        binding,
+        mintedAt: row.minted_at,
+        workspaceRoot: row.workspace_root,
+        ...(effectivePolicy === undefined ? {} : { effectivePolicy }),
+    }, `${databasePath}#projection_identity`);
+}