@qawolf/api-contracts 0.52.0 → 0.54.0

package/dist/v1/index.d.ts

@@ -1,13 +1,5 @@
 import type { z } from "zod";
-export { type AgentSessionStatus, agentSessionStatusSchema, } from "./agent/status.js";
-export { type AuthConfigResponse, authConfigResponse } from "./auth/config.js";
-export type { AnyPublicApiContract, PublicApiContract, PublicApiContractKind, } from "./definition.js";
-export { type EmailDirection, emailDirectionSchema } from "./email/resource.js";
-export { type IdentityResponse, identityResponse } from "./identity/index.js";
-export { type IdentityOrganizationsResponse, identityOrganizationsResponse, } from "./identity/organizations.js";
-export { type PublicIdSchema, type PublicIdSchemas, defaultIdSchemas, } from "./ids.js";
-export { makeFlowSelectionSchema } from "./run/index.js";
-export * from "./runnerReexports.js";
+export * from "./sharedSchemas.js";
 import type { AnyPublicApiContract } from "./definition.js";
 import { type PublicIdSchema, type PublicIdSchemasOf } from "./ids.js";
 export type PublicApiInput<Api extends AnyPublicApiContract> = z.input<Api["input"]>;
@@ -19,16 +11,23 @@ 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>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, AutomationId, IssueId, WorkspaceId, AiTaskId, ChatSessionId>) => {
+export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, FlowId extends PublicIdSchema, RunId extends PublicIdSchema, AutomationId extends PublicIdSchema = PublicIdSchema, IssueId extends PublicIdSchema = PublicIdSchema, WorkspaceId extends PublicIdSchema = PublicIdSchema, AiTaskId extends PublicIdSchema = PublicIdSchema, ChatSessionId extends PublicIdSchema = PublicIdSchema, TriggerId extends PublicIdSchema = PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, AutomationId, IssueId, WorkspaceId, AiTaskId, ChatSessionId, TriggerId>) => {
     agent: {
         get: {
-            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Replies accumulate, so compare them with what you have already seen. Continue monitoring silently when the status and replies are unchanged; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
             readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
                 sessionId: ChatSessionId;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "agent.get";
             readonly output: z.ZodObject<{
+                nextCursor: z.ZodString;
                 replies: z.ZodArray<z.ZodObject<{
                     askedAt: z.ZodISODateTime;
                     choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -46,9 +45,15 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         send: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Start or continue work with the QA Wolf AI and return a live session URL to share with the user. Use it to cover a user journey, investigate a failing run, or fix a broken flow. This is the one verb that starts work from nothing: every other write acts on a flow, run or issue that already exists. Returns sessionId, status, and url as soon as the request is accepted; work can take minutes to tens of minutes. After each send, make the next action a normal user-visible assistant message containing the exact returned url, before any tool call or wait. Tool output and internal reasoning do not count as sharing the link. Do not run a timer or monitoring call alongside this send. Acceptance does not mean the work is complete. Then monitor the session with agent.get, reporting new progress, blockers, and the final outcome rather than unchanged status. Send here again to answer a question or add context to the same session.";
             readonly input: z.ZodObject<{
                 environmentId: z.ZodOptional<PublicIdSchema>;
+                filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
                 sessionId: z.ZodOptional<ChatSessionId>;
                 workspaceId: z.ZodOptional<WorkspaceId>;
@@ -69,12 +74,18 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
         };
     };
     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";
@@ -83,8 +94,64 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             url: z.ZodURL;
         }, z.core.$strip>;
     };
+    deployment: {
+        reportStatus: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                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 input: z.ZodObject<{
+                deployTarget: z.ZodOptional<z.ZodURL>;
+                environment: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    id: EnvironmentId;
+                }, z.core.$strict>, z.ZodObject<{
+                    baseEphemeralEnvironment: z.ZodOptional<z.ZodString>;
+                    ephemeral: z.ZodOptional<z.ZodBoolean>;
+                    name: z.ZodString;
+                }, z.core.$strict>]>>;
+                environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                metadata: z.ZodOptional<z.ZodObject<{
+                    commitAuthorName: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+                    ref: z.ZodOptional<z.ZodString>;
+                    repository: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                providerDeploymentId: z.ZodString;
+                status: z.ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>;
+                workspaceId: WorkspaceId;
+            }, z.core.$strict>;
+            readonly kind: "write";
+            readonly name: "deployment.reportStatus";
+            readonly output: z.ZodObject<{
+                deployment: z.ZodObject<{
+                    id: PublicIdSchema;
+                    status: z.ZodEnum<{
+                        success: "success";
+                        pending: "pending";
+                        failure: "failure";
+                        inactive: "inactive";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
     email: {
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the workspace's inbox, or its sent mail, newest first. Read a message body with email.get.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -122,6 +189,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read one email of the workspace, with its plain text and HTML bodies. Use it to pull a sign-in code or a verification link out of a message.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
@@ -169,6 +241,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         getAttachment: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read one attachment of a workspace email as base64 content, by file name or by position. email.get lists both.";
             readonly input: z.ZodObject<{
                 fileName: z.ZodOptional<z.ZodString>;
@@ -187,6 +264,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         listAddresses: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the workspace's inbox addresses, alphabetical. A flow can sign up with a plus-suffixed form of any of them, and email.find reads what arrives.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -205,6 +287,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         registerAddress: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Register an inbox address for the workspace. Registering an address the workspace already has changes nothing. A refusal names the domains the workspace can use.";
             readonly input: z.ZodObject<{
                 address: z.ZodEmail;
@@ -219,6 +306,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         send: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Send an email from one of the workspace's inbox addresses, for example to exercise a flow that reacts to incoming mail. Returns the sent email; read it back with email.get.";
             readonly input: z.ZodObject<{
                 attachments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBase64>>;
@@ -257,7 +349,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
     };
     environment: {
         create: {
-            readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Create an environment on the caller's team and return it in the environment.get shape. This can also create a branch on the team's connected Git provider.";
             readonly input: z.ZodObject<{
                 name: z.ZodString;
                 workspaceId: z.ZodOptional<WorkspaceId>;
@@ -283,9 +380,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -293,10 +390,16 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         deleteVariable: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Remove one environment variable by name. Succeeds whether or not the variable existed.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.deleteVariable";
@@ -305,6 +408,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's environments, newest first.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -339,9 +447,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     name: z.ZodString;
                     runConcurrencyLimit: z.ZodString;
                     status: z.ZodEnum<{
-                        ready: "ready";
                         blocked: "blocked";
                         "needs-investigation": "needs-investigation";
+                        ready: "ready";
                         running: "running";
                     }>;
                     terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -351,9 +459,15 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read a single environment's name, kind, standing run health, flow-code branch and reconciliation state, run concurrency limit, and termination state. If flowCodeBranch exists, use its syncStatus for Git reconciliation and read lastSyncedCommitHash only when syncStatus is reconciled.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.get";
@@ -376,9 +490,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -386,10 +500,16 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         getVariable: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read the values of named environment variables in one call. Values are secrets. Names that do not exist go to missingNames and do not fail the call.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 variableNames: z.ZodArray<z.ZodString>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.getVariable";
@@ -402,9 +522,15 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         listVariableNames: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Use this to answer which QA Wolf environment variables are available to test code. Returns names only; values never leave the server.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.listVariableNames";
@@ -413,11 +539,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         setVariable: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create or replace an environment variable. If the user asks to create one for \"my email\" without naming it, use DEFAULT_EMAIL. The value is never returned.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodString;
                 value: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.setVariable";
@@ -426,11 +558,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Update an environment owned by the caller's team and return it in the environment.get shape. Omitted fields remain unchanged.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodOptional<z.ZodString>;
                 runConcurrencyLimit: z.ZodOptional<z.ZodString>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.update";
@@ -453,9 +591,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -463,8 +601,54 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
     };
+    file: {
+        requestDownload: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Get a URL for reading a file out of the caller's team storage. Answers 404 when nothing is stored at that path.";
+            readonly input: z.ZodObject<{
+                filePath: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "file.requestDownload";
+            readonly output: z.ZodObject<{
+                expiresAt: z.ZodISODateTime;
+                path: z.ZodString;
+                readUrl: z.ZodString;
+            }, z.core.$strip>;
+        };
+        requestUpload: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Get a URL to put a file into team storage: a spreadsheet of journeys, anything too large to paste. PUT with the returned contentType, then name the path in filePaths.";
+            readonly input: z.ZodObject<{
+                fileName: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "file.requestUpload";
+            readonly output: z.ZodObject<{
+                contentType: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+                path: z.ZodString;
+                uploadUrl: z.ZodString;
+            }, z.core.$strip>;
+        };
+    };
     flow: {
         addTag: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Assign an existing tag to the selected flows. Create tags with tag.create. Flows that already carry the tag are reported in skippedFlows.";
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<FlowId>;
@@ -486,15 +670,31 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the flows of an environment at its latest reconciled commit, or, when an AI task is given, the flows on that task's branch.";
             readonly input: z.ZodObject<{
                 aiTaskId: z.ZodOptional<AiTaskId>;
                 environmentId: PublicIdSchema;
                 includeDrafts: z.ZodDefault<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "flow.list";
             readonly output: z.ZodObject<{
+                emptyReason: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"branch-never-reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"commit-has-no-flow-files">;
+                }, z.core.$strip>, z.ZodObject<{
+                    hiddenDraftCount: z.ZodNumber;
+                    type: z.ZodLiteral<"every-flow-is-a-draft">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-flow-matched-the-listing">;
+                }, z.core.$strip>], "type">>;
                 flows: z.ZodArray<z.ZodObject<{
                     executionTarget: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
                     flowId: FlowId;
@@ -510,6 +710,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         removeTag: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Remove a tag from the selected flows. Succeeds whether or not each flow carried the tag; the flows that did not are reported in skippedFlows.";
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<FlowId>;
@@ -531,6 +736,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Move a flow between draft and active readiness. The other statuses shown in the app are derived and cannot be set.";
             readonly input: z.ZodObject<{
                 flowId: FlowId;
@@ -556,6 +766,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
     };
     issue: {
         addFlows: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<FlowId>;
@@ -603,6 +818,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"bug">;
@@ -672,6 +892,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's bug reports, maintenance reports, or coverage requests, newest first.";
             readonly input: z.ZodObject<{
                 statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
@@ -734,6 +959,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Get an issue by id.";
             readonly input: z.ZodObject<{
                 issueId: IssueId;
@@ -780,6 +1010,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         removeFlows: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<FlowId>;
@@ -827,6 +1062,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Update an issue owned by the caller's team. Omitted fields remain unchanged.";
             readonly input: z.ZodObject<{
                 description: z.ZodOptional<z.ZodString>;
@@ -892,6 +1132,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
     };
     run: {
         create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create a run for the selected flows and/or tags in an environment.";
             readonly input: z.ZodIntersection<z.ZodObject<{
                 aiTaskId: z.ZodOptional<AiTaskId>;
@@ -901,6 +1146,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 ignoreRules: z.ZodDefault<z.ZodBoolean>;
                 pullRequestNumber: z.ZodOptional<z.ZodNumber>;
                 repository: z.ZodOptional<z.ZodString>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>, z.ZodObject<{
                 flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
                 tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -926,6 +1172,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         diagnose: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<FlowId>;
@@ -974,9 +1225,15 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List an environment's recent runs, newest first.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<WorkspaceId>;
                 cursor: z.ZodOptional<z.ZodString>;
                 limit: z.ZodDefault<z.ZodNumber>;
                 createdAfter: z.ZodOptional<z.ZodISODateTime>;
@@ -1007,6 +1264,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Get a run's status, per-flow results, and links.";
             readonly input: z.ZodObject<{
                 runId: RunId;
@@ -1112,6 +1374,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         reattempt: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodOptional<z.ZodArray<FlowId>>;
@@ -1126,7 +1393,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         stop: {
-            readonly description: "Stop a run, including its queued flows and automatic retries. Stopping is asynchronous. 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 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: RunId;
             }, z.core.$strip>;
@@ -1145,6 +1417,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
     };
     runner: {
         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;
@@ -1165,27 +1442,42 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 }>;
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
                     "runner-cannot-evaluate-snippets": "runner-cannot-evaluate-snippets";
+                    "runner-unreachable": "runner-unreachable";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
         get: {
-            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.";
+            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.ZodObject<{
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 id: z.ZodString;
                 outcome: z.ZodLiteral<"success">;
-                running: z.ZodBoolean;
-            }, z.core.$strip>;
+                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;
@@ -1213,6 +1505,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, 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;
@@ -1235,6 +1532,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, 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;
@@ -1266,7 +1568,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "outcome">;
         };
         inspectMobile: {
-            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 or carrying some text. 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. `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 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<{
@@ -1288,6 +1595,16 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     partial: z.ZodOptional<z.ZodBoolean>;
                     text: z.ZodString;
                     what: z.ZodLiteral<"elements">;
+                }, z.core.$strip>, z.ZodObject<{
+                    by: z.ZodLiteral<"selector">;
+                    context: z.ZodOptional<z.ZodString>;
+                    selector: z.ZodString;
+                    strategy: z.ZodDefault<z.ZodEnum<{
+                        "ios-predicate": "ios-predicate";
+                        shadow: "shadow";
+                        xpath: "xpath";
+                    }>>;
+                    what: z.ZodLiteral<"elements">;
                 }, z.core.$strip>], "by">], "what">;
                 workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
@@ -1462,6 +1779,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "what">, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
+                    "invalid-selector": "invalid-selector";
                     "runner-is-not-mobile": "runner-is-not-mobile";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
@@ -1470,7 +1788,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "outcome">;
         };
         launch: {
-            readonly description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `alreadyRunning` to tell which happened.";
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `alreadyRunning` to tell which happened. After a successful launch, make the next action a normal user-visible assistant message containing the exact returned `url`, before the first browser action. Tool output and internal reasoning do not count as sharing the link. When `alreadyRunning` is true the `url` is the same page, so share it again instead of assuming the caller still has it.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
                 runnerName: z.ZodOptional<z.ZodEnum<{
@@ -1492,11 +1815,17 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     android: "android";
                     ios: "ios";
                 }>;
+                url: z.ZodURL;
                 alreadyRunning: z.ZodBoolean;
                 outcome: z.ZodLiteral<"success">;
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the runners running on the caller's team right now. A team API key already names the team and sends nothing; a credential bound to no single workspace names one in `workspaceId`. A runner that was terminated, or that terminated on its own after inactivity, is not listed, because the run system keeps no record of a runner once it is gone. 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. It is how to find a runner launched from another machine or in an earlier session, when the id it was launched under is no longer at hand.";
             readonly input: z.ZodObject<{
                 workspaceId: z.ZodOptional<WorkspaceId>;
@@ -1514,10 +1843,16 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                         android: "android";
                         ios: "ios";
                     }>;
+                    url: z.ZodURL;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         };
         performAction: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `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. A `navigate` does not go through the screen, so a screen that is not ready does not stop 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. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. With `withScreenshot: true`, the answer also carries `imageJpegBase64`: a screenshot taken after the action, once the screen has changed from just before it or half a second has passed, whichever comes first. One call instead of `runner.performAction` followed by `runner.takeScreenshot`, with no fixed wait in between. Anything animating on the page counts as a change. The action itself is performed exactly as without the option; if the screen could serve no frame after it — a display restart, or a `navigate` on a desktop that is still starting — the action's result comes back without `imageJpegBase64`, so take a screenshot separately rather than repeating the action. On a mobile runner the screenshot is the device's own, taken right after a performed action. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
                 action: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1581,6 +1916,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "failureReason">], "outcome">;
         };
         promoteSnapshot: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Accept a run's screenshot as the new baseline for an image diff, on the runner that produced it. The two paths are the ones the diff reported, which reach a caller as an `image-diff-artifact` entry on the runner's `run-events` journal stream. `snapshot-not-found` if the run wrote no screenshot at that path, which usually means the paths were not taken from a diff this run produced; nothing is changed, so correcting the path and repeating is safe. `runner-cannot-promote-snapshots` on a runner that stores no screenshots. `runner-unreachable` if the runner could not be reached: it may still be starting, or it may have terminated after inactivity. A promotion that lands is not undone by promoting again, so a retry after an unreachable answer is safe.";
             readonly input: z.ZodObject<{
                 baselinePath: z.ZodString;
@@ -1602,6 +1942,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "outcome">;
         };
         readJournal: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: `run-status` settles it, `run-logs` and `run-events` carry what it produced, and `recorder` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. `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<{
                 runId: z.ZodOptional<z.ZodString>;
@@ -1618,7 +1963,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     payload: z.ZodUnknown;
                     recordedAt: z.ZodISODateTime;
                     sequence: z.ZodNumber;
-                }, z.core.$strip>, z.ZodTransform<import("./runnerReexports.js").JournalEntry<unknown>, {
+                }, z.core.$strip>, z.ZodTransform<import("./sharedSchemas.js").JournalEntry<unknown>, {
                     payload: unknown;
                     recordedAt: string;
                     sequence: number;
@@ -1635,6 +1980,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, 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;
@@ -1681,6 +2031,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, 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;
@@ -1699,7 +2054,12 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "outcome">;
         };
         takeScreenshot: {
-            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. 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 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<WorkspaceId>;
@@ -1720,6 +2080,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, 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;
@@ -1736,6 +2101,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
     };
     tag: {
         create: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create a tag on the caller's team. Tags select flows in run.create.";
             readonly input: z.ZodObject<{
                 name: z.ZodString;
@@ -1750,6 +2120,11 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's tags, alphabetical by name. Tag names select flows in run.create.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -1771,17 +2146,515 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
     };
+    trigger: {
+        create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"schedule">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                cadence: z.ZodEnum<{
+                    hourly: "hourly";
+                    daily: "daily";
+                }>;
+                environmentId: PublicIdSchema;
+                minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                timeOfDay: z.ZodOptional<z.ZodString>;
+                timezoneId: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"deployment">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                branchPattern: z.ZodOptional<z.ZodString>;
+                deployTargetPattern: z.ZodOptional<z.ZodString>;
+                environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                environmentPattern: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>], "kind">;
+            readonly kind: "write";
+            readonly name: "trigger.create";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        delete: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                triggerId: TriggerId;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.delete";
+            readonly output: z.ZodObject<{
+                triggerId: TriggerId;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the team's triggers, newest first.";
+            readonly input: z.ZodObject<{
+                isPaused: z.ZodOptional<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "trigger.find";
+            readonly output: z.ZodObject<{
+                triggers: z.ZodArray<z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Get one trigger by id.";
+            readonly input: z.ZodObject<{
+                triggerId: TriggerId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "trigger.get";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, 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<{
+                triggerId: TriggerId;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.pause";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        resume: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                triggerId: TriggerId;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.resume";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"schedule">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                cadence: z.ZodEnum<{
+                    hourly: "hourly";
+                    daily: "daily";
+                }>;
+                environmentId: PublicIdSchema;
+                minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                timeOfDay: z.ZodOptional<z.ZodString>;
+                timezoneId: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                triggerId: TriggerId;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"deployment">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                branchPattern: z.ZodOptional<z.ZodString>;
+                deployTargetPattern: z.ZodOptional<z.ZodString>;
+                environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                environmentPattern: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                triggerId: TriggerId;
+            }, z.core.$strip>], "kind">;
+            readonly kind: "write";
+            readonly name: "trigger.update";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: EnvironmentId;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<EnvironmentId>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: TriggerId;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
 };
 export declare const publicContractsV1: {
     agent: {
         get: {
-            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Replies accumulate, so compare them with what you have already seen. Continue monitoring silently when the status and replies are unchanged; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
             readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
                 sessionId: PublicIdSchema;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "agent.get";
             readonly output: z.ZodObject<{
+                nextCursor: z.ZodString;
                 replies: z.ZodArray<z.ZodObject<{
                     askedAt: z.ZodISODateTime;
                     choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1799,9 +2672,15 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         send: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Start or continue work with the QA Wolf AI and return a live session URL to share with the user. Use it to cover a user journey, investigate a failing run, or fix a broken flow. This is the one verb that starts work from nothing: every other write acts on a flow, run or issue that already exists. Returns sessionId, status, and url as soon as the request is accepted; work can take minutes to tens of minutes. After each send, make the next action a normal user-visible assistant message containing the exact returned url, before any tool call or wait. Tool output and internal reasoning do not count as sharing the link. Do not run a timer or monitoring call alongside this send. Acceptance does not mean the work is complete. Then monitor the session with agent.get, reporting new progress, blockers, and the final outcome rather than unchanged status. Send here again to answer a question or add context to the same session.";
             readonly input: z.ZodObject<{
                 environmentId: z.ZodOptional<PublicIdSchema>;
+                filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodString;
                 sessionId: z.ZodOptional<PublicIdSchema>;
                 workspaceId: z.ZodOptional<PublicIdSchema>;
@@ -1822,12 +2701,18 @@ export declare const publicContractsV1: {
         };
     };
     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";
@@ -1836,8 +2721,64 @@ export declare const publicContractsV1: {
             url: z.ZodURL;
         }, z.core.$strip>;
     };
+    deployment: {
+        reportStatus: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                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 input: z.ZodObject<{
+                deployTarget: z.ZodOptional<z.ZodURL>;
+                environment: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    id: PublicIdSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    baseEphemeralEnvironment: z.ZodOptional<z.ZodString>;
+                    ephemeral: z.ZodOptional<z.ZodBoolean>;
+                    name: z.ZodString;
+                }, z.core.$strict>]>>;
+                environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                metadata: z.ZodOptional<z.ZodObject<{
+                    commitAuthorName: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+                    ref: z.ZodOptional<z.ZodString>;
+                    repository: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                providerDeploymentId: z.ZodString;
+                status: z.ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>;
+                workspaceId: PublicIdSchema;
+            }, z.core.$strict>;
+            readonly kind: "write";
+            readonly name: "deployment.reportStatus";
+            readonly output: z.ZodObject<{
+                deployment: z.ZodObject<{
+                    id: PublicIdSchema;
+                    status: z.ZodEnum<{
+                        success: "success";
+                        pending: "pending";
+                        failure: "failure";
+                        inactive: "inactive";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
     email: {
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the workspace's inbox, or its sent mail, newest first. Read a message body with email.get.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -1875,6 +2816,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read one email of the workspace, with its plain text and HTML bodies. Use it to pull a sign-in code or a verification link out of a message.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
@@ -1922,6 +2868,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         getAttachment: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read one attachment of a workspace email as base64 content, by file name or by position. email.get lists both.";
             readonly input: z.ZodObject<{
                 fileName: z.ZodOptional<z.ZodString>;
@@ -1940,6 +2891,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         listAddresses: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the workspace's inbox addresses, alphabetical. A flow can sign up with a plus-suffixed form of any of them, and email.find reads what arrives.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -1958,6 +2914,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         registerAddress: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Register an inbox address for the workspace. Registering an address the workspace already has changes nothing. A refusal names the domains the workspace can use.";
             readonly input: z.ZodObject<{
                 address: z.ZodEmail;
@@ -1972,6 +2933,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         send: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Send an email from one of the workspace's inbox addresses, for example to exercise a flow that reacts to incoming mail. Returns the sent email; read it back with email.get.";
             readonly input: z.ZodObject<{
                 attachments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBase64>>;
@@ -2010,7 +2976,12 @@ export declare const publicContractsV1: {
     };
     environment: {
         create: {
-            readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Create an environment on the caller's team and return it in the environment.get shape. This can also create a branch on the team's connected Git provider.";
             readonly input: z.ZodObject<{
                 name: z.ZodString;
                 workspaceId: z.ZodOptional<PublicIdSchema>;
@@ -2036,9 +3007,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -2046,10 +3017,16 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         deleteVariable: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Remove one environment variable by name. Succeeds whether or not the variable existed.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.deleteVariable";
@@ -2058,6 +3035,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's environments, newest first.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -2092,9 +3074,9 @@ export declare const publicContractsV1: {
                     name: z.ZodString;
                     runConcurrencyLimit: z.ZodString;
                     status: z.ZodEnum<{
-                        ready: "ready";
                         blocked: "blocked";
                         "needs-investigation": "needs-investigation";
+                        ready: "ready";
                         running: "running";
                     }>;
                     terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -2104,9 +3086,15 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read a single environment's name, kind, standing run health, flow-code branch and reconciliation state, run concurrency limit, and termination state. If flowCodeBranch exists, use its syncStatus for Git reconciliation and read lastSyncedCommitHash only when syncStatus is reconciled.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.get";
@@ -2129,9 +3117,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -2139,10 +3127,16 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         getVariable: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Read the values of named environment variables in one call. Values are secrets. Names that do not exist go to missingNames and do not fail the call.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 variableNames: z.ZodArray<z.ZodString>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.getVariable";
@@ -2155,9 +3149,15 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         listVariableNames: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Use this to answer which QA Wolf environment variables are available to test code. Returns names only; values never leave the server.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "environment.listVariableNames";
@@ -2166,11 +3166,17 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         setVariable: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create or replace an environment variable. If the user asks to create one for \"my email\" without naming it, use DEFAULT_EMAIL. The value is never returned.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodString;
                 value: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.setVariable";
@@ -2179,11 +3185,17 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Update an environment owned by the caller's team and return it in the environment.get shape. Omitted fields remain unchanged.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
                 name: z.ZodOptional<z.ZodString>;
                 runConcurrencyLimit: z.ZodOptional<z.ZodString>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "environment.update";
@@ -2206,9 +3218,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
-                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
+                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -2216,8 +3228,54 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
     };
+    file: {
+        requestDownload: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Get a URL for reading a file out of the caller's team storage. Answers 404 when nothing is stored at that path.";
+            readonly input: z.ZodObject<{
+                filePath: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "file.requestDownload";
+            readonly output: z.ZodObject<{
+                expiresAt: z.ZodISODateTime;
+                path: z.ZodString;
+                readUrl: z.ZodString;
+            }, z.core.$strip>;
+        };
+        requestUpload: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Get a URL to put a file into team storage: a spreadsheet of journeys, anything too large to paste. PUT with the returned contentType, then name the path in filePaths.";
+            readonly input: z.ZodObject<{
+                fileName: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "file.requestUpload";
+            readonly output: z.ZodObject<{
+                contentType: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+                path: z.ZodString;
+                uploadUrl: z.ZodString;
+            }, z.core.$strip>;
+        };
+    };
     flow: {
         addTag: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Assign an existing tag to the selected flows. Create tags with tag.create. Flows that already carry the tag are reported in skippedFlows.";
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<PublicIdSchema>;
@@ -2239,15 +3297,31 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the flows of an environment at its latest reconciled commit, or, when an AI task is given, the flows on that task's branch.";
             readonly input: z.ZodObject<{
                 aiTaskId: z.ZodOptional<PublicIdSchema>;
                 environmentId: PublicIdSchema;
                 includeDrafts: z.ZodDefault<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "flow.list";
             readonly output: z.ZodObject<{
+                emptyReason: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"branch-never-reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"commit-has-no-flow-files">;
+                }, z.core.$strip>, z.ZodObject<{
+                    hiddenDraftCount: z.ZodNumber;
+                    type: z.ZodLiteral<"every-flow-is-a-draft">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-flow-matched-the-listing">;
+                }, z.core.$strip>], "type">>;
                 flows: z.ZodArray<z.ZodObject<{
                     executionTarget: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
                     flowId: PublicIdSchema;
@@ -2263,6 +3337,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         removeTag: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Remove a tag from the selected flows. Succeeds whether or not each flow carried the tag; the flows that did not are reported in skippedFlows.";
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<PublicIdSchema>;
@@ -2284,6 +3363,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Move a flow between draft and active readiness. The other statuses shown in the app are derived and cannot be set.";
             readonly input: z.ZodObject<{
                 flowId: PublicIdSchema;
@@ -2309,6 +3393,11 @@ export declare const publicContractsV1: {
     };
     issue: {
         addFlows: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<PublicIdSchema>;
@@ -2356,6 +3445,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"bug">;
@@ -2425,6 +3519,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's bug reports, maintenance reports, or coverage requests, newest first.";
             readonly input: z.ZodObject<{
                 statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
@@ -2487,6 +3586,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Get an issue by id.";
             readonly input: z.ZodObject<{
                 issueId: PublicIdSchema;
@@ -2533,6 +3637,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         removeFlows: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<PublicIdSchema>;
@@ -2580,6 +3689,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Update an issue owned by the caller's team. Omitted fields remain unchanged.";
             readonly input: z.ZodObject<{
                 description: z.ZodOptional<z.ZodString>;
@@ -2645,6 +3759,11 @@ export declare const publicContractsV1: {
     };
     run: {
         create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create a run for the selected flows and/or tags in an environment.";
             readonly input: z.ZodIntersection<z.ZodObject<{
                 aiTaskId: z.ZodOptional<PublicIdSchema>;
@@ -2654,6 +3773,7 @@ export declare const publicContractsV1: {
                 ignoreRules: z.ZodDefault<z.ZodBoolean>;
                 pullRequestNumber: z.ZodOptional<z.ZodNumber>;
                 repository: z.ZodOptional<z.ZodString>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>, z.ZodObject<{
                 flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
                 tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -2679,6 +3799,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         diagnose: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodArray<PublicIdSchema>;
@@ -2727,9 +3852,15 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List an environment's recent runs, newest first.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
                 cursor: z.ZodOptional<z.ZodString>;
                 limit: z.ZodDefault<z.ZodNumber>;
                 createdAfter: z.ZodOptional<z.ZodISODateTime>;
@@ -2760,6 +3891,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "Get a run's status, per-flow results, and links.";
             readonly input: z.ZodObject<{
                 runId: PublicIdSchema;
@@ -2865,6 +4001,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         reattempt: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: string;
             readonly input: z.ZodObject<{
                 flowIds: z.ZodOptional<z.ZodArray<PublicIdSchema>>;
@@ -2879,7 +4020,12 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         stop: {
-            readonly description: "Stop a run, including its queued flows and automatic retries. Stopping is asynchronous. 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 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>;
@@ -2898,6 +4044,11 @@ export declare const publicContractsV1: {
     };
     runner: {
         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;
@@ -2918,27 +4069,42 @@ export declare const publicContractsV1: {
                 }>;
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
-                    "runner-unreachable": "runner-unreachable";
                     "runner-cannot-evaluate-snippets": "runner-cannot-evaluate-snippets";
+                    "runner-unreachable": "runner-unreachable";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
         };
         get: {
-            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.";
+            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<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.get";
-            readonly output: z.ZodObject<{
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 id: z.ZodString;
                 outcome: z.ZodLiteral<"success">;
-                running: z.ZodBoolean;
-            }, z.core.$strip>;
+                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;
@@ -2966,6 +4132,11 @@ export declare const publicContractsV1: {
             }, 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;
@@ -2988,6 +4159,11 @@ export declare const publicContractsV1: {
             }, 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;
@@ -3019,7 +4195,12 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "outcome">;
         };
         inspectMobile: {
-            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 or carrying some text. 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. `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 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<{
@@ -3041,6 +4222,16 @@ export declare const publicContractsV1: {
                     partial: z.ZodOptional<z.ZodBoolean>;
                     text: z.ZodString;
                     what: z.ZodLiteral<"elements">;
+                }, z.core.$strip>, z.ZodObject<{
+                    by: z.ZodLiteral<"selector">;
+                    context: z.ZodOptional<z.ZodString>;
+                    selector: z.ZodString;
+                    strategy: z.ZodDefault<z.ZodEnum<{
+                        "ios-predicate": "ios-predicate";
+                        shadow: "shadow";
+                        xpath: "xpath";
+                    }>>;
+                    what: z.ZodLiteral<"elements">;
                 }, z.core.$strip>], "by">], "what">;
                 workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
@@ -3215,6 +4406,7 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "what">, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
+                    "invalid-selector": "invalid-selector";
                     "runner-is-not-mobile": "runner-is-not-mobile";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
@@ -3223,7 +4415,12 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "outcome">;
         };
         launch: {
-            readonly description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `alreadyRunning` to tell which happened.";
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `alreadyRunning` to tell which happened. After a successful launch, make the next action a normal user-visible assistant message containing the exact returned `url`, before the first browser action. Tool output and internal reasoning do not count as sharing the link. When `alreadyRunning` is true the `url` is the same page, so share it again instead of assuming the caller still has it.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
                 runnerName: z.ZodOptional<z.ZodEnum<{
@@ -3245,11 +4442,17 @@ export declare const publicContractsV1: {
                     android: "android";
                     ios: "ios";
                 }>;
+                url: z.ZodURL;
                 alreadyRunning: z.ZodBoolean;
                 outcome: z.ZodLiteral<"success">;
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the runners running on the caller's team right now. A team API key already names the team and sends nothing; a credential bound to no single workspace names one in `workspaceId`. A runner that was terminated, or that terminated on its own after inactivity, is not listed, because the run system keeps no record of a runner once it is gone. 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. It is how to find a runner launched from another machine or in an earlier session, when the id it was launched under is no longer at hand.";
             readonly input: z.ZodObject<{
                 workspaceId: z.ZodOptional<PublicIdSchema>;
@@ -3267,10 +4470,16 @@ export declare const publicContractsV1: {
                         android: "android";
                         ios: "ios";
                     }>;
+                    url: z.ZodURL;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         };
         performAction: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `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. A `navigate` does not go through the screen, so a screen that is not ready does not stop 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. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. With `withScreenshot: true`, the answer also carries `imageJpegBase64`: a screenshot taken after the action, once the screen has changed from just before it or half a second has passed, whichever comes first. One call instead of `runner.performAction` followed by `runner.takeScreenshot`, with no fixed wait in between. Anything animating on the page counts as a change. The action itself is performed exactly as without the option; if the screen could serve no frame after it — a display restart, or a `navigate` on a desktop that is still starting — the action's result comes back without `imageJpegBase64`, so take a screenshot separately rather than repeating the action. On a mobile runner the screenshot is the device's own, taken right after a performed action. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
                 action: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -3334,6 +4543,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "failureReason">], "outcome">;
         };
         promoteSnapshot: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Accept a run's screenshot as the new baseline for an image diff, on the runner that produced it. The two paths are the ones the diff reported, which reach a caller as an `image-diff-artifact` entry on the runner's `run-events` journal stream. `snapshot-not-found` if the run wrote no screenshot at that path, which usually means the paths were not taken from a diff this run produced; nothing is changed, so correcting the path and repeating is safe. `runner-cannot-promote-snapshots` on a runner that stores no screenshots. `runner-unreachable` if the runner could not be reached: it may still be starting, or it may have terminated after inactivity. A promotion that lands is not undone by promoting again, so a retry after an unreachable answer is safe.";
             readonly input: z.ZodObject<{
                 baselinePath: z.ZodString;
@@ -3355,6 +4569,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "outcome">;
         };
         readJournal: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: `run-status` settles it, `run-logs` and `run-events` carry what it produced, and `recorder` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. `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<{
                 runId: z.ZodOptional<z.ZodString>;
@@ -3371,7 +4590,7 @@ export declare const publicContractsV1: {
                     payload: z.ZodUnknown;
                     recordedAt: z.ZodISODateTime;
                     sequence: z.ZodNumber;
-                }, z.core.$strip>, z.ZodTransform<import("./runnerReexports.js").JournalEntry<unknown>, {
+                }, z.core.$strip>, z.ZodTransform<import("./sharedSchemas.js").JournalEntry<unknown>, {
                     payload: unknown;
                     recordedAt: string;
                     sequence: number;
@@ -3388,6 +4607,11 @@ export declare const publicContractsV1: {
             }, 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;
@@ -3434,6 +4658,11 @@ export declare const publicContractsV1: {
             }, 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;
@@ -3452,7 +4681,12 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "outcome">;
         };
         takeScreenshot: {
-            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. 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 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>;
@@ -3473,6 +4707,11 @@ export declare const publicContractsV1: {
             }, 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;
@@ -3489,6 +4728,11 @@ export declare const publicContractsV1: {
     };
     tag: {
         create: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
             readonly description: "Create a tag on the caller's team. Tags select flows in run.create.";
             readonly input: z.ZodObject<{
                 name: z.ZodString;
@@ -3503,6 +4747,11 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         list: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
             readonly description: "List the team's tags, alphabetical by name. Tag names select flows in run.create.";
             readonly input: z.ZodObject<{
                 cursor: z.ZodOptional<z.ZodString>;
@@ -3524,5 +4773,496 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
     };
+    trigger: {
+        create: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"schedule">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                cadence: z.ZodEnum<{
+                    hourly: "hourly";
+                    daily: "daily";
+                }>;
+                environmentId: PublicIdSchema;
+                minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                timeOfDay: z.ZodOptional<z.ZodString>;
+                timezoneId: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"deployment">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                branchPattern: z.ZodOptional<z.ZodString>;
+                deployTargetPattern: z.ZodOptional<z.ZodString>;
+                environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                environmentPattern: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>], "kind">;
+            readonly kind: "write";
+            readonly name: "trigger.create";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        delete: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.delete";
+            readonly output: z.ZodObject<{
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "List the team's triggers, newest first.";
+            readonly input: z.ZodObject<{
+                isPaused: z.ZodOptional<z.ZodBoolean>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "trigger.find";
+            readonly output: z.ZodObject<{
+                triggers: z.ZodArray<z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly annotations: {
+                readonly destructiveHint: false;
+                readonly openWorldHint: false;
+                readonly readOnlyHint: true;
+            };
+            readonly description: "Get one trigger by id.";
+            readonly input: z.ZodObject<{
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "trigger.get";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, 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<{
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.pause";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        resume: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodObject<{
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "trigger.resume";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        update: {
+            readonly annotations: {
+                readonly destructiveHint: true;
+                readonly openWorldHint: true;
+                readonly readOnlyHint: false;
+            };
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"schedule">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                cadence: z.ZodEnum<{
+                    hourly: "hourly";
+                    daily: "daily";
+                }>;
+                environmentId: PublicIdSchema;
+                minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                timeOfDay: z.ZodOptional<z.ZodString>;
+                timezoneId: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"deployment">;
+                action: z.ZodObject<{
+                    flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                    instructions: z.ZodOptional<z.ZodString>;
+                    investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodDefault<z.ZodEnum<{
+                        createSuite: "createSuite";
+                        generativeSuite: "generativeSuite";
+                    }>>;
+                    tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                branchPattern: z.ZodOptional<z.ZodString>;
+                deployTargetPattern: z.ZodOptional<z.ZodString>;
+                environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                environmentPattern: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                triggerId: PublicIdSchema;
+            }, z.core.$strip>], "kind">;
+            readonly kind: "write";
+            readonly name: "trigger.update";
+            readonly output: z.ZodObject<{
+                trigger: z.ZodObject<{
+                    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"schedule">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        cadence: z.ZodEnum<{
+                            hourly: "hourly";
+                            daily: "daily";
+                        }>;
+                        environmentId: PublicIdSchema;
+                        minuteOfHour: z.ZodOptional<z.ZodNumber>;
+                        timeOfDay: z.ZodOptional<z.ZodString>;
+                        timezoneId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"deployment">;
+                        action: z.ZodObject<{
+                            flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                            instructions: z.ZodOptional<z.ZodString>;
+                            investigateFailures: z.ZodOptional<z.ZodBoolean>;
+                            kind: z.ZodDefault<z.ZodEnum<{
+                                createSuite: "createSuite";
+                                generativeSuite: "generativeSuite";
+                            }>>;
+                            tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>;
+                        branchPattern: z.ZodOptional<z.ZodString>;
+                        deployTargetPattern: z.ZodOptional<z.ZodString>;
+                        environmentIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                        environmentPattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        actionCount: z.ZodNumber;
+                        kind: z.ZodLiteral<"advanced">;
+                        whenCount: z.ZodNumber;
+                    }, z.core.$strip>], "kind">;
+                    createdAt: z.ZodISODateTime;
+                    id: PublicIdSchema;
+                    isPaused: z.ZodBoolean;
+                    name: z.ZodString;
+                    nextScheduledAt: z.ZodOptional<z.ZodISODateTime>;
+                    pausedAt: z.ZodOptional<z.ZodISODateTime>;
+                    updatedAt: z.ZodISODateTime;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
 };
 //# sourceMappingURL=index.d.ts.map