@qawolf/api-contracts 0.58.0 → 0.63.0

package/dist/v1/index.d.ts

@@ -11,7 +11,7 @@ export type PublicApiOutput<Api extends AnyPublicApiContract> = z.infer<Api["out
  * the same factory with its own strict id schemas, so the contract shape can
  * never drift between the two while validation strictness stays server-owned.
  */
-export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, FlowId extends PublicIdSchema, RunId extends PublicIdSchema, AutomationId extends PublicIdSchema = PublicIdSchema, IssueId extends PublicIdSchema = PublicIdSchema, WorkspaceId extends PublicIdSchema = PublicIdSchema, AiTaskId extends PublicIdSchema = PublicIdSchema, ChatSessionId extends PublicIdSchema = PublicIdSchema, TriggerId extends PublicIdSchema = PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, AutomationId, IssueId, WorkspaceId, AiTaskId, ChatSessionId, TriggerId>) => {
+export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, FlowId extends PublicIdSchema, RunId extends PublicIdSchema, IssueId extends PublicIdSchema = PublicIdSchema, WorkspaceId extends PublicIdSchema = PublicIdSchema, AiTaskId extends PublicIdSchema = PublicIdSchema, ChatSessionId extends PublicIdSchema = PublicIdSchema, TriggerId extends PublicIdSchema = PublicIdSchema, DeploymentId extends PublicIdSchema = PublicIdSchema, LegacyTriggerId extends PublicIdSchema = PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, IssueId, WorkspaceId, AiTaskId, ChatSessionId, TriggerId, DeploymentId, LegacyTriggerId>) => {
     agent: {
         get: {
             readonly annotations: {
@@ -19,10 +19,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 readonly openWorldHint: false;
                 readonly readOnlyHint: true;
             };
-            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
                 sessionId: ChatSessionId;
+                waitSeconds: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "agent.get";
@@ -41,6 +42,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     failed: "failed";
                     cancelled: "cancelled";
                 }>;
+                waitSeconds: z.ZodOptional<z.ZodNumber>;
+                wokeOn: z.ZodOptional<z.ZodEnum<{
+                    reply: "reply";
+                    status: "status";
+                    timeout: "timeout";
+                }>>;
                 url: z.ZodURL;
             }, z.core.$strip>;
         };
@@ -55,6 +62,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 environmentId: z.ZodOptional<PublicIdSchema>;
                 filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
+                runnerId: z.ZodOptional<z.ZodString>;
                 sessionId: z.ZodOptional<ChatSessionId>;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
@@ -73,27 +81,6 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
     };
