@wopr-network/defcon 1.12.0 → 1.13.0

package/dist/src/execution/cli.js

@@ -19,6 +19,7 @@ import { buildConfigFromEnv, isLitestreamEnabled, LitestreamManager } from "../l
 import { withTransaction } from "../main.js";
 import { DrizzleDomainEventRepository } from "../repositories/drizzle/domain-event.repo.js";
 import { DrizzleEntityRepository } from "../repositories/drizzle/entity.repo.js";
+import { DrizzleEntitySnapshotRepository } from "../repositories/drizzle/entity-snapshot.repo.js";
 import { DrizzleEventRepository } from "../repositories/drizzle/event.repo.js";
 import { DrizzleFlowRepository } from "../repositories/drizzle/flow.repo.js";
 import { DrizzleGateRepository } from "../repositories/drizzle/gate.repo.js";
@@ -26,6 +27,8 @@ import { DrizzleInvocationRepository } from "../repositories/drizzle/invocation.
 import * as schema from "../repositories/drizzle/schema.js";
 import { entities, entityHistory, flowDefinitions, flowVersions, gateDefinitions, gateResults, invocations, stateDefinitions, transitionRules, } from "../repositories/drizzle/schema.js";
 import { DrizzleTransitionLogRepository } from "../repositories/drizzle/transition-log.repo.js";
+import { EventSourcedEntityRepository } from "../repositories/event-sourced/entity.repo.js";
+import { EventSourcedInvocationRepository } from "../repositories/event-sourced/invocation.repo.js";
 import { UiSseAdapter } from "../ui/sse.js";
 import { WebSocketBroadcaster } from "../ws/broadcast.js";
 import { createMcpServer, startStdioServer } from "./mcp-server.js";
@@ -171,12 +174,26 @@ program
     if (litestreamMgr) {
         litestreamMgr.start();
     }
-    const entityRepo = new DrizzleEntityRepository(db);
+    const mutableEntityRepo = new DrizzleEntityRepository(db);
     const flowRepo = new DrizzleFlowRepository(db);
-    const invocationRepo = new DrizzleInvocationRepository(db);
+    const mutableInvocationRepo = new DrizzleInvocationRepository(db);
     const gateRepo = new DrizzleGateRepository(db);
     const transitionLogRepo = new DrizzleTransitionLogRepository(db);
     const domainEventRepo = new DrizzleDomainEventRepository(db);
