@probelabs/visor 0.1.106 → 0.1.107

package/dist/generated/config-schema.d.ts

@@ -1,10 +1,14 @@
 export declare const configSchema: {
     readonly $schema: "http://json-schema.org/draft-07/schema#";
-    readonly $ref: "#/definitions/VisorConfig";
+    readonly $ref: "#/definitions/VisorConfigSchema";
     readonly definitions: {
-        readonly VisorConfig: {
+        readonly VisorConfigSchema: {
             readonly type: "object";
+            readonly additionalProperties: false;
             readonly properties: {
+                readonly hooks: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
+                };
                 readonly version: {
                     readonly type: "string";
                     readonly description: "Configuration version";
@@ -20,6 +24,28 @@ export declare const configSchema: {
                     }];
                     readonly description: "Extends from other configurations - can be file path, HTTP(S) URL, or \"default\"";
                 };
+                readonly include: {
+                    readonly anyOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    }];
+                    readonly description: "Alias for extends - include from other configurations (backward compatibility)";
+                };
+                readonly tools: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2CCustomToolDefinition%3E";
+                    readonly description: "Custom tool definitions that can be used in MCP blocks";
+                };
+                readonly imports: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Import workflow definitions from external files or URLs";
+                };
                 readonly steps: {
                     readonly $ref: "#/definitions/Record%3Cstring%2CCheckConfig%3E";
                     readonly description: "Step configurations (recommended)";
@@ -80,14 +106,132 @@ export declare const configSchema: {
                     readonly $ref: "#/definitions/RoutingDefaults";
                     readonly description: "Optional routing defaults for retry/goto/run policies";
                 };
+                readonly limits: {
+                    readonly $ref: "#/definitions/LimitsConfig";
+                    readonly description: "Global execution limits";
+                };
+                readonly frontends: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly name: {
+                                readonly type: "string";
+                                readonly description: "Frontend name, e.g., 'ndjson-sink', 'github'";
+                            };
+                            readonly config: {
+                                readonly description: "Frontend-specific configuration";
+                            };
+                        };
+                        readonly required: readonly ["name"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "Optional integrations: event-driven frontends (e.g., ndjson-sink, github)";
+                };
+            };
+            readonly required: readonly ["output", "version"];
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
+        readonly 'Record<string,unknown>': {
+            readonly type: "object";
+            readonly additionalProperties: {};
+        };
+        readonly 'Record<string,CustomToolDefinition>': {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly $ref: "#/definitions/CustomToolDefinition";
+            };
+        };
+        readonly CustomToolDefinition: {
+            readonly type: "object";
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Tool name - used to reference the tool in MCP blocks";
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly description: "Description of what the tool does";
+                };
+                readonly inputSchema: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly const: "object";
+                        };
+                        readonly properties: {
+                            readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
+                        };
+                        readonly required: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly additionalProperties: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["type"];
+                    readonly additionalProperties: false;
+                    readonly description: "Input schema for the tool (JSON Schema format)";
+                    readonly patternProperties: {
+                        readonly '^x-': {};
+                    };
+                };
+                readonly exec: {
+                    readonly type: "string";
+                    readonly description: "Command to execute - supports Liquid template";
+                };
+                readonly stdin: {
+                    readonly type: "string";
+                    readonly description: "Optional stdin input - supports Liquid template";
+                };
+                readonly transform: {
+                    readonly type: "string";
+                    readonly description: "Transform the raw output - supports Liquid template";
+                };
+                readonly transform_js: {
+                    readonly type: "string";
+                    readonly description: "Transform the output using JavaScript - alternative to transform";
+                };
+                readonly cwd: {
+                    readonly type: "string";
+                    readonly description: "Working directory for command execution";
+                };
+                readonly env: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cstring%3E";
+                    readonly description: "Environment variables for the command";
+                };
+                readonly timeout: {
+                    readonly type: "number";
+                    readonly description: "Timeout in milliseconds";
+                };
+                readonly parseJson: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to parse output as JSON automatically";
+                };
+                readonly outputSchema: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
+                    readonly description: "Expected output schema for validation";
+                };
             };
