@wopr-network/defcon 1.6.0 → 1.6.1

package/dist/src/engine/engine.d.ts

@@ -38,6 +38,8 @@ export interface EngineDeps {
     adapters: Map<string, unknown>;
     eventEmitter: IEventBusAdapter;
     logger?: Logger;
+    /** Optional transaction wrapper from the database layer. When provided, processSignal runs inside a single transaction and events are flushed only after successful commit. */
+    withTransaction?: <T>(fn: () => T | Promise<T>) => Promise<T>;
 }
 export declare class Engine {
     private entityRepo;
@@ -48,6 +50,7 @@ export declare class Engine {
     readonly adapters: Map<string, unknown>;
     private eventEmitter;
     private readonly logger;
+    private readonly withTransactionFn;
     private drainingWorkers;
     constructor(deps: EngineDeps);
     drainWorker(workerId: string): void;
@@ -56,6 +59,7 @@ export declare class Engine {
     listDrainingWorkers(): string[];
     emit(event: import("./event-types.js").EngineEvent): Promise<void>;
     processSignal(entityId: string, signal: string, artifacts?: Artifacts, triggeringInvocationId?: string): Promise<ProcessSignalResult>;
+    private _processSignalInner;
     /**
      * Evaluate a gate and return a routing decision:
      * - `proceed`  — gate passed, continue to transition.toState

package/dist/src/engine/engine.js

@@ -17,6 +17,7 @@ export class Engine {
     adapters;
     eventEmitter;
     logger;
+    withTransactionFn;
     drainingWorkers = new Set();
     constructor(deps) {
         this.entityRepo = deps.entityRepo;
@@ -27,6 +28,7 @@ export class Engine {
         this.adapters = deps.adapters;
         this.eventEmitter = deps.eventEmitter;
         this.logger = deps.logger ?? consoleLogger;
+        this.withTransactionFn = deps.withTransaction ?? null;
     }
     drainWorker(workerId) {
         this.drainingWorkers.add(workerId);
@@ -44,6 +46,28 @@ export class Engine {
         await this.eventEmitter.emit(event);
     }
     async processSignal(entityId, signal, artifacts, triggeringInvocationId) {
+        const pendingEvents = [];
+        const bufferingEmitter = {
+            emit: async (event) => {
+                pendingEvents.push(event);
+            },
+        };
+        if (this.withTransactionFn) {
+            // Run DB writes inside a transaction; events are buffered and only
+            // flushed to real subscribers after successful COMMIT.
+            const result = await this.withTransactionFn(() => this._processSignalInner(entityId, signal, artifacts, triggeringInvocationId, bufferingEmitter));
+            for (const event of pendingEvents) {
+                await this.eventEmitter.emit(event);
+            }
+            return result;
+        }
+        const result = await this._processSignalInner(entityId, signal, artifacts, triggeringInvocationId, bufferingEmitter);
+        for (const event of pendingEvents) {
+            await this.eventEmitter.emit(event);
+        }
+        return result;
+    }
+    async _processSignalInner(entityId, signal, artifacts, triggeringInvocationId, emitter = this.eventEmitter) {
         // 1. Load entity
         const entity = await this.entityRepo.get(entityId);
         if (!entity)
@@ -98,7 +122,7 @@ export class Engine {
         // Keep the in-memory entity in sync so buildInvocation sees the cleared failures
         updated = { ...updated, artifacts: { ...updated.artifacts, gate_failures: [] } };
         // 6. Emit transition event
-        await this.eventEmitter.emit({
+        await emitter.emit({
             type: "entity.transitioned",
             entityId,
             flowId: flow.id,
@@ -118,7 +142,7 @@ export class Engine {
         if (newStateDef?.onEnter) {
             const onEnterResult = await executeOnEnter(newStateDef.onEnter, updated, this.entityRepo);
             if (onEnterResult.skipped) {
-                await this.eventEmitter.emit({
+                await emitter.emit({
                     type: "onEnter.skipped",
                     entityId,
                     state: toState,
@@ -126,7 +150,7 @@ export class Engine {
                 });
             }
             else if (onEnterResult.error) {
-                await this.eventEmitter.emit({
+                await emitter.emit({
                     type: "onEnter.failed",
                     entityId,
                     state: toState,
@@ -151,7 +175,7 @@ export class Engine {
                 };
             }
             else {
-                await this.eventEmitter.emit({
+                await emitter.emit({
                     type: "onEnter.completed",
                     entityId,
                     state: toState,
@@ -179,7 +203,7 @@ export class Engine {
                     ? { systemPrompt: build.systemPrompt, userContent: build.userContent }
                     : undefined, newStateDef.agentRole ?? null);
                 result.invocationId = invocation.id;
-                await this.eventEmitter.emit({
+                await emitter.emit({
                     type: "invocation.created",
                     entityId,
                     invocationId: invocation.id,
@@ -202,7 +226,7 @@ export class Engine {
         const spawned = await executeSpawn({ spawnFlow }, updated, this.flowRepo, this.entityRepo, this.logger);
         if (spawned) {
             result.spawned = [spawned.id];
-            await this.eventEmitter.emit({
+            await emitter.emit({
                 type: "flow.spawned",
                 entityId,
                 flowId: flow.id,

package/dist/src/execution/cli.js

@@ -14,6 +14,7 @@ import { loadSeed } from "../config/seed-loader.js";
 import { resolveCorsOrigin } from "../cors.js";
 import { Engine } from "../engine/engine.js";
 import { EventEmitter } from "../engine/event-emitter.js";
+import { withTransaction } from "../main.js";
 import { DrizzleEntityRepository } from "../repositories/drizzle/entity.repo.js";
 import { DrizzleEventRepository } from "../repositories/drizzle/event.repo.js";
 import { DrizzleFlowRepository } from "../repositories/drizzle/flow.repo.js";
@@ -173,6 +174,7 @@ program
         transitionLogRepo,
         adapters: new Map(),
         eventEmitter,
+        withTransaction: (fn) => withTransaction(sqlite, fn),
     });
     const deps = {
         entities: entityRepo,

package/dist/src/main.d.ts

@@ -5,6 +5,12 @@ export declare function createDatabase(dbPath?: string): {
     db: ReturnType<typeof drizzle<typeof schema>>;
     sqlite: Database.Database;
 };
+/**
+ * Wraps `fn` in a BEGIN/COMMIT/ROLLBACK transaction on `sqlite`.
+ * If already inside a transaction, runs `fn` directly (allows nested calls).
+ * Supports both synchronous and Promise-returning `fn`.
+ */
+export declare function withTransaction<T>(sqlite: Database.Database, fn: () => T | Promise<T>): Promise<T>;
 export declare function runMigrations(db: ReturnType<typeof drizzle>, migrationsFolder?: string): void;
 export declare function bootstrap(dbPath?: string): {
     db: ReturnType<typeof drizzle>;

package/dist/src/main.js

@@ -10,6 +10,26 @@ export function createDatabase(dbPath = DB_PATH) {
     const db = drizzle(sqlite, { schema });
     return { db, sqlite };
 }
+/**
+ * Wraps `fn` in a BEGIN/COMMIT/ROLLBACK transaction on `sqlite`.
+ * If already inside a transaction, runs `fn` directly (allows nested calls).
+ * Supports both synchronous and Promise-returning `fn`.
+ */
+export async function withTransaction(sqlite, fn) {
+    if (sqlite.inTransaction) {
+        return fn();
+    }
+    sqlite.exec("BEGIN");
+    try {
+        const result = await fn();
+        sqlite.exec("COMMIT");
+        return result;
+    }
+    catch (err) {
+        sqlite.exec("ROLLBACK");
+        throw err;
+    }
+}
 export function runMigrations(db, migrationsFolder = "./drizzle") {
     migrate(db, { migrationsFolder });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/defcon",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "type": "module",
   "packageManager": "pnpm@9.15.4",
   "engines": {