@wopr-network/defcon 1.11.0 → 1.13.0

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>;
+}

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

@@ -0,0 +1,61 @@
+import { replayInvocation } from "./replay.js";
+export class EventSourcedInvocationRepository {
+    mutable;
+    domainEvents;
+    constructor(mutable, domainEvents) {
+        this.mutable = mutable;
+        this.domainEvents = domainEvents;
+    }
+    async create(entityId, stage, prompt, mode, ttlMs, context, agentRole) {
+        return this.mutable.create(entityId, stage, prompt, mode, ttlMs, context, agentRole);
+    }
+    async get(id) {
+        const mutableInv = await this.mutable.get(id);
+        if (!mutableInv)
+            return null;
+        const events = await this.domainEvents.list(mutableInv.entityId, { limit: 10000 });
+        const invocationEvents = events.filter((e) => {
+            const p = e.payload;
+            return p.invocationId === id;
+        });
+        if (invocationEvents.length === 0)
+            return mutableInv;
+        return replayInvocation(id, invocationEvents) ?? mutableInv;
+    }
+    async claim(invocationId, agentId) {
+        return this.mutable.claim(invocationId, agentId);
+    }
+    async complete(id, signal, artifacts) {
+        return this.mutable.complete(id, signal, artifacts);
+    }
+    async fail(id, error) {
+        return this.mutable.fail(id, error);
+    }
+    async releaseClaim(id) {
+        return this.mutable.releaseClaim(id);
+    }
+    async findByEntity(entityId) {
+        return this.mutable.findByEntity(entityId);
+    }
+    async findUnclaimedWithAffinity(flowId, role, workerId) {
+        return this.mutable.findUnclaimedWithAffinity(flowId, role, workerId);
+    }
+    async findUnclaimedByFlow(flowId) {
+        return this.mutable.findUnclaimedByFlow(flowId);
+    }
+    async findByFlow(flowId) {
+        return this.mutable.findByFlow(flowId);
+    }
+    async reapExpired() {
+        return this.mutable.reapExpired();
+    }
+    async findUnclaimedActive(flowId) {
+        return this.mutable.findUnclaimedActive(flowId);
+    }
+    async countActiveByFlow(flowId) {
+        return this.mutable.countActiveByFlow(flowId);
+    }
+    async countPendingByFlow(flowId) {
+        return this.mutable.countPendingByFlow(flowId);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { DomainEvent, Entity, Invocation } from "../interfaces.js";
+/**
+ * Replay entity state from a snapshot (or null) plus subsequent domain events.
+ * Events must be ordered by sequence ascending.
+ */
+export declare function replayEntity(snapshot: Entity | null, events: DomainEvent[], entityId: string): Entity | null;
+/**
+ * Replay a single invocation's state from domain events.
+ * Filters events by invocationId in the payload.
+ */
+export declare function replayInvocation(invocationId: string, events: DomainEvent[]): Invocation | null;