-            readonly required: readonly ["version", "output"];
+            readonly required: readonly ["name", "exec"];
             readonly additionalProperties: false;
-            readonly description: "Main Visor configuration";
+            readonly description: "Custom tool definition for use in MCP blocks";
             readonly patternProperties: {
                 readonly '^x-': {};
             };
         };
+        readonly 'Record<string,string>': {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
         readonly 'Record<string,CheckConfig>': {
             readonly type: "object";
             readonly additionalProperties: {
@@ -145,6 +289,10 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Transform using JavaScript expressions (evaluated in secure sandbox) - optional";
                 };
+                readonly content: {
+                    readonly type: "string";
+                    readonly description: "Script content to execute for script checks";
+                };
                 readonly schedule: {
                     readonly type: "string";
                     readonly description: "Cron schedule expression (e.g., \"0 2 * * *\") - optional for any check type";
@@ -183,6 +331,22 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "AI provider to use for this check - overrides global setting";
                 };
+                readonly ai_persona: {
+                    readonly type: "string";
+                    readonly description: "Optional persona hint, prepended to the prompt as 'Persona: <value>'";
+                };
+                readonly ai_prompt_type: {
+                    readonly type: "string";
+                    readonly description: "Probe promptType for this check (underscore style)";
+                };
+                readonly ai_system_prompt: {
+                    readonly type: "string";
+                    readonly description: "System prompt for this check (underscore style)";
+                };
+                readonly ai_custom_prompt: {
+                    readonly type: "string";
+                    readonly description: "Legacy customPrompt (underscore style) — deprecated, use ai_system_prompt";
+                };
                 readonly ai_mcp_servers: {
                     readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                     readonly description: "MCP servers for this AI check - overrides global setting";
@@ -218,6 +382,10 @@ export declare const configSchema: {
                     }];
                     readonly description: "Schema type for template rendering (e.g., \"code-review\", \"markdown\") or inline JSON schema object - optional";
                 };
+                readonly output_schema: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
+                    readonly description: "Optional JSON Schema to validate the produced output. If omitted and `schema` is an object, the engine will treat that object as the output_schema for validation purposes while still using string schemas (e.g., 'code-review') for template selection.";
+                };
                 readonly template: {
                     readonly $ref: "#/definitions/CustomTemplateConfig";
                     readonly description: "Custom template configuration - optional";
@@ -250,10 +418,28 @@ export declare const configSchema: {
                     };
                     readonly description: "Tags for categorizing and filtering checks (e.g., [\"local\", \"fast\", \"security\"])";
                 };
+                readonly criticality: {
+                    readonly type: "string";
+                    readonly enum: readonly ["external", "internal", "policy", "info"];
+                    readonly description: "Operational criticality of this step. Drives default safety policies (contracts, retries, loop budgets) at load time. Behavior can still be overridden explicitly per step via on_*, fail_if, assume/guarantee, etc.\n\n- 'external': interacts with external systems (side effects). Highest safety.\n- 'internal': modifies CI/config/state but not prod. High safety.\n- 'policy': organizational checks (linting, style, doc). Moderate safety.\n- 'info': informational checks. Lowest safety.";
+                };
+                readonly continue_on_failure: {
+                    readonly type: "boolean";
+                    readonly description: "Allow dependents to run even if this step fails. Defaults to false (dependents are gated when this step fails). Similar to GitHub Actions' continue-on-error.";
+                };
                 readonly forEach: {
                     readonly type: "boolean";
                     readonly description: "Process output as array and run dependent checks for each item";
                 };