+    const useEventSourced = process.env.DEFCON_EVENT_SOURCED === "true";
+    const snapshotInterval = parseInt(process.env.DEFCON_SNAPSHOT_INTERVAL ?? "10", 10);
+    let entityRepo;
+    let invocationRepo;
+    if (useEventSourced) {
+        const snapshotRepo = new DrizzleEntitySnapshotRepository(db);
+        entityRepo = new EventSourcedEntityRepository(mutableEntityRepo, domainEventRepo, snapshotRepo, snapshotInterval);
+        invocationRepo = new EventSourcedInvocationRepository(mutableInvocationRepo, domainEventRepo);
+        process.stderr.write("[defcon] Event-sourced repositories enabled\n");
+    }
+    else {
+        entityRepo = mutableEntityRepo;
+        invocationRepo = mutableInvocationRepo;
+    }
     const eventEmitter = new EventEmitter();
     eventEmitter.register({
         emit: async (event) => {

package/dist/src/repositories/drizzle/domain-event.repo.d.ts

@@ -11,6 +11,7 @@ export declare class DrizzleDomainEventRepository implements IDomainEventReposit
     list(entityId: string, opts?: {
         type?: string;
         limit?: number;
+        minSequence?: number;
     }): Promise<DomainEvent[]>;
 }
 export {};

package/dist/src/repositories/drizzle/domain-event.repo.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { and, eq, sql } from "drizzle-orm";
+import { and, eq, gt, sql } from "drizzle-orm";
 import { domainEvents } from "./schema.js";
 export class DrizzleDomainEventRepository {
     db;
@@ -62,6 +62,9 @@ export class DrizzleDomainEventRepository {
         if (opts?.type) {
             conditions.push(eq(domainEvents.type, opts.type));
         }
+        if (opts?.minSequence !== undefined) {
+            conditions.push(gt(domainEvents.sequence, opts.minSequence));
+        }
         const rows = this.db
             .select()
             .from(domainEvents)

package/dist/src/repositories/drizzle/entity-snapshot.repo.d.ts

@@ -0,0 +1,14 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { Entity, IEntitySnapshotRepository } from "../interfaces.js";
+import type * as schema from "./schema.js";
+type Db = BetterSQLite3Database<typeof schema>;
+export declare class DrizzleEntitySnapshotRepository implements IEntitySnapshotRepository {
+    private readonly db;
+    constructor(db: Db);
+    save(entityId: string, sequence: number, state: Entity): Promise<void>;
+    loadLatest(entityId: string): Promise<{
+        sequence: number;
+        state: Entity;
+    } | null>;
+}
+export {};

package/dist/src/repositories/drizzle/entity-snapshot.repo.js

@@ -0,0 +1,68 @@
+import { randomUUID } from "node:crypto";
+import { desc, eq } from "drizzle-orm";
+import { entitySnapshots } from "./schema.js";
+export class DrizzleEntitySnapshotRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(entityId, sequence, state) {
+        const id = randomUUID();
+        this.db
+            .insert(entitySnapshots)
+            .values({
+            id,
+            entityId,
+            sequence,
+            state: state.state,
+            flowId: state.flowId,
+            refs: state.refs,
+            artifacts: state.artifacts,
+            claimedBy: state.claimedBy,
+            claimedAt: state.claimedAt?.getTime() ?? null,
+            flowVersion: state.flowVersion,
+            priority: state.priority,
+            affinityWorkerId: state.affinityWorkerId,
+            affinityRole: state.affinityRole,
+            affinityExpiresAt: state.affinityExpiresAt?.getTime() ?? null,
+            createdAt: state.createdAt.getTime(),
+            updatedAt: state.updatedAt.getTime(),
+            snapshotAt: Date.now(),
+            parentEntityId: state.parentEntityId,
+        })
+            .onConflictDoNothing()
+            .run();
+    }
+    async loadLatest(entityId) {
+        const rows = this.db
+            .select()
+            .from(entitySnapshots)
+            .where(eq(entitySnapshots.entityId, entityId))
+            .orderBy(desc(entitySnapshots.sequence))
+            .limit(1)
+            .all();
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return {
+            sequence: row.sequence,
+            state: {
+                id: entityId,
+                flowId: row.flowId,
+                state: row.state,
+                refs: row.refs,
+                artifacts: row.artifacts,
+                claimedBy: row.claimedBy,
+                claimedAt: row.claimedAt ? new Date(row.claimedAt) : null,
+                flowVersion: row.flowVersion ?? 1,
+                priority: row.priority ?? 0,
+                createdAt: new Date(row.createdAt ?? 0),
+                updatedAt: new Date(row.updatedAt ?? 0),
+                affinityWorkerId: row.affinityWorkerId ?? null,
+                affinityRole: row.affinityRole ?? null,
+                affinityExpiresAt: row.affinityExpiresAt ? new Date(row.affinityExpiresAt) : null,
+                parentEntityId: row.parentEntityId ?? null,
+            },
+        };
+    }
+}

package/dist/src/repositories/drizzle/index.d.ts

@@ -1,5 +1,6 @@
 export { DrizzleDomainEventRepository } from "./domain-event.repo.js";
 export { DrizzleEntityRepository } from "./entity.repo.js";
+export { DrizzleEntitySnapshotRepository } from "./entity-snapshot.repo.js";
 export { DrizzleEventRepository } from "./event.repo.js";
 export { DrizzleFlowRepository } from "./flow.repo.js";
 export { DrizzleGateRepository } from "./gate.repo.js";

package/dist/src/repositories/drizzle/index.js

@@ -1,6 +1,7 @@
 // Drizzle ORM implementations of repository interfaces
 export { DrizzleDomainEventRepository } from "./domain-event.repo.js";
 export { DrizzleEntityRepository } from "./entity.repo.js";
+export { DrizzleEntitySnapshotRepository } from "./entity-snapshot.repo.js";
 export { DrizzleEventRepository } from "./event.repo.js";
 export { DrizzleFlowRepository } from "./flow.repo.js";
 export { DrizzleGateRepository } from "./gate.repo.js";

package/dist/src/repositories/drizzle/schema.d.ts

@@ -2149,3 +2149,332 @@ export declare const domainEvents: import("drizzle-orm/sqlite-core").SQLiteTable
     };
     dialect: "sqlite";
 }>;
+export declare const entitySnapshots: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "entity_snapshots";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        entityId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "entity_id";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sequence: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sequence";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        state: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        flowId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "flow_id";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        refs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "refs";
+            tableName: "entity_snapshots";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        artifacts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "artifacts";
+            tableName: "entity_snapshots";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        claimedBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "claimed_by";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        claimedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "claimed_at";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        flowVersion: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "flow_version";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priority: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "priority";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        affinityWorkerId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "affinity_worker_id";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        affinityRole: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "affinity_role";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        affinityExpiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "affinity_expires_at";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        snapshotAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "snapshot_at";
+            tableName: "entity_snapshots";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parentEntityId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "parent_entity_id";
+            tableName: "entity_snapshots";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/src/repositories/drizzle/schema.js

@@ -173,3 +173,26 @@ export const domainEvents = sqliteTable("domain_events", {
     entitySeqIdx: uniqueIndex("domain_events_entity_seq_idx").on(table.entityId, table.sequence),
     typeIdx: index("domain_events_type_idx").on(table.type, table.emittedAt),
 }));
