@defai.digital/contracts 13.0.3

package/dist/workflow/v1/step-guard.d.ts

@@ -0,0 +1,571 @@
+/**
+ * Workflow Step Guard Contracts
+ *
+ * Step guards enable governance checks at workflow step boundaries.
+ *
+ * Invariants:
+ * - INV-WF-GUARD-001: Before guards run before step execution starts
+ * - INV-WF-GUARD-002: After guards run after step completes (before next step)
+ * - INV-WF-GUARD-003: Block failures prevent step execution/continuation
+ * - INV-WF-GUARD-004: Guard results included in trace events
+ */
+import { z } from 'zod';
+/**
+ * Position of guard relative to step execution
+ */
+export declare const GuardPositionSchema: z.ZodEnum<["before", "after"]>;
+export type GuardPosition = z.infer<typeof GuardPositionSchema>;
+/**
+ * Action to take when guard fails
+ */
+export declare const GuardFailActionSchema: z.ZodEnum<["block", "warn", "continue"]>;
+export type GuardFailAction = z.infer<typeof GuardFailActionSchema>;
+/**
+ * Step guard configuration
+ */
+export declare const WorkflowStepGuardSchema: z.ZodObject<{
+    /** Unique guard ID */
+    guardId: z.ZodString;
+    /** Step ID this guard applies to (or '*' for all steps) */
+    stepId: z.ZodString;
+    /** When to run the guard */
+    position: z.ZodEnum<["before", "after"]>;
+    /** Gate IDs to run */
+    gates: z.ZodArray<z.ZodString, "many">;
+    /** Action on failure */
+    onFail: z.ZodDefault<z.ZodEnum<["block", "warn", "continue"]>>;
+    /** Guard description */
+    description: z.ZodOptional<z.ZodString>;
+    /** Whether guard is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    stepId: string;
+    guardId: string;
+    position: "before" | "after";
+    gates: string[];
+    onFail: "block" | "warn" | "continue";
+    enabled: boolean;
+    description?: string | undefined;
+}, {
+    stepId: string;
+    guardId: string;
+    position: "before" | "after";
+    gates: string[];
+    description?: string | undefined;
+    onFail?: "block" | "warn" | "continue" | undefined;
+    enabled?: boolean | undefined;
+}>;
+export type WorkflowStepGuard = z.infer<typeof WorkflowStepGuardSchema>;
+/**
+ * Guard check status
+ */
+export declare const GuardCheckStatusSchema: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+export type GuardCheckStatus = z.infer<typeof GuardCheckStatusSchema>;
+/**
+ * Individual step gate result
+ * (Named StepGateResult to avoid conflict with MCP GateResult)
+ */
+export declare const StepGateResultSchema: z.ZodObject<{
+    /** Gate ID */
+    gateId: z.ZodString;
+    /** Gate status */
+    status: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+    /** Gate message */
+    message: z.ZodString;
+    /** Additional details */
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Suggestion for fixing issues */
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    status: "PASS" | "WARN" | "FAIL";
+    gateId: string;
+    details?: Record<string, unknown> | undefined;
+    suggestion?: string | undefined;
+}, {
+    message: string;
+    status: "PASS" | "WARN" | "FAIL";
+    gateId: string;
+    details?: Record<string, unknown> | undefined;
+    suggestion?: string | undefined;
+}>;
+export type StepGateResult = z.infer<typeof StepGateResultSchema>;
+/**
+ * Step guard check result
+ */
+export declare const StepGuardResultSchema: z.ZodObject<{
+    /** Guard ID */
+    guardId: z.ZodString;
+    /** Step ID */
+    stepId: z.ZodString;
+    /** Guard position */
+    position: z.ZodEnum<["before", "after"]>;
+    /** Overall status (FAIL if any gate fails) */
+    status: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+    /** Individual gate results */
+    gates: z.ZodArray<z.ZodObject<{
+        /** Gate ID */
+        gateId: z.ZodString;
+        /** Gate status */
+        status: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+        /** Gate message */
+        message: z.ZodString;
+        /** Additional details */
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Suggestion for fixing issues */
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "PASS" | "WARN" | "FAIL";
+        gateId: string;
+        details?: Record<string, unknown> | undefined;
+        suggestion?: string | undefined;
+    }, {
+        message: string;
+        status: "PASS" | "WARN" | "FAIL";
+        gateId: string;
+        details?: Record<string, unknown> | undefined;
+        suggestion?: string | undefined;
+    }>, "many">;
+    /** Whether step execution should be blocked */
+    blocked: z.ZodBoolean;
+    /** Human-readable summary */
+    summary: z.ZodString;
+    /** Timestamp of check */
+    timestamp: z.ZodString;
+    /** Duration of guard check in ms */
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "PASS" | "WARN" | "FAIL";
+    stepId: string;
+    guardId: string;
+    position: "before" | "after";
+    gates: {
+        message: string;
+        status: "PASS" | "WARN" | "FAIL";
+        gateId: string;
+        details?: Record<string, unknown> | undefined;
+        suggestion?: string | undefined;
+    }[];
+    blocked: boolean;
+    summary: string;
+    timestamp: string;
+    durationMs: number;
+}, {
+    status: "PASS" | "WARN" | "FAIL";
+    stepId: string;
+    guardId: string;
+    position: "before" | "after";
+    gates: {
+        message: string;
+        status: "PASS" | "WARN" | "FAIL";
+        gateId: string;
+        details?: Record<string, unknown> | undefined;
+        suggestion?: string | undefined;
+    }[];
+    blocked: boolean;
+    summary: string;
+    timestamp: string;
+    durationMs: number;
+}>;
+export type StepGuardResult = z.infer<typeof StepGuardResultSchema>;
+/**
+ * Policy for applying step guards to workflows
+ */
+export declare const StepGuardPolicySchema: z.ZodObject<{
+    /** Policy ID */
+    policyId: z.ZodString;
+    /** Policy name */
+    name: z.ZodString;
+    /** Policy description */
+    description: z.ZodOptional<z.ZodString>;
+    /** Workflow patterns this policy applies to (glob) */
+    workflowPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Step types this policy applies to */
+    stepTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Agent patterns this policy applies to (glob) */
+    agentPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Guards to apply */
+    guards: z.ZodArray<z.ZodObject<{
+        /** Unique guard ID */
+        guardId: z.ZodString;
+        /** Step ID this guard applies to (or '*' for all steps) */
+        stepId: z.ZodString;
+        /** When to run the guard */
+        position: z.ZodEnum<["before", "after"]>;
+        /** Gate IDs to run */
+        gates: z.ZodArray<z.ZodString, "many">;
+        /** Action on failure */
+        onFail: z.ZodDefault<z.ZodEnum<["block", "warn", "continue"]>>;
+        /** Guard description */
+        description: z.ZodOptional<z.ZodString>;
+        /** Whether guard is enabled */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: string[];
+        onFail: "block" | "warn" | "continue";
+        enabled: boolean;
+        description?: string | undefined;
+    }, {
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: string[];
+        description?: string | undefined;
+        onFail?: "block" | "warn" | "continue" | undefined;
+        enabled?: boolean | undefined;
+    }>, "many">;
+    /** Whether policy is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Priority (higher = runs first) */
+    priority: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    enabled: boolean;
+    policyId: string;
+    workflowPatterns: string[];
+    agentPatterns: string[];
+    guards: {
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: string[];
+        onFail: "block" | "warn" | "continue";
+        enabled: boolean;
+        description?: string | undefined;
+    }[];
+    priority: number;
+    description?: string | undefined;
+    stepTypes?: string[] | undefined;
+}, {
+    name: string;
+    policyId: string;
+    guards: {
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: string[];
+        description?: string | undefined;
+        onFail?: "block" | "warn" | "continue" | undefined;
+        enabled?: boolean | undefined;
+    }[];
+    description?: string | undefined;
+    enabled?: boolean | undefined;
+    workflowPatterns?: string[] | undefined;
+    stepTypes?: string[] | undefined;
+    agentPatterns?: string[] | undefined;
+    priority?: number | undefined;
+}>;
+export type StepGuardPolicy = z.infer<typeof StepGuardPolicySchema>;
+/**
+ * Context provided to step guards
+ */
+export declare const StepGuardContextSchema: z.ZodObject<{
+    /** Agent ID executing the workflow */
+    agentId: z.ZodString;
+    /** Execution ID */
+    executionId: z.ZodString;
+    /** Session ID (if any) */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /** Step being guarded */
+    stepId: z.ZodString;
+    /** Step type */
+    stepType: z.ZodString;
+    /** Step index in workflow */
+    stepIndex: z.ZodNumber;
+    /** Total steps in workflow */
+    totalSteps: z.ZodNumber;
+    /** Previous step outputs */
+    previousOutputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    /** Step configuration */
+    stepConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Workflow ID (if named) */
+    workflowId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    stepId: string;
+    agentId: string;
+    executionId: string;
+    stepType: string;
+    stepIndex: number;
+    totalSteps: number;
+    previousOutputs: Record<string, unknown>;
+    workflowId?: string | undefined;
+    sessionId?: string | undefined;
+    stepConfig?: Record<string, unknown> | undefined;
+}, {
+    stepId: string;
+    agentId: string;
+    executionId: string;
+    stepType: string;
+    stepIndex: number;
+    totalSteps: number;
+    previousOutputs: Record<string, unknown>;
+    workflowId?: string | undefined;
+    sessionId?: string | undefined;
+    stepConfig?: Record<string, unknown> | undefined;
+}>;
+export type StepGuardContext = z.infer<typeof StepGuardContextSchema>;
+/**
+ * Stage progress status
+ */
+export declare const StageProgressStatusSchema: z.ZodEnum<["pending", "starting", "completed", "failed", "skipped", "blocked"]>;
+export type StageProgressStatus = z.infer<typeof StageProgressStatusSchema>;
+/**
+ * Stage progress event for visibility
+ *
+ * INV-PROG-001: Every stage emits 'starting' event before execution
+ * INV-PROG-002: Every stage emits terminal event (completed/failed/skipped/blocked)
+ * INV-PROG-003: stageIndex is 0-based, stageTotal is constant per execution
+ */
+export declare const StageProgressEventSchema: z.ZodObject<{
+    /** Event type */
+    type: z.ZodLiteral<"stage.progress">;
+    /** Execution ID */
+    executionId: z.ZodString;
+    /** Agent ID */
+    agentId: z.ZodString;
+    /** Session ID (if any) */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /** Stage index (0-based) */
+    stageIndex: z.ZodNumber;
+    /** Total stages */
+    stageTotal: z.ZodNumber;
+    /** Stage name (step ID) */
+    stageName: z.ZodString;
+    /** Stage type */
+    stageType: z.ZodString;
+    /** Progress status */
+    status: z.ZodEnum<["pending", "starting", "completed", "failed", "skipped", "blocked"]>;
+    /** Duration in ms (for completed/failed) */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    /** Error message (for failed) */
+    error: z.ZodOptional<z.ZodString>;
+    /** Guard result (if blocked) */
+    guardResult: z.ZodOptional<z.ZodObject<{
+        /** Guard ID */
+        guardId: z.ZodString;
+        /** Step ID */
+        stepId: z.ZodString;
+        /** Guard position */
+        position: z.ZodEnum<["before", "after"]>;
+        /** Overall status (FAIL if any gate fails) */
+        status: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+        /** Individual gate results */
+        gates: z.ZodArray<z.ZodObject<{
+            /** Gate ID */
+            gateId: z.ZodString;
+            /** Gate status */
+            status: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
+            /** Gate message */
+            message: z.ZodString;
+            /** Additional details */
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            /** Suggestion for fixing issues */
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }, {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }>, "many">;
+        /** Whether step execution should be blocked */
+        blocked: z.ZodBoolean;
+        /** Human-readable summary */
+        summary: z.ZodString;
+        /** Timestamp of check */
+        timestamp: z.ZodString;
+        /** Duration of guard check in ms */
+        durationMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "PASS" | "WARN" | "FAIL";
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }[];
+        blocked: boolean;
+        summary: string;
+        timestamp: string;
+        durationMs: number;
+    }, {
+        status: "PASS" | "WARN" | "FAIL";
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }[];
+        blocked: boolean;
+        summary: string;
+        timestamp: string;
+        durationMs: number;
+    }>>;
+    /** Additional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Timestamp */
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "stage.progress";
+    status: "blocked" | "pending" | "starting" | "completed" | "failed" | "skipped";
+    timestamp: string;
+    agentId: string;
+    executionId: string;
+    stageIndex: number;
+    stageTotal: number;
+    stageName: string;
+    stageType: string;
+    metadata?: Record<string, unknown> | undefined;
+    durationMs?: number | undefined;
+    sessionId?: string | undefined;
+    error?: string | undefined;
+    guardResult?: {
+        status: "PASS" | "WARN" | "FAIL";
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }[];
+        blocked: boolean;
+        summary: string;
+        timestamp: string;
+        durationMs: number;
+    } | undefined;
+}, {
+    type: "stage.progress";
+    status: "blocked" | "pending" | "starting" | "completed" | "failed" | "skipped";
+    timestamp: string;
+    agentId: string;
+    executionId: string;
+    stageIndex: number;
+    stageTotal: number;
+    stageName: string;
+    stageType: string;
+    metadata?: Record<string, unknown> | undefined;
+    durationMs?: number | undefined;
+    sessionId?: string | undefined;
+    error?: string | undefined;
+    guardResult?: {
+        status: "PASS" | "WARN" | "FAIL";
+        stepId: string;
+        guardId: string;
+        position: "before" | "after";
+        gates: {
+            message: string;
+            status: "PASS" | "WARN" | "FAIL";
+            gateId: string;
+            details?: Record<string, unknown> | undefined;
+            suggestion?: string | undefined;
+        }[];
+        blocked: boolean;
+        summary: string;
+        timestamp: string;
+        durationMs: number;
+    } | undefined;
+}>;
+export type StageProgressEvent = z.infer<typeof StageProgressEventSchema>;
+/**
+ * Goal anchor trigger
+ */
+export declare const GoalAnchorTriggerSchema: z.ZodEnum<["every_step", "on_checkpoint", "on_decision", "on_delegation"]>;
+export type GoalAnchorTrigger = z.infer<typeof GoalAnchorTriggerSchema>;
+/**
+ * Goal anchor configuration
+ *
+ * Prevents context drift by periodically reminding agent of original task.
+ */
+export declare const GoalAnchorConfigSchema: z.ZodObject<{
+    /** Original task description */
+    originalTask: z.ZodString;
+    /** Key checkpoints/milestones reached */
+    checkpointsReached: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** When to inject goal reminder */
+    trigger: z.ZodDefault<z.ZodEnum<["every_step", "on_checkpoint", "on_decision", "on_delegation"]>>;
+    /** Include remaining steps in reminder */
+    includeRemainingSteps: z.ZodDefault<z.ZodBoolean>;
+    /** Include progress percentage */
+    includeProgress: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    originalTask: string;
+    checkpointsReached: string[];
+    trigger: "every_step" | "on_checkpoint" | "on_decision" | "on_delegation";
+    includeRemainingSteps: boolean;
+    includeProgress: boolean;
+}, {
+    originalTask: string;
+    checkpointsReached?: string[] | undefined;
+    trigger?: "every_step" | "on_checkpoint" | "on_decision" | "on_delegation" | undefined;
+    includeRemainingSteps?: boolean | undefined;
+    includeProgress?: boolean | undefined;
+}>;
+export type GoalAnchorConfig = z.infer<typeof GoalAnchorConfigSchema>;
+/**
+ * Goal anchor context injected into prompts
+ */
+export declare const GoalAnchorContextSchema: z.ZodObject<{
+    /** Original task */
+    task: z.ZodString;
+    /** Current progress description */
+    progress: z.ZodString;
+    /** Checkpoints reached */
+    checkpointsReached: z.ZodArray<z.ZodString, "many">;
+    /** Remaining steps (if available) */
+    remainingSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Completion percentage */
+    percentComplete: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    checkpointsReached: string[];
+    task: string;
+    progress: string;
+    remainingSteps?: string[] | undefined;
+    percentComplete?: number | undefined;
+}, {
+    checkpointsReached: string[];
+    task: string;
+    progress: string;
+    remainingSteps?: string[] | undefined;
+    percentComplete?: number | undefined;
+}>;
+export type GoalAnchorContext = z.infer<typeof GoalAnchorContextSchema>;
+/**
+ * Default step guard for all workflows
+ */
+export declare const DEFAULT_STEP_GUARD: WorkflowStepGuard;
+/**
+ * Creates a step guard result
+ */
+export declare function createStepGuardResult(guardId: string, stepId: string, position: GuardPosition, gates: StepGateResult[], blocked: boolean): StepGuardResult;
+/**
+ * Creates a progress event
+ */
+export declare function createProgressEvent(executionId: string, agentId: string, stageIndex: number, stageTotal: number, stageName: string, stageType: string, status: StageProgressStatus, options?: {
+    sessionId?: string;
+    durationMs?: number;
+    error?: string;
+    guardResult?: StepGuardResult;
+    metadata?: Record<string, unknown>;
+}): StageProgressEvent;
+//# sourceMappingURL=step-guard.d.ts.map

package/dist/workflow/v1/step-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-guard.d.ts","sourceRoot":"","sources":["../../../src/workflow/v1/step-guard.ts"],"names":[],"mappings":"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"}