+                readonly fanout: {
+                    readonly type: "string";
+                    readonly enum: readonly ["map", "reduce"];
+                    readonly description: "Control scheduling behavior when this check is triggered via routing (run/goto) from a forEach scope.\n- 'map': schedule once per item (fan-out) using item scopes.\n- 'reduce': schedule a single run at the parent scope (aggregation). If unset, the current default is a single run (reduce) for backward compatibility.";
+                };
+                readonly reduce: {
+                    readonly type: "boolean";
+                    readonly description: "Alias for fanout: 'reduce'";
+                };
                 readonly on_fail: {
                     readonly $ref: "#/definitions/OnFailConfig";
                     readonly description: "Failure routing configuration for this check (retry/goto/run)";
@@ -262,6 +448,36 @@ export declare const configSchema: {
                     readonly $ref: "#/definitions/OnSuccessConfig";
                     readonly description: "Success routing configuration for this check (post-actions and optional goto)";
                 };
+                readonly on_finish: {
+                    readonly $ref: "#/definitions/OnFinishConfig";
+                    readonly description: "Finish routing configuration for forEach checks (runs after ALL iterations complete)";
+                };
+                readonly assume: {
+                    readonly anyOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    }];
+                    readonly description: "Preconditions that must hold before executing the check. If any expression evaluates to false, the check is skipped (skipReason='assume').";
+                };
+                readonly guarantee: {
+                    readonly anyOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    }];
+                    readonly description: "Postconditions that should hold after executing the check. Expressions are evaluated against the produced result/output; violations are recorded as error issues with ruleId \"contract/guarantee_failed\".";
+                };
+                readonly max_runs: {
+                    readonly type: "number";
+                    readonly description: "Hard cap on how many times this check may execute within a single engine run. Overrides global limits.max_runs_per_check. Set to 0 or negative to disable for this step.";
+                };
                 readonly message: {
                     readonly type: "string";
                     readonly description: "Message template for log checks";
@@ -283,10 +499,15 @@ export declare const configSchema: {
                     readonly type: "boolean";
                     readonly description: "Include execution metadata in log output";
                 };
+                readonly output_format: {
+                    readonly type: "string";
+                    readonly enum: readonly ["json", "text"];
+                    readonly description: "Output parsing hint for command provider (optional) When set to 'json', command stdout is expected to be JSON. When 'text', treat as plain text. Note: command provider attempts JSON parsing heuristically; this flag mainly suppresses schema warnings and may be used by providers to alter parsing behavior in the future.";
+                };
                 readonly operation: {
                     readonly type: "string";
-                    readonly enum: readonly ["get", "set", "append", "increment", "delete", "clear", "list", "exec_js"];
-                    readonly description: "Memory operation to perform";
+                    readonly enum: readonly ["get", "set", "append", "increment", "delete", "clear", "list"];
+                    readonly description: "Memory operation to perform. Use `type: 'script'` for custom JavaScript.";
                 };
                 readonly key: {
                     readonly type: "string";
@@ -299,10 +520,6 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "JavaScript expression to compute value dynamically";
                 };
-                readonly memory_js: {
-                    readonly type: "string";
-                    readonly description: "JavaScript code for exec_js operation with full memory access";
-                };
                 readonly namespace: {
                     readonly type: "string";
                     readonly description: "Override namespace for this check";
@@ -339,7 +556,7 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Session ID for HTTP transport (optional, server may generate one)";
                 };
-                readonly args: {
+                readonly command_args: {
                     readonly type: "array";
                     readonly items: {
                         readonly type: "string";
@@ -350,6 +567,38 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Working directory (for stdio transport in MCP checks)";
                 };
+                readonly placeholder: {
+                    readonly type: "string";
+                    readonly description: "Placeholder text to show in input field";
+                };
+                readonly allow_empty: {
+                    readonly type: "boolean";
+                    readonly description: "Allow empty input (default: false)";
+                };
+                readonly multiline: {
+                    readonly type: "boolean";
+                    readonly description: "Support multiline input (default: false)";
+                };
+                readonly default: {
+                    readonly type: "string";
+                    readonly description: "Default value if timeout occurs or empty input when allow_empty is true";
+                };
+                readonly workflow: {
+                    readonly type: "string";
+                    readonly description: "Workflow ID or path to workflow file";
+                };
+                readonly args: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
+                    readonly description: "Arguments/inputs for the workflow";
+                };
+                readonly overrides: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2CPartial%3Cinterface-src_types_config.ts-10692-20779-src_types_config.ts-0-34222%3E%3E";
+                    readonly description: "Override specific step configurations in the workflow";
+                };
+                readonly output_mapping: {
+                    readonly $ref: "#/definitions/Record%3Cstring%2Cstring%3E";
+                    readonly description: "Map workflow outputs to check outputs";
+                };
             };
             readonly additionalProperties: false;
             readonly description: "Configuration for a single check";
