@wopr-network/defcon 1.3.0 → 1.4.0

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

@@ -75,6 +75,7 @@ async function parseSeedAndLoad(json, flowRepo, gateRepo, db) {
                 initialState: f.initialState,
                 maxConcurrent: f.maxConcurrent,
                 maxConcurrentPerRepo: f.maxConcurrentPerRepo,
+                claimRetryAfterMs: f.claimRetryAfterMs,
                 gateTimeoutMs: f.gateTimeoutMs,
                 createdBy: f.createdBy,
                 discipline: f.discipline,
@@ -90,6 +91,7 @@ async function parseSeedAndLoad(json, flowRepo, gateRepo, db) {
                     promptTemplate: s.promptTemplate,
                     constraints: s.constraints,
                     onEnter: s.onEnter,
+                    retryAfterMs: s.retryAfterMs,
                 });
             }
             const flowTransitions = parsed.transitions.filter((t) => t.flowName === f.name);

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

@@ -7,6 +7,7 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
     maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxConcurrentPerRepo: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     affinityWindowMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    claimRetryAfterMs: z.ZodOptional<z.ZodNumber>;
     gateTimeoutMs: z.ZodOptional<z.ZodNumber>;
     version: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     createdBy: z.ZodOptional<z.ZodString>;
@@ -34,6 +35,7 @@ export declare const StateDefinitionSchema: z.ZodObject<{
         artifacts: z.ZodArray<z.ZodString>;
         timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const CommandGateSchema: z.ZodObject<{
     name: z.ZodString;
@@ -101,6 +103,7 @@ export declare const SeedFileSchema: z.ZodObject<{
         maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         maxConcurrentPerRepo: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         affinityWindowMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        claimRetryAfterMs: z.ZodOptional<z.ZodNumber>;
         gateTimeoutMs: z.ZodOptional<z.ZodNumber>;
         version: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         createdBy: z.ZodOptional<z.ZodString>;
@@ -123,6 +126,7 @@ export declare const SeedFileSchema: z.ZodObject<{
             artifacts: z.ZodArray<z.ZodString>;
             timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         }, z.core.$strip>>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         name: z.ZodString;

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

@@ -10,6 +10,7 @@ export const FlowDefinitionSchema = z.object({
     maxConcurrent: z.number().int().min(0).optional().default(0),
     maxConcurrentPerRepo: z.number().int().min(0).optional().default(0),
     affinityWindowMs: z.number().int().min(0).optional().default(300000),
+    claimRetryAfterMs: z.number().int().min(0).optional(),
     gateTimeoutMs: z.number().int().min(1).optional(),
     version: z.number().int().min(1).optional().default(1),
     createdBy: z.string().optional(),
@@ -47,6 +48,7 @@ export const StateDefinitionSchema = z.object({
         .optional(),
     constraints: z.record(z.string(), z.unknown()).optional(),
     onEnter: OnEnterSchema.optional(),
+    retryAfterMs: z.number().int().min(0).optional(),
 });
 // Gate: discriminated union on `type`
 const BaseGateSchema = z.object({

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

@@ -54,6 +54,7 @@ export declare class Engine {
     undrainWorker(workerId: string): void;
     isDraining(workerId: string): boolean;
     listDrainingWorkers(): string[];
+    emit(event: import("./event-types.js").EngineEvent): Promise<void>;
     processSignal(entityId: string, signal: string, artifacts?: Artifacts, triggeringInvocationId?: string): Promise<ProcessSignalResult>;
     createEntity(flowName: string, refs?: Record<string, {
         adapter: string;

package/dist/src/engine/engine.js

@@ -39,6 +39,9 @@ export class Engine {
     listDrainingWorkers() {
         return Array.from(this.drainingWorkers);
     }
+    async emit(event) {
+        await this.eventEmitter.emit(event);
+    }
     async processSignal(entityId, signal, artifacts, triggeringInvocationId) {
         // 1. Load entity
         const entity = await this.entityRepo.get(entityId);

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

@@ -2,7 +2,32 @@ import { DEFAULT_TIMEOUT_PROMPT } from "../../engine/constants.js";
 import { errorResult, jsonResult, validateInput } from "../mcp-helpers.js";
 import { FlowClaimSchema, FlowFailSchema, FlowGetPromptSchema, FlowReportSchema } from "../tool-schemas.js";
 const RETRY_SHORT_MS = 30_000; // entities exist but all claimed
-const RETRY_LONG_MS = 300_000; // backlog empty
+const RETRY_LONG_MS = 300_000; // backlog empty — fallback when no per-flow/state config
+/**
+ * Resolve the check_back delay for a "no work" response.
+ * Priority: state.retryAfterMs > flow.claimRetryAfterMs > RETRY_LONG_MS
+ */
+function resolveRetryMs(flows, forEmpty) {
+    if (!forEmpty)
+        return RETRY_SHORT_MS;
+    // Find the minimum configured retryAfterMs across all candidate flows/states.
+    let best = null;
+    for (const flow of flows) {
+        const flowDefault = flow.claimRetryAfterMs ?? null;
+        // Check each state for a state-level override
+        for (const state of flow.states) {
+            if (state.promptTemplate === null)
+                continue; // not a claimable state
+            const ms = state.retryAfterMs ?? flowDefault;
+            if (ms !== null && (best === null || ms < best))
+                best = ms;
+        }
+        // If no states had overrides but the flow has a default
+        if (flowDefault !== null && (best === null || flowDefault < best))
+            best = flowDefault;
+    }
+    return best ?? RETRY_LONG_MS;
+}
 function noWorkResult(retryAfterMs, role) {
     return jsonResult({
         next_action: "check_back",
@@ -15,6 +40,10 @@ export async function handleFlowClaim(deps, args) {
     if (!v.ok)
         return v.result;
     const { worker_id, role, flow: flowName } = v.data;
+    // 0. Reject drained workers immediately
+    if (worker_id && deps.engine?.isDraining(worker_id)) {
+        return noWorkResult(RETRY_SHORT_MS, role);
+    }
     // 1. Find candidate flows filtered by discipline
     let candidateFlows = [];
     if (flowName) {
@@ -23,15 +52,18 @@ export async function handleFlowClaim(deps, args) {
             return errorResult(`Flow not found: ${flowName}`);
         // Discipline must match — null discipline flows are claimable by any role
         if (flow.discipline !== null && flow.discipline !== role)
-            return noWorkResult(RETRY_LONG_MS, role);
+            return noWorkResult(flow.claimRetryAfterMs ?? RETRY_LONG_MS, role);
+        // Paused flows have no claimable work
+        if (flow.paused)
+            return noWorkResult(flow.claimRetryAfterMs ?? RETRY_LONG_MS, role);
         candidateFlows = [flow];
     }
     else {
         const allFlows = await deps.flows.list();
-        candidateFlows = allFlows.filter((f) => f.discipline === null || f.discipline === role);
+        candidateFlows = allFlows.filter((f) => !f.paused && (f.discipline === null || f.discipline === role));
     }
     if (candidateFlows.length === 0)
-        return noWorkResult(RETRY_LONG_MS, role);
+        return noWorkResult(RETRY_LONG_MS, role); // no flows configured for this role
     const allCandidates = [];
     for (const flow of candidateFlows) {
         const unclaimed = await deps.invocations.findUnclaimedByFlow(flow.id);
@@ -48,7 +80,7 @@ export async function handleFlowClaim(deps, args) {
                 break;
             }
         }
-        return noWorkResult(hasEntities ? RETRY_SHORT_MS : RETRY_LONG_MS, role);
+        return noWorkResult(resolveRetryMs(candidateFlows, !hasEntities), role);
     }
     // 3. Load entities for priority sorting
     const entityMap = new Map();
@@ -60,27 +92,18 @@ export async function handleFlowClaim(deps, args) {
     }));
     // 4. Build a flow lookup map (needed for affinity window below)
     const flowById = new Map(candidateFlows.map((f) => [f.id, f]));
-    // 5. Check affinity for each entity using the flow's configured window
+    // 5. Check affinity for each entity using findUnclaimedWithAffinity per flow
     const affinitySet = new Set();
-    const now = Date.now();
     if (worker_id) {
-        await Promise.all(uniqueEntityIds.map(async (eid) => {
-            const entity = entityMap.get(eid);
-            const flow = entity ? flowById.get(entity.flowId) : undefined;
-            const affinityWindowMs = flow?.affinityWindowMs ?? 300000;
-            const invocations = await deps.invocations.findByEntity(eid);
-            const lastCompleted = invocations
-                .filter((inv) => inv.completedAt !== null && inv.claimedBy === worker_id)
-                .sort((a, b) => (b.completedAt?.getTime() ?? 0) - (a.completedAt?.getTime() ?? 0));
-            if (lastCompleted.length > 0) {
-                const elapsed = now - (lastCompleted[0].completedAt?.getTime() ?? 0);
-                if (elapsed < affinityWindowMs) {
-                    affinitySet.add(eid);
-                }
+        await Promise.all(candidateFlows.map(async (flow) => {
+            const affinityInvocations = await deps.invocations.findUnclaimedWithAffinity(flow.id, role, worker_id);
+            for (const inv of affinityInvocations) {
+                affinitySet.add(inv.entityId);
             }
         }));
     }
     // 6. Sort candidates by priority algorithm
+    const now = Date.now();
     allCandidates.sort((a, b) => {
         const entityA = entityMap.get(a.entityId);
         const entityB = entityMap.get(b.entityId);
@@ -100,55 +123,89 @@ export async function handleFlowClaim(deps, args) {
         return timeA - timeB;
     });
     // 7. Try claiming in priority order (handle race conditions)
+    const claimerId = worker_id ?? `agent:${role}`;
     for (const invocation of allCandidates) {
+        const entity = entityMap.get(invocation.entityId);
+        // Finding 3: If entity is not in the entityMap, the invocation is orphaned.
+        // Skip it — do not claim it, as that would permanently lock it.
+        if (!entity) {
+            continue;
+        }
+        // Claim entity first to establish ownership, then claim the invocation.
+        // If invocation claim loses a race (returns null), release the entity so
+        // another worker can pick it up.
+        let claimedEntity = null;
+        try {
+            claimedEntity = await deps.entities.claimById(entity.id, claimerId);
+        }
+        catch (err) {
+            console.error(`Failed to claim entity ${entity.id}:`, err);
+            continue;
+        }
+        if (!claimedEntity) {
+            // Another worker claimed this entity first — skip.
+            continue;
+        }
+        // Finding 1: Verify entity state still matches invocation stage after claiming.
+        // A race can leave stale invocation data if the entity changed state between
+        // the invocation query and the entity claim.
+        if (claimedEntity.state !== invocation.stage) {
+            await deps.entities.release(entity.id, claimerId).catch(() => { });
+            return noWorkResult(RETRY_SHORT_MS, role);
+        }
         let claimed;
         try {
-            claimed = await deps.invocations.claim(invocation.id, worker_id ?? `agent:${role}`);
+            claimed = await deps.invocations.claim(invocation.id, claimerId);
         }
         catch (err) {
             console.error(`Failed to claim invocation ${invocation.id}:`, err);
+            if (entity && claimedEntity) {
+                await deps.entities.release(entity.id, claimerId).catch(() => { });
+            }
             continue;
         }
-        if (claimed) {
-            const entity = entityMap.get(claimed.entityId);
-            if (entity) {
-                let claimedEntity;
-                try {
-                    claimedEntity = await deps.entities.claimById(entity.id, worker_id ?? `agent:${role}`);
-                }
-                catch (err) {
-                    console.error(`Failed to claim entity ${entity.id}:`, err);
-                    await deps.invocations.releaseClaim(claimed.id);
-                    continue;
-                }
-                if (!claimedEntity) {
-                    // Race condition: another worker claimed this entity first.
-                    // Release the invocation claim so it can be picked up by another worker.
-                    await deps.invocations.releaseClaim(claimed.id);
-                    continue;
-                }
+        if (!claimed) {
+            // Race condition: invocation already claimed by another worker.
+            // Release the entity so another worker can pick it up.
+            if (entity && claimedEntity) {
+                await deps.entities.release(entity.id, claimerId).catch(() => { });
             }
-            const flow = entity ? flowById.get(entity.flowId) : undefined;
-            // Record affinity for the claiming worker (best-effort; failure must not block the claim)
-            if (worker_id && entity && flow) {
-                try {
-                    const windowMs = flow.affinityWindowMs ?? 300000;
-                    await deps.entities.setAffinity(claimed.entityId, worker_id, role, new Date(Date.now() + windowMs));
-                }
-                catch (err) {
-                    console.error(`Failed to set affinity for entity ${claimed.entityId}:`, err);
-                }
+            continue;
+        }
+        const flow = entity ? flowById.get(entity.flowId) : undefined;
+        // Record affinity for the claiming worker (best-effort; failure must not block the claim)
+        if (worker_id && entity && flow) {
+            try {
+                const windowMs = flow.affinityWindowMs ?? 300000;
+                await deps.entities.setAffinity(claimed.entityId, worker_id, role, new Date(Date.now() + windowMs));
             }
-            return jsonResult({
-                worker_id: worker_id,
-                entity_id: claimed.entityId,
-                invocation_id: claimed.id,
-                flow: flow?.name ?? null,
-                stage: claimed.stage,
-                prompt: claimed.prompt,
-                context: claimed.context,
+            catch (err) {
+                console.error(`Failed to set affinity for entity ${claimed.entityId}:`, err);
+            }
+        }
+        // Finding 2: Emit entity.claimed event for WebSocket broadcast.
+        if (deps.engine) {
+            deps.engine
+                .emit({
+                type: "entity.claimed",
+                entityId: entity.id,
+                flowId: entity.flowId,
+                agentId: claimerId,
+                emittedAt: new Date(),
+            })
+                .catch((err) => {
+                console.error(`Failed to emit entity.claimed for entity ${entity.id}:`, err);
             });
         }
+        return jsonResult({
+            worker_id: worker_id,
+            entity_id: claimed.entityId,
+            invocation_id: claimed.id,
+            flow: flow?.name ?? null,
+            stage: claimed.stage,
+            prompt: claimed.prompt,
+            context: claimed.context,
+        });
     }
     return noWorkResult(RETRY_SHORT_MS, role);
 }

package/dist/src/execution/mcp-server.js

@@ -7,7 +7,8 @@ import { DEFAULT_TIMEOUT_PROMPT } from "../engine/constants.js";
 import { isTerminal } from "../engine/state-machine.js";
 import { consoleLogger } from "../logger.js";
 import { AdminEntityCancelSchema, AdminEntityResetSchema, AdminFlowCreateSchema, AdminFlowPauseSchema, AdminFlowRestoreSchema, AdminFlowSnapshotSchema, AdminFlowUpdateSchema, AdminGateAttachSchema, AdminGateCreateSchema, AdminGateRerunSchema, AdminStateCreateSchema, AdminStateUpdateSchema, AdminTransitionCreateSchema, AdminTransitionUpdateSchema, AdminWorkerDrainSchema, } from "./admin-schemas.js";
-import { FlowClaimSchema, FlowFailSchema, FlowGetPromptSchema, FlowReportSchema, FlowSeedSchema, QueryEntitiesSchema, QueryEntitySchema, QueryFlowSchema, QueryInvocationsSchema, } from "./tool-schemas.js";
+import { handleFlowClaim } from "./handlers/flow.js";
+import { FlowFailSchema, FlowGetPromptSchema, FlowReportSchema, FlowSeedSchema, QueryEntitiesSchema, QueryEntitySchema, QueryFlowSchema, QueryInvocationsSchema, } from "./tool-schemas.js";
 function getSystemDefaultGateTimeoutMs() {
     const parsed = parseInt(process.env.DEFCON_DEFAULT_GATE_TIMEOUT_MS ?? "", 10);
     return !Number.isNaN(parsed) && parsed > 0 ? parsed : 300000;
@@ -490,57 +491,12 @@ function errorResult(message) {
         isError: true,
     };
 }
-const RETRY_SHORT_MS = 30_000; // work exists but all entities currently claimed
-const RETRY_LONG_MS = 300_000; // backlog empty
-function noWorkResult(retryAfterMs, role) {
-    return jsonResult({
-        next_action: "check_back",
-        retry_after_ms: retryAfterMs,
-        message: `No work available for role '${role}' right now. Call flow.claim again after the retry delay.`,
-    });
-}
 function constantTimeEqual(a, b) {
     const hashA = createHash("sha256").update(a.trim()).digest();
     const hashB = createHash("sha256").update(b.trim()).digest();
     return timingSafeEqual(hashA, hashB);
 }
 // ─── Tool Handlers ───
-async function handleFlowClaim(deps, args) {
-    const v = validateInput(FlowClaimSchema, args);
-    if (!v.ok)
-        return v.result;
-    const { worker_id, role, flow: flowName } = v.data;
-    if (!deps.engine) {
-        return errorResult("Engine not available — MCP server started without engine dependency");
-    }
-    let result;
-    try {
-        result = await deps.engine.claimWork(role, flowName, worker_id);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const isNotFound = /not found|unknown flow/i.test(message);
-        if (isNotFound) {
-            return errorResult(message);
-        }
-        return jsonResult({ next_action: "check_back", retry_after_ms: RETRY_LONG_MS, message });
-    }
-    if (result === "all_claimed") {
-        return noWorkResult(RETRY_SHORT_MS, role);
-    }
-    if (!result) {
-        return noWorkResult(RETRY_LONG_MS, role);
-    }
-    return jsonResult({
-        worker_id: worker_id,
-        entity_id: result.entityId,
-        invocation_id: result.invocationId,
-        flow: result.flowName,
-        stage: result.stage,
-        prompt: result.prompt,
-        context: result.context,
-    });
-}
 async function handleFlowGetPrompt(deps, args) {
     const v = validateInput(FlowGetPromptSchema, args);
     if (!v.ok)

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

@@ -14,6 +14,7 @@ function rowToState(r) {
         promptTemplate: r.promptTemplate ?? null,
         constraints: r.constraints,
         onEnter: r.onEnter ?? null,
+        retryAfterMs: r.retryAfterMs ?? null,
     };
 }
 function rowToTransition(r) {
@@ -41,6 +42,7 @@ function rowToFlow(r, states, transitions) {
         maxConcurrent: r.maxConcurrent ?? 0,
         maxConcurrentPerRepo: r.maxConcurrentPerRepo ?? 0,
         affinityWindowMs: r.affinityWindowMs ?? 300000,
+        claimRetryAfterMs: r.claimRetryAfterMs ?? null,
         gateTimeoutMs: r.gateTimeoutMs ?? null,
         version: r.version ?? 1,
         createdBy: r.createdBy ?? null,
@@ -86,6 +88,7 @@ export class DrizzleFlowRepository {
             maxConcurrent: input.maxConcurrent ?? 0,
             maxConcurrentPerRepo: input.maxConcurrentPerRepo ?? 0,
             affinityWindowMs: input.affinityWindowMs ?? 300000,
+            claimRetryAfterMs: input.claimRetryAfterMs ?? null,
             gateTimeoutMs: input.gateTimeoutMs ?? null,
             version: 1,
             createdBy: input.createdBy ?? null,
@@ -138,6 +141,8 @@ export class DrizzleFlowRepository {
             updateValues.maxConcurrentPerRepo = changes.maxConcurrentPerRepo;
         if (changes.affinityWindowMs !== undefined)
             updateValues.affinityWindowMs = changes.affinityWindowMs;
+        if (changes.claimRetryAfterMs !== undefined)
+            updateValues.claimRetryAfterMs = changes.claimRetryAfterMs;
         if (changes.gateTimeoutMs !== undefined)
             updateValues.gateTimeoutMs = changes.gateTimeoutMs;
         if (changes.version !== undefined)
@@ -168,6 +173,7 @@ export class DrizzleFlowRepository {
             promptTemplate: state.promptTemplate ?? null,
             constraints: (state.constraints ?? null),
             onEnter: (state.onEnter ?? null),
+            retryAfterMs: state.retryAfterMs ?? null,
         };
         this.db.transaction((tx) => {
             tx.insert(stateDefinitions).values(row).run();
@@ -192,6 +198,8 @@ export class DrizzleFlowRepository {
             updateValues.constraints = changes.constraints;
         if (changes.onEnter !== undefined)
             updateValues.onEnter = changes.onEnter;
+        if (changes.retryAfterMs !== undefined)
+            updateValues.retryAfterMs = changes.retryAfterMs;
         if (Object.keys(updateValues).length > 0) {
             this.db.update(stateDefinitions).set(updateValues).where(eq(stateDefinitions.id, stateId)).run();
         }
@@ -272,6 +280,7 @@ export class DrizzleFlowRepository {
             updatedAt: flow.updatedAt,
             discipline: flow.discipline,
             defaultModelTier: flow.defaultModelTier,
+            claimRetryAfterMs: flow.claimRetryAfterMs,
             states: flow.states,
             transitions: flow.transitions,
         };
@@ -325,6 +334,7 @@ export class DrizzleFlowRepository {
                     promptTemplate: s.promptTemplate,
                     constraints: s.constraints,
                     onEnter: (s.onEnter ?? null),
+                    retryAfterMs: s.retryAfterMs ?? null,
                 })
                     .run();
             }
@@ -359,6 +369,7 @@ export class DrizzleFlowRepository {
                 createdBy: snap.createdBy,
                 discipline: snap.discipline,
                 defaultModelTier: snap.defaultModelTier ?? null,
+                claimRetryAfterMs: snap.claimRetryAfterMs ?? null,
                 timeoutPrompt: snap.timeoutPrompt,
                 updatedAt: Date.now(),
             })

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

@@ -146,6 +146,23 @@ export declare const flowDefinitions: import("drizzle-orm/sqlite-core").SQLiteTa
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        claimRetryAfterMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "claim_retry_after_ms";
+            tableName: "flow_definitions";
+            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;
+        }, {}, {}>;
         gateTimeoutMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "gate_timeout_ms";
             tableName: "flow_definitions";
@@ -481,6 +498,23 @@ export declare const stateDefinitions: import("drizzle-orm/sqlite-core").SQLiteT
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        retryAfterMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "retry_after_ms";
+            tableName: "state_definitions";
+            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;
+        }, {}, {}>;
     };
     dialect: "sqlite";
 }>;

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

@@ -9,6 +9,7 @@ export const flowDefinitions = sqliteTable("flow_definitions", {
     maxConcurrent: integer("max_concurrent").default(0),
     maxConcurrentPerRepo: integer("max_concurrent_per_repo").default(0),
     affinityWindowMs: integer("affinity_window_ms").default(300000),
+    claimRetryAfterMs: integer("claim_retry_after_ms"),
     gateTimeoutMs: integer("gate_timeout_ms"),
     version: integer("version").default(1),
     createdBy: text("created_by"),
@@ -31,6 +32,7 @@ export const stateDefinitions = sqliteTable("state_definitions", {
     promptTemplate: text("prompt_template"),
     constraints: text("constraints", { mode: "json" }),
     onEnter: text("on_enter", { mode: "json" }),
+    retryAfterMs: integer("retry_after_ms"),
 }, (table) => ({
     flowNameUnique: uniqueIndex("state_definitions_flow_name_unique").on(table.flowId, table.name),
 }));

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

@@ -87,6 +87,8 @@ export interface State {
     promptTemplate: string | null;
     constraints: Record<string, unknown> | null;
     onEnter: OnEnterConfig | null;
+    /** Override check_back delay for workers claiming this state. Falls back to Flow.claimRetryAfterMs. */
+    retryAfterMs: number | null;
 }
 /** A transition rule between two states */
 export interface Transition {
@@ -124,6 +126,8 @@ export interface Flow {
     maxConcurrent: number;
     maxConcurrentPerRepo: number;
     affinityWindowMs: number;
+    /** Flow-level default check_back delay when no work is available. Falls back to RETRY_LONG_MS (300s) if null. */
+    claimRetryAfterMs: number | null;
     gateTimeoutMs: number | null;
     version: number;
     createdBy: string | null;
@@ -155,6 +159,7 @@ export interface CreateFlowInput {
     maxConcurrent?: number;
     maxConcurrentPerRepo?: number;
     affinityWindowMs?: number;
+    claimRetryAfterMs?: number;
     gateTimeoutMs?: number;
     createdBy?: string;
     discipline?: string;
@@ -170,6 +175,7 @@ export interface CreateStateInput {
     promptTemplate?: string;
     constraints?: Record<string, unknown>;
     onEnter?: OnEnterConfig;
+    retryAfterMs?: number;
 }
 /** Input for adding a transition rule */
 export interface CreateTransitionInput {

package/drizzle/0012_certain_human_fly.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `flow_definitions` ADD `claim_retry_after_ms` integer;--> statement-breakpoint
+ALTER TABLE `state_definitions` ADD `retry_after_ms` integer;

package/drizzle/meta/0010_snapshot.json

@@ -2,7 +2,7 @@
   "version": "6",
   "dialect": "sqlite",
   "id": "0010_amusing_bastion",
-  "prevId": "0010_amusing_bastion",
+  "prevId": "0009_brief_midnight",
   "tables": {
     "entities": {
       "name": "entities",
@@ -1062,4 +1062,4 @@
   "internal": {
     "indexes": {}
   }
-}
+}