@wopr-network/defcon 1.4.0 → 1.6.0

package/dist/src/engine/on-exit.js

@@ -0,0 +1,45 @@
+import { execFile } from "node:child_process";
+import { getHandlebars } from "./handlebars.js";
+export async function executeOnExit(onExit, entity) {
+    const hbs = getHandlebars();
+    let renderedCommand;
+    // Merge artifact refs into entity.refs (same pattern as on-enter.ts)
+    const artifactRefs = entity.artifacts !== null &&
+        typeof entity.artifacts === "object" &&
+        "refs" in entity.artifacts &&
+        entity.artifacts.refs !== null &&
+        typeof entity.artifacts.refs === "object"
+        ? entity.artifacts.refs
+        : {};
+    const entityForContext = { ...entity, refs: { ...artifactRefs, ...(entity.refs ?? {}) } };
+    try {
+        renderedCommand = hbs.compile(onExit.command)({ entity: entityForContext });
+    }
+    catch (err) {
+        const error = `onExit template error: ${err instanceof Error ? err.message : String(err)}`;
+        return { error, timedOut: false };
+    }
+    const timeoutMs = onExit.timeout_ms ?? 30000;
+    const { exitCode, stdout, stderr, timedOut } = await runCommand(renderedCommand, timeoutMs);
+    if (timedOut) {
+        return { error: `onExit command timed out after ${timeoutMs}ms`, timedOut: true };
+    }
+    if (exitCode !== 0) {
+        return { error: `onExit command exited with code ${exitCode}: ${stderr || stdout}`, timedOut: false };
+    }
+    return { error: null, timedOut: false };
+}
+function runCommand(command, timeoutMs) {
+    return new Promise((resolve) => {
+        execFile("/bin/sh", ["-c", command], { timeout: timeoutMs }, (error, stdout, stderr) => {
+            const execErr = error;
+            const timedOut = execErr !== null && execErr.killed === true;
+            resolve({
+                exitCode: execErr ? (typeof execErr.code === "number" ? execErr.code : 1) : 0,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                timedOut,
+            });
+        });
+    });
+}

package/dist/src/execution/active-runner.js

@@ -104,7 +104,7 @@ export class ActiveRunner {
                 await this.entityRepo.updateArtifacts(invocation.entityId, { stuck: true, stuckAt: new Date().toISOString() });
                 return;
             }
-            await this.invocationRepo.create(invocation.entityId, invocation.stage, invocation.prompt, invocation.mode, undefined, { ...(invocation.context ?? {}), retryCount: retryCount + 1 });
+            await this.invocationRepo.create(invocation.entityId, invocation.stage, invocation.prompt, invocation.mode, undefined, { ...(invocation.context ?? {}), retryCount: retryCount + 1 }, invocation.agentRole);
             return;
         }
         // Gate timed out — re-queue after backoff instead of failing.
@@ -113,7 +113,7 @@ export class ActiveRunner {
         if (result.gated && result.gateTimedOut) {
             const retryAfterMs = 30000;
             this.logger.info(`[active-runner] gate timed out for entity ${invocation.entityId}, re-queuing after ${retryAfterMs}ms`);
-            await this.invocationRepo.create(invocation.entityId, invocation.stage, invocation.prompt, invocation.mode, undefined, invocation.context ?? undefined);
+            await this.invocationRepo.create(invocation.entityId, invocation.stage, invocation.prompt, invocation.mode, undefined, invocation.context ?? undefined, invocation.agentRole);
             await sleep(retryAfterMs, signal);
             return;
         }

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

@@ -203,6 +203,7 @@ export async function handleFlowClaim(deps, args) {
             invocation_id: claimed.id,
             flow: flow?.name ?? null,
             stage: claimed.stage,
+            agent_role: claimed.agentRole || null,
             prompt: claimed.prompt,
             context: claimed.context,
         });
@@ -260,7 +261,7 @@ export async function handleFlowReport(deps, args) {
         // would regress the entity back to a stale state.
         const entityAfter = await deps.entities.get(entityId).catch(() => null);
         if (!entityAfter || entityAfter.state === activeInvocation.stage) {
-            await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined);
+            await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined, activeInvocation.agentRole);
         }
         return errorResult(message);
     }