@@ -359,15 +608,9 @@ export declare const configSchema: {
         };
         readonly ConfigCheckType: {
             readonly type: "string";
-            readonly enum: readonly ["ai", "command", "http", "http_input", "http_client", "noop", "log", "memory", "github", "claude-code", "mcp", "human-input"];
+            readonly enum: readonly ["ai", "command", "script", "http", "http_input", "http_client", "noop", "log", "memory", "github", "claude-code", "mcp", "human-input", "workflow"];
             readonly description: "Valid check types in configuration";
         };
-        readonly 'Record<string,string>': {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly type: "string";
-            };
-        };
         readonly EventTrigger: {
             readonly type: "string";
             readonly enum: readonly ["pr_opened", "pr_updated", "pr_closed", "issue_opened", "issue_comment", "manual", "schedule", "webhook_received"];
@@ -397,10 +640,61 @@ export declare const configSchema: {
                     readonly type: "boolean";
                     readonly description: "Enable debug mode";
                 };
+                readonly prompt_type: {
+                    readonly type: "string";
+                    readonly description: "Probe promptType to use (e.g., engineer, code-review, architect)";
+                };
+                readonly system_prompt: {
+                    readonly type: "string";
+                    readonly description: "System prompt (baseline preamble). Replaces legacy custom_prompt.";
+                };
+                readonly custom_prompt: {
+                    readonly type: "string";
+                    readonly description: "Probe customPrompt (baseline/system prompt) — deprecated, use system_prompt";
+                };
+                readonly skip_code_context: {
+                    readonly type: "boolean";
+                    readonly description: "Skip adding code context (diffs, files, PR info) to the prompt";
+                };
                 readonly mcpServers: {
                     readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                     readonly description: "MCP servers configuration";
                 };
+                readonly enableDelegate: {
+                    readonly type: "boolean";
+                    readonly description: "Enable the delegate tool for task distribution to subagents";
+                };
+                readonly retry: {
+                    readonly $ref: "#/definitions/AIRetryConfig";
+                    readonly description: "Retry configuration for this provider";
+                };
+                readonly fallback: {
+                    readonly $ref: "#/definitions/AIFallbackConfig";
+                    readonly description: "Fallback configuration for provider failures";
+                };
+                readonly allowEdit: {
+                    readonly type: "boolean";
+                    readonly description: "Enable Edit and Create tools for file modification (disabled by default for security)";
+                };
+                readonly allowedTools: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Filter allowed tools - supports whitelist, exclusion (!prefix), or raw AI mode (empty array)";
+                };
+                readonly disableTools: {
+                    readonly type: "boolean";
+                    readonly description: "Disable all tools for raw AI mode (alternative to allowedTools: [])";
+                };
+                readonly allowBash: {
+                    readonly type: "boolean";
+                    readonly description: "Enable bash command execution (shorthand for bashConfig.enabled)";
+                };
+                readonly bashConfig: {
+                    readonly $ref: "#/definitions/BashConfig";
+                    readonly description: "Advanced bash command execution configuration";
+                };
             };
             readonly additionalProperties: false;
             readonly description: "AI provider configuration";
@@ -440,6 +734,149 @@ export declare const configSchema: {
                 readonly '^x-': {};
             };
         };
