ai-foreman 1.7.6 → 1.7.7

package/dist/tickets/stateDb.js

@@ -1,6 +1,7 @@
 import Database from "better-sqlite3";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import { createHash } from "node:crypto";
 /** The only valid initial/fully-reset active state for a ticket. */
 export function pristineTicketState(ticketId, now, actor = null) {
     return {
@@ -130,6 +131,38 @@ CREATE TABLE IF NOT EXISTS operation_receipts (
   payload_json TEXT NOT NULL DEFAULT '{}'
 );
 
+CREATE TABLE IF NOT EXISTS ticket_groups (
+  sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+  origin TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  legacy INTEGER NOT NULL DEFAULT 0,
+  operation_id TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS ticket_group_members (
+  group_sequence INTEGER NOT NULL REFERENCES ticket_groups(sequence) ON DELETE RESTRICT,
+  ticket_id TEXT NOT NULL UNIQUE,
+  position INTEGER NOT NULL,
+  snapshot_json TEXT NOT NULL,
+  snapshot_digest TEXT NOT NULL,
+  snapshot_validated_at TEXT NOT NULL,
+  PRIMARY KEY(group_sequence, ticket_id),
+  UNIQUE(group_sequence, position),
+  CHECK(position >= 1)
+);
+
+CREATE TABLE IF NOT EXISTS ticket_group_receipts (
+  operation_id TEXT PRIMARY KEY,
+  group_sequence INTEGER NOT NULL UNIQUE REFERENCES ticket_groups(sequence) ON DELETE RESTRICT,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS ticket_group_sequence_ledger (
+  sequence INTEGER PRIMARY KEY,
+  operation_id TEXT NOT NULL UNIQUE,
+  allocated_at TEXT NOT NULL
+);
+
 CREATE INDEX IF NOT EXISTS idx_ticket_state_status ON ticket_state(status);
 CREATE INDEX IF NOT EXISTS idx_ticket_events_ticket_id ON ticket_events(ticket_id);
 CREATE INDEX IF NOT EXISTS idx_ticket_events_timestamp ON ticket_events(timestamp);
@@ -137,6 +170,7 @@ CREATE INDEX IF NOT EXISTS idx_validation_snapshots_timestamp ON validation_snap
 CREATE INDEX IF NOT EXISTS idx_future_work_disposition ON future_work(disposition);
 CREATE INDEX IF NOT EXISTS idx_review_recommendations_status ON review_recommendations(status);
 CREATE INDEX IF NOT EXISTS idx_operation_receipts_run ON operation_receipts(run_id);
+CREATE INDEX IF NOT EXISTS idx_ticket_group_members_group ON ticket_group_members(group_sequence, position);
 `;
 export class StateDb {
     db;
@@ -145,6 +179,8 @@ export class StateDb {
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(INIT_SQL);
+        this.db.prepare(`INSERT OR IGNORE INTO ticket_group_sequence_ledger(sequence,operation_id,allocated_at)
+      SELECT sequence,operation_id,created_at FROM ticket_groups`).run();
         this.migrateObsoleteStatus();
     }
     migrateObsoleteStatus() {
@@ -369,8 +405,179 @@ export class StateDb {
     `).run(receipt);
         return result.changes === 1;
     }
+    // ── immutable ticket creation groups ─────────────────────────────────────
+    createTicketGroup(input) {
+        const existing = this.getTicketGroupByOperation(input.operationId);
+        if (existing) {
+            const requestedIds = input.members.map((member) => member.ticketId);
+            const existingIds = existing.members.map((member) => member.ticketId);
+            if (existing.origin !== input.origin || JSON.stringify(existingIds) !== JSON.stringify(requestedIds))
+                throw new Error(`ticket group operation ${input.operationId} was retried with different immutable membership`);
+            return existing;
+        }
+        if (!input.operationId.trim())
+            throw new Error("ticket group operation ID must not be empty");
+        if (input.members.length === 0)
+            throw new Error("ticket creation updates/no-ops must not create an empty group");
+        const ids = input.members.map((member) => member.ticketId);
+        if (new Set(ids).size !== ids.length)
+            throw new Error("ticket group members must be unique");
+        const createdAt = input.createdAt ?? new Date().toISOString();
+        return this.transaction(() => {
+            const result = this.db.prepare("INSERT INTO ticket_groups(origin,created_at,legacy,operation_id) VALUES(?,?,?,?)")
+                .run(input.origin, createdAt, input.legacy ? 1 : 0, input.operationId);
+            const sequence = Number(result.lastInsertRowid);
+            this.db.prepare("INSERT INTO ticket_group_sequence_ledger(sequence,operation_id,allocated_at) VALUES(?,?,?)").run(sequence, input.operationId, createdAt);
+            const insert = this.db.prepare(`INSERT INTO ticket_group_members(group_sequence,ticket_id,position,snapshot_json,snapshot_digest,snapshot_validated_at)
+        VALUES(?,?,?,?,?,?)`);
+            input.members.forEach((member, index) => {
+                const snapshot = makeDefinitionSnapshot(member.ticketId, member.definition, member.validatedAt ?? createdAt);
+                insert.run(sequence, member.ticketId, index + 1, JSON.stringify(snapshot.definition), snapshot.digest, snapshot.validatedAt);
+                // The creation receipt, immutable membership, recoverable definition,
+                // and initial active state are one SQLite publication. Existing state
+                // is preserved on replay or when importing an externally completed
+                // ticket.
+                if (!this.getState(member.ticketId)) {
+                    this.upsertState(member.ticketId, pristineTicketState(member.ticketId, createdAt, "rafi ticket publication"), createdAt);
+                }
+            });
+            this.db.prepare("INSERT INTO ticket_group_receipts(operation_id,group_sequence,created_at) VALUES(?,?,?)").run(input.operationId, sequence, createdAt);
+            return this.getTicketGroupBySequence(sequence);
+        });
+    }
+    /** Update only the recoverable definition; membership and order never change. */
+    updateTicketDefinitionSnapshot(ticketId, definition, validatedAt = new Date().toISOString()) {
+        const snapshot = makeDefinitionSnapshot(ticketId, definition, validatedAt);
+        const result = this.db.prepare(`UPDATE ticket_group_members SET snapshot_json=?,snapshot_digest=?,snapshot_validated_at=? WHERE ticket_id=?`)
+            .run(JSON.stringify(snapshot.definition), snapshot.digest, snapshot.validatedAt, ticketId);
+        if (result.changes !== 1)
+            throw new Error(`ticket ${ticketId} has no creation-group membership`);
+        return snapshot;
+    }
+    getTicketGroupByOperation(operationId) {
+        const row = this.db.prepare("SELECT sequence FROM ticket_groups WHERE operation_id=?").get(operationId);
+        return row ? this.getTicketGroupBySequence(row.sequence) : undefined;
+    }
+    getTicketGroup(groupId) {
+        const match = /^TG-([1-9]\d*)$/.exec(groupId);
+        return match ? this.getTicketGroupBySequence(Number(match[1])) : undefined;
+    }
+    getTicketGroupForTicket(ticketId) {
+        const row = this.db.prepare("SELECT group_sequence AS sequence FROM ticket_group_members WHERE ticket_id=?").get(ticketId);
+        return row ? this.getTicketGroupBySequence(row.sequence) : undefined;
+    }
+    listTicketGroups() {
+        const rows = this.db.prepare("SELECT sequence FROM ticket_groups ORDER BY sequence DESC").all();
+        return rows.map((row) => this.getTicketGroupBySequence(row.sequence));
+    }
+    /** One-time migration for repositories whose complete ticket set predates groups. */
+    ensureSyntheticLegacyGroup(definitions, now = new Date()) {
+        if (definitions.length === 0 || this.listTicketGroups().length > 0)
+            return undefined;
+        return this.createTicketGroup({
+            origin: "legacy",
+            operationId: "ticket-groups:synthetic-legacy:v1",
+            legacy: true,
+            createdAt: now.toISOString(),
+            members: definitions.map((definition) => ({ ticketId: definition.id, definition, validatedAt: now.toISOString() })),
+        });
+    }
+    ungroupedTicketIds(ticketIds) {
+        const grouped = new Set(this.db.prepare("SELECT ticket_id FROM ticket_group_members").all().map((row) => row.ticket_id));
+        return ticketIds.filter((ticketId) => !grouped.has(ticketId));
+    }
+    repairTicketGroups(definitions, operationId, now = new Date()) {
+        const ungrouped = new Set(this.ungroupedTicketIds(definitions.map((definition) => definition.id)));
+        if (ungrouped.size === 0)
+            return undefined;
+        return this.createTicketGroup({
+            origin: "repair", operationId, createdAt: now.toISOString(),
+            members: definitions.filter((definition) => ungrouped.has(definition.id)).map((definition) => ({ ticketId: definition.id, definition })),
+        });
+    }
+    validateTicketGroups(knownTicketIds = []) {
+        const issues = [];
+        const groups = this.listTicketGroups();
+        const known = new Set(knownTicketIds);
+        for (const group of groups) {
+            if (group.members.length === 0)
+                issues.push({ code: "empty-group", groupId: group.id, message: `${group.id} has no members` });
+            for (const member of group.members) {
+                if (known.size > 0 && !known.has(member.ticketId))
+                    issues.push({ code: "unknown-member", groupId: group.id, ticketId: member.ticketId, message: `${group.id} references unknown ticket ${member.ticketId}` });
+                if (definitionDigest(member.snapshot.definition) !== member.snapshot.digest)
+                    issues.push({ code: "snapshot-corruption", groupId: group.id, ticketId: member.ticketId, message: `${group.id} snapshot for ${member.ticketId} does not match its digest` });
+            }
+        }
+        for (const ticketId of known)
+            if (!this.getTicketGroupForTicket(ticketId))
+                issues.push({ code: "missing-membership", ticketId, message: `ticket ${ticketId} has no creation-group membership` });
+        const duplicates = this.db.prepare("SELECT ticket_id,COUNT(*) AS count FROM ticket_group_members GROUP BY ticket_id HAVING COUNT(*)<>1").all();
+        for (const row of duplicates)
+            issues.push({ code: "multiple-membership", ticketId: row.ticket_id, message: `ticket ${row.ticket_id} belongs to ${row.count} creation groups` });
+        const maximum = groups.reduce((value, group) => Math.max(value, group.sequence), 0);
+        const sequence = this.db.prepare("SELECT seq FROM sqlite_sequence WHERE name='ticket_groups'").get();
+        if (maximum > 0 && (!sequence || sequence.seq < maximum))
+            issues.push({ code: "sequence-corruption", message: `ticket group sequence is ${sequence?.seq ?? "missing"}, below allocated ${maximum}` });
+        const missingLedger = this.db.prepare("SELECT sequence FROM ticket_groups WHERE sequence NOT IN (SELECT sequence FROM ticket_group_sequence_ledger)").all();
+        for (const row of missingLedger)
+            issues.push({ code: "sequence-corruption", groupId: `TG-${row.sequence}`, message: `TG-${row.sequence} has no immutable allocation ledger entry` });
+        const reused = this.db.prepare(`SELECT g.sequence FROM ticket_groups g JOIN ticket_group_sequence_ledger l ON l.sequence=g.sequence WHERE g.operation_id<>l.operation_id`).all();
+        for (const row of reused)
+            issues.push({ code: "reused-id", groupId: `TG-${row.sequence}`, message: `TG-${row.sequence} was reused for a different creation operation` });
+        const deletedAllocations = this.db.prepare("SELECT sequence FROM ticket_group_sequence_ledger WHERE sequence NOT IN (SELECT sequence FROM ticket_groups)").all();
+        for (const row of deletedAllocations)
+            issues.push({ code: "sequence-corruption", groupId: `TG-${row.sequence}`, message: `allocated TG-${row.sequence} is missing; group IDs must never be deleted or reused` });
+        const orphanReceipts = this.db.prepare("SELECT operation_id FROM ticket_group_receipts WHERE group_sequence NOT IN (SELECT sequence FROM ticket_groups)").all();
+        for (const row of orphanReceipts)
+            issues.push({ code: "receipt-without-group", message: `creation receipt ${row.operation_id} has no group` });
+        return issues;
+    }
+    getTicketGroupBySequence(sequence) {
+        const row = this.db.prepare("SELECT * FROM ticket_groups WHERE sequence=?").get(sequence);
+        if (!row)
+            return undefined;
+        const members = this.db.prepare("SELECT * FROM ticket_group_members WHERE group_sequence=? ORDER BY position").all(sequence);
+        return {
+            id: `TG-${row.sequence}`,
+            sequence: row.sequence,
+            origin: row.origin,
+            createdAt: row.created_at,
+            legacy: Boolean(row.legacy),
+            operationId: row.operation_id,
+            members: members.map((member) => ({
+                groupId: `TG-${row.sequence}`,
+                ticketId: member.ticket_id,
+                position: member.position,
+                snapshot: { version: 1, ticketId: member.ticket_id, definition: parseSnapshot(member.snapshot_json), digest: member.snapshot_digest, validatedAt: member.snapshot_validated_at },
+            })),
+        };
+    }
     // ── transactions ──────────────────────────────────────────────────────────
     transaction(fn) {
         return this.db.transaction(fn)();
     }
 }
+function makeDefinitionSnapshot(ticketId, definition, validatedAt) {
+    const cloned = JSON.parse(JSON.stringify(definition));
+    if (cloned && typeof cloned === "object" && !Array.isArray(cloned)) {
+        const definitionId = cloned.id;
+        if (definitionId !== undefined && definitionId !== ticketId)
+            throw new Error(`ticket definition snapshot ID ${String(definitionId)} does not match group member ${ticketId}`);
+    }
+    return { version: 1, ticketId, definition: cloned, digest: definitionDigest(cloned), validatedAt };
+}
+function definitionDigest(value) { return createHash("sha256").update(stableJson(value)).digest("hex"); }
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+    return JSON.stringify(value) ?? "null";
+}
+function parseSnapshot(value) { try {
+    return JSON.parse(value);
+}
+catch {
+    return { __rafi_corrupt_snapshot: true, raw: value };
+} }

