@qawolf/api-contracts 0.59.0 → 0.64.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, DeploymentId extends PublicIdSchema = PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, AutomationId, IssueId, WorkspaceId, AiTaskId, ChatSessionId, TriggerId, DeploymentId>) => {
+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: {
@@ -62,6 +62,8 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 environmentId: z.ZodOptional<PublicIdSchema>;
                 filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
+                parentSessionId: z.ZodOptional<ChatSessionId>;
+                runnerId: z.ZodOptional<z.ZodString>;
                 sessionId: z.ZodOptional<ChatSessionId>;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
@@ -80,27 +82,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: {
@@ -295,7 +276,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 readonly openWorldHint: true;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs. This route requires an organization or user API key.";
+            readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs.";
             readonly input: z.ZodObject<{
                 deployTarget: z.ZodOptional<z.ZodURL>;
                 environment: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
@@ -1328,6 +1309,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: {
@@ -1612,178 +1711,454 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 url: z.ZodURL;
             }, z.core.$strip>;
         };
+        triage: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                flowId: FlowId;
+                runId: RunId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.triage";
+            readonly output: z.ZodObject<{
+                answers: z.ZodObject<{
+                    verdict: z.ZodObject<{
+                        choice: z.ZodEnum<{
+                            bug: "bug";
+                            maintenance: "maintenance";
+                        }>;
+                        confidence: z.ZodNumber;
+                        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                        type: z.ZodLiteral<"choice">;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                decision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    diagnosis: z.ZodEnum<{
+                        bug: "bug";
+                        maintenance: "maintenance";
+                    }>;
+                    type: z.ZodLiteral<"diagnose">;
+                }, z.core.$strip>, z.ZodObject<{
+                    diagnosis: z.ZodEnum<{
+                        bug: "bug";
+                        maintenance: "maintenance";
+                    }>;
+                    type: z.ZodLiteral<"suggest">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"needsHuman">;
+                }, z.core.$strip>], "type">;
+                model: z.ZodString;
+                state: z.ZodJSONSchema;
+            }, z.core.$strip>;
+        };
     };
     runner: {
-        evaluateSnippet: {
+        runFlow: {
             readonly annotations: {
                 readonly destructiveHint: true;
                 readonly openWorldHint: true;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Evaluate a snippet against whatever the runner's browser is showing right now. Answers whether the snippet ran, and its error if it threw — not the value it evaluated to, so read anything you want back out of the runner's journal (a snippet's `console.log` lands in the `console` stream). A snippet starts no run and leaves no run-scoped journal entries of its own. `runner-cannot-evaluate-snippets` on a runner with nothing attached to serve one — which will never clear, so check that the runner you launched is one that runs a browser or app before retrying. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Neither is proof the snippet did not run: a snippet that outlives the answer window is still executing when you read this, so do not blindly resubmit one that mutates what the page is looking at.";
+            readonly description: "Run a flow on an interactive runner. When `selection` is given the lines run against the browser as it stands, so nothing is re-navigated and nothing is signed in again; without it the whole entry point runs from a fresh browser. A runner with no live browser starts one before a selection and says so with `bootstrappedRunner`, which means those lines ran against a fresh page rather than the one an earlier run left. A selection produces no `runStarted` event, so follow it by its run id on `run-status` like any other run. Send `unchangedFiles` to ship only what changed since an earlier run on this runner; a `needs-full-sync` failure names the paths it does not hold, and the way to recover is the same run again with every file in `files`. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call fails with `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.";
             readonly input: z.ZodObject<{
-                code: z.ZodString;
-                filePath: z.ZodOptional<z.ZodString>;
-                files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                entryPointPath: z.ZodString;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                environmentId: z.ZodOptional<PublicIdSchema>;
+                files: z.ZodRecord<z.ZodString, z.ZodString>;
                 id: z.ZodString;
+                selection: z.ZodOptional<z.ZodObject<{
+                    endLine: z.ZodInt;
+                    path: z.ZodString;
+                    startLine: z.ZodInt;
+                }, z.core.$strip>>;
+                unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
-            readonly name: "runner.evaluateSnippet";
+            readonly name: "runner.runFlow";
             readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                errorMessage: z.ZodOptional<z.ZodString>;
+                bootstrappedRunner: z.ZodOptional<z.ZodBoolean>;
                 outcome: z.ZodLiteral<"success">;
-                result: z.ZodEnum<{
-                    success: "success";
-                    error: "error";
-                    stopped: "stopped";
+                runId: z.ZodString;
+            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                failureReason: z.ZodLiteral<"runner-target-mismatch">;
+                outcome: z.ZodLiteral<"failure">;
+                requiredRunnerName: z.ZodEnum<{
+                    basic: "basic";
+                    playwright: "playwright";
+                    android: "android";
+                    ios: "ios";
                 }>;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodEnum<{
-                    "runner-cannot-evaluate-snippets": "runner-cannot-evaluate-snippets";
-                    "runner-unreachable": "runner-unreachable";
+                runnerName: z.ZodEnum<{
+                    basic: "basic";
+                    playwright: "playwright";
+                    android: "android";
+                    ios: "ios";
                 }>;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodLiteral<"needs-full-sync">;
+                missingPaths: z.ZodArray<z.ZodString>;
                 outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
-        };
-        get: {
-            readonly annotations: {
-                readonly destructiveHint: false;
-                readonly openWorldHint: false;
-                readonly readOnlyHint: true;
-            };
-            readonly description: "Report whether a runner is running under this id on the caller's team. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. An id that is not running is a success with `running: false` rather than an error, so this is how to check a runner is still there before addressing it. A running runner also reports the `url` to watch it on, so an id alone is enough to recover the link to give the user.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<WorkspaceId>;
-            }, z.core.$strip>;
-            readonly kind: "read";
-            readonly name: "runner.get";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                id: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-                running: z.ZodLiteral<false>;
             }, z.core.$strip>, z.ZodObject<{
-                id: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-                running: z.ZodLiteral<true>;
-                url: z.ZodURL;
-            }, z.core.$strip>], "running">;
+                failureReason: z.ZodLiteral<"runner-unreachable">;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "failureReason">], "outcome">;
         };
-        highlightSelector: {
+        stopRun: {
             readonly annotations: {
-                readonly destructiveHint: false;
+                readonly destructiveHint: true;
                 readonly openWorldHint: false;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Highlight the elements a selector matches on an interactive runner's live page, and answer how many it matched. The highlight stays until it is replaced or cleared, so it is visible in the next `runner.takeScreenshot` — which is the point, since a caller cannot see the runner's screen otherwise. Send an empty selector to clear, which answers `cleared`. `status` tells a selector that matched nothing (`empty`) from one the page could not parse (`invalid`), so a caller can tell a bad locator from a locator pointing at nothing. `no-answer` if the page did not answer in time: the highlight runs inside the page, so a page that is gone or mid-navigation does not answer slowly, it does not answer at all. `runner-cannot-highlight-selectors` on a runner with no browser to draw on. `runner-unreachable` if the runner could not be reached: it may still be starting, or it may have terminated after inactivity.";
+            readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
-                selector: z.ZodString;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
-            readonly name: "runner.highlightSelector";
+            readonly name: "runner.stopRun";
             readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                matchCount: z.ZodNumber;
                 outcome: z.ZodLiteral<"success">;
-                selector: z.ZodString;
-                status: z.ZodLiteral<"valid" | "invalid" | "empty">;
-                targetPage: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>, z.ZodObject<{
-                outcome: z.ZodLiteral<"cleared">;
+                wasRunning: z.ZodBoolean;
             }, z.core.$strip>, z.ZodObject<{
-                errorMessage: z.ZodOptional<z.ZodString>;
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "no-answer": "no-answer";
-                    "runner-cannot-highlight-selectors": "runner-cannot-highlight-selectors";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
-        importPackage: {
+        takeScreenshot: {
             readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: true;
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Install a package into an interactive runner's live run and import it, so a snippet or a selection can use it without a full run to reinstall dependencies. An `install-failed` failure carries npm's reason in `errorMessage`. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The install may still have landed, but installing the same version again does nothing, so retrying is safe.";
+            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all; this refreshes the inactivity timer and can extend the runner's billed lifetime. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
-                npmDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
-                packageName: z.ZodString;
-                packageVersion: z.ZodString;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.importPackage";
+            readonly kind: "read";
+            readonly name: "runner.takeScreenshot";
             readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                imageJpegBase64: z.ZodString;
                 outcome: z.ZodLiteral<"success">;
             }, z.core.$strip>, z.ZodObject<{
-                errorMessage: z.ZodOptional<z.ZodString>;
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "install-failed": "install-failed";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
-        inspect: {
+        terminate: {
             readonly annotations: {
-                readonly destructiveHint: false;
+                readonly destructiveHint: true;
                 readonly openWorldHint: false;
                 readonly readOnlyHint: false;
             };
-            readonly description: string;
+            readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
-                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    selector: z.ZodString;
-                    what: z.ZodLiteral<"element-html">;
-                }, z.core.$strip>, z.ZodObject<{
-                    selector: z.ZodOptional<z.ZodString>;
-                    what: z.ZodLiteral<"page-html">;
-                }, z.core.$strip>, z.ZodObject<{
-                    variableName: z.ZodString;
-                    what: z.ZodLiteral<"variable">;
-                }, z.core.$strip>], "what">;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
-            readonly kind: "read";
-            readonly name: "runner.inspect";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            readonly kind: "write";
+            readonly name: "runner.terminate";
+            readonly output: z.ZodObject<{
+                id: z.ZodString;
                 outcome: z.ZodLiteral<"success">;
-                value: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
-                errorMessage: z.ZodOptional<z.ZodString>;
-                failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
-                    "nothing-to-inspect": "nothing-to-inspect";
-                    "runner-is-not-a-browser": "runner-is-not-a-browser";
-                }>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
+                wasRunning: z.ZodBoolean;
+            }, z.core.$strip>;
         };
-        inspectMobile: {
+        record: {
             readonly annotations: {
                 readonly destructiveHint: false;
                 readonly openWorldHint: false;
-                readonly readOnlyHint: true;
+                readonly readOnlyHint: false;
             };
-            readonly description: "Inspect one thing on a mobile interactive runner: the Appium session's status, the WebView contexts available, the current context's page source, or the elements at a point, carrying some text, or matching a selector. This does not refresh the runner's inactivity timer. Mobile only — a browser runner answers `runner-is-not-mobile`; call `runner.inspect` for a browser's equivalent surface instead. `what: \"session\"` always answers with the session's own status rather than `screen-needs-a-run`, since that is the question it exists to answer; the other three request kinds need a live session first and answer the same `screen-needs-a-run` or `screen-not-ready` outcomes `runner.performAction` and `runner.takeScreenshot` use, instead of reading anything when there is none. `screen-needs-a-run` means no Appium session has started on this runner yet — call `runner.runFlow` with a flow that opens one, then inspect again. `screen-not-ready` means the runner's Appium session exists but did not answer this instant, or more than one is somehow live — retry once; if it persists, relaunch the runner. `runner-is-not-mobile` means there is nothing here to inspect, and retrying will never help — launch an `android` or `ios` runner instead. `invalid-selector` (elements by selector only) means the selector itself could not be parsed under the given `strategy` — distinct from a selector that parsed fine but matched nothing, which answers `matches: []` instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly description: "Control video recording on a Playwright runner. Start requires a caller-generated UUID; stop targets that UUID so retries cannot stop a later recording. Manual capture spans runs and suppresses automatic capture. Auto settings affect subsequent full runs. The URL opens recording history after the runner terminates. Videos may be unavailable after abrupt pod loss.";
             readonly input: z.ZodObject<{
+                command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    action: z.ZodLiteral<"start">;
+                    recordingId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"stop">;
+                    recordingId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"auto">;
+                    enabled: z.ZodBoolean;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"status">;
+                }, z.core.$strict>], "action">;
                 id: z.ZodString;
-                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    what: z.ZodLiteral<"session">;
-                }, z.core.$strip>, z.ZodObject<{
-                    what: z.ZodLiteral<"contexts">;
-                }, z.core.$strip>, z.ZodObject<{
-                    context: z.ZodOptional<z.ZodString>;
-                    what: z.ZodLiteral<"page">;
-                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    by: z.ZodLiteral<"point">;
-                    context: z.ZodOptional<z.ZodString>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.record";
+            readonly output: z.ZodObject<{
+                result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    outcome: z.ZodLiteral<"success">;
+                    recording: z.ZodOptional<z.ZodObject<{
+                        endedAt: z.ZodISODateTime;
+                        id: z.ZodUUID;
+                        mode: z.ZodEnum<{
+                            manual: "manual";
+                            automatic: "automatic";
+                        }>;
+                        runIds: z.ZodArray<z.ZodString>;
+                        runnerId: z.ZodString;
+                        runnerInstanceId: z.ZodUUID;
+                        startedAt: z.ZodISODateTime;
+                        status: z.ZodEnum<{
+                            failed: "failed";
+                            ready: "ready";
+                        }>;
+                        version: z.ZodLiteral<1>;
+                    }, z.core.$strip>>;
+                    state: z.ZodObject<{
+                        active: z.ZodOptional<z.ZodObject<{
+                            id: z.ZodUUID;
+                            mode: z.ZodEnum<{
+                                manual: "manual";
+                                automatic: "automatic";
+                            }>;
+                            startedAt: z.ZodISODateTime;
+                        }, z.core.$strip>>;
+                        auto: z.ZodEnum<{
+                            default: "default";
+                            on: "on";
+                            off: "off";
+                        }>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    failureReason: z.ZodEnum<{
+                        "runner-unreachable": "runner-unreachable";
+                        "screen-not-ready": "screen-not-ready";
+                        unsupported: "unsupported";
+                        "recording-in-progress": "recording-in-progress";
+                        "recording-not-found": "recording-not-found";
+                        "recording-id-used": "recording-id-used";
+                        "recording-failed": "recording-failed";
+                    }>;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>], "outcome">;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        recordings: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Read a runner's finalized recordings from workspace storage, including after the runner terminates. Omit recordingId to list recordings in storage-key order; follow nextPageToken for more. An empty list for a specific recording means it is not published or does not exist. Video URLs expire; platform URLs remain stable.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                pageToken: z.ZodOptional<z.ZodString>;
+                recordingId: z.ZodOptional<z.ZodUUID>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.recordings";
+            readonly output: z.ZodObject<{
+                nextPageToken: z.ZodOptional<z.ZodString>;
+                recordings: z.ZodArray<z.ZodObject<{
+                    endedAt: z.ZodISODateTime;
+                    id: z.ZodUUID;
+                    mode: z.ZodEnum<{
+                        manual: "manual";
+                        automatic: "automatic";
+                    }>;
+                    runIds: z.ZodArray<z.ZodString>;
+                    runnerId: z.ZodString;
+                    runnerInstanceId: z.ZodUUID;
+                    startedAt: z.ZodISODateTime;
+                    status: z.ZodEnum<{
+                        failed: "failed";
+                        ready: "ready";
+                    }>;
+                    version: z.ZodLiteral<1>;
+                    url: z.ZodURL;
+                    videoUrl: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        evaluateSnippet: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Evaluate a snippet against whatever the runner's browser is showing right now. Answers whether the snippet ran, and its error if it threw — not the value it evaluated to, so read anything you want back out of the runner's journal (a snippet's `console.log` lands in the `console` stream). A snippet starts no run and leaves no run-scoped journal entries of its own. `runner-cannot-evaluate-snippets` on a runner with nothing attached to serve one — which will never clear, so check that the runner you launched is one that runs a browser or app before retrying. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Neither is proof the snippet did not run: a snippet that outlives the answer window is still executing when you read this, so do not blindly resubmit one that mutates what the page is looking at.";
+            readonly input: z.ZodObject<{
+                code: z.ZodString;
+                filePath: z.ZodOptional<z.ZodString>;
+                files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.evaluateSnippet";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                outcome: z.ZodLiteral<"success">;
+                result: z.ZodEnum<{
+                    success: "success";
+                    error: "error";
+                    stopped: "stopped";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodEnum<{
+                    "runner-cannot-evaluate-snippets": "runner-cannot-evaluate-snippets";
+                    "runner-unreachable": "runner-unreachable";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Report whether a runner is running under this id on the caller's team. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. An id that is not running is a success with `running: false` rather than an error, so this is how to check a runner is still there before addressing it. A running runner also reports the `url` to watch it on, so an id alone is enough to recover the link to give the user.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.get";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+                running: z.ZodLiteral<false>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+                running: z.ZodLiteral<true>;
+                url: z.ZodURL;
+            }, z.core.$strip>], "running">;
+        };
+        highlightSelector: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Highlight the elements a selector matches on an interactive runner's live page, and answer how many it matched. The highlight stays until it is replaced or cleared, so it is visible in the next `runner.takeScreenshot` — which is the point, since a caller cannot see the runner's screen otherwise. Send an empty selector to clear, which answers `cleared`. `status` tells a selector that matched nothing (`empty`) from one the page could not parse (`invalid`), so a caller can tell a bad locator from a locator pointing at nothing. `no-answer` if the page did not answer in time: the highlight runs inside the page, so a page that is gone or mid-navigation does not answer slowly, it does not answer at all. `runner-cannot-highlight-selectors` on a runner with no browser to draw on. `runner-unreachable` if the runner could not be reached: it may still be starting, or it may have terminated after inactivity.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                selector: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.highlightSelector";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                matchCount: z.ZodNumber;
+                outcome: z.ZodLiteral<"success">;
+                selector: z.ZodString;
+                status: z.ZodLiteral<"valid" | "invalid" | "empty">;
+                targetPage: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                outcome: z.ZodLiteral<"cleared">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "no-answer": "no-answer";
+                    "runner-cannot-highlight-selectors": "runner-cannot-highlight-selectors";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        importPackage: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Install a package into an interactive runner's live run and import it, so a snippet or a selection can use it without a full run to reinstall dependencies. An `install-failed` failure carries npm's reason in `errorMessage`. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The install may still have landed, but installing the same version again does nothing, so retrying is safe.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                npmDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
+                packageName: z.ZodString;
+                packageVersion: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.importPackage";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "install-failed": "install-failed";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        inspect: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    selector: z.ZodString;
+                    what: z.ZodLiteral<"element-html">;
+                }, z.core.$strip>, z.ZodObject<{
+                    selector: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"page-html">;
+                }, z.core.$strip>, z.ZodObject<{
+                    variableName: z.ZodString;
+                    what: z.ZodLiteral<"variable">;
+                }, z.core.$strip>], "what">;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.inspect";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodOptional<z.ZodString>;
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "nothing-to-inspect": "nothing-to-inspect";
+                    "runner-is-not-a-browser": "runner-is-not-a-browser";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        inspectMobile: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Inspect one thing on a mobile interactive runner: the Appium session's status, the WebView contexts available, the current context's page source, or the elements at a point, carrying some text, or matching a selector. This does not refresh the runner's inactivity timer. Mobile only — a browser runner answers `runner-is-not-mobile`; call `runner.inspect` for a browser's equivalent surface instead. `what: \"session\"` always answers with the session's own status rather than `screen-needs-a-run`, since that is the question it exists to answer; the other three request kinds need a live session first and answer the same `screen-needs-a-run` or `screen-not-ready` outcomes `runner.performAction` and `runner.takeScreenshot` use, instead of reading anything when there is none. `screen-needs-a-run` means no Appium session has started on this runner yet — call `runner.runFlow` with a flow that opens one, then inspect again. `screen-not-ready` means the runner's Appium session exists but did not answer this instant, or more than one is somehow live — retry once; if it persists, relaunch the runner. `runner-is-not-mobile` means there is nothing here to inspect, and retrying will never help — launch an `android` or `ios` runner instead. `invalid-selector` (elements by selector only) means the selector itself could not be parsed under the given `strategy` — distinct from a selector that parsed fine but matched nothing, which answers `matches: []` instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    what: z.ZodLiteral<"session">;
+                }, z.core.$strip>, z.ZodObject<{
+                    what: z.ZodLiteral<"contexts">;
+                }, z.core.$strip>, z.ZodObject<{
+                    context: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"page">;
+                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    by: z.ZodLiteral<"point">;
+                    context: z.ZodOptional<z.ZodString>;
                     what: z.ZodLiteral<"elements">;
                     x: z.ZodInt;
                     y: z.ZodInt;
@@ -2113,6 +2488,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;
@@ -2177,123 +2670,45 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
-        runFlow: {
-            readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: true;
-                readonly readOnlyHint: false;
-            };
-            readonly description: "Run a flow on an interactive runner. When `selection` is given the lines run against the browser as it stands, so nothing is re-navigated and nothing is signed in again; without it the whole entry point runs from a fresh browser. A runner with no live browser starts one before a selection and says so with `bootstrappedRunner`, which means those lines ran against a fresh page rather than the one an earlier run left. A selection produces no `runStarted` event, so follow it by its run id on `run-status` like any other run. Send `unchangedFiles` to ship only what changed since an earlier run on this runner; a `needs-full-sync` failure names the paths it does not hold, and the way to recover is the same run again with every file in `files`. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call fails with `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.";
-            readonly input: z.ZodObject<{
-                entryPointPath: z.ZodString;
-                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                environmentId: z.ZodOptional<PublicIdSchema>;
-                files: z.ZodRecord<z.ZodString, z.ZodString>;
-                id: z.ZodString;
-                selection: z.ZodOptional<z.ZodObject<{
-                    endLine: z.ZodInt;
-                    path: z.ZodString;
-                    startLine: z.ZodInt;
-                }, z.core.$strip>>;
-                unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                workspaceId: z.ZodOptional<WorkspaceId>;
-            }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.runFlow";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                bootstrappedRunner: z.ZodOptional<z.ZodBoolean>;
-                outcome: z.ZodLiteral<"success">;
-                runId: z.ZodString;
-            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-                failureReason: z.ZodLiteral<"runner-target-mismatch">;
-                outcome: z.ZodLiteral<"failure">;
-                requiredRunnerName: z.ZodEnum<{
-                    basic: "basic";
-                    playwright: "playwright";
-                    android: "android";
-                    ios: "ios";
-                }>;
-                runnerName: z.ZodEnum<{
-                    basic: "basic";
-                    playwright: "playwright";
-                    android: "android";
-                    ios: "ios";
-                }>;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodLiteral<"needs-full-sync">;
-                missingPaths: z.ZodArray<z.ZodString>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodLiteral<"runner-unreachable">;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "failureReason">], "outcome">;
-        };
-        stopRun: {
-            readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: false;
-                readonly readOnlyHint: false;
-            };
-            readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<WorkspaceId>;
-            }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.stopRun";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                outcome: z.ZodLiteral<"success">;
-                wasRunning: z.ZodBoolean;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
-                }>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
-        };
-        takeScreenshot: {
+    };
+    skill: {
+        get: {
             readonly annotations: {
                 readonly destructiveHint: false;
                 readonly openWorldHint: false;
-                readonly readOnlyHint: false;
+                readonly readOnlyHint: true;
             };
-            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all; this refreshes the inactivity timer and can extend the runner's billed lifetime. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            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<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<WorkspaceId>;
+                name: z.ZodString;
             }, z.core.$strip>;
             readonly kind: "read";
-            readonly name: "runner.takeScreenshot";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                imageJpegBase64: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
-                    "screen-needs-a-run": "screen-needs-a-run";
-                    "screen-not-ready": "screen-not-ready";
-                    "runner-has-no-screen": "runner-has-no-screen";
-                }>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
+            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>;
         };
-        terminate: {
+        list: {
             readonly annotations: {
-                readonly destructiveHint: true;
+                readonly destructiveHint: false;
                 readonly openWorldHint: false;
-                readonly readOnlyHint: false;
+                readonly readOnlyHint: true;
             };
-            readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<WorkspaceId>;
-            }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.terminate";
+            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<{
-                id: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-                wasRunning: z.ZodBoolean;
+                skills: z.ZodArray<z.ZodObject<{
+                    description: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
             }, z.core.$strip>;
         };
     };
@@ -2367,7 +2782,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>;
@@ -2412,7 +2837,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>;
@@ -2495,7 +2930,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>;
@@ -2561,7 +3006,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>;
@@ -2627,7 +3082,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>;
@@ -2693,7 +3158,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>;
@@ -2752,7 +3227,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>;
@@ -2797,7 +3282,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>;
@@ -2887,6 +3382,8 @@ export declare const publicContractsV1: {
                 environmentId: z.ZodOptional<PublicIdSchema>;
                 filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
+                parentSessionId: z.ZodOptional<PublicIdSchema>;
+                runnerId: z.ZodOptional<z.ZodString>;
                 sessionId: z.ZodOptional<PublicIdSchema>;
                 workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
@@ -2905,27 +3402,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: {
@@ -3120,7 +3596,7 @@ export declare const publicContractsV1: {
                 readonly openWorldHint: true;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs. This route requires an organization or user API key.";
+            readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs.";
             readonly input: z.ZodObject<{
                 deployTarget: z.ZodOptional<z.ZodURL>;
                 environment: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
@@ -4153,6 +4629,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: {
@@ -4399,46 +4993,322 @@ export declare const publicContractsV1: {
         reattempt: {
             readonly annotations: {
                 readonly destructiveHint: true;
-                readonly openWorldHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                flowIds: z.ZodOptional<z.ZodArray<PublicIdSchema>>;
+                runId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "run.reattempt";
+            readonly output: z.ZodObject<{
+                reattemptedFlowIds: z.ZodArray<PublicIdSchema>;
+                runId: PublicIdSchema;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        stop: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Stop a run, including its queued flows and automatic retries. Stopping is asynchronous and can update run-status messages and commit statuses in connected integrations. Repeated requests are safe, and finished runs keep their results. A run that is still being created returns not found; retry once run.get returns the run. If run.get returns a different runId, use that ID. Poll run.get for results.";
+            readonly input: z.ZodObject<{
+                runId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "run.stop";
+            readonly output: z.ZodObject<{
+                runId: PublicIdSchema;
+                status: z.ZodEnum<{
+                    accepted: "accepted";
+                    "already-finished": "already-finished";
+                    "execution-not-found": "execution-not-found";
+                }>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        triage: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                flowId: PublicIdSchema;
+                runId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.triage";
+            readonly output: z.ZodObject<{
+                answers: z.ZodObject<{
+                    verdict: z.ZodObject<{
+                        choice: z.ZodEnum<{
+                            bug: "bug";
+                            maintenance: "maintenance";
+                        }>;
+                        confidence: z.ZodNumber;
+                        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                        type: z.ZodLiteral<"choice">;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                decision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    diagnosis: z.ZodEnum<{
+                        bug: "bug";
+                        maintenance: "maintenance";
+                    }>;
+                    type: z.ZodLiteral<"diagnose">;
+                }, z.core.$strip>, z.ZodObject<{
+                    diagnosis: z.ZodEnum<{
+                        bug: "bug";
+                        maintenance: "maintenance";
+                    }>;
+                    type: z.ZodLiteral<"suggest">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"needsHuman">;
+                }, z.core.$strip>], "type">;
+                model: z.ZodString;
+                state: z.ZodJSONSchema;
+            }, z.core.$strip>;
+        };
+    };
+    runner: {
+        runFlow: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Run a flow on an interactive runner. When `selection` is given the lines run against the browser as it stands, so nothing is re-navigated and nothing is signed in again; without it the whole entry point runs from a fresh browser. A runner with no live browser starts one before a selection and says so with `bootstrappedRunner`, which means those lines ran against a fresh page rather than the one an earlier run left. A selection produces no `runStarted` event, so follow it by its run id on `run-status` like any other run. Send `unchangedFiles` to ship only what changed since an earlier run on this runner; a `needs-full-sync` failure names the paths it does not hold, and the way to recover is the same run again with every file in `files`. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call fails with `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.";
+            readonly input: z.ZodObject<{
+                entryPointPath: z.ZodString;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                environmentId: z.ZodOptional<PublicIdSchema>;
+                files: z.ZodRecord<z.ZodString, z.ZodString>;
+                id: z.ZodString;
+                selection: z.ZodOptional<z.ZodObject<{
+                    endLine: z.ZodInt;
+                    path: z.ZodString;
+                    startLine: z.ZodInt;
+                }, z.core.$strip>>;
+                unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.runFlow";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                bootstrappedRunner: z.ZodOptional<z.ZodBoolean>;
+                outcome: z.ZodLiteral<"success">;
+                runId: z.ZodString;
+            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                failureReason: z.ZodLiteral<"runner-target-mismatch">;
+                outcome: z.ZodLiteral<"failure">;
+                requiredRunnerName: z.ZodEnum<{
+                    basic: "basic";
+                    playwright: "playwright";
+                    android: "android";
+                    ios: "ios";
+                }>;
+                runnerName: z.ZodEnum<{
+                    basic: "basic";
+                    playwright: "playwright";
+                    android: "android";
+                    ios: "ios";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodLiteral<"needs-full-sync">;
+                missingPaths: z.ZodArray<z.ZodString>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodLiteral<"runner-unreachable">;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "failureReason">], "outcome">;
+        };
+        stopRun: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "runner.stopRun";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                wasRunning: z.ZodBoolean;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        takeScreenshot: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all; this refreshes the inactivity timer and can extend the runner's billed lifetime. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.takeScreenshot";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                imageJpegBase64: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+            }, z.core.$strip>, z.ZodObject<{
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        terminate: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
                 readonly readOnlyHint: false;
             };
-            readonly description: string;
+            readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
             readonly input: z.ZodObject<{
-                flowIds: z.ZodOptional<z.ZodArray<PublicIdSchema>>;
-                runId: PublicIdSchema;
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
-            readonly name: "run.reattempt";
+            readonly name: "runner.terminate";
             readonly output: z.ZodObject<{
-                reattemptedFlowIds: z.ZodArray<PublicIdSchema>;
-                runId: PublicIdSchema;
-                url: z.ZodURL;
+                id: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+                wasRunning: z.ZodBoolean;
             }, z.core.$strip>;
         };
-        stop: {
+        record: {
             readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: true;
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
                 readonly readOnlyHint: false;
             };
-            readonly description: "Stop a run, including its queued flows and automatic retries. Stopping is asynchronous and can update run-status messages and commit statuses in connected integrations. Repeated requests are safe, and finished runs keep their results. A run that is still being created returns not found; retry once run.get returns the run. If run.get returns a different runId, use that ID. Poll run.get for results.";
+            readonly description: "Control video recording on a Playwright runner. Start requires a caller-generated UUID; stop targets that UUID so retries cannot stop a later recording. Manual capture spans runs and suppresses automatic capture. Auto settings affect subsequent full runs. The URL opens recording history after the runner terminates. Videos may be unavailable after abrupt pod loss.";
             readonly input: z.ZodObject<{
-                runId: PublicIdSchema;
+                command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    action: z.ZodLiteral<"start">;
+                    recordingId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"stop">;
+                    recordingId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"auto">;
+                    enabled: z.ZodBoolean;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"status">;
+                }, z.core.$strict>], "action">;
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
-            readonly name: "run.stop";
+            readonly name: "runner.record";
             readonly output: z.ZodObject<{
-                runId: PublicIdSchema;
-                status: z.ZodEnum<{
-                    accepted: "accepted";
-                    "already-finished": "already-finished";
-                    "execution-not-found": "execution-not-found";
-                }>;
+                result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    outcome: z.ZodLiteral<"success">;
+                    recording: z.ZodOptional<z.ZodObject<{
+                        endedAt: z.ZodISODateTime;
+                        id: z.ZodUUID;
+                        mode: z.ZodEnum<{
+                            manual: "manual";
+                            automatic: "automatic";
+                        }>;
+                        runIds: z.ZodArray<z.ZodString>;
+                        runnerId: z.ZodString;
+                        runnerInstanceId: z.ZodUUID;
+                        startedAt: z.ZodISODateTime;
+                        status: z.ZodEnum<{
+                            failed: "failed";
+                            ready: "ready";
+                        }>;
+                        version: z.ZodLiteral<1>;
+                    }, z.core.$strip>>;
+                    state: z.ZodObject<{
+                        active: z.ZodOptional<z.ZodObject<{
+                            id: z.ZodUUID;
+                            mode: z.ZodEnum<{
+                                manual: "manual";
+                                automatic: "automatic";
+                            }>;
+                            startedAt: z.ZodISODateTime;
+                        }, z.core.$strip>>;
+                        auto: z.ZodEnum<{
+                            default: "default";
+                            on: "on";
+                            off: "off";
+                        }>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    failureReason: z.ZodEnum<{
+                        "runner-unreachable": "runner-unreachable";
+                        "screen-not-ready": "screen-not-ready";
+                        unsupported: "unsupported";
+                        "recording-in-progress": "recording-in-progress";
+                        "recording-not-found": "recording-not-found";
+                        "recording-id-used": "recording-id-used";
+                        "recording-failed": "recording-failed";
+                    }>;
+                    outcome: z.ZodLiteral<"failure">;
+                }, z.core.$strip>], "outcome">;
                 url: z.ZodURL;
             }, z.core.$strip>;
         };
-    };
-    runner: {
+        recordings: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Read a runner's finalized recordings from workspace storage, including after the runner terminates. Omit recordingId to list recordings in storage-key order; follow nextPageToken for more. An empty list for a specific recording means it is not published or does not exist. Video URLs expire; platform URLs remain stable.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                pageToken: z.ZodOptional<z.ZodString>;
+                recordingId: z.ZodOptional<z.ZodUUID>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.recordings";
+            readonly output: z.ZodObject<{
+                nextPageToken: z.ZodOptional<z.ZodString>;
+                recordings: z.ZodArray<z.ZodObject<{
+                    endedAt: z.ZodISODateTime;
+                    id: z.ZodUUID;
+                    mode: z.ZodEnum<{
+                        manual: "manual";
+                        automatic: "automatic";
+                    }>;
+                    runIds: z.ZodArray<z.ZodString>;
+                    runnerId: z.ZodString;
+                    runnerInstanceId: z.ZodUUID;
+                    startedAt: z.ZodISODateTime;
+                    status: z.ZodEnum<{
+                        failed: "failed";
+                        ready: "ready";
+                    }>;
+                    version: z.ZodLiteral<1>;
+                    url: z.ZodURL;
+                    videoUrl: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
         evaluateSnippet: {
             readonly annotations: {
                 readonly destructiveHint: true;
@@ -4938,6 +5808,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;
@@ -5002,123 +5990,45 @@ export declare const publicContractsV1: {
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
-        runFlow: {
+    };
+    skill: {
+        get: {
             readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: true;
-                readonly readOnlyHint: false;
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
             };
-            readonly description: "Run a flow on an interactive runner. When `selection` is given the lines run against the browser as it stands, so nothing is re-navigated and nothing is signed in again; without it the whole entry point runs from a fresh browser. A runner with no live browser starts one before a selection and says so with `bootstrappedRunner`, which means those lines ran against a fresh page rather than the one an earlier run left. A selection produces no `runStarted` event, so follow it by its run id on `run-status` like any other run. Send `unchangedFiles` to ship only what changed since an earlier run on this runner; a `needs-full-sync` failure names the paths it does not hold, and the way to recover is the same run again with every file in `files`. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call fails with `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.";
+            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<{
-                entryPointPath: z.ZodString;
-                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                environmentId: z.ZodOptional<PublicIdSchema>;
-                files: z.ZodRecord<z.ZodString, z.ZodString>;
-                id: z.ZodString;
-                selection: z.ZodOptional<z.ZodObject<{
-                    endLine: z.ZodInt;
+                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;
-                    startLine: z.ZodInt;
+                    text: z.ZodString;
                 }, z.core.$strip>>;
-                unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                workspaceId: z.ZodOptional<PublicIdSchema>;
-            }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.runFlow";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                bootstrappedRunner: z.ZodOptional<z.ZodBoolean>;
-                outcome: z.ZodLiteral<"success">;
-                runId: z.ZodString;
-            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-                failureReason: z.ZodLiteral<"runner-target-mismatch">;
-                outcome: z.ZodLiteral<"failure">;
-                requiredRunnerName: z.ZodEnum<{
-                    basic: "basic";
-                    playwright: "playwright";
-                    android: "android";
-                    ios: "ios";
-                }>;
-                runnerName: z.ZodEnum<{
-                    basic: "basic";
-                    playwright: "playwright";
-                    android: "android";
-                    ios: "ios";
-                }>;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodLiteral<"needs-full-sync">;
-                missingPaths: z.ZodArray<z.ZodString>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodLiteral<"runner-unreachable">;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "failureReason">], "outcome">;
-        };
-        stopRun: {
-            readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: false;
-                readonly readOnlyHint: false;
-            };
-            readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.stopRun";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                outcome: z.ZodLiteral<"success">;
-                wasRunning: z.ZodBoolean;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
-                }>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
         };
-        takeScreenshot: {
+        list: {
             readonly annotations: {
                 readonly destructiveHint: false;
                 readonly openWorldHint: false;
-                readonly readOnlyHint: false;
+                readonly readOnlyHint: true;
             };
-            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all; this refreshes the inactivity timer and can extend the runner's billed lifetime. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<PublicIdSchema>;
-            }, z.core.$strip>;
+            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: "runner.takeScreenshot";
-            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                imageJpegBase64: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-            }, z.core.$strip>, z.ZodObject<{
-                failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
-                    "screen-needs-a-run": "screen-needs-a-run";
-                    "screen-not-ready": "screen-not-ready";
-                    "runner-has-no-screen": "runner-has-no-screen";
-                }>;
-                outcome: z.ZodLiteral<"failure">;
-            }, z.core.$strip>], "outcome">;
-        };
-        terminate: {
-            readonly annotations: {
-                readonly destructiveHint: true;
-                readonly openWorldHint: false;
-                readonly readOnlyHint: false;
-            };
-            readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
-            readonly input: z.ZodObject<{
-                id: z.ZodString;
-                workspaceId: z.ZodOptional<PublicIdSchema>;
-            }, z.core.$strip>;
-            readonly kind: "write";
-            readonly name: "runner.terminate";
+            readonly name: "skill.list";
             readonly output: z.ZodObject<{
-                id: z.ZodString;
-                outcome: z.ZodLiteral<"success">;
-                wasRunning: z.ZodBoolean;
+                skills: z.ZodArray<z.ZodObject<{
+                    description: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
             }, z.core.$strip>;
         };
     };
@@ -5192,7 +6102,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>;
@@ -5237,7 +6157,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>;
@@ -5320,7 +6250,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>;
@@ -5386,7 +6326,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>;
@@ -5452,7 +6402,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>;
@@ -5518,7 +6478,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>;
@@ -5577,7 +6547,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>;
@@ -5622,7 +6602,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>;