+        readonly AIRetryConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                    readonly description: "Maximum retry attempts (0-50)";
+                };
+                readonly initialDelay: {
+                    readonly type: "number";
+                    readonly description: "Initial delay in milliseconds (0-60000)";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                    readonly description: "Maximum delay cap in milliseconds (0-300000)";
+                };
+                readonly backoffFactor: {
+                    readonly type: "number";
+                    readonly description: "Exponential backoff multiplier (1-10)";
+                };
+                readonly retryableErrors: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Custom error patterns to retry on";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Retry configuration for AI provider calls";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
+        readonly AIFallbackConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly strategy: {
+                    readonly type: "string";
+                    readonly enum: readonly ["same-model", "same-provider", "any", "custom"];
+                    readonly description: "Fallback strategy: 'same-model', 'same-provider', 'any', or 'custom'";
+                };
+                readonly providers: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/AIFallbackProviderConfig";
+                    };
+                    readonly description: "Array of fallback provider configurations";
+                };
+                readonly maxTotalAttempts: {
+                    readonly type: "number";
+                    readonly description: "Maximum total attempts across all providers";
+                };
+                readonly auto: {
+                    readonly type: "boolean";
+                    readonly description: "Enable automatic fallback using available environment variables";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Fallback configuration for AI providers";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
+        readonly AIFallbackProviderConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly provider: {
+                    readonly type: "string";
+                    readonly enum: readonly ["google", "anthropic", "openai", "bedrock"];
+                    readonly description: "AI provider to use";
+                };
+                readonly model: {
+                    readonly type: "string";
+                    readonly description: "Model name to use";
+                };
+                readonly apiKey: {
+                    readonly type: "string";
+                    readonly description: "API key for this provider";
+                };
+                readonly maxRetries: {
+                    readonly type: "number";
+                    readonly description: "Per-provider retry override";
+                };
+                readonly region: {
+                    readonly type: "string";
+                    readonly description: "AWS region (for Bedrock)";
+                };
+                readonly accessKeyId: {
+                    readonly type: "string";
+                    readonly description: "AWS access key ID (for Bedrock)";
+                };
+                readonly secretAccessKey: {
+                    readonly type: "string";
+                    readonly description: "AWS secret access key (for Bedrock)";
+                };
+            };
+            readonly required: readonly ["provider", "model"];
+            readonly additionalProperties: false;
+            readonly description: "Fallback provider configuration";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
+        readonly BashConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly allow: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Array of permitted command patterns (e.g., ['ls', 'git status'])";
+                };
+                readonly deny: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Array of blocked command patterns (e.g., ['rm -rf', 'sudo'])";
+                };
+                readonly noDefaultAllow: {
+                    readonly type: "boolean";
+                    readonly description: "Disable default safe command list (use with caution)";
+                };
+                readonly noDefaultDeny: {
+                    readonly type: "boolean";
+                    readonly description: "Disable default dangerous command blocklist (use with extreme caution)";
+                };
+                readonly timeout: {
+                    readonly type: "number";
+                    readonly description: "Execution timeout in milliseconds";
+                };
+                readonly workingDirectory: {
+                    readonly type: "string";
+                    readonly description: "Default working directory for command execution";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Bash command execution configuration for ProbeAgent Note: Use 'allowBash: true' in AIProviderConfig to enable bash execution";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
         readonly ClaudeCodeConfig: {
             readonly type: "object";
             readonly properties: {
@@ -466,6 +903,10 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Path to subagent script";
                 };
+                readonly enableDelegate: {
+                    readonly type: "boolean";
+                    readonly description: "Enable the delegate tool for task distribution to subagents";
+                };
                 readonly hooks: {
                     readonly type: "object";
                     readonly properties: {
@@ -502,10 +943,6 @@ export declare const configSchema: {
             };
             readonly description: "Environment variable reference configuration";
         };
-        readonly 'Record<string,unknown>': {
-            readonly type: "object";
-            readonly additionalProperties: {};
-        };
         readonly CustomTemplateConfig: {
             readonly type: "object";
             readonly properties: {
@@ -605,6 +1042,13 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Dynamic remediation list: JS expression returning string[]";
                 };
+                readonly transitions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/TransitionRule";
+                    };
+                    readonly description: "Declarative transitions. Evaluated in order; first matching rule wins. If a rule's `to` is null, no goto occurs. When omitted or none match, the engine falls back to goto_js/goto for backward compatibility.";
+                };
             };
             readonly additionalProperties: false;
             readonly description: "Failure routing configuration per check";
@@ -649,6 +1093,29 @@ export declare const configSchema: {
                 readonly '^x-': {};
             };
         };