-    automate: {
-        readonly annotations: {
-            readonly destructiveHint: true;
-            readonly openWorldHint: true;
-            readonly readOnlyHint: false;
-        };
-        readonly description: "Request automation for draft flows. First create a named local .flow.ts draft for every requested journey that does not already have a matching draft; never reuse a generic starter or placeholder. Each new draft must start with a JSDoc Goal: description, import flow from @qawolf/flows/web, and use export default flow(...); a comment-only file or direct test(...) call is not a valid draft. Commit and push all changes with Git to publish them, then list remote drafts to resolve every selected ID. Do not use patch to create or rename a selected flow. Finally make one automation request containing all requested flow IDs.";
-        readonly input: z.ZodObject<{
-            aiTaskId: z.ZodOptional<AiTaskId>;
-            environmentId: PublicIdSchema;
-            flowIds: z.ZodArray<FlowId>;
-            patch: z.ZodOptional<z.ZodString>;
-            workspaceId: z.ZodOptional<WorkspaceId>;
-        }, z.core.$strip>;
-        readonly kind: "write";
-        readonly name: "automate";
-        readonly output: z.ZodObject<{
-            automationId: AutomationId;
-            url: z.ZodURL;
-        }, z.core.$strip>;
-    };
     codeHostIntegration: {
         find: {
             readonly annotations: {
@@ -152,6 +139,136 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
         };
     };
     deployment: {
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "deployment.find";
+            readonly output: z.ZodObject<{
+                deployments: z.ZodArray<z.ZodObject<{
+                    branch: z.ZodOptional<z.ZodString>;
+                    commitAuthorName: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    deployedAt: z.ZodISODateTime;
+                    deployTarget: z.ZodOptional<z.ZodString>;
+                    environmentId: EnvironmentId;
+                    environmentName: z.ZodOptional<z.ZodString>;
+                    id: DeploymentId;
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        github: "github";
+                        gitlab: "gitlab";
+                        api: "api";
+                    }>>;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        success: "success";
+                        pending: "pending";
+                        failure: "failure";
+                        inactive: "inactive";
+                    }>>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        listTriggerEvaluations: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+            readonly input: z.ZodObject<{
+                deploymentId: DeploymentId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "deployment.listTriggerEvaluations";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                evaluations: z.ZodArray<z.ZodObject<{
+                    triggerId: z.ZodOptional<TriggerId>;
+                    triggerName: z.ZodString;
+                    verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        conditionSets: z.ZodArray<z.ZodObject<{
+                            conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"matched">;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"did-not-match">;
+                                reason: z.ZodString;
+                            }, z.core.$strip>], "outcome">>;
+                            outcome: z.ZodEnum<{
+                                matched: "matched";
+                                "did-not-match": "did-not-match";
+                            }>;
+                        }, z.core.$strip>>;
+                        outcome: z.ZodLiteral<"matched">;
+                        run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            runId: RunId;
+                            status: z.ZodLiteral<"ran">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            status: z.ZodLiteral<"starting">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            reason: z.ZodString;
+                            status: z.ZodLiteral<"did-not-run">;
+                            supersededByRunId: z.ZodOptional<RunId>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            status: z.ZodLiteral<"unknown">;
+                        }, z.core.$strip>], "status">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        conditionSets: z.ZodArray<z.ZodObject<{
+                            conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"matched">;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"did-not-match">;
+                                reason: z.ZodString;
+                            }, z.core.$strip>], "outcome">>;
+                            outcome: z.ZodEnum<{
+                                matched: "matched";
+                                "did-not-match": "did-not-match";
+                            }>;
+                        }, z.core.$strip>>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        outcome: z.ZodLiteral<"not-considered">;
+                        reason: z.ZodEnum<{
+                            "trigger-paused": "trigger-paused";
+                            "not-a-deployment-trigger": "not-a-deployment-trigger";
+                        }>;
+                    }, z.core.$strip>], "outcome">;
+                }, z.core.$strip>>;
+                state: z.ZodLiteral<"evaluated">;
+            }, z.core.$strip>, z.ZodObject<{
+                state: z.ZodLiteral<"not-evaluated">;
+            }, z.core.$strip>], "state">;
+        };
         reportStatus: {
             readonly annotations: {
                 readonly destructiveHint: true;
@@ -190,7 +307,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly name: "deployment.reportStatus";
             readonly output: z.ZodObject<{
                 deployment: z.ZodObject<{
-                    id: PublicIdSchema;
+                    id: DeploymentId;
                     status: z.ZodEnum<{
                         success: "success";
                         pending: "pending";
@@ -1191,6 +1308,124 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
     };
+    legacyTrigger: {
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                kind: z.ZodDefault<z.ZodEnum<{
+                    static: "static";
+                    active: "active";
+                    all: "all";
+                }>>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "legacyTrigger.find";
+            readonly output: z.ZodObject<{
+                legacyTriggers: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    nextAt: z.ZodOptional<z.ZodISODateTime>;
+                    repeatMinutes: z.ZodNumber;
+                    startAt: z.ZodOptional<z.ZodISODateTime>;
+                    timezoneId: z.ZodOptional<z.ZodString>;
+                    type: z.ZodLiteral<"scheduled">;
+                    environment: z.ZodObject<{
+                        id: EnvironmentId;
+                        kind: z.ZodEnum<{
+                            static: "static";
+                            preview: "preview";
+                        }>;
+                        name: z.ZodString;
+                        terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    }, z.core.$strip>;
+                    id: LegacyTriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    tags: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    adaptiveFlowSelection: z.ZodBoolean;
+                    branchScope: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"all-branches">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        caseSensitiveGlobs: z.ZodArray<z.ZodString>;
+                        kind: z.ZodLiteral<"listed-branches">;
+                        negated: z.ZodBoolean;
+                        raw: z.ZodString;
+                    }, z.core.$strip>]>;
+                    codeHostingServiceRepository: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"any">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"none">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        id: z.ZodString;
+                        kind: z.ZodLiteral<"by-id">;
+                    }, z.core.$strip>]>;
+                    deploymentPrLabel: z.ZodOptional<z.ZodString>;
+                    deploymentType: z.ZodOptional<z.ZodString>;
+                    type: z.ZodUnion<readonly [z.ZodLiteral<"generic">, z.ZodLiteral<"pr-testing-button">]>;
+                    environment: z.ZodObject<{
+                        id: EnvironmentId;
+                        kind: z.ZodEnum<{
+                            static: "static";
+                            preview: "preview";
+                        }>;
+                        name: z.ZodString;
+                        terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    }, z.core.$strip>;
+                    id: LegacyTriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    tags: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>;
+        };
+        pause: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                legacyTriggerId: LegacyTriggerId;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "legacyTrigger.pause";
+            readonly output: z.ZodObject<{
+                isPaused: z.ZodBoolean;
+                legacyTriggerId: LegacyTriggerId;
+            }, z.core.$strip>;
+        };
+        resume: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                legacyTriggerId: LegacyTriggerId;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "legacyTrigger.resume";
+            readonly output: z.ZodObject<{
+                isPaused: z.ZodBoolean;
+                legacyTriggerId: LegacyTriggerId;
+            }, z.core.$strip>;
+        };
+    };
     run: {
         create: {
             readonly annotations: {
@@ -1976,6 +2211,124 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "failureReason">], "outcome">;
         };
+        performActions: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Perform a sequence of raw browser actions on an interactive runner in one request, one after another, and answer with what happened to each. A `success` means every action took effect. A `failure` names the first action that did not (`failedIndex`, `failureReason`), the last one that did (`lastCompletedIndex`), and whether actions were left unperformed (`stoppedEarly`); `results` has one entry per action reached, in order. Read `effect` on an entry before sending its action again: `performed` means the runner did it; `not-performed` means the runner answered that it did not take effect, though a `navigate` that timed out may still be loading; `unknown` means the runner stopped answering with the action in flight (`runner-unreachable`), or its screen went quiet mid-action (`action-unconfirmed`), and it may have taken effect — a click that submitted a form, say — so take a screenshot instead of repeating it. A sequence gets about a minute to start its actions; an action it did not reach in time is `out-of-time`, nothing after it was attempted, and the rest can go in a new request. Everything `runner.performAction` says about a runner that has never run anything, a mobile runner, and the `screen-needs-a-run`, `screen-not-ready`, `runner-has-no-screen` and `action-not-supported-on-mobile` reasons holds for each action here.";
+            readonly input: z.ZodObject<{
+                actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
+                    type: z.ZodLiteral<"click">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"double_click">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    scroll_x: z.ZodInt;
+                    scroll_y: z.ZodInt;
+                    type: z.ZodLiteral<"scroll">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"move">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    path: z.ZodArray<z.ZodObject<{
+                        x: z.ZodInt;
+                        y: z.ZodInt;
+                    }, z.core.$strict>>;
+                    type: z.ZodLiteral<"drag">;
+                }, z.core.$strict>, z.ZodObject<{
+                    keys: z.ZodArray<z.ZodString>;
+                    type: z.ZodLiteral<"keypress">;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"navigate">;
+                    url: z.ZodURL;
+                }, z.core.$strict>, z.ZodObject<{
+                    text: z.ZodString;
+                    type: z.ZodLiteral<"type">;
+                }, z.core.$strict>], "type">>;
+                id: z.ZodString;
+                screenshotMode: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    final: "final";
+                    each: "each";
+                }>>;
+                stopOnFailure: z.ZodOptional<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.performActions";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                imageJpegBase64: z.ZodOptional<z.ZodString>;
+                lastCompletedIndex: z.ZodInt;
+                outcome: z.ZodLiteral<"success">;
+                results: z.ZodArray<z.ZodObject<{
+                    effect: z.ZodLiteral<"performed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"success">;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                failedIndex: z.ZodInt;
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
+                    "action-failed": "action-failed";
+                    "runner-has-no-screen": "runner-has-no-screen";
+                    "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+                    "out-of-time": "out-of-time";
+                    "action-unconfirmed": "action-unconfirmed";
+                }>;
+                imageJpegBase64: z.ZodOptional<z.ZodString>;
+                lastCompletedIndex: z.ZodOptional<z.ZodInt>;
+                outcome: z.ZodLiteral<"failure">;
+                results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    effect: z.ZodLiteral<"performed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"success">;
+                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    effect: z.ZodLiteral<"not-performed">;
+                    errorMessage: z.ZodString;
+                    failureReason: z.ZodLiteral<"action-failed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"unknown">;
+                    failureReason: z.ZodLiteral<"runner-unreachable">;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"unknown">;
+                    errorMessage: z.ZodString;
+                    failureReason: z.ZodLiteral<"action-unconfirmed">;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"not-performed">;
+                    failureReason: z.ZodEnum<{
+                        "screen-needs-a-run": "screen-needs-a-run";
+                        "screen-not-ready": "screen-not-ready";
+                        "runner-has-no-screen": "runner-has-no-screen";
+                        "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+                        "out-of-time": "out-of-time";
+                    }>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>], "failureReason">], "outcome">>;
+                stoppedEarly: z.ZodBoolean;
+            }, z.core.$strip>], "outcome">;
+        };
         promoteSnapshot: {
             readonly annotations: {
                 readonly destructiveHint: true;
@@ -2160,6 +2513,47 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
     };
+    skill: {
+        get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "skill.get";
+            readonly output: z.ZodObject<{
+                description: z.ZodString;
+                name: z.ZodString;
+                instructions: z.ZodString;
+                references: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.";
+            readonly input: z.ZodObject<{}, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "skill.list";
+            readonly output: z.ZodObject<{
+                skills: z.ZodArray<z.ZodObject<{
+                    description: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+    };
     tag: {
         create: {
             readonly annotations: {
@@ -2230,7 +2624,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 cadence: z.ZodEnum<{
                     hourly: "hourly";
                     daily: "daily";
+                    weekly: "weekly";
                 }>;
+                dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>>;
                 environmentId: PublicIdSchema;
                 minuteOfHour: z.ZodOptional<z.ZodNumber>;
                 timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2275,7 +2679,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2358,7 +2772,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2424,7 +2848,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2490,7 +2924,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2556,7 +3000,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2615,7 +3069,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 cadence: z.ZodEnum<{
                     hourly: "hourly";
                     daily: "daily";
+                    weekly: "weekly";
                 }>;
+                dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>>;
                 environmentId: PublicIdSchema;
                 minuteOfHour: z.ZodOptional<z.ZodNumber>;
                 timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2660,7 +3124,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: EnvironmentId;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -2707,10 +3181,11 @@ export declare const publicContractsV1: {
                 readonly openWorldHint: false;
                 readonly readOnlyHint: true;
             };
-            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
                 sessionId: PublicIdSchema;
+                waitSeconds: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "agent.get";
@@ -2729,6 +3204,12 @@ export declare const publicContractsV1: {
                     failed: "failed";
                     cancelled: "cancelled";
                 }>;
+                waitSeconds: z.ZodOptional<z.ZodNumber>;
+                wokeOn: z.ZodOptional<z.ZodEnum<{
+                    reply: "reply";
+                    status: "status";
+                    timeout: "timeout";
+                }>>;
                 url: z.ZodURL;
             }, z.core.$strip>;
         };
@@ -2743,6 +3224,7 @@ export declare const publicContractsV1: {
                 environmentId: z.ZodOptional<PublicIdSchema>;
                 filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
+                runnerId: z.ZodOptional<z.ZodString>;
                 sessionId: z.ZodOptional<PublicIdSchema>;
                 workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
@@ -2761,27 +3243,6 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
     };
-    automate: {
-        readonly annotations: {
-            readonly destructiveHint: true;
-            readonly openWorldHint: true;
-            readonly readOnlyHint: false;
-        };
-        readonly description: "Request automation for draft flows. First create a named local .flow.ts draft for every requested journey that does not already have a matching draft; never reuse a generic starter or placeholder. Each new draft must start with a JSDoc Goal: description, import flow from @qawolf/flows/web, and use export default flow(...); a comment-only file or direct test(...) call is not a valid draft. Commit and push all changes with Git to publish them, then list remote drafts to resolve every selected ID. Do not use patch to create or rename a selected flow. Finally make one automation request containing all requested flow IDs.";
-        readonly input: z.ZodObject<{
-            aiTaskId: z.ZodOptional<PublicIdSchema>;
-            environmentId: PublicIdSchema;
-            flowIds: z.ZodArray<PublicIdSchema>;
-            patch: z.ZodOptional<z.ZodString>;
-            workspaceId: z.ZodOptional<PublicIdSchema>;
-        }, z.core.$strip>;
-        readonly kind: "write";
-        readonly name: "automate";
-        readonly output: z.ZodObject<{
-            automationId: PublicIdSchema;
-            url: z.ZodURL;
-        }, z.core.$strip>;
-    };
     codeHostIntegration: {
         find: {
             readonly annotations: {
@@ -2840,6 +3301,136 @@ export declare const publicContractsV1: {
         };
     };
     deployment: {
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "deployment.find";
+            readonly output: z.ZodObject<{
+                deployments: z.ZodArray<z.ZodObject<{
+                    branch: z.ZodOptional<z.ZodString>;
+                    commitAuthorName: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    deployedAt: z.ZodISODateTime;
+                    deployTarget: z.ZodOptional<z.ZodString>;
+                    environmentId: PublicIdSchema;
+                    environmentName: z.ZodOptional<z.ZodString>;
+                    id: PublicIdSchema;
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        github: "github";
+                        gitlab: "gitlab";
+                        api: "api";
+                    }>>;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        success: "success";
+                        pending: "pending";
+                        failure: "failure";
+                        inactive: "inactive";
+                    }>>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        listTriggerEvaluations: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+            readonly input: z.ZodObject<{
+                deploymentId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "deployment.listTriggerEvaluations";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                evaluations: z.ZodArray<z.ZodObject<{
+                    triggerId: z.ZodOptional<PublicIdSchema>;
+                    triggerName: z.ZodString;
+                    verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        conditionSets: z.ZodArray<z.ZodObject<{
+                            conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"matched">;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"did-not-match">;
+                                reason: z.ZodString;
+                            }, z.core.$strip>], "outcome">>;
+                            outcome: z.ZodEnum<{
+                                matched: "matched";
+                                "did-not-match": "did-not-match";
+                            }>;
+                        }, z.core.$strip>>;
+                        outcome: z.ZodLiteral<"matched">;
+                        run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            runId: PublicIdSchema;
+                            status: z.ZodLiteral<"ran">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            status: z.ZodLiteral<"starting">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            reason: z.ZodString;
+                            status: z.ZodLiteral<"did-not-run">;
+                            supersededByRunId: z.ZodOptional<PublicIdSchema>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            status: z.ZodLiteral<"unknown">;
+                        }, z.core.$strip>], "status">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        conditionSets: z.ZodArray<z.ZodObject<{
+                            conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"matched">;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    branch: "branch";
+                                    deployTarget: "deployTarget";
+                                    environment: "environment";
+                                }>;
+                                outcome: z.ZodLiteral<"did-not-match">;
+                                reason: z.ZodString;
+                            }, z.core.$strip>], "outcome">>;
+                            outcome: z.ZodEnum<{
+                                matched: "matched";
+                                "did-not-match": "did-not-match";
+                            }>;
+                        }, z.core.$strip>>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        outcome: z.ZodLiteral<"not-considered">;
+                        reason: z.ZodEnum<{
+                            "trigger-paused": "trigger-paused";
+                            "not-a-deployment-trigger": "not-a-deployment-trigger";
+                        }>;
+                    }, z.core.$strip>], "outcome">;
+                }, z.core.$strip>>;
+                state: z.ZodLiteral<"evaluated">;
+            }, z.core.$strip>, z.ZodObject<{
+                state: z.ZodLiteral<"not-evaluated">;
+            }, z.core.$strip>], "state">;
+        };
         reportStatus: {
             readonly annotations: {
                 readonly destructiveHint: true;
@@ -3879,6 +4470,124 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
     };
+    legacyTrigger: {
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                kind: z.ZodDefault<z.ZodEnum<{
+                    static: "static";
+                    active: "active";
+                    all: "all";
+                }>>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "legacyTrigger.find";
+            readonly output: z.ZodObject<{
+                legacyTriggers: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    nextAt: z.ZodOptional<z.ZodISODateTime>;
+                    repeatMinutes: z.ZodNumber;
+                    startAt: z.ZodOptional<z.ZodISODateTime>;
+                    timezoneId: z.ZodOptional<z.ZodString>;
+                    type: z.ZodLiteral<"scheduled">;
+                    environment: z.ZodObject<{
+                        id: PublicIdSchema;
+                        kind: z.ZodEnum<{
+                            static: "static";
+                            preview: "preview";
+                        }>;
+                        name: z.ZodString;
+                        terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    }, z.core.$strip>;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    tags: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    adaptiveFlowSelection: z.ZodBoolean;
+                    branchScope: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"all-branches">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        caseSensitiveGlobs: z.ZodArray<z.ZodString>;
+                        kind: z.ZodLiteral<"listed-branches">;
+                        negated: z.ZodBoolean;
+                        raw: z.ZodString;
+                    }, z.core.$strip>]>;
+                    codeHostingServiceRepository: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"any">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"none">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        id: z.ZodString;
+                        kind: z.ZodLiteral<"by-id">;
+                    }, z.core.$strip>]>;
+                    deploymentPrLabel: z.ZodOptional<z.ZodString>;
+                    deploymentType: z.ZodOptional<z.ZodString>;
+                    type: z.ZodUnion<readonly [z.ZodLiteral<"generic">, z.ZodLiteral<"pr-testing-button">]>;
+                    environment: z.ZodObject<{
+                        id: PublicIdSchema;
+                        kind: z.ZodEnum<{
+                            static: "static";
+                            preview: "preview";
+                        }>;
+                        name: z.ZodString;
+                        terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    }, z.core.$strip>;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    tags: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>;
+        };
+        pause: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                legacyTriggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "legacyTrigger.pause";
+            readonly output: z.ZodObject<{
+                isPaused: z.ZodBoolean;
+                legacyTriggerId: PublicIdSchema;
+            }, z.core.$strip>;
+        };
+        resume: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                legacyTriggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "legacyTrigger.resume";
+            readonly output: z.ZodObject<{
+                isPaused: z.ZodBoolean;
+                legacyTriggerId: PublicIdSchema;
+            }, z.core.$strip>;
+        };
+    };
     run: {
         create: {
             readonly annotations: {
@@ -4664,6 +5373,124 @@ export declare const publicContractsV1: {
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "failureReason">], "outcome">;
         };
+        performActions: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Perform a sequence of raw browser actions on an interactive runner in one request, one after another, and answer with what happened to each. A `success` means every action took effect. A `failure` names the first action that did not (`failedIndex`, `failureReason`), the last one that did (`lastCompletedIndex`), and whether actions were left unperformed (`stoppedEarly`); `results` has one entry per action reached, in order. Read `effect` on an entry before sending its action again: `performed` means the runner did it; `not-performed` means the runner answered that it did not take effect, though a `navigate` that timed out may still be loading; `unknown` means the runner stopped answering with the action in flight (`runner-unreachable`), or its screen went quiet mid-action (`action-unconfirmed`), and it may have taken effect — a click that submitted a form, say — so take a screenshot instead of repeating it. A sequence gets about a minute to start its actions; an action it did not reach in time is `out-of-time`, nothing after it was attempted, and the rest can go in a new request. Everything `runner.performAction` says about a runner that has never run anything, a mobile runner, and the `screen-needs-a-run`, `screen-not-ready`, `runner-has-no-screen` and `action-not-supported-on-mobile` reasons holds for each action here.";
+            readonly input: z.ZodObject<{
+                actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
+                    type: z.ZodLiteral<"click">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"double_click">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    scroll_x: z.ZodInt;
+                    scroll_y: z.ZodInt;
+                    type: z.ZodLiteral<"scroll">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"move">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    path: z.ZodArray<z.ZodObject<{
+                        x: z.ZodInt;
+                        y: z.ZodInt;
+                    }, z.core.$strict>>;
+                    type: z.ZodLiteral<"drag">;
+                }, z.core.$strict>, z.ZodObject<{
+                    keys: z.ZodArray<z.ZodString>;
+                    type: z.ZodLiteral<"keypress">;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"navigate">;
+                    url: z.ZodURL;
+                }, z.core.$strict>, z.ZodObject<{
+                    text: z.ZodString;
+                    type: z.ZodLiteral<"type">;
+                }, z.core.$strict>], "type">>;
+                id: z.ZodString;
+                screenshotMode: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    final: "final";
+                    each: "each";
+                }>>;
+                stopOnFailure: z.ZodOptional<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.performActions";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                imageJpegBase64: z.ZodOptional<z.ZodString>;
+                lastCompletedIndex: z.ZodInt;
+                outcome: z.ZodLiteral<"success">;
+                results: z.ZodArray<z.ZodObject<{
+                    effect: z.ZodLiteral<"performed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"success">;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                failedIndex: z.ZodInt;
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
+                    "action-failed": "action-failed";
+                    "runner-has-no-screen": "runner-has-no-screen";
+                    "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+                    "out-of-time": "out-of-time";
+                    "action-unconfirmed": "action-unconfirmed";
+                }>;
+                imageJpegBase64: z.ZodOptional<z.ZodString>;
+                lastCompletedIndex: z.ZodOptional<z.ZodInt>;
+                outcome: z.ZodLiteral<"failure">;
+                results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    effect: z.ZodLiteral<"performed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"success">;
+                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    effect: z.ZodLiteral<"not-performed">;
+                    errorMessage: z.ZodString;
+                    failureReason: z.ZodLiteral<"action-failed">;
+                    imageJpegBase64: z.ZodOptional<z.ZodString>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"unknown">;
+                    failureReason: z.ZodLiteral<"runner-unreachable">;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"unknown">;
+                    errorMessage: z.ZodString;
+                    failureReason: z.ZodLiteral<"action-unconfirmed">;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>, z.ZodObject<{
+                    effect: z.ZodLiteral<"not-performed">;
+                    failureReason: z.ZodEnum<{
+                        "screen-needs-a-run": "screen-needs-a-run";
+                        "screen-not-ready": "screen-not-ready";
+                        "runner-has-no-screen": "runner-has-no-screen";
+                        "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+                        "out-of-time": "out-of-time";
+                    }>;
+                    index: z.ZodInt;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>], "failureReason">], "outcome">>;
+                stoppedEarly: z.ZodBoolean;
+            }, z.core.$strip>], "outcome">;
+        };
         promoteSnapshot: {
             readonly annotations: {
                 readonly destructiveHint: true;
@@ -4848,6 +5675,47 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
     };
+    skill: {
+        get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "skill.get";
+            readonly output: z.ZodObject<{
+                description: z.ZodString;
+                name: z.ZodString;
+                instructions: z.ZodString;
+                references: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.";
+            readonly input: z.ZodObject<{}, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "skill.list";
+            readonly output: z.ZodObject<{
+                skills: z.ZodArray<z.ZodObject<{
+                    description: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+    };
     tag: {
         create: {
             readonly annotations: {
@@ -4918,7 +5786,17 @@ export declare const publicContractsV1: {
                 cadence: z.ZodEnum<{
                     hourly: "hourly";
                     daily: "daily";
+                    weekly: "weekly";
                 }>;
+                dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>>;
                 environmentId: PublicIdSchema;
                 minuteOfHour: z.ZodOptional<z.ZodNumber>;
                 timeOfDay: z.ZodOptional<z.ZodString>;
@@ -4963,7 +5841,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5046,7 +5934,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5112,7 +6010,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5178,7 +6086,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5244,7 +6162,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5303,7 +6231,17 @@ export declare const publicContractsV1: {
                 cadence: z.ZodEnum<{
                     hourly: "hourly";
                     daily: "daily";
+                    weekly: "weekly";
                 }>;
+                dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                    monday: "monday";
+                    tuesday: "tuesday";
+                    wednesday: "wednesday";
+                    thursday: "thursday";
+                    friday: "friday";
+                    saturday: "saturday";
+                    sunday: "sunday";
+                }>>;
                 environmentId: PublicIdSchema;
                 minuteOfHour: z.ZodOptional<z.ZodNumber>;
                 timeOfDay: z.ZodOptional<z.ZodString>;
@@ -5348,7 +6286,17 @@ export declare const publicContractsV1: {
                         cadence: z.ZodEnum<{
                             hourly: "hourly";
                             daily: "daily";
+                            weekly: "weekly";
                         }>;
+                        dayOfWeek: z.ZodOptional<z.ZodEnum<{
+                            monday: "monday";
+                            tuesday: "tuesday";
+                            wednesday: "wednesday";
+                            thursday: "thursday";
+                            friday: "friday";
+                            saturday: "saturday";
+                            sunday: "sunday";
+                        }>>;
                         environmentId: PublicIdSchema;
                         minuteOfHour: z.ZodOptional<z.ZodNumber>;
                         timeOfDay: z.ZodOptional<z.ZodString>;