@@ -286,7 +287,7 @@ export async function handleFlowReport(deps, args) {
     // check_back) finds an active invocation without requiring a round-trip through
     // flow.claim. Workers on the "waiting" path will re-claim via flow.claim as usual.
     if (result.gated) {
-        const replacement = await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined);
+        const replacement = await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined, activeInvocation.agentRole);
         const claimedBy = activeInvocation.claimedBy;
         if (claimedBy) {
             await deps.invocations.claim(replacement.id, claimedBy).catch(() => {

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

@@ -556,7 +556,7 @@ async function handleFlowReport(deps, args) {
             const flow = currentEntity ? await deps.flows.get(currentEntity.flowId) : null;
             const entityIsTerminal = currentEntity && flow ? isTerminal(flow, currentEntity.state) : false;
             if (!entityIsTerminal) {
-                const replacement = await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined);
+                const replacement = await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined, activeInvocation.agentRole);
                 // Claim the replacement for the same worker so it can retry immediately.
                 if (worker_id && replacement) {
                     try {
@@ -590,7 +590,7 @@ async function handleFlowReport(deps, args) {
     // Gate blocked — create a replacement unclaimed invocation so the entity
     // can be reclaimed; without it the entity would be permanently orphaned.
     if (result.gated) {
-        await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined);
+        await deps.invocations.create(entityId, activeInvocation.stage, activeInvocation.prompt, activeInvocation.mode, undefined, activeInvocation.context ?? undefined, activeInvocation.agentRole);
         if (result.gateTimedOut) {
             const renderedPrompt = result.timeoutPrompt ?? DEFAULT_TIMEOUT_PROMPT;
             return jsonResult({

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

@@ -9,11 +9,13 @@ function rowToState(r) {
         id: r.id,
         flowId: r.flowId,
         name: r.name,
+        agentRole: r.agentRole ?? null,
         modelTier: r.modelTier ?? null,
         mode: (r.mode ?? "passive"),
         promptTemplate: r.promptTemplate ?? null,
         constraints: r.constraints,
         onEnter: r.onEnter ?? null,
+        onExit: r.onExit ?? null,
         retryAfterMs: r.retryAfterMs ?? null,
     };
 }
@@ -167,12 +169,13 @@ export class DrizzleFlowRepository {
             id,
             flowId,
             name: state.name,
-            agentRole: null,
+            agentRole: state.agentRole || null,
             modelTier: state.modelTier ?? null,
             mode: state.mode ?? "passive",
             promptTemplate: state.promptTemplate ?? null,
             constraints: (state.constraints ?? null),
             onEnter: (state.onEnter ?? null),
+            onExit: (state.onExit ?? null),
             retryAfterMs: state.retryAfterMs ?? null,
         };
         this.db.transaction((tx) => {
@@ -188,6 +191,8 @@ export class DrizzleFlowRepository {
         const updateValues = {};
         if (changes.name !== undefined)
             updateValues.name = changes.name;
+        if (changes.agentRole !== undefined)
+            updateValues.agentRole = changes.agentRole;
         if (changes.modelTier !== undefined)
             updateValues.modelTier = changes.modelTier;
         if (changes.mode !== undefined)
@@ -198,6 +203,8 @@ export class DrizzleFlowRepository {
             updateValues.constraints = changes.constraints;
         if (changes.onEnter !== undefined)
             updateValues.onEnter = changes.onEnter;
+        if (changes.onExit !== undefined)
+            updateValues.onExit = changes.onExit;
         if (changes.retryAfterMs !== undefined)
             updateValues.retryAfterMs = changes.retryAfterMs;
         if (Object.keys(updateValues).length > 0) {
@@ -329,11 +336,13 @@ export class DrizzleFlowRepository {
                     id: s.id,
                     flowId,
                     name: s.name,
+                    agentRole: s.agentRole || null,
                     modelTier: s.modelTier,
                     mode: s.mode ?? "passive",
                     promptTemplate: s.promptTemplate,
                     constraints: s.constraints,
                     onEnter: (s.onEnter ?? null),
+                    onExit: (s.onExit ?? null),
                     retryAfterMs: s.retryAfterMs ?? null,
                 })
                     .run();

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

@@ -13,6 +13,7 @@ function toGate(row) {
         timeoutMs: row.timeoutMs ?? null,
         failurePrompt: row.failurePrompt ?? null,
         timeoutPrompt: row.timeoutPrompt ?? null,
+        outcomes: row.outcomes ?? null,
     };
 }
 function toGateResult(row) {
@@ -42,6 +43,7 @@ export class DrizzleGateRepository {
             ...(gate.timeoutMs != null ? { timeoutMs: gate.timeoutMs } : {}),
             failurePrompt: gate.failurePrompt ?? null,
             timeoutPrompt: gate.timeoutPrompt ?? null,
+            outcomes: gate.outcomes ?? null,
         };
         this.db.insert(gateDefinitions).values(values).run();
         const row = this.db.select().from(gateDefinitions).where(eq(gateDefinitions.id, id)).get();

package/dist/src/repositories/drizzle/invocation.repo.d.ts

@@ -5,7 +5,7 @@ type Db = BetterSQLite3Database<typeof schema>;
 export declare class DrizzleInvocationRepository implements IInvocationRepository {
     private db;
     constructor(db: Db);
-    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs?: number, context?: Record<string, unknown>): Promise<Invocation>;
+    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>;

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

@@ -6,6 +6,7 @@ function toInvocation(row) {
         id: row.id,
         entityId: row.entityId,
         stage: row.stage,
+        agentRole: row.agentRole ?? null,
         mode: row.mode,
         prompt: row.prompt,
         context: row.context,
@@ -25,7 +26,7 @@ export class DrizzleInvocationRepository {
     constructor(db) {
         this.db = db;
     }
-    async create(entityId, stage, prompt, mode, ttlMs, context) {
+    async create(entityId, stage, prompt, mode, ttlMs, context, agentRole) {
         const id = crypto.randomUUID();
         this.db
             .insert(invocations)
@@ -33,6 +34,7 @@ export class DrizzleInvocationRepository {
             id,
             entityId,
             stage,
+            agentRole: agentRole || null,
             prompt,
             mode,
             ttlMs: ttlMs ?? 1800000,

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

@@ -498,6 +498,23 @@ export declare const stateDefinitions: import("drizzle-orm/sqlite-core").SQLiteT
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        onExit: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "on_exit";
+            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;
+        }, {}, {}>;
         retryAfterMs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "retry_after_ms";
             tableName: "state_definitions";
@@ -689,6 +706,23 @@ export declare const gateDefinitions: import("drizzle-orm/sqlite-core").SQLiteTa
         }, {}, {
             length: number | undefined;
         }>;
+        outcomes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "outcomes";
+            tableName: "gate_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

@@ -32,6 +32,7 @@ export const stateDefinitions = sqliteTable("state_definitions", {
     promptTemplate: text("prompt_template"),
     constraints: text("constraints", { mode: "json" }),
     onEnter: text("on_enter", { mode: "json" }),
+    onExit: text("on_exit", { mode: "json" }),
     retryAfterMs: integer("retry_after_ms"),
 }, (table) => ({
     flowNameUnique: uniqueIndex("state_definitions_flow_name_unique").on(table.flowId, table.name),
@@ -46,6 +47,7 @@ export const gateDefinitions = sqliteTable("gate_definitions", {
     timeoutMs: integer("timeout_ms"),
     failurePrompt: text("failure_prompt"),
     timeoutPrompt: text("timeout_prompt"),
+    outcomes: text("outcomes", { mode: "json" }),
 });
 export const transitionRules = sqliteTable("transition_rules", {
     id: text("id").primaryKey(),

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

@@ -12,6 +12,11 @@ export interface OnEnterConfig {
     artifacts: string[];
     timeout_ms?: number;
 }
+/** Configuration for running a cleanup command when an entity exits a state */
+export interface OnExitConfig {
+    command: string;
+    timeout_ms?: number;
+}
 /** Invocation execution mode */
 export type Mode = "active" | "passive";
 /** Runtime entity tracked through a flow */
@@ -36,6 +41,7 @@ export interface Invocation {
     id: string;
     entityId: string;
     stage: string;
+    agentRole: string | null;
     mode: Mode;
     prompt: string;
     context: Record<string, unknown> | null;
@@ -82,11 +88,14 @@ export interface State {
     id: string;
     flowId: string;
     name: string;
+    /** Agent type identifier — maps to an agent MD file (e.g. "wopr-architect" → ~/.claude/agents/wopr-architect.md). */
+    agentRole: string | null;
     modelTier: string | null;
     mode: Mode;
     promptTemplate: string | null;
     constraints: Record<string, unknown> | null;
     onEnter: OnEnterConfig | null;
+    onExit: OnExitConfig | null;
     /** Override check_back delay for workers claiming this state. Falls back to Flow.claimRetryAfterMs. */
     retryAfterMs: number | null;
 }
@@ -115,6 +124,13 @@ export interface Gate {
     timeoutMs: number | null;
     failurePrompt: string | null;
     timeoutPrompt: string | null;
+    /** Named outcome map from structured gate output. Keys are outcome names; values declare
+     *  where the entity goes. `proceed: true` means the original transition continues.
+     *  `toState` redirects to a different state. */
+    outcomes: Record<string, {
+        proceed?: boolean;
+        toState?: string;
+    }> | null;
 }
 /** A complete flow definition with its states and transitions */
 export interface Flow {
@@ -170,11 +186,13 @@ export interface CreateFlowInput {
 /** Input for adding a state to a flow */
 export interface CreateStateInput {
     name: string;
+    agentRole?: string;
     modelTier?: string;
     mode?: Mode;
     promptTemplate?: string;
     constraints?: Record<string, unknown>;
     onEnter?: OnEnterConfig;
+    onExit?: OnExitConfig;
     retryAfterMs?: number;
 }
 /** Input for adding a transition rule */
@@ -198,6 +216,10 @@ export interface CreateGateInput {
     timeoutMs?: number;
     failurePrompt?: string;
     timeoutPrompt?: string;
+    outcomes?: Record<string, {
+        proceed?: boolean;
+        toState?: string;
+    }>;
 }
 /** Data-access contract for entity lifecycle operations. */
 export interface IEntityRepository {
@@ -274,7 +296,7 @@ export interface IFlowRepository {
 /** Data-access contract for invocation lifecycle and claiming. */
 export interface IInvocationRepository {
     /** Create a new invocation for an entity at a given stage. */
-    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs?: number, context?: Record<string, unknown>): Promise<Invocation>;
+    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs: number | undefined, context: Record<string, unknown> | undefined, agentRole: string | null): Promise<Invocation>;
     /** Get an invocation by ID, or null if not found. */
     get(id: string): Promise<Invocation | null>;
     /** Atomically claim an unclaimed invocation for the specified agent. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). Returns null if already claimed. */
@@ -329,7 +351,7 @@ export interface IGateRepository {
     /** Get all gate results for a given entity. */
     resultsFor(entityId: string): Promise<GateResult[]>;
     /** Update mutable fields on a gate definition. */
-    update(id: string, changes: Partial<Pick<Gate, "command" | "functionRef" | "apiConfig" | "timeoutMs" | "failurePrompt" | "timeoutPrompt">>): Promise<Gate>;
+    update(id: string, changes: Partial<Pick<Gate, "command" | "functionRef" | "apiConfig" | "timeoutMs" | "failurePrompt" | "timeoutPrompt" | "outcomes">>): Promise<Gate>;
     /** Delete the gate result for a specific entity+gate combination. */
     clearResult(entityId: string, gateId: string): Promise<void>;
 }

package/drizzle/0013_gate_outcomes.sql

@@ -0,0 +1 @@
+ALTER TABLE `gate_definitions` ADD `outcomes` text;

package/drizzle/0014_smiling_crusher_hogan.sql

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