+export const entitySnapshots = sqliteTable("entity_snapshots", {
+    id: text("id").primaryKey(),
+    entityId: text("entity_id").notNull(),
+    sequence: integer("sequence").notNull(),
+    state: text("state").notNull(),
+    flowId: text("flow_id").notNull(),
+    refs: text("refs", { mode: "json" }),
+    artifacts: text("artifacts", { mode: "json" }),
+    claimedBy: text("claimed_by"),
+    claimedAt: integer("claimed_at"),
+    flowVersion: integer("flow_version"),
+    priority: integer("priority").default(0),
+    affinityWorkerId: text("affinity_worker_id"),
+    affinityRole: text("affinity_role"),
+    affinityExpiresAt: integer("affinity_expires_at"),
+    createdAt: integer("created_at"),
+    updatedAt: integer("updated_at"),
+    snapshotAt: integer("snapshot_at").notNull(),
+    parentEntityId: text("parent_entity_id"),
+}, (table) => ({
+    entitySeqUnique: uniqueIndex("entity_snapshots_entity_seq_idx").on(table.entityId, table.sequence),
+    entityLatestIdx: index("entity_snapshots_entity_latest_idx").on(table.entityId, table.snapshotAt),
+}));

package/dist/src/repositories/event-sourced/entity.repo.d.ts

@@ -0,0 +1,29 @@
+import type { Artifacts, Entity, IDomainEventRepository, IEntityRepository, IEntitySnapshotRepository, Refs } from "../interfaces.js";
+export declare class EventSourcedEntityRepository implements IEntityRepository {
+    private readonly mutable;
+    private readonly domainEvents;
+    private readonly snapshots;
+    private readonly snapshotInterval;
+    constructor(mutable: IEntityRepository, domainEvents: IDomainEventRepository, snapshots: IEntitySnapshotRepository, snapshotInterval?: number);
+    create(flowId: string, initialState: string, refs?: Refs, flowVersion?: number): Promise<Entity>;
+    get(id: string): Promise<Entity | null>;
+    findByFlowAndState(flowId: string, state: string, limit?: number): Promise<Entity[]>;
+    hasAnyInFlowAndState(flowId: string, stateNames: string[]): Promise<boolean>;
+    transition(id: string, toState: string, trigger: string, artifacts?: Partial<Artifacts>): Promise<Entity>;
+    updateArtifacts(id: string, artifacts: Partial<Artifacts>): Promise<void>;
+    claim(flowId: string, state: string, agentId: string): Promise<Entity | null>;
+    claimById(entityId: string, agentId: string): Promise<Entity | null>;
+    release(entityId: string, agentId: string): Promise<void>;
+    reapExpired(ttlMs: number): Promise<string[]>;
+    setAffinity(entityId: string, workerId: string, role: string, expiresAt: Date): Promise<void>;
+    clearExpiredAffinity(): Promise<string[]>;
+    appendSpawnedChild(parentId: string, entry: {
+        childId: string;
+        childFlow: string;
+        spawnedAt: string;
+    }): Promise<void>;
+    findByParentId(parentEntityId: string): Promise<Entity[]>;
+    cancelEntity(entityId: string): Promise<void>;
+    resetEntity(entityId: string, targetState: string): Promise<Entity>;
+    updateFlowVersion(entityId: string, version: number): Promise<void>;
+}

package/dist/src/repositories/event-sourced/entity.repo.js