package/dist/tickets/ticketLoader.js

@@ -1,4 +1,5 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { readFileSync, renameSync, writeFileSync, existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { parse, stringify } from "yaml";
 import { Ajv } from "ajv";
 import { TICKET_JSON_SCHEMA } from "./ticketSchema.js";
@@ -13,7 +14,9 @@ export function loadTickets(ticketsPath) {
     return raw.tickets;
 }
 export function saveTickets(ticketsPath, tickets) {
-    writeFileSync(ticketsPath, stringify({ tickets }, { lineWidth: 120 }), "utf8");
+    const temporary = `${ticketsPath}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, stringify({ tickets }, { lineWidth: 120 }), "utf8");
+    renameSync(temporary, ticketsPath);
 }
 export function validateTicketDefs(tickets) {
     const errors = [];

package/dist/tickets/validate.js

@@ -5,6 +5,7 @@ import { buildNextQueue } from "./queue.js";
 import { loadDeliveryConfig, validateDeliveryConfig } from "./delivery.js";
 export function runAllValidation(config, projectDir, ticketDefs, states, db) {
     const issues = [];
+    db.ensureSyntheticLegacyGroup(ticketDefs);
     // Pass 1: schema and source
     for (const err of validateTicketDefs(ticketDefs)) {
         issues.push({ pass: 1, severity: "error", message: `[schema] ${err.path}: ${err.message}` });
@@ -12,6 +13,9 @@ export function runAllValidation(config, projectDir, ticketDefs, states, db) {
     for (const cycle of detectCycles(ticketDefs)) {
         issues.push({ pass: 1, severity: "error", message: `[cycle] dependency cycle: ${cycle}` });
     }
+    for (const issue of db.validateTicketGroups(ticketDefs.map((ticket) => ticket.id))) {
+        issues.push({ pass: 1, severity: "error", message: `[ticket-group:${issue.code}] ${issue.message}` });
+    }
     try {
         const delivery = loadDeliveryConfig(projectDir);
         if (delivery) {

package/dist/workflowDb.d.ts

@@ -1,4 +1,4 @@
-import type { OperationLifecycle, ResolvedAgentSettings, WorkflowIssue } from "rafi-spec";
+import type { BuildRecoveryDecisionReceipt, ContextSample, ContinuityCheckpoint, ContinuityDelta, ContinuityEvent, ContinuityHead, ContinuityHeadState, HandoffLineage, HandoffManifestV1, LiveSettingsAcknowledgment, OperationLifecycle, ProviderSessionRefV1, ResolvedAgentSettings, SessionUsageSample, WorkflowIssue } from "rafi-spec";
 export declare const WORKFLOW_DB_FILE = ".rafi/recovery.sqlite3";
 export type WorkflowKind = "plan" | "ticket-plan" | "ticket-populate" | "uninstall" | "build" | "qa-remediation" | "recovery" | "legacy";
 export type WorkflowRunStatus = "running" | "paused" | "blocked" | "completed" | "failed" | "cancelled" | "superseded";
@@ -47,6 +47,30 @@ export interface PublicationTransaction {
     createdAt: string;
     updatedAt: string;
 }
+export interface CompactionAttemptRecord {
+    idempotencyKey: string;
+    runId: string;
+    role: "builder" | "qa";
+    providerSessionId?: string;
+    sessionRef?: ProviderSessionRefV1;
+    sessionKey?: string;
+    crossingKey: string;
+    status: "started" | "succeeded" | "failed";
+    beforeSample?: ContextSample;
+    afterSample?: ContextSample;
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RoleMutationLease {
+    runId: string;
+    role: "builder" | "qa";
+    generation: number;
+    providerSessionId: string;
+    sessionRef?: ProviderSessionRefV1;
+    sessionKey?: string;
+    movedAt: string;
+}
 /** Authoritative persistence for every resumable workflow in a project. */
 export declare class WorkflowDb {
     readonly projectDir: string;
@@ -54,6 +78,8 @@ export declare class WorkflowDb {
     private readonly db;
     constructor(projectDir: string, path?: string);
     close(): void;
+    /** Ensure non-workflow build records can use the same durable event store. */
+    ensureRun(runId: string, kind?: WorkflowKind, now?: Date): WorkflowRunSnapshot;
     createRun(input: {
         runId?: string;
         kind: WorkflowKind;
@@ -84,7 +110,40 @@ export declare class WorkflowDb {
     recordSettings(runId: string, role: string, boundary: number, settings: ResolvedAgentSettings, now?: Date): void;
     recordProjectSettingsRevision(revision: number, defaults: unknown, now?: Date): void;
     recordTelemetry(runId: string, snapshot: unknown, now?: Date): void;
-    recordSession(runId: string, role: string, stream: string, sessionId: string | undefined, transition: string, settings: ResolvedAgentSettings, now?: Date): void;
+    recordContextSample(sample: ContextSample): void;
+    contextSamples(runId: string, role?: "builder" | "qa"): ContextSample[];
+    recordSessionUsage(sample: SessionUsageSample): void;
+    sessionUsageSamples(runId: string, role?: "builder" | "qa"): SessionUsageSample[];
+    acknowledgeSettings(ack: LiveSettingsAcknowledgment): void;
+    settingsAcknowledgments(revision: number): LiveSettingsAcknowledgment[];
+    appendContinuityEvent(input: {
+        runId: string;
+        role: "builder" | "qa" | "host";
+        kind: string;
+        payload: unknown;
+        authoritativeStateRevision: number;
+        sessionRef?: ProviderSessionRefV1;
+        sessionKey?: string;
+    }, now?: Date): ContinuityEvent;
+    continuityEvents(runId: string, afterSequence?: number): ContinuityEvent[];
+    publishContinuityCheckpoint(input: {
+        runId: string;
+        role: "builder" | "qa";
+        delta: ContinuityDelta;
+        state?: ContinuityHeadState;
+        authoritativeStateRevision: number;
+        sessionRef?: ProviderSessionRefV1;
+        sessionKey?: string;
+    }, now?: Date): ContinuityCheckpoint;
+    continuityCheckpoints(runId: string, role?: "builder" | "qa"): ContinuityCheckpoint[];
+    latestContinuityCheckpoint(runId: string, role: "builder" | "qa"): ContinuityCheckpoint | undefined;
+    continuityHead(runId: string, role: "builder" | "qa" | "run"): ContinuityHead | undefined;
+    setContinuityHeadState(runId: string, role: "builder" | "qa", state: ContinuityHeadState, now?: Date): ContinuityHead | undefined;
+    recordSession(runId: string, role: string, stream: string, session: string | ProviderSessionRefV1 | undefined, transition: string, settings: ResolvedAgentSettings, now?: Date): void;
+    providerSessionRefs(runId: string, role?: string): ProviderSessionRefV1[];
+    /** Project-local lookup used to resolve compatibility raw IDs into scoped references. */
+    recordProviderSessionBinding(ref: ProviderSessionRefV1, now?: Date): void;
+    providerSessionBindings(sessionId?: string, role?: string): ProviderSessionRefV1[];
     recordIssue(runId: string, issue: WorkflowIssue): number;
     issues(runId: string): WorkflowIssue[];
     planOperation(input: {
@@ -102,6 +161,41 @@ export declare class WorkflowDb {
     operations(runId: string): OperationRecord[];
     putEvidence(kind: "handoff" | "diff" | "test", value: string | Buffer, now?: Date): string;
     getEvidence(digest: string): Buffer | undefined;
+    stageHandoff(manifest: HandoffManifestV1, markdown: string): HandoffLineage;
+    acceptHandoff(runId: string, generation: number, successor: string | ProviderSessionRefV1, now?: Date): HandoffLineage;
+    /** Fence the initial role owner without overwriting a lease already moved by a handoff. */
+    claimInitialRoleLease(runId: string, role: "builder" | "qa", providerSession: string | ProviderSessionRefV1, now?: Date): RoleMutationLease;
+    roleMutationLease(runId: string, role: "builder" | "qa"): RoleMutationLease | undefined;
+    /** Move a dead predecessor's lease only after a fresh recovery produced a schema-valid checkpoint. */
+    moveRoleLeaseAfterValidatedRecovery(runId: string, role: "builder" | "qa", providerSession: string | ProviderSessionRefV1, reason: string, now?: Date): RoleMutationLease;
+    failHandoff(runId: string, generation: number, reason: string, now?: Date): HandoffLineage;
+    handoff(runId: string, generation: number): HandoffLineage | undefined;
+    handoffs(runId: string): HandoffLineage[];
+    handoffContent(runId: string, generation: number): {
+        lineage: HandoffLineage;
+        manifest: HandoffManifestV1;
+        markdown: string;
+    } | undefined;
+    deleteHandoffHistory(runId: string): number;
+    startCompactionAttempt(input: {
+        idempotencyKey: string;
+        runId: string;
+        role: "builder" | "qa";
+        providerSessionId?: string;
+        sessionRef?: ProviderSessionRefV1;
+        sessionKey?: string;
+        crossingKey: string;
+        beforeSample?: ContextSample;
+    }, now?: Date): CompactionAttemptRecord;
+    finishCompactionAttempt(idempotencyKey: string, input: {
+        ok: boolean;
+        afterSample?: ContextSample;
+        error?: string;
+    }, now?: Date): CompactionAttemptRecord;
+    compactionAttempt(idempotencyKey: string): CompactionAttemptRecord | undefined;
+    successfulCompactionCount(runId: string, role: "builder" | "qa", providerSession?: string | ProviderSessionRefV1): number;
+    recordRecoveryDecision(receipt: BuildRecoveryDecisionReceipt): void;
+    recoveryDecisions(runId: string): BuildRecoveryDecisionReceipt[];
     beginPublication(runId: string, intent: unknown, previousDigests: unknown, now?: Date): PublicationTransaction;
     updatePublication(transactionId: string, status: PublicationTransaction["status"], now?: Date): PublicationTransaction;
     publication(transactionId: string): PublicationTransaction | undefined;
@@ -111,6 +205,9 @@ export declare class WorkflowDb {
     releaseLease(lease: ProjectLease, now?: Date): void;
     currentLease(): ProjectLease | undefined;
     importLegacyOnce(now?: Date): number;
+    private upsertContinuityHead;
+    private refreshRunContinuityHead;
     private insertEvent;
     private migrate;
+    private ensureColumn;
 }