+        readonly TransitionRule: {
+            readonly type: "object";
+            readonly properties: {
+                readonly when: {
+                    readonly type: "string";
+                    readonly description: "JavaScript expression evaluated in the same sandbox as goto_js; truthy enables the rule.";
+                };
+                readonly to: {
+                    readonly type: readonly ["string", "null"];
+                    readonly description: "Target step ID, or null to explicitly prevent goto.";
+                };
+                readonly goto_event: {
+                    readonly $ref: "#/definitions/EventTrigger";
+                    readonly description: "Optional event override when performing goto.";
+                };
+            };
+            readonly required: readonly ["when"];
+            readonly additionalProperties: false;
+            readonly description: "Declarative transition rule for on_* blocks.";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
         readonly OnSuccessConfig: {
             readonly type: "object";
             readonly properties: {
@@ -675,6 +1142,13 @@ export declare const configSchema: {
                     readonly type: "string";
                     readonly description: "Dynamic post-success steps: JS expression returning string[]";
                 };
+                readonly transitions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/TransitionRule";
+                    };
+                    readonly description: "Declarative transitions (see OnFailConfig.transitions).";
+                };
             };
             readonly additionalProperties: false;
             readonly description: "Success routing configuration per check";
@@ -682,6 +1156,56 @@ export declare const configSchema: {
                 readonly '^x-': {};
             };
         };
+        readonly OnFinishConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly run: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Post-finish steps to run";
+                };
+                readonly goto: {
+                    readonly type: "string";
+                    readonly description: "Optional jump back to ancestor step (by id)";
+                };
+                readonly goto_event: {
+                    readonly $ref: "#/definitions/EventTrigger";
+                    readonly description: "Simulate a different event when performing goto (e.g., 'pr_updated')";
+                };
+                readonly goto_js: {
+                    readonly type: "string";
+                    readonly description: "Dynamic goto: JS expression returning step id or null";
+                };
+                readonly run_js: {
+                    readonly type: "string";
+                    readonly description: "Dynamic post-finish steps: JS expression returning string[]";
+                };
+                readonly transitions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/TransitionRule";
+                    };
+                    readonly description: "Declarative transitions (see OnFailConfig.transitions).";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Finish routing configuration for forEach checks Runs once after ALL iterations of forEach and ALL dependent checks complete";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
+        readonly 'Record<string,Partial<interface-src_types_config.ts-10692-20779-src_types_config.ts-0-34222>>': {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly $ref: "#/definitions/Partial%3Cinterface-src_types_config.ts-10692-20779-src_types_config.ts-0-34222%3E";
+            };
+        };
+        readonly 'Partial<interface-src_types_config.ts-10692-20779-src_types_config.ts-0-34222>': {
+            readonly type: "object";
+            readonly additionalProperties: false;
+        };
         readonly OutputConfig: {
             readonly type: "object";
             readonly properties: {
@@ -1026,6 +1550,24 @@ export declare const configSchema: {
                 readonly '^x-': {};
             };
         };
+        readonly LimitsConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly max_runs_per_check: {
+                    readonly type: "number";
+                    readonly description: "Maximum number of executions per check within a single engine run. Applies to each distinct scope independently for forEach item executions. Set to 0 or negative to disable. Default: 50.";
+                };
+                readonly max_workflow_depth: {
+                    readonly type: "number";
+                    readonly description: "Maximum nesting depth for workflows executed by the state machine engine. Nested workflows are invoked by the workflow provider; this limit prevents accidental infinite recursion. Default: 3.";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Global engine limits";
+            readonly patternProperties: {
+                readonly '^x-': {};
+            };
+        };
     };
 };
 export default configSchema;