@@ -0,0 +1,84 @@
+import { replayEntity } from "./replay.js";
+const DEFAULT_SNAPSHOT_INTERVAL = 10;
+export class EventSourcedEntityRepository {
+    mutable;
+    domainEvents;
+    snapshots;
+    snapshotInterval;
+    constructor(mutable, domainEvents, snapshots, snapshotInterval) {
+        this.mutable = mutable;
+        this.domainEvents = domainEvents;
+        this.snapshots = snapshots;
+        this.snapshotInterval = snapshotInterval ?? DEFAULT_SNAPSHOT_INTERVAL;
+    }
+    async create(flowId, initialState, refs, flowVersion) {
+        return this.mutable.create(flowId, initialState, refs, flowVersion);
+    }
+    async get(id) {
+        const snapshot = await this.snapshots.loadLatest(id);
+        const afterSeq = snapshot?.sequence ?? 0;
+        const eventsAfterSnapshot = await this.domainEvents.list(id, { minSequence: afterSeq, limit: 10000 });
+        if (eventsAfterSnapshot.length === 0 && !snapshot) {
+            return this.mutable.get(id);
+        }
+        const entity = replayEntity(snapshot?.state ?? null, eventsAfterSnapshot, id);
+        if (!entity) {
+            return this.mutable.get(id);
+        }
+        if (eventsAfterSnapshot.length >= this.snapshotInterval) {
+            const lastEvent = eventsAfterSnapshot[eventsAfterSnapshot.length - 1];
+            try {
+                await this.snapshots.save(id, lastEvent.sequence, entity);
+            }
+            catch {
+                // snapshot write failure is non-fatal — continue with in-memory entity
+            }
+        }
+        return entity;
+    }
+    async findByFlowAndState(flowId, state, limit) {
+        return this.mutable.findByFlowAndState(flowId, state, limit);
+    }
+    async hasAnyInFlowAndState(flowId, stateNames) {
+        return this.mutable.hasAnyInFlowAndState(flowId, stateNames);
+    }
+    async transition(id, toState, trigger, artifacts) {
+        return this.mutable.transition(id, toState, trigger, artifacts);
+    }
+    async updateArtifacts(id, artifacts) {
+        return this.mutable.updateArtifacts(id, artifacts);
+    }
+    async claim(flowId, state, agentId) {
+        return this.mutable.claim(flowId, state, agentId);
+    }
+    async claimById(entityId, agentId) {
+        return this.mutable.claimById(entityId, agentId);
+    }
+    async release(entityId, agentId) {
+        return this.mutable.release(entityId, agentId);
+    }
+    async reapExpired(ttlMs) {
+        return this.mutable.reapExpired(ttlMs);
+    }
+    async setAffinity(entityId, workerId, role, expiresAt) {
+        return this.mutable.setAffinity(entityId, workerId, role, expiresAt);
+    }
+    async clearExpiredAffinity() {
+        return this.mutable.clearExpiredAffinity();
+    }
+    async appendSpawnedChild(parentId, entry) {
+        return this.mutable.appendSpawnedChild(parentId, entry);
+    }
+    async findByParentId(parentEntityId) {
+        return this.mutable.findByParentId(parentEntityId);
+    }
+    async cancelEntity(entityId) {
+        return this.mutable.cancelEntity(entityId);
+    }
+    async resetEntity(entityId, targetState) {
+        return this.mutable.resetEntity(entityId, targetState);
+    }
+    async updateFlowVersion(entityId, version) {
+        return this.mutable.updateFlowVersion(entityId, version);
+    }
+}

package/dist/src/repositories/event-sourced/index.d.ts

@@ -0,0 +1,3 @@
+export { EventSourcedEntityRepository } from "./entity.repo.js";
+export { EventSourcedInvocationRepository } from "./invocation.repo.js";
+export { replayEntity, replayInvocation } from "./replay.js";

package/dist/src/repositories/event-sourced/index.js

@@ -0,0 +1,3 @@
+export { EventSourcedEntityRepository } from "./entity.repo.js";
+export { EventSourcedInvocationRepository } from "./invocation.repo.js";
+export { replayEntity, replayInvocation } from "./replay.js";

package/dist/src/repositories/event-sourced/invocation.repo.d.ts

@@ -0,0 +1,20 @@
+import type { Artifacts, IDomainEventRepository, IInvocationRepository, Invocation, Mode } from "../interfaces.js";
+export declare class EventSourcedInvocationRepository implements IInvocationRepository {
+    private readonly mutable;
+    private readonly domainEvents;
+    constructor(mutable: IInvocationRepository, domainEvents: IDomainEventRepository);
+    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs: number | undefined, context: Record<string, unknown> | undefined, agentRole: string | null): Promise<Invocation>;
+    get(id: string): Promise<Invocation | null>;
+    claim(invocationId: string, agentId: string): Promise<Invocation | null>;
+    complete(id: string, signal: string, artifacts?: Artifacts): Promise<Invocation>;
+    fail(id: string, error: string): Promise<Invocation>;
+    releaseClaim(id: string): Promise<void>;
+    findByEntity(entityId: string): Promise<Invocation[]>;
+    findUnclaimedWithAffinity(flowId: string, role: string, workerId: string): Promise<Invocation[]>;
+    findUnclaimedByFlow(flowId: string): Promise<Invocation[]>;
+    findByFlow(flowId: string): Promise<Invocation[]>;
+    reapExpired(): Promise<Invocation[]>;
+    findUnclaimedActive(flowId?: string): Promise<Invocation[]>;
+    countActiveByFlow(flowId: string): Promise<number>;
+    countPendingByFlow(flowId: string): Promise<number>;
+}