@wopr-network/defcon 1.15.0 → 1.16.0

package/dist/src/api/wire-types.d.ts

@@ -7,15 +7,12 @@ export type ClaimResponse = {
     retry_after_ms: number;
     message: string;
 } | {
-    worker_id?: string;
     entity_id: string;
     invocation_id: string;
     flow: string | null;
-    stage: string;
-    agent_role: string | null;
-    prompt: string;
-    context: Record<string, unknown> | null;
-    worker_notice?: string;
+    state: string;
+    refs: Record<string, unknown> | null;
+    artifacts: Record<string, unknown> | null;
 };
 export type ReportResponse = {
     next_action: "continue";

package/dist/src/config/seed-loader.js

@@ -95,6 +95,7 @@ async function parseSeedAndLoad(json, flowRepo, gateRepo, db) {
                     onEnter: s.onEnter,
                     onExit: s.onExit,
                     retryAfterMs: s.retryAfterMs,
+                    meta: s.meta,
                 });
             }
             const flowTransitions = parsed.transitions.filter((t) => t.flowName === f.name);

package/dist/src/config/zod-schemas.d.ts

@@ -45,6 +45,7 @@ export declare const StateDefinitionSchema: z.ZodObject<{
         timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
     retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export declare const CommandGateSchema: z.ZodObject<{
     name: z.ZodString;
@@ -165,6 +166,7 @@ export declare const SeedFileSchema: z.ZodObject<{
             timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         }, z.core.$strip>>;
         retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
     gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         name: z.ZodString;

package/dist/src/config/zod-schemas.js

@@ -60,6 +60,8 @@ export const StateDefinitionSchema = z.object({
     onEnter: OnEnterSchema.optional(),
     onExit: OnExitSchema.optional(),
     retryAfterMs: z.number().int().min(0).optional(),
+    /** Opaque metadata passed through to consumers (e.g. radar). Defcon stores but does not interpret. */
+    meta: z.record(z.string(), z.unknown()).optional(),
 });
 // Gate: discriminated union on `type`
 const GateOutcomeSchema = z.object({

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

@@ -21,8 +21,8 @@ export interface ClaimWorkResult {
     invocationId: string;
     flowName: string;
     stage: string;
-    prompt: string;
-    context: Record<string, unknown> | null;
+    refs: Record<string, unknown> | null;
+    artifacts: Record<string, unknown> | null;
 }
 export interface EngineStatus {
     flows: Record<string, Record<string, number>>;

package/dist/src/engine/engine.js

@@ -579,12 +579,6 @@ export class Engine {
                     this.logger.warn(`[engine] setAffinity failed for entity ${claimed.id} worker ${worker_id} — continuing:`, err);
                 }
             }
-            const versionedFlow = await this.flowRepo.getAtVersion(claimed.flowId, claimed.flowVersion);
-            const effectiveFlow = versionedFlow ?? flow;
-            const state = effectiveFlow.states.find((s) => s.name === pending.stage);
-            const build = state
-                ? await this.buildPromptForEntity(state, claimed, effectiveFlow)
-                : { prompt: pending.prompt, context: null };
             await this.eventEmitter.emit({
                 type: "entity.claimed",
                 entityId: claimed.id,
@@ -597,8 +591,8 @@ export class Engine {
                 invocationId: claimedInvocation.id,
                 flowName: flow.name,
                 stage: pending.stage,
-                prompt: build.prompt,
-                context: build.context,
+                refs: claimed.refs ?? null,
+                artifacts: claimed.artifacts ?? null,
             };
         }
         // 8. Fallback: no unclaimed invocations — claim entity directly and create invocation
@@ -676,8 +670,8 @@ export class Engine {
                     invocationId: claimedInvocation.id,
                     flowName: flow.name,
                     stage: state.name,
-                    prompt: build.prompt,
-                    context: build.context,
+                    refs: claimed.refs ?? null,
+                    artifacts: claimed.artifacts ?? null,
                 };
             }
         }

package/dist/src/execution/handlers/flow.js

@@ -173,8 +173,15 @@ export async function handleFlowClaim(deps, args) {
             continue;
         }
         const flow = entity ? flowById.get(entity.flowId) : undefined;
+        if (!flow) {
+            await deps.entities.release(entity.id, claimerId).catch(() => { });
+            await deps.invocations
+                .fail(claimed.id, `Flow not found for entity ${entity.id} (flowId: ${entity.flowId})`)
+                .catch(() => { });
+            continue;
+        }
         // Record affinity for the claiming worker (best-effort; failure must not block the claim)
-        if (worker_id && entity && flow) {
+        if (worker_id && entity) {
             try {
                 const windowMs = flow.affinityWindowMs ?? 300000;
                 await deps.entities.setAffinity(claimed.entityId, worker_id, role, new Date(Date.now() + windowMs));
@@ -198,14 +205,12 @@ export async function handleFlowClaim(deps, args) {
             });
         }
         return jsonResult({
-            worker_id: worker_id,
-            entity_id: claimed.entityId,
+            entity_id: entity.id,
             invocation_id: claimed.id,
-            flow: flow?.name ?? null,
-            stage: claimed.stage,
-            agent_role: claimed.agentRole || null,
-            prompt: claimed.prompt,
-            context: claimed.context,
+            flow: flow.name,
+            state: claimed.stage,
+            refs: claimedEntity.refs ?? null,
+            artifacts: claimedEntity.artifacts ?? null,
         });
     }
     return noWorkResult(RETRY_SHORT_MS, role);

package/dist/src/repositories/drizzle/flow.repo.js

@@ -17,6 +17,7 @@ function rowToState(r) {
         onEnter: r.onEnter ?? null,
         onExit: r.onExit ?? null,
         retryAfterMs: r.retryAfterMs ?? null,
+        meta: r.meta,
     };
 }
 function rowToTransition(r) {
@@ -161,6 +162,7 @@ export class DrizzleFlowRepository {
                 onEnter: s.onEnter ?? null,
                 onExit: s.onExit ?? null,
                 retryAfterMs: s.retryAfterMs ?? null,
+                meta: s.meta ?? null,
             })),
             transitions: (snap.transitions ?? []).map((t) => ({
                 id: t.id,
@@ -238,6 +240,7 @@ export class DrizzleFlowRepository {
             onEnter: (state.onEnter ?? null),
             onExit: (state.onExit ?? null),
             retryAfterMs: state.retryAfterMs ?? null,
+            meta: (state.meta ?? null),
         };
         this.db.transaction((tx) => {
             tx.insert(stateDefinitions).values(row).run();
@@ -268,6 +271,8 @@ export class DrizzleFlowRepository {
             updateValues.onExit = changes.onExit;
         if (changes.retryAfterMs !== undefined)
             updateValues.retryAfterMs = changes.retryAfterMs;
+        if (changes.meta !== undefined)
+            updateValues.meta = changes.meta;
         if (Object.keys(updateValues).length > 0) {
             this.db.update(stateDefinitions).set(updateValues).where(eq(stateDefinitions.id, stateId)).run();
         }

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

@@ -532,6 +532,23 @@ export declare const stateDefinitions: import("drizzle-orm/sqlite-core").SQLiteT
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        meta: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "meta";
+            tableName: "state_definitions";
+            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;
+        }, {}, {}>;
     };
     dialect: "sqlite";
 }>;

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

@@ -34,6 +34,8 @@ export const stateDefinitions = sqliteTable("state_definitions", {
     onEnter: text("on_enter", { mode: "json" }),
     onExit: text("on_exit", { mode: "json" }),
     retryAfterMs: integer("retry_after_ms"),
+    /** Opaque metadata passed through to consumers. Defcon stores but does not interpret. */
+    meta: text("meta", { mode: "json" }),
 }, (table) => ({
     flowNameUnique: uniqueIndex("state_definitions_flow_name_unique").on(table.flowId, table.name),
 }));

package/dist/src/repositories/interfaces.d.ts

@@ -99,6 +99,8 @@ export interface State {
     onExit: OnExitConfig | null;
     /** Override check_back delay for workers claiming this state. Falls back to Flow.claimRetryAfterMs. */
     retryAfterMs: number | null;
+    /** Opaque metadata passed through to consumers (e.g. radar). Defcon stores but does not interpret. */
+    meta: Record<string, unknown> | null;
 }
 /** A transition rule between two states */
 export interface Transition {
@@ -195,6 +197,7 @@ export interface CreateStateInput {
     onEnter?: OnEnterConfig;
     onExit?: OnExitConfig;
     retryAfterMs?: number;
+    meta?: Record<string, unknown>;
 }
 /** Input for adding a transition rule */
 export interface CreateTransitionInput {

package/drizzle/0019_same_rhodey.sql

@@ -0,0 +1 @@
+ALTER TABLE `state_definitions` ADD `meta` text;