@qawolf/cli 1.32.0 → 1.34.0

package/dist/runner-sdk.js

@@ -2431,6 +2431,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
+var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
@@ -2461,6 +2462,7 @@ var bigint = /^-?\d+n?$/;
 var integer = /^-?\d+$/;
 var number = /^-?\d+(?:\.\d+)?$/;
 var boolean = /^(?:true|false)$/i;
+var _null = /^null$/i;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 
@@ -3381,6 +3383,23 @@ var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
     return payload;
   };
 });
+var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = _null;
+  inst._zod.values = new Set([null]);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (input === null)
+      return payload;
+    payload.issues.push({
+      expected: "null",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
 var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload) => payload;
@@ -4865,6 +4884,12 @@ function _coercedBigint(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _null2(Class, params) {
+  return new Class({
+    type: "null",
+    ...normalizeParams(params)
+  });
+}
 function _unknown(Class) {
   return new Class({
     type: "unknown"
@@ -6316,6 +6341,9 @@ var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
   $ZodUUID.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function uuid2(params) {
+  return _uuid(ZodUUID, params);
+}
 var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
   $ZodURL.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -6323,6 +6351,13 @@ var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
 function url(params) {
   return _url(ZodURL, params);
 }
+function httpUrl(params) {
+  return _url(ZodURL, {
+    protocol: httpProtocol,
+    hostname: domain,
+    ...normalizeParams(params)
+  });
+}
 var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
   $ZodEmoji.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -6484,6 +6519,14 @@ var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
   inst.maxValue = bag.maximum ?? null;
   inst.format = bag.format ?? null;
 });
+var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+  $ZodNull.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
+});
+function _null3(params) {
+  return _null2(ZodNull, params);
+}
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
@@ -6914,6 +6957,12 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
+function json(params) {
+  const jsonSchema = lazy(() => {
+    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+  });
+  return jsonSchema;
+}
 // node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
@@ -6956,6 +7005,10 @@ var agentReplySchema = object({
   text: string2().describe("What the AI said.")
 });
 
+// node_modules/@qawolf/api-contracts/dist/v1/agent/wait.js
+var maxAgentWaitSeconds = 45;
+var agentWakeReasonSchema = _enum(["reply", "status", "timeout"]).describe('Why a held check answered. "reply" means the AI said something new, "status" means the session settled or needs you, "timeout" means the hold ran out with nothing new.');
+
 // node_modules/@qawolf/api-contracts/dist/v1/resource.js
 function resource(fields, { urlFieldDescription = "Absolute URL." } = {}) {
   return object({
@@ -7113,16 +7166,18 @@ var identityOrganizationsResponse = object({
 // node_modules/@qawolf/api-contracts/dist/v1/ids.js
 var defaultIdSchemas = {
   aiTask: string2().min(1).describe("The id of the AI task."),
-  automation: string2().min(1).describe("The id of the automation."),
   chatSession: string2().min(1).describe("The id of the chat session."),
+  deployment: string2().min(1).describe("The id of the deployment."),
   environment: string2().min(1).describe("The id of the environment."),
-  environmentRef: string2().min(1).describe("The id or alias of the environment. Aliases require a team API key."),
+  environmentRef: string2().min(1).describe("The id or alias of the environment. An organization or user API key must also send workspaceId to use an alias."),
   flow: string2().min(1).describe("The id of the flow."),
   issue: string2().min(1).describe("The id of the issue."),
+  legacyTrigger: string2().min(1).describe("The id of the legacy trigger, from legacyTrigger.find."),
   run: string2().min(1).describe("The id of the run."),
   trigger: string2().min(1).describe("The id of the trigger."),
   workspace: string2().min(1).describe("The id of the workspace.")
 };
+var workspaceForEnvironmentRef = (workspace) => workspace.optional().describe("The workspace the environment belongs to. Required to reference the environment by alias when authenticating with an organization or user API key.");
 
 // node_modules/@qawolf/api-contracts/dist/v1/run/flowSelection.js
 var makeFlowSelectionSchema = (ids) => object({
@@ -7141,7 +7196,8 @@ var makeCreateRunContract = (ids) => {
     environmentVariables: record(string2(), string2()).optional(),
     ignoreRules: boolean2().describe("Ignore this team's sequencing rules for this run. By default they are honoured: the flows your selection depends on are added to the run, and flows run in the order the rules require. Set this to run exactly what you selected, in any order.").default(false),
     pullRequestNumber: number2().int().positive().describe("The number of the pull request to associate with the run.").optional(),
-    repository: string2().min(1).describe('The owner/name of the repository, e.g. "acme/web".').optional()
+    repository: string2().min(1).describe('The owner/name of the repository, e.g. "acme/web".').optional(),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   }).and(makeFlowSelectionSchema(ids)).refine((value) => !(value.aiTaskId && value.chatSessionId), {
     message: "Provide at most one of aiTaskId and chatSessionId: a task already implies its own chat session.",
     path: ["chatSessionId"]
@@ -7169,6 +7225,10 @@ var makeCreateRunContract = (ids) => {
   };
 };
 
+// node_modules/@qawolf/api-contracts/dist/v1/runner/actionSequence.js
+var maxActionsPerRequest = 10;
+var screenshotModes = ["none", "final", "each"];
+
 // node_modules/@qawolf/api-contracts/dist/v1/runner/browserAction.js
 var maxScreenCoordinate = 20000;
 var screenCoordinateSchema = int().min(0).max(maxScreenCoordinate);
@@ -7296,11 +7356,12 @@ var runnerNameSchema = _enum([
 var runnerWorkspaceRequirement = "Required when the credential is not bound to a single workspace, such as a user API key or an OAuth connection whose organization owns several.";
 var runnerWorkspaceIdDescription = `The workspace the runner belongs to. ${runnerWorkspaceRequirement}`;
 var runnerIdSchema = string2().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "A runner id may contain only lowercase letters, digits and dashes, and must start and end with a letter or digit.");
+var runnerWatchUrlSchema = url().describe("A QA Wolf page showing what the runner is doing right now, where the person who launched it can watch and take over with their own mouse and keyboard. Opening it requires being signed in to QA Wolf. This link belongs to the user: put it in a normal message as soon as the runner is launched, so they can follow along while the browser is being driven. It is theirs to open, never a page for the caller to fetch or navigate to. The page ends when the runner is terminated, so share it while the runner is alive and report what you found at the end instead of repeating a dead link.");
 var makeRunnerSchema = () => object({
   gpuAccelerated: boolean2().describe("Whether the runner was placed on GPU hardware. Chosen by QA Wolf from the team's configuration and what the fleet can provide, not requested."),
   id: runnerIdSchema.describe("The runner's id, as supplied when launching it."),
   runnerName: runnerNameSchema.describe("The runner family requested when the runner was launched. QA Wolf may place it on faster hardware, reported in gpuAccelerated."),
-  url: url().describe("A QA Wolf page showing what the runner is doing right now, where the person who launched it can watch and take over with their own mouse and keyboard. Opening it requires being signed in to QA Wolf.")
+  url: runnerWatchUrlSchema
 });
 
 // node_modules/@qawolf/api-contracts/dist/v1/runner/unreachable.js
@@ -7591,13 +7652,13 @@ var screenshotImageSchema = string2().min(1).describe("The screenshot, as a base
 // node_modules/@qawolf/api-contracts/dist/v1/runner/performAction.js
 var unreachableDescription = "`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.";
 var notSupportedOnMobileDescription = "`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.";
-var withScreenshotDescription = "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.";
+var withScreenshotDescription = "With `withScreenshot: true`, the answer also carries `imageJpegBase64`: a screenshot taken after the action. One call instead of `runner.performAction` followed by `runner.takeScreenshot`. 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.";
 var maxActionErrorMessageLength = 1000;
 var makePerformActionOnRunnerContract = (ids) => {
   const input = object({
-    action: browserActionSchema.describe("The action to perform. Coordinates are pixels on the screenshot's own coordinate space."),
+    action: browserActionSchema.describe(`The action to perform. Coordinates are whole pixels on the runner's virtual desktop, in the same space as \`runner.takeScreenshot\`. The action shapes follow the computer-use vocabulary, minus \`screenshot\` (use \`runner.takeScreenshot\`) and \`wait\` (delay on the caller's side). A \`navigate\` does not go through the screen, so a screen that is not ready does not stop it. ${notSupportedOnMobileDescription}`),
     id: runnerIdSchema.describe("Id of the runner to act on."),
-    withScreenshot: boolean2().optional().describe("Also answer with a screenshot taken after the action, once the screen has changed or half a second has passed. Saves the separate `runner.takeScreenshot` call and its fixed wait."),
+    withScreenshot: boolean2().optional().describe(withScreenshotDescription),
     workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
   });
   const screenshotAfterAction = screenshotImageSchema.optional();
@@ -7627,7 +7688,7 @@ var makePerformActionOnRunnerContract = (ids) => {
       openWorldHint: true,
       readOnlyHint: false
     },
-    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. ${screenNotReadyDescription} A \`navigate\` does not go through the screen, so a screen that is not ready does not stop it. ${runnerHasNoScreenDescription} ${notSupportedOnMobileDescription} ${withScreenshotDescription} ${unreachableDescription}`,
+    description: `Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. One action per request, and the runner serves one at a time. 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. ${screenNotReadyDescription} ${runnerHasNoScreenDescription} ${unreachableDescription}`,
     input,
     kind: "write",
     name: "runner.performAction",
@@ -7635,6 +7696,214 @@ var makePerformActionOnRunnerContract = (ids) => {
   };
 };
 
+// node_modules/@qawolf/api-contracts/dist/v1/runner/performActionsSteps.js
+var outOfTimeFailureReason = "out-of-time";
+var unconfirmedFailureReason = "action-unconfirmed";
+var actionIndexSchema = int().min(0).max(maxActionsPerRequest - 1).describe("Position of the action in the request's `actions`, from 0.");
+var screenshotAfterStep = screenshotImageSchema.optional();
+var performedStepSchema = object({
+  effect: literal("performed"),
+  imageJpegBase64: screenshotAfterStep,
+  index: actionIndexSchema,
+  outcome: literal("success")
+});
+var failedStepSchema = discriminatedUnion("failureReason", [
+  object({
+    effect: literal("not-performed"),
+    errorMessage: string2().max(maxActionErrorMessageLength).describe("What stopped the action from taking effect."),
+    failureReason: literal("action-failed"),
+    imageJpegBase64: screenshotAfterStep,
+    index: actionIndexSchema,
+    outcome: literal("failure")
+  }),
+  object({
+    effect: literal("unknown"),
+    failureReason: literal(runnerUnreachableFailureReason),
+    index: actionIndexSchema,
+    outcome: literal("failure")
+  }),
+  object({
+    effect: literal("unknown"),
+    errorMessage: string2().max(maxActionErrorMessageLength).describe("How the runner's screen went quiet with the action in flight."),
+    failureReason: literal(unconfirmedFailureReason),
+    index: actionIndexSchema,
+    outcome: literal("failure")
+  }),
+  object({
+    effect: literal("not-performed"),
+    failureReason: _enum([
+      ...screenFailureReasons,
+      "action-not-supported-on-mobile",
+      outOfTimeFailureReason
+    ]),
+    index: actionIndexSchema,
+    outcome: literal("failure")
+  })
+]);
+var stepResultSchema = discriminatedUnion("outcome", [
+  performedStepSchema,
+  failedStepSchema
+]);
+var sequenceFailureReasons = [
+  "action-failed",
+  ...screenFailureReasons,
+  "action-not-supported-on-mobile",
+  outOfTimeFailureReason,
+  unconfirmedFailureReason,
+  runnerUnreachableFailureReason
+];
+
+// node_modules/@qawolf/api-contracts/dist/v1/runner/performActions.js
+var actionsDescription = `The actions to perform, in order, each exactly what \`runner.performAction\` takes: coordinates are whole pixels on the runner's virtual desktop, in the same space as \`runner.takeScreenshot\`, and the shapes follow the computer-use vocabulary. At most ${maxActionsPerRequest} per request. For when the next several steps are already known — click a field, type into it, press Enter — and one look at the screen at the end is enough. They run back to back on the runner, with no pause between them: put in one request only steps whose targets are all on the screen you last saw and are not moved by the steps before them, and when a step changes the page — a submit, a navigation, opening a menu — make it the last one and read the frame.`;
+var screenshotModeDescription = "`final`, the default, answers with one screenshot in `imageJpegBase64`: the screen after the last action, or, after a stop, as it stands. `each` puts a screenshot after every action on its entry in `results`, for when each step must be checked; every frame is a full image, so keep such sequences short. `none` sends no screenshot.";
+var stopOnFailureDescription = "`true`, the default, leaves the remaining actions unperformed once one fails. `false` carries on past an action that reached the runner and did not take effect (`action-failed`, `action-not-supported-on-mobile`), so use it only for actions that do not depend on each other: a `type` after a `click` that failed goes to whatever has focus. A runner that cannot be reached, a screen that cannot serve, or running out of time ends the sequence either way.";
+var finalImageDescription = "Present with `screenshotMode: final` when the runner still answered: the screen after the last action performed, or, after a stop, as it stands.";
+var makePerformActionsOnRunnerContract = (ids) => {
+  const input = object({
+    actions: array(browserActionSchema).min(1).max(maxActionsPerRequest).describe(actionsDescription),
+    id: runnerIdSchema.describe("Id of the runner to act on."),
+    screenshotMode: _enum(screenshotModes).optional().describe(screenshotModeDescription),
+    stopOnFailure: boolean2().optional().describe(stopOnFailureDescription),
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
+  });
+  const output = discriminatedUnion("outcome", [
+    object({
+      imageJpegBase64: screenshotImageSchema.optional().describe(finalImageDescription),
+      lastCompletedIndex: actionIndexSchema.describe("Index of the last action that took effect: here, the last one sent."),
+      outcome: literal("success"),
+      results: array(performedStepSchema).min(1).max(maxActionsPerRequest).describe("One entry per action, in order.")
+    }),
+    object({
+      errorMessage: string2().max(maxActionErrorMessageLength).optional().describe("What stopped the first failed action, when its reason is `action-failed` or `action-unconfirmed`."),
+      failedIndex: actionIndexSchema.describe("Index of the first action that did not take effect."),
+      failureReason: _enum(sequenceFailureReasons).describe("Why that action did not take effect, the same as on its entry in `results`."),
+      imageJpegBase64: screenshotImageSchema.optional().describe(finalImageDescription),
+      lastCompletedIndex: actionIndexSchema.optional().describe("Index of the last action that took effect. Absent when none did. With `stopOnFailure: false` it can follow a failed action, so `results` says which ones before it took effect."),
+      outcome: literal("failure"),
+      results: array(stepResultSchema).min(1).max(maxActionsPerRequest).describe("One entry per action reached, in order. Actions after a stop have no entry."),
+      stoppedEarly: boolean2().describe("Whether actions after the failure were left unperformed. False when every action was attempted.")
+    })
+  ]);
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Perform a sequence of raw browser actions on an interactive runner in one request, one after another, and answer with what happened to each. A `success` means every action took effect. A `failure` names the first action that did not (`failedIndex`, `failureReason`), the last one that did (`lastCompletedIndex`), and whether actions were left unperformed (`stoppedEarly`); `results` has one entry per action reached, in order. Read `effect` on an entry before sending its action again: `performed` means the runner did it; `not-performed` means the runner answered that it did not take effect, though a `navigate` that timed out may still be loading; `unknown` means the runner stopped answering with the action in flight (`runner-unreachable`), or its screen went quiet mid-action (`action-unconfirmed`), and it may have taken effect — a click that submitted a form, say — so take a screenshot instead of repeating it. A sequence gets about a minute to start its actions; an action it did not reach in time is `out-of-time`, nothing after it was attempted, and the rest can go in a new request. Everything `runner.performAction` says about a runner that has never run anything, a mobile runner, and the `screen-needs-a-run`, `screen-not-ready`, `runner-has-no-screen` and `action-not-supported-on-mobile` reasons holds for each action here.",
+    input,
+    kind: "write",
+    name: "runner.performActions",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/runner/recording.js
+var recordingIdSchema = uuid2();
+var runnerRecordingCommandSchema = discriminatedUnion("action", [
+  strictObject({
+    action: literal("start"),
+    recordingId: recordingIdSchema
+  }),
+  strictObject({ action: literal("stop"), recordingId: recordingIdSchema }),
+  strictObject({ action: literal("auto"), enabled: boolean2() }),
+  strictObject({ action: literal("status") })
+]);
+var runnerRecordingSchema = object({
+  endedAt: exports_iso.datetime(),
+  id: recordingIdSchema,
+  mode: _enum(["manual", "automatic"]),
+  runIds: array(string2()),
+  runnerId: runnerIdSchema,
+  runnerInstanceId: uuid2(),
+  startedAt: exports_iso.datetime(),
+  status: _enum(["ready", "failed"]),
+  version: literal(1)
+});
+var runnerRecordingStateSchema = object({
+  active: object({
+    id: recordingIdSchema,
+    mode: _enum(["manual", "automatic"]),
+    startedAt: exports_iso.datetime()
+  }).optional(),
+  auto: _enum(["on", "off", "default"])
+});
+var runnerRecordingResultSchema = discriminatedUnion("outcome", [
+  object({
+    outcome: literal("success"),
+    recording: runnerRecordingSchema.optional(),
+    state: runnerRecordingStateSchema
+  }),
+  object({
+    failureReason: _enum([
+      "unsupported",
+      "screen-not-ready",
+      "recording-in-progress",
+      "recording-not-found",
+      "recording-id-used",
+      "runner-unreachable",
+      "recording-failed"
+    ]),
+    outcome: literal("failure")
+  })
+]);
+var makeRecordOnRunnerContract = (ids) => {
+  const input = object({
+    command: runnerRecordingCommandSchema,
+    id: runnerIdSchema,
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
+  });
+  const output = object({
+    result: runnerRecordingResultSchema,
+    url: url()
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    description: "Control video recording on a Playwright runner. Start requires a caller-generated UUID; stop targets that UUID so retries cannot stop a later recording. Manual capture spans runs and suppresses automatic capture. Auto settings affect subsequent full runs. The URL opens recording history after the runner terminates. Videos may be unavailable after abrupt pod loss.",
+    input,
+    kind: "write",
+    name: "runner.record",
+    output
+  };
+};
+var makeRunnerRecordingsContract = (ids) => {
+  const input = object({
+    id: runnerIdSchema,
+    pageToken: string2().max(4096).optional(),
+    recordingId: recordingIdSchema.optional(),
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
+  });
+  const output = object({
+    nextPageToken: string2().optional(),
+    recordings: array(runnerRecordingSchema.extend({
+      url: url(),
+      videoUrl: url().optional()
+    }))
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "Read a runner's finalized recordings from workspace storage, including after the runner terminates. Omit recordingId to list recordings in storage-key order; follow nextPageToken for more. An empty list for a specific recording means it is not published or does not exist. Video URLs expire; platform URLs remain stable.",
+    input,
+    kind: "read",
+    name: "runner.recordings",
+    output
+  };
+};
+function makeRecordingContracts(ids) {
+  return {
+    record: makeRecordOnRunnerContract(ids),
+    recordings: makeRunnerRecordingsContract(ids)
+  };
+}
+
 // node_modules/@qawolf/api-contracts/dist/v1/runner/runSelection.js
 var runSelectionSchema = object({
   endLine: int().positive().describe("Last line to run, 1-indexed and inclusive."),
@@ -7653,7 +7922,16 @@ var isTimezone = (value) => {
     return false;
   }
 };
-var triggerCadenceSchema = _enum(["hourly", "daily"]).describe("How often the schedule fires.");
+var triggerCadenceSchema = _enum(["hourly", "daily", "weekly"]).describe("How often the schedule fires.");
+var triggerDayOfWeekSchema = _enum([
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+]).describe("A day of the week, named rather than numbered.");
 var triggerActionKindSchema = _enum(["createSuite", "generativeSuite"]).describe("createSuite runs the flows named by flowIds and tagNames. generativeSuite lets QA Wolf choose the flows from the deployment's changes, and is not available to a schedule.");
 var makeTriggerActionSchema = (ids) => object({
   flowIds: array(ids.flow).default([]).describe("Flows to run. Combined with tagNames."),
@@ -7665,10 +7943,11 @@ var makeTriggerActionSchema = (ids) => object({
 var makeTriggerScheduleFields = (ids) => ({
   action: makeTriggerActionSchema(ids),
   cadence: triggerCadenceSchema,
+  dayOfWeek: triggerDayOfWeekSchema.optional().describe("The day a weekly schedule fires on, read in timezoneId. Required when cadence is weekly."),
   environmentId: ids.environmentId.describe("The environment the scheduled runs happen in."),
   minuteOfHour: number2().int().min(0).max(59).optional().describe("Minutes past the hour an hourly schedule fires. Defaults to 0."),
-  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional().describe('The wall clock time a daily schedule fires, as "HH:mm". Required when cadence is daily.'),
-  timezoneId: string2().min(1).refine(isTimezone, "Expected an IANA timezone, such as America/New_York.").optional().describe("The IANA timezone that timeOfDay is read in, such as America/New_York. Required when cadence is daily.")
+  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional().describe('The wall clock time a daily or weekly schedule fires, as "HH:mm". Required when cadence is daily or weekly.'),
+  timezoneId: string2().min(1).refine(isTimezone, "Expected an IANA timezone, such as America/New_York.").optional().describe("The IANA timezone that timeOfDay is read in, such as America/New_York. Required when cadence is daily or weekly.")
 });
 var makeTriggerDeploymentFields = (ids) => ({
   action: makeTriggerActionSchema(ids),
@@ -7678,6 +7957,98 @@ var makeTriggerDeploymentFields = (ids) => ({
   environmentPattern: string2().min(1).optional().describe("Only fire for deployments to environments matching this pattern. Mutually exclusive with environmentIds.")
 });
 
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/configurationRules.js
+var checkAction = (action, ctx) => {
+  const namesFlows = action.flowIds.length + action.tagNames.length > 0;
+  if (action.kind === "generativeSuite") {
+    if (namesFlows) {
+      ctx.addIssue({
+        code: "custom",
+        message: "flowIds and tagNames do not apply when the action is generativeSuite.",
+        path: ["action", "flowIds"]
+      });
+    }
+    return;
+  }
+  if (action.instructions !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: "instructions apply to a generativeSuite action only.",
+      path: ["action", "instructions"]
+    });
+  }
+  if (!namesFlows) {
+    ctx.addIssue({
+      code: "custom",
+      message: "At least one flow or tag is required.",
+      path: ["action", "flowIds"]
+    });
+  }
+};
+var requiredScheduleFields = {
+  daily: ["timeOfDay", "timezoneId"],
+  hourly: [],
+  weekly: ["dayOfWeek", "timeOfDay", "timezoneId"]
+};
+var cadencesUsingField = {
+  dayOfWeek: "a weekly cadence",
+  minuteOfHour: "an hourly cadence",
+  timeOfDay: "a daily or weekly cadence",
+  timezoneId: "a daily or weekly cadence"
+};
+var scheduleFields = [
+  "dayOfWeek",
+  "minuteOfHour",
+  "timeOfDay",
+  "timezoneId"
+];
+var checkScheduleFields = (value, ctx) => {
+  const required = requiredScheduleFields[value.cadence];
+  for (const field of scheduleFields) {
+    const isSupplied = value[field] !== undefined;
+    if (required.includes(field)) {
+      if (!isSupplied) {
+        ctx.addIssue({
+          code: "custom",
+          message: `${field} is required when cadence is ${value.cadence}.`,
+          path: [field]
+        });
+      }
+      continue;
+    }
+    if (isSupplied && !(value.cadence === "hourly" && field === "minuteOfHour")) {
+      ctx.addIssue({
+        code: "custom",
+        message: `${field} applies to ${cadencesUsingField[field]} only.`,
+        path: [field]
+      });
+    }
+  }
+};
+var checkSchedule = (value, ctx) => {
+  checkScheduleFields(value, ctx);
+  if (value.action.kind === "generativeSuite") {
+    ctx.addIssue({
+      code: "custom",
+      message: "A schedule trigger cannot use a generativeSuite action.",
+      path: ["action", "kind"]
+    });
+    return;
+  }
+  checkAction(value.action, ctx);
+};
+var checkDeployment = (value, ctx) => {
+  if (value.environmentPattern !== undefined && value.environmentIds.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Supply environmentIds or environmentPattern, not both.",
+      path: ["environmentPattern"]
+    });
+  }
+  checkAction(value.action, ctx);
+};
+var checkTriggerConfiguration = (value, ctx) => value.kind === "schedule" ? checkSchedule(value, ctx) : checkDeployment(value, ctx);
+
 // node_modules/@qawolf/api-contracts/dist/v1/trigger/resource.js
 var makeTriggerConfigurationSchema = (ids) => discriminatedUnion("kind", [
   object({
@@ -7707,19 +8078,51 @@ var makeTriggerResourceSchema = (ids) => resource({
   pausedAt: exports_iso.datetime().optional().describe("When it was paused."),
   updatedAt: exports_iso.datetime()
 }, { urlFieldDescription: "Absolute URL of the team's triggers page." });
-// node_modules/@qawolf/api-contracts/dist/v1/agent/get.js
-var makeAgentGetContract = (ids) => {
+
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/create.js
+var makeCreateTriggerContract = (ids) => {
+  const commonFields = {
+    name: string2().trim().min(1).max(255),
+    workspaceId: ids.workspace.optional().describe("The workspace to create the trigger in. Required when authenticating with an organization or user API key.")
+  };
+  const input = discriminatedUnion("kind", [
+    object({
+      ...commonFields,
+      ...makeTriggerScheduleFields({
+        environmentId: ids.environmentRef,
+        flow: ids.flow
+      }),
+      kind: literal("schedule")
+    }),
+    object({
+      ...commonFields,
+      ...makeTriggerDeploymentFields(ids),
+      kind: literal("deployment")
+    })
+  ]).superRefine(checkTriggerConfiguration);
+  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Create a trigger. A schedule trigger runs a named set of flows on a cadence; " + "a deployment trigger runs when a matching deployment is reported.",
+    input,
+    kind: "write",
+    name: "trigger.create",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/find.js
+var makeFindTriggersContract = (ids) => {
   const input = object({
-    cursor: string2().min(1).optional().describe("Opaque cursor copied from this same session's previous nextCursor. Omit to read from its first reply."),
-    sessionId: ids.chatSession.describe("The id agent.send answered with.")
+    isPaused: boolean2().optional().describe("Only list paused, or only unpaused, triggers. Omit for both."),
+    workspaceId: ids.workspace.optional().describe("The workspace to list triggers from. Required when authenticating with an organization or user API key.")
   });
-  const output = resource({
-    nextCursor: string2().min(1).describe("Send back as cursor on the next check to read only what follows. Always present, even with no replies. Belongs to this session alone."),
-    replies: array(agentReplySchema).describe("What the AI has said since the cursor, oldest first. A reply still being written returns again, longer. A reply carrying choices is a question the work is blocked on."),
-    sessionId: ids.chatSession,
-    status: agentSessionStatusSchema
-  }, {
-    urlFieldDescription: "Absolute URL of the live session in the QA Wolf app."
+  const output = object({
+    triggers: array(makeTriggerResourceSchema(ids)).describe("The team's triggers, newest first.")
   });
   return {
     annotations: {
@@ -7727,23 +8130,172 @@ var makeAgentGetContract = (ids) => {
       openWorldHint: false,
       readOnlyHint: true
     },
-    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.',
+    description: "List the team's triggers, newest first.",
     input,
     kind: "read",
-    name: "agent.get",
+    name: "trigger.find",
     output
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/agent/send.js
-var makeAgentSendContract = (ids) => {
-  const input = object({
-    environmentId: ids.environmentRef.optional().describe("The environment to work in. Omit to use the team's default environment. Ignored when sessionId is given, because a session keeps the environment it opened in."),
-    filePaths: array(teamStoragePathSchema).max(20).optional().describe("Paths of files this request is about, from file.requestUpload. The AI reads them from storage rather than the message, so a plan of hundreds of journeys costs nothing to send."),
-    message: string2().trim().min(1).max(1e4).describe("What you want QA Wolf to do, in plain language. Name the journey, the part of the app it covers, and anything the AI cannot discover for itself, such as a test account, a feature flag, or how to reach a staging environment. When answering a question from agent.get, send the answer here."),
-    sessionId: ids.chatSession.optional().describe("Continue the session with this id instead of opening a new one. Omit to start fresh. Send this to answer a question or to add context to work already running."),
-    workspaceId: ids.workspace.optional().describe("The workspace to work in. Required when authenticating with an organization or user API key.")
-  });
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/get.js
+var makeGetTriggerContract = (ids) => {
+  const input = object({ triggerId: ids.trigger });
+  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "Get one trigger by id.",
+    input,
+    kind: "read",
+    name: "trigger.get",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/lifecycle.js
+var makePauseTriggerContract = (ids) => {
+  const input = object({ triggerId: ids.trigger });
+  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    description: "Pause a trigger so it stops firing. Pausing is idempotent. A team whose " + "triggers are all paused reports no trigger activity at all.",
+    input,
+    kind: "write",
+    name: "trigger.pause",
+    output
+  };
+};
+var makeResumeTriggerContract = (ids) => {
+  const input = object({ triggerId: ids.trigger });
+  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Resume a paused trigger. A schedule trigger restarts from the next " + "upcoming slot: the slots it missed while paused do not run.",
+    input,
+    kind: "write",
+    name: "trigger.resume",
+    output
+  };
+};
+var makeDeleteTriggerContract = (ids) => {
+  const input = object({ triggerId: ids.trigger });
+  const output = object({
+    triggerId: ids.trigger.describe("The id of the deleted trigger.")
+  });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    description: "Delete a trigger permanently. The runs it already created are kept. " + "To stop a trigger without losing it, use trigger.pause.",
+    input,
+    kind: "write",
+    name: "trigger.delete",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/update.js
+var makeUpdateTriggerContract = (ids) => {
+  const commonFields = {
+    name: string2().trim().min(1).max(255),
+    triggerId: ids.trigger
+  };
+  const input = discriminatedUnion("kind", [
+    object({
+      ...commonFields,
+      ...makeTriggerScheduleFields({
+        environmentId: ids.environmentRef,
+        flow: ids.flow
+      }),
+      kind: literal("schedule")
+    }),
+    object({
+      ...commonFields,
+      ...makeTriggerDeploymentFields(ids),
+      kind: literal("deployment")
+    })
+  ]).superRefine(checkTriggerConfiguration);
+  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Replace a trigger's configuration. Every field is written, so read the " + "trigger first and send its configuration back with your changes applied. " + "Pausing is separate: use trigger.pause and trigger.resume.",
+    input,
+    kind: "write",
+    name: "trigger.update",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/trigger/index.js
+var makeTriggerContracts = (ids) => ({
+  create: makeCreateTriggerContract(ids),
+  delete: makeDeleteTriggerContract(ids),
+  find: makeFindTriggersContract(ids),
+  get: makeGetTriggerContract(ids),
+  pause: makePauseTriggerContract(ids),
+  resume: makeResumeTriggerContract(ids),
+  update: makeUpdateTriggerContract(ids)
+});
+// node_modules/@qawolf/api-contracts/dist/v1/agent/get.js
+var makeAgentGetContract = (ids) => {
+  const input = object({
+    cursor: string2().min(1).optional().describe("Opaque cursor copied from this same session's previous nextCursor. Omit to read from its first reply."),
+    sessionId: ids.chatSession.describe("The id agent.send answered with."),
+    waitSeconds: number2().int().min(0).optional().describe(`How long the server may hold this check open, in seconds. Omit or pass 0 to answer at once. A larger value clamps to ${maxAgentWaitSeconds}. Check again as soon as a held check returns.`)
+  });
+  const output = resource({
+    nextCursor: string2().min(1).describe("Send back as cursor on the next check to read only what follows. Always present, even with no replies. Belongs to this session alone."),
+    replies: array(agentReplySchema).describe("What the AI has said since the cursor, oldest first. A reply still being written returns again, longer. A reply carrying choices is a question the work is blocked on."),
+    sessionId: ids.chatSession,
+    status: agentSessionStatusSchema,
+    waitSeconds: number2().int().optional().describe("The hold this check was allowed, in seconds, after clamping. Absent when the check did not wait."),
+    wokeOn: agentWakeReasonSchema.optional().describe('Why this check answered when it did. Absent when the check did not wait. "timeout" means nothing new: replies is empty and nextCursor unchanged, so check again with the same cursor.')
+  }, {
+    urlFieldDescription: "Absolute URL of the live session in the QA Wolf app."
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: 'Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of "waiting-for-you" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says "working". Include the session URL when reporting a blocker or final outcome. On "completed", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains "working", report the mismatch and stop monitoring. Stop on "failed" or "cancelled" and report any confirmed partial result.',
+    input,
+    kind: "read",
+    name: "agent.get",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/agent/send.js
+var makeAgentSendContract = (ids) => {
+  const input = object({
+    environmentId: ids.environmentRef.optional().describe("The environment to work in. Omit to use the team's default environment. Ignored when sessionId is given, because a session keeps the environment it opened in."),
+    filePaths: array(teamStoragePathSchema).max(20).optional().describe("Paths of files this request is about, from file.requestUpload. The AI reads them from storage rather than the message, so a plan of hundreds of journeys costs nothing to send."),
+    message: string2().trim().min(1).max(1e4).describe("What you want QA Wolf to do, in plain language. Name the journey, the part of the app it covers, and anything the AI cannot discover for itself, such as a test account, a feature flag, or how to reach a staging environment. When answering a question from agent.get, send the answer here."),
+    parentSessionId: ids.chatSession.optional().describe("The session that is starting this one. QA Wolf lists the new session underneath it, so whoever is watching that session can open the work it handed out. The session you name must not itself have been started this way, because a sub-session cannot start sub-sessions of its own. Ignored when sessionId is given, since continuing a session does not change what started it."),
+    runnerId: runnerIdSchema.optional().describe("The runner you explored on, from runner.launch. Pass it to hand that browser to QA Wolf instead of having a fresh one started, so the pages you opened and any sign-in the user completed there are carried over. Leave the runner running: QA Wolf takes it over and terminates it when the work is done. Omit this when you have no runner, or when you already terminated it."),
+    sessionId: ids.chatSession.optional().describe("Continue the session with this id instead of opening a new one. Omit to start fresh. Send this to answer a question or to add context to work already running."),
+    workspaceId: ids.workspace.optional().describe("The workspace to work in. Required when authenticating with an organization or user API key.")
+  });
   const output = resource({
     sessionId: ids.chatSession.describe("Follow the work by passing this to agent.get."),
     status: agentSessionStatusSchema
@@ -7756,7 +8308,7 @@ var makeAgentSendContract = (ids) => {
       openWorldHint: true,
       readOnlyHint: false
     },
-    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.",
+    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, put the exact returned url in a normal user-visible assistant message, and repeat it in the last message of the turn: only a turn's trailing message is shown expanded. 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.",
     input,
     kind: "write",
     name: "agent.send",
@@ -7764,25 +8316,40 @@ var makeAgentSendContract = (ids) => {
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/automate/index.js
-var makeAutomateContract = (ids) => {
+// node_modules/@qawolf/api-contracts/dist/v1/codeHostIntegration/resource.js
+var makeCodeHostIntegrationResourceSchema = () => resource({
+  connectedAt: exports_iso.datetime().describe("When the code host was connected to the workspace."),
+  provider: _enum(["github", "gitlab"]).describe("The code host this integration connects."),
+  suspendedAt: exports_iso.datetime().optional().describe("Set while GitHub has the QA Wolf app installation suspended. While suspended, GitHub sends QA Wolf no webhooks.")
+}, {
+  urlFieldDescription: "Absolute URL of the workspace's integrations settings page."
+});
+var makeCodeHostRepositoryResourceSchema = () => resource({
+  fullName: string2().describe(`The repository's full name on the code host, such as "acme/storefront".`),
+  provider: _enum(["github", "gitlab"]).describe("The code host the covering integration connects.")
+}, {
+  urlFieldDescription: "Absolute URL of the workspace's integrations settings page."
+});
+
+// node_modules/@qawolf/api-contracts/dist/v1/codeHostIntegration/find.js
+var makeFindCodeHostIntegrationsContract = (ids) => {
   const input = object({
-    aiTaskId: ids.aiTask.describe("The AI task to build the automation on: drafts are read from and the automation branches off the task's branch instead of the environment's.").optional(),
-    environmentId: ids.environmentRef,
-    flowIds: array(ids.flow).min(1).max(300).refine((flowIds) => new Set(flowIds).size === flowIds.length, "flowIds must be unique").describe("IDs of every requested draft flow the automation builds. Reuse an existing draft only when its name matches the requested journey; a generic starter or placeholder is not a match. After publishing, resolve the IDs with `qawolf --json flows list --remote --env <environment-id-or-alias> --include-drafts`, adding `--ai-task-id` when the drafts live on an AI task's branch."),
-    patch: string2().min(1).max(1e6).optional().describe("Unified diff applied to the automation's working branch before it runs. It cannot create or rename a selected flow; publish selected flows with Git first.")
+    workspaceId: ids.workspace.optional().describe("The workspace to list code host integrations from. Required when authenticating with an organization or user API key.")
+  });
+  const output = object({
+    integrations: array(makeCodeHostIntegrationResourceSchema()).describe("The workspace's code host integrations. Empty when no code host is connected."),
+    settingsUrl: url().describe("Absolute URL of the workspace's integrations settings page.")
   });
-  const output = resource({ automationId: ids.automation }, { urlFieldDescription: "Absolute URL of the automation review page." });
   return {
     annotations: {
-      destructiveHint: true,
-      openWorldHint: true,
-      readOnlyHint: false
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
     },
-    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.",
+    description: "List the workspace's code host integrations (GitHub or GitLab). A connected integration lets QA Wolf read repositories and receive the code host's webhooks. codeHostIntegration.listRepositories pages the repositories each integration covers.",
     input,
-    kind: "write",
-    name: "automate",
+    kind: "read",
+    name: "codeHostIntegration.find",
     output
   };
 };
@@ -7794,6 +8361,221 @@ var makePaginationInputFields = (limits) => ({
 });
 var nextCursorSchema = string2().min(1).optional().describe("Repeat the request with this value as cursor to fetch the next page. Absent when there are no further results.");
 
+// node_modules/@qawolf/api-contracts/dist/v1/codeHostIntegration/listRepositories.js
+var makeListCodeHostRepositoriesContract = (ids) => {
+  const input = object({
+    provider: _enum(["github", "gitlab"]).optional().describe("Only list repositories covered by this code host's integration. Omit for all."),
+    workspaceId: ids.workspace.optional().describe("The workspace to list covered repositories from. Required when authenticating with an organization or user API key."),
+    ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 })
+  });
+  const output = object({
+    nextCursor: nextCursorSchema,
+    repositories: array(makeCodeHostRepositoryResourceSchema()).describe("The repositories the workspace's code host integrations cover, alphabetical by full name.")
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "List the repositories the workspace's code host integrations cover, alphabetical by full name. The list reflects the last sync from the code host; codeHostIntegration.find lists the integrations themselves.",
+    input,
+    kind: "read",
+    name: "codeHostIntegration.listRepositories",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/resource.js
+var makeDeploymentResourceSchema = (ids) => resource({
+  branch: string2().optional().describe("The git branch the deployed commit is on. Absent when neither the deployer nor the code host declared one."),
+  commitAuthorName: string2().optional().describe("The author of the deployed commit."),
+  commitMessage: string2().optional().describe("The message of the deployed commit."),
+  commitSha: string2().optional().describe("The sha of the deployed commit."),
+  deployedAt: exports_iso.datetime().describe("When QA Wolf first received the deployment."),
+  deployTarget: string2().optional().describe("Identifies the deployed app within the environment: the URL it serves, or the build path of a mobile build. A trigger's deployTargetPattern matches against it."),
+  environmentId: ids.environment.describe("The QA Wolf environment the deployment reported into."),
+  environmentName: string2().optional().describe("The environment's name. Absent when the environment has since been deleted."),
+  id: ids.deployment,
+  provider: _enum(["github", "gitlab", "api"]).optional().describe("How QA Wolf received the deployment: a GitHub webhook, a GitLab webhook, or the deployment.reportStatus API."),
+  status: _enum(["pending", "success", "failure", "inactive"]).optional().describe("The deployment's lifecycle status, in the vocabulary deployment.reportStatus accepts. Absent when no status was ever reported.")
+}, {
+  urlFieldDescription: "Absolute URL of the workspace's deployments page."
+});
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/find.js
+var makeFindDeploymentsContract = (ids) => {
+  const input = object({
+    workspaceId: ids.workspace.optional().describe("The workspace to list deployments from. Required when authenticating with an organization or user API key."),
+    ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 })
+  });
+  const output = object({
+    deployments: array(makeDeploymentResourceSchema(ids)).describe("The workspace's deployments, newest first."),
+    nextCursor: nextCursorSchema
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.",
+    input,
+    kind: "read",
+    name: "deployment.find",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/listTriggerEvaluations.js
+var conditionKindSchema = _enum(["environment", "deployTarget", "branch"]).describe("What the condition checks on the deployment: the environment it reported into, the deploy target identifying the deployed app, or the git branch of the deployed commit.");
+var conditionVerdictSchema = discriminatedUnion("outcome", [
+  object({
+    kind: conditionKindSchema,
+    outcome: literal("matched")
+  }),
+  object({
+    kind: conditionKindSchema,
+    outcome: literal("did-not-match"),
+    reason: string2().describe("Why the condition did not match this deployment, in plain language.")
+  })
+]);
+var conditionSetsField = array(object({
+  conditions: array(conditionVerdictSchema).describe("One verdict per condition. Conditions in a set are ANDed; a set with no conditions matches every deployment."),
+  outcome: _enum(["matched", "did-not-match"]).describe("Whether every condition in the set matched.")
+})).describe("The trigger's condition sets as they were when the deployment was evaluated, each with per-condition verdicts. Sets are ORed: the trigger matches when any one set matches. Most triggers have exactly one set.");
+var makeRunOutcomeSchema = (ids) => discriminatedUnion("status", [
+  object({
+    runId: ids.run.describe("The run the trigger created."),
+    status: literal("ran")
+  }),
+  object({ status: literal("starting") }),
+  object({
+    reason: string2().describe("Why the matched trigger created no run, in plain language."),
+    status: literal("did-not-run"),
+    supersededByRunId: ids.run.optional().describe("The run that covered this deployment instead, when an earlier delivery of the same deployment had already created one.")
+  }),
+  object({ status: literal("unknown") })
+]).describe("What became of the match. Matching is not running: a matched trigger can still be stopped from creating a run, and did-not-run carries the reason. starting means run creation is still in progress; unknown means QA Wolf has no record of what followed the match.");
+var makeVerdictSchema = (ids) => discriminatedUnion("outcome", [
+  object({
+    conditionSets: conditionSetsField,
+    outcome: literal("matched"),
+    run: makeRunOutcomeSchema(ids)
+  }),
+  object({
+    conditionSets: conditionSetsField,
+    outcome: literal("did-not-match")
+  }),
+  object({
+    outcome: literal("not-considered"),
+    reason: _enum(["trigger-paused", "not-a-deployment-trigger"]).describe("Why the conditions were never checked. trigger-paused: the trigger was paused when the deployment was evaluated. not-a-deployment-trigger: the trigger has no deployment conditions (a schedule trigger, for example), so no deployment can fire it.")
+  })
+]).describe("The trigger's verdict for this deployment: matched, did-not-match with per-condition verdicts, or not-considered when the conditions were never checked at all.");
+var makeEvaluationSchema = (ids) => object({
+  triggerId: ids.trigger.optional().describe("Absent when the trigger has been deleted since."),
+  triggerName: string2().describe("The trigger's name when the deployment was evaluated."),
+  verdict: makeVerdictSchema(ids)
+});
+var makeListDeploymentTriggerEvaluationsContract = (ids) => {
+  const input = object({ deploymentId: ids.deployment });
+  const output = discriminatedUnion("state", [
+    object({
+      evaluations: array(makeEvaluationSchema(ids)).describe("One verdict per trigger that existed when the deployment was evaluated."),
+      state: literal("evaluated")
+    }),
+    object({ state: literal("not-evaluated") }).describe("Triggers were never evaluated for this deployment. Only a deployment's first success report evaluates triggers, so a deployment that never reported success carries no verdicts.")
+  ]);
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.",
+    input,
+    kind: "read",
+    name: "deployment.listTriggerEvaluations",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/reportStatusMetadata.js
+var deploymentReportMetadata = strictObject({
+  commitAuthorName: string2().trim().min(1).max(255).describe("The display name of the person who authored the deployed commit.").optional(),
+  commitMessage: string2().trim().min(1).max(2048).describe("The message of the deployed commit. The deployments list shows its first line.").optional(),
+  commitSha: string2().trim().min(1).max(255).describe("The commit sha of the deployed application revision.").optional(),
+  pullRequestNumber: number2().int().positive().describe("The number of the pull request the deployment belongs to. Requires repository.").optional(),
+  ref: string2().trim().min(1).max(255).describe("The branch or ref that was deployed.").optional(),
+  repository: string2().trim().min(1).max(255).describe('The owner/name of the repository, e.g. "acme/web".').optional()
+}).refine((value) => value.pullRequestNumber === undefined || value.repository !== undefined, {
+  message: "repository is required when pullRequestNumber is provided.",
+  path: ["pullRequestNumber"]
+});
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/reportStatus.js
+var deploymentStatusSchema = _enum([
+  "pending",
+  "success",
+  "failure",
+  "inactive"
+]);
+var makeReportDeploymentStatusContract = (ids) => {
+  const environment = union([
+    strictObject({
+      id: ids.environment.describe("The id of an existing environment. Never creates an environment. Send an alias through name instead.")
+    }),
+    strictObject({
+      baseEphemeralEnvironment: string2().trim().min(1).max(255).describe("The alias or name of the environment a created ephemeral environment copies from. Only valid with ephemeral. The server uses the team default base environment when no environment matches this value.").optional(),
+      ephemeral: boolean2().describe("Requests an ephemeral environment when the name creates one. A name that matches an existing environment keeps that environment's kind.").optional(),
+      name: string2().trim().min(1).max(255).describe("The provider deploy environment name. Resolves an environment by alias or name; creates one when no match exists.")
+    })
+  ], {
+    error: "Send environment as either { id } or { name }, with optional ephemeral and baseEphemeralEnvironment."
+  });
+  const input = strictObject({
+    deployTarget: httpUrl().max(2048).describe("The URL the deployment serves, e.g. a preview URL.").optional(),
+    environment: environment.describe("Selects the environment the deployment reports into.").optional(),
+    environmentVariables: record(string2(), string2()).describe("Environment variable overrides for the runs this deployment requests. A report that omits this field keeps the stored values. A report that sends it replaces them.").optional(),
+    metadata: deploymentReportMetadata.describe("Details the deployer declares about the deployed revision; a code host integration's own record of the same commit is shown in preference to the message and author declared here.").optional(),
+    providerDeploymentId: string2().trim().min(1).max(255).describe('Your identifier for the deployment, e.g. "vercel_dpl_123". Reports with the same providerDeploymentId update one deployment within this workspace.'),
+    status: deploymentStatusSchema.describe("The deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does. The response does not include the resulting runs."),
+    workspaceId: ids.workspace.describe("The workspace to report the deployment status into. A team API key must name its own workspace.")
+  }).superRefine((value, context) => {
+    if (value.environment !== undefined && "name" in value.environment && value.environment.baseEphemeralEnvironment !== undefined && value.environment.ephemeral !== true) {
+      context.addIssue({
+        code: "custom",
+        message: "baseEphemeralEnvironment is only valid with ephemeral.",
+        path: ["environment", "baseEphemeralEnvironment"]
+      });
+    }
+  });
+  const deployment = resource({
+    id: ids.deployment,
+    status: deploymentStatusSchema.describe("The status reported in this request.")
+  }, { urlFieldDescription: "Absolute URL of the environment's runs page." });
+  const output = object({ deployment });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    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.",
+    input,
+    kind: "write",
+    name: "deployment.reportStatus",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/deployment/index.js
+var makeDeploymentContracts = (ids) => ({
+  find: makeFindDeploymentsContract(ids),
+  listTriggerEvaluations: makeListDeploymentTriggerEvaluationsContract(ids),
+  reportStatus: makeReportDeploymentStatusContract(ids)
+});
+
 // node_modules/@qawolf/api-contracts/dist/v1/email/find.js
 var makeFindEmailsContract = (ids) => {
   const input = object({
@@ -7961,29 +8743,6 @@ var makeSendEmailContract = (ids) => {
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/environment/deleteVariable.js
-var makeDeleteEnvironmentVariableContract = (ids) => {
-  const input = object({
-    environmentId: ids.environmentRef,
-    name: string2().trim().min(1, "Environment variable name cannot be blank.").max(255).describe("Name of the environment variable to remove. Canonicalized the same way as environment.setVariable, so the name that was set is the name that deletes.")
-  });
-  const output = object({
-    name: string2().describe("The canonicalized name that was removed. Returned even when the environment had no such variable.")
-  });
-  return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: false,
-      readOnlyHint: false
-    },
-    description: "Remove one environment variable by name. Succeeds whether or not the variable existed.",
-    input,
-    kind: "write",
-    name: "environment.deleteVariable",
-    output
-  };
-};
-
 // node_modules/@qawolf/api-contracts/dist/v1/environment/resource.js
 var makeEnvironmentResourceSchema = (ids) => resource({
   alias: string2().optional().describe("The environment's alias: a team-unique slug that team API keys can use in place of the id. Terminated environments have none."),
@@ -8004,9 +8763,55 @@ var makeEnvironmentResourceSchema = (ids) => resource({
   name: string2(),
   runConcurrencyLimit: string2().describe('Maximum number of concurrent runs: a whole number, "unlimited", or a concurrency expression.'),
   status: _enum(["blocked", "needs-investigation", "ready", "running"]).describe("Standing health across the environment's runs, not its Git reconciliation state: blocked (open blocking bugs), needs-investigation (failures awaiting triage), running (flows executing), ready (none of the above — the greenlit state)."),
-  terminatedAt: exports_iso.datetime().optional().describe("When the environment was terminated, if it has been.")
+  terminatedAt: exports_iso.datetime().optional().describe("When the environment was terminated, if it has been."),
+  variablesUrl: url().optional().describe("Absolute URL of the page where a person saves this environment's variables. Give it to the user when a login or key is missing, rather than collecting the value yourself. Absent once the environment is terminated, because that page no longer exists.")
 }, { urlFieldDescription: "Absolute URL of the environment page." });
 
+// node_modules/@qawolf/api-contracts/dist/v1/environment/create.js
+var makeCreateEnvironmentContract = (ids) => {
+  const input = object({
+    name: string2().min(1).max(255).regex(/\S/, "Environment name cannot be blank.").describe("Display name of the new environment."),
+    workspaceId: ids.workspace.optional().describe("The workspace to create the environment in. Required when authenticating with an organization or user API key.")
+  });
+  const output = makeEnvironmentResourceSchema(ids);
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    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.",
+    input,
+    kind: "write",
+    name: "environment.create",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/environment/deleteVariable.js
+var makeDeleteEnvironmentVariableContract = (ids) => {
+  const input = object({
+    environmentId: ids.environmentRef,
+    name: string2().trim().min(1, "Environment variable name cannot be blank.").max(255).describe("Name of the environment variable to remove. Canonicalized the same way as environment.setVariable, so the name that was set is the name that deletes."),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
+  });
+  const output = object({
+    name: string2().describe("The canonicalized name that was removed. Returned even when the environment had no such variable.")
+  });
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    description: "Remove one environment variable by name. Succeeds whether or not the variable existed.",
+    input,
+    kind: "write",
+    name: "environment.deleteVariable",
+    output
+  };
+};
+
 // node_modules/@qawolf/api-contracts/dist/v1/environment/find.js
 var makeFindEnvironmentsContract = (ids) => {
   const input = object({
@@ -8038,7 +8843,8 @@ var makeFindEnvironmentsContract = (ids) => {
 var makeGetEnvironmentVariableContract = (ids) => {
   const input = object({
     environmentId: ids.environmentRef,
-    variableNames: array(string2().min(1).max(255)).min(1).max(100).describe("Names of the environment variables to read. Names match exactly as environment.listVariableNames returns them. Request every name you need in a single call, up to 100 names per call.")
+    variableNames: array(string2().min(1).max(255)).min(1).max(100).describe("Names of the environment variables to read. Names match exactly as environment.listVariableNames returns them. Request every name you need in a single call, up to 100 names per call."),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const output = object({
     missingNames: array(string2()).describe("Requested names the environment does not have, sorted alphabetically."),
@@ -8064,7 +8870,8 @@ var makeGetEnvironmentVariableContract = (ids) => {
 // node_modules/@qawolf/api-contracts/dist/v1/environment/index.js
 var makeGetEnvironmentContract = (ids) => {
   const input = object({
-    environmentId: ids.environmentRef
+    environmentId: ids.environmentRef,
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const output = makeEnvironmentResourceSchema(ids);
   return {
@@ -8082,7 +8889,8 @@ var makeGetEnvironmentContract = (ids) => {
 };
 var makeListEnvironmentVariableNamesContract = (ids) => {
   const input = object({
-    environmentId: ids.environmentRef
+    environmentId: ids.environmentRef,
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const output = object({
     variableNames: array(string2()).describe("Names of the environment's variables, sorted alphabetically. Values are never returned.")
@@ -8104,7 +8912,8 @@ var makeSetEnvironmentVariableContract = (ids) => {
   const input = object({
     environmentId: ids.environmentRef,
     name: string2().trim().min(1, "Environment variable name cannot be blank.").max(255).describe("Name of the environment variable to create or replace. Leading and trailing whitespace is removed, remaining whitespace is replaced with underscores, and letters are uppercased."),
-    value: string2().describe("Value to store. This secret value is accepted but never returned.")
+    value: string2().describe("Value to store. This secret value is accepted but never returned."),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const output = object({
     name: string2().describe("The stored variable name after whitespace is replaced with underscores and letters are uppercased.")
@@ -8122,25 +8931,6 @@ var makeSetEnvironmentVariableContract = (ids) => {
     output
   };
 };
-var makeCreateEnvironmentContract = (ids) => {
-  const input = object({
-    name: string2().min(1).max(255).regex(/\S/, "Environment name cannot be blank.").describe("Display name of the new environment."),
-    workspaceId: ids.workspace.optional().describe("The workspace to create the environment in. Required when authenticating with an organization or user API key.")
-  });
-  const output = makeEnvironmentResourceSchema(ids);
-  return {
-    annotations: {
-      destructiveHint: false,
-      openWorldHint: true,
-      readOnlyHint: false
-    },
-    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.",
-    input,
-    kind: "write",
-    name: "environment.create",
-    output
-  };
-};
 
 // node_modules/@qawolf/api-contracts/dist/v1/environment/update.js
 var makeUpdateEnvironmentContract = (ids) => {
@@ -8149,7 +8939,8 @@ var makeUpdateEnvironmentContract = (ids) => {
   const input = object({
     environmentId: ids.environmentRef,
     name: nameSchema.optional(),
-    runConcurrencyLimit: runConcurrencyLimitSchema.optional()
+    runConcurrencyLimit: runConcurrencyLimitSchema.optional(),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   }).refine((update) => update.name !== undefined || update.runConcurrencyLimit !== undefined, {
     message: "At least one of name or runConcurrencyLimit is required."
   });
@@ -8236,10 +9027,27 @@ var makeListFlowsContract = (ids) => {
   const input = object({
     aiTaskId: ids.aiTask.describe("List the flows on this AI task's branch, including drafts, instead of the ones in the environment. The task must belong to the environment.").optional(),
     environmentId: ids.environmentRef,
-    includeDrafts: boolean2().default(false).describe("Include draft flows in the listing.")
+    includeDrafts: boolean2().default(false).describe("Include draft flows in the listing."),
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const executionTarget = union([string2().min(1), record(string2(), unknown())]).describe("The target the flow executes against, as a preset or object.");
+  const emptyReason = discriminatedUnion("type", [
+    object({
+      type: literal("branch-never-reconciled").describe("The environment's flow code branch has no reconciled commit yet, so there is nothing to list. Read environment.get's flowCodeBranch and list again once syncStatus is reconciled.")
+    }),
+    object({
+      type: literal("commit-has-no-flow-files").describe("The reconciled commit holds no flow file. The branch may never have had one, or a commit removed it: read the branch history at lastSyncedCommitHash before concluding either.")
+    }),
+    object({
+      hiddenDraftCount: number2().int().positive().describe("How many draft flows this listing hid."),
+      type: literal("every-flow-is-a-draft").describe("Every flow this listing matched is a draft, and the listing excluded drafts. Send includeDrafts to see them.")
+    }),
+    object({
+      type: literal("no-flow-matched-the-listing").describe("The reconciled commit contains flow files, but this listing matched none of them: their flows were deleted after the commit reconciled, or a filter excluded every one.")
+    })
+  ]).describe("Why this listing has no flows, present only when flows is empty. Read it before concluding that a flow went missing.");
   const output = object({
+    emptyReason: emptyReason.optional(),
     flows: array(resource({
       executionTarget,
       flowId: ids.flow,
@@ -8505,14 +9313,134 @@ var makeUpdateIssueContract = (ids) => {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Update an issue owned by the caller's team. Omitted fields remain unchanged.",
+    description: "Update an issue owned by the caller's team. Omitted fields remain unchanged.",
+    input,
+    kind: "write",
+    name: "issue.update",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/legacyTrigger/resource.js
+var namedIdentity = object({ id: string2(), name: string2() });
+var branchScope = union([
+  object({ kind: literal("all-branches") }),
+  object({
+    caseSensitiveGlobs: array(string2()),
+    kind: literal("listed-branches"),
+    negated: boolean2(),
+    raw: string2()
+  })
+]);
+var codeHostingServiceRepository = union([
+  object({ kind: literal("any") }),
+  object({ kind: literal("none") }),
+  object({ id: string2(), kind: literal("by-id") })
+]);
+var makeLegacyTriggerSchema = (ids) => {
+  const base = {
+    environment: object({
+      id: ids.environment,
+      kind: _enum(["static", "preview"]).describe("Whether the environment is static or a preview. A preview environment holds copies of the static deployment triggers."),
+      name: string2(),
+      terminatedAt: exports_iso.datetime().optional().describe("When the environment was terminated, if it has been.")
+    }),
+    id: ids.legacyTrigger,
+    isPaused: boolean2(),
+    name: string2(),
+    pausedAt: exports_iso.datetime().optional(),
+    tags: array(namedIdentity)
+  };
+  return union([
+    object({
+      ...base,
+      nextAt: exports_iso.datetime().optional(),
+      repeatMinutes: number2(),
+      startAt: exports_iso.datetime().optional(),
+      timezoneId: string2().optional(),
+      type: literal("scheduled")
+    }),
+    object({
+      ...base,
+      adaptiveFlowSelection: boolean2().describe("Whether QA Wolf picks the flows to run from the deployment's changes. Such a trigger migrates to a generativeSuite action, which names no flows or tags of its own."),
+      branchScope,
+      codeHostingServiceRepository,
+      deploymentPrLabel: string2().optional(),
+      deploymentType: string2().optional(),
+      type: union([literal("generic"), literal("pr-testing-button")])
+    })
+  ]);
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/legacyTrigger/find.js
+var makeFindLegacyTriggersContract = (ids) => {
+  const input = object({
+    kind: _enum(["active", "all", "static"]).default("active").describe(`Which environments to list triggers from. "active", the default, covers the static environments plus the pull request environments still in use. "static" covers the static environments only, where every pull request copy's original lives. "all" adds the pull request environments that have already been torn down, whose environment carries a terminatedAt.`),
+    workspaceId: ids.workspace.optional().describe("The workspace to list legacy triggers from. Required when authenticating with an organization or user API key.")
+  });
+  const output = object({
+    legacyTriggers: array(makeLegacyTriggerSchema(ids)).describe("The workspace's legacy triggers, by name.")
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "List a workspace's legacy per-environment triggers; trigger.find " + "lists the current ones. For migration only; it goes when legacy " + "triggers go. adaptiveFlowSelection becomes a generativeSuite action, " + "which takes no tags.",
+    input,
+    kind: "read",
+    name: "legacyTrigger.find",
+    output
+  };
+};
+
+// node_modules/@qawolf/api-contracts/dist/v1/legacyTrigger/lifecycle.js
+var makeLifecycleShape = (ids) => ({
+  input: object({ legacyTriggerId: ids.legacyTrigger }),
+  output: object({
+    isPaused: boolean2(),
+    legacyTriggerId: ids.legacyTrigger
+  })
+});
+var makePauseLegacyTriggerContract = (ids) => {
+  const { input, output } = makeLifecycleShape(ids);
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    description: "Pause one legacy trigger, the older per-environment kind, so it stops " + "firing; use trigger.pause for a current one. Its copies in pull " + "request environments pause too. For migration only; it goes when " + "legacy triggers go.",
+    input,
+    kind: "write",
+    name: "legacyTrigger.pause",
+    output
+  };
+};
+var makeResumeLegacyTriggerContract = (ids) => {
+  const { input, output } = makeLifecycleShape(ids);
+  return {
+    annotations: {
+      destructiveHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Resume one legacy trigger, the older per-environment kind; use " + "trigger.resume for a current one. Its copies in pull request " + "environments resume too, and a scheduled one jumps to the next " + "upcoming slot even if it was not paused. For migration only; it goes " + "when legacy triggers go.",
     input,
     kind: "write",
-    name: "issue.update",
+    name: "legacyTrigger.resume",
     output
   };
 };
 
+// node_modules/@qawolf/api-contracts/dist/v1/legacyTrigger/index.js
+var makeLegacyTriggerContracts = (ids) => ({
+  find: makeFindLegacyTriggersContract(ids),
+  pause: makePauseLegacyTriggerContract(ids),
+  resume: makeResumeLegacyTriggerContract(ids)
+});
+
 // node_modules/@qawolf/api-contracts/dist/v1/run/diagnose.js
 var makeDiagnoseRunContract = (ids) => {
   const input = object({
@@ -8556,7 +9484,8 @@ var makeFindRunsContract = (ids) => {
   const input = object({
     createdAfter: exports_iso.datetime({ offset: true }).optional().describe("Only include runs created after this instant, e.g. the runs since a deploy."),
     ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 }),
-    environmentId: ids.environmentRef
+    environmentId: ids.environmentRef,
+    workspaceId: workspaceForEnvironmentRef(ids.workspace)
   });
   const output = object({
     nextCursor: nextCursorSchema,
@@ -8704,6 +9633,54 @@ var makeStopRunContract = (ids) => {
   };
 };
 
+// node_modules/@qawolf/api-contracts/dist/v1/run/triage.js
+var probability = number2().min(0).max(1);
+var verdictAnswer = object({
+  choice: _enum(["bug", "maintenance"]),
+  confidence: probability,
+  probabilities: record(string2(), probability),
+  type: literal("choice")
+});
+var makeTriageRunContract = (ids) => {
+  const input = object({
+    flowId: ids.flow.describe("The flow that failed in the run."),
+    runId: ids.run
+  });
+  const decision = discriminatedUnion("type", [
+    object({
+      diagnosis: _enum(["bug", "maintenance"]),
+      type: literal("diagnose")
+    }),
+    object({
+      diagnosis: _enum(["bug", "maintenance"]),
+      type: literal("suggest")
+    }),
+    object({
+      type: literal("needsHuman")
+    })
+  ]);
+  const output = object({
+    answers: object({
+      verdict: verdictAnswer
+    }),
+    decision: decision.describe("What the triage would do with the verdict. The prototype records nothing; it only reports."),
+    model: string2(),
+    state: json().describe("The context that was sent to the model, for inspection.")
+  });
+  return {
+    annotations: {
+      destructiveHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    description: "Prototype. Ask Jev, a TypeSafe System One model, whether a flow failure in a run is a bug in the product " + "or a test that needs maintenance. Compares the failing attempt with the flow's last passing run in the " + "same environment. Records nothing.",
+    input,
+    kind: "read",
+    name: "run.triage",
+    output
+  };
+};
+
 // node_modules/@qawolf/api-contracts/dist/v1/runner/evaluateSnippet.js
 var maxSnippetCodeLength = 64 * 1024;
 var makeEvaluateSnippetOnRunnerContract = (ids) => {
@@ -8748,18 +9725,26 @@ var makeGetRunnerContract = (ids) => {
     id: runnerIdSchema.describe("Id of the runner to look up."),
     workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
   });
-  const output = object({
+  const addressed = object({
     id: runnerIdSchema.describe("Id of the runner the call addressed."),
-    outcome: literal("success"),
-    running: boolean2().describe("False when no runner is running under this id: it was never launched, it was terminated, or it terminated on its own after inactivity. These are not distinguished, because the run system keeps no record of a runner once it is gone.")
+    outcome: literal("success")
   });
+  const output = discriminatedUnion("running", [
+    addressed.extend({
+      running: literal(false).describe("No runner is running under this id: it was never launched, it was terminated, or it terminated on its own after inactivity. These are not distinguished, because the run system keeps no record of a runner once it is gone.")
+    }),
+    addressed.extend({
+      running: literal(true).describe("A runner is running under this id and can be addressed."),
+      url: runnerWatchUrlSchema
+    })
+  ]);
   return {
     annotations: {
       destructiveHint: false,
       openWorldHint: false,
       readOnlyHint: true
     },
-    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.",
+    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.",
     input,
     kind: "read",
     name: "runner.get",
@@ -8860,7 +9845,7 @@ var makeLaunchRunnerContract = (ids) => {
       openWorldHint: false,
       readOnlyHint: false
     },
-    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.",
+    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. A success means the runner is answering: the call waits for the pod it started to come up, so the very next call to the runner reaches it. If the pod does not come up in time the call fails instead, leaving the runner running — launching the same id again attaches to it. After a successful launch, put the exact returned `url` in a normal user-visible assistant message so they can watch while the browser is driven. 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.",
     input,
     kind: "write",
     name: "runner.launch",
@@ -8976,405 +9961,230 @@ var makeReadRunnerJournalContract = (ids) => {
 // node_modules/@qawolf/api-contracts/dist/v1/runner/runFlow.js
 var unchangedFilesSchema = record(string2(), string2().min(1)).superRefine((hashes, refinementContext) => {
   for (const path of Object.keys(hashes)) {
-    if (isShippableRunFilePath(path))
-      continue;
-    refinementContext.addIssue({
-      code: "custom",
-      message: runFilePathRefusal,
-      path: [path]
-    });
-  }
-});
-var makeRunFlowOnRunnerContract = (ids) => {
-  const input = object({
-    entryPointPath: runFilePathSchema.describe("Path of the flow file to run, as it appears in `files`."),
-    env: runEnvironmentSchema.optional().describe("Environment variables to make available to the run."),
-    environmentId: ids.environmentRef.optional().describe("A QA Wolf environment whose variables the run is given, by id or alias. QA Wolf reads and decrypts them itself, so they never travel in the request and the count and length limits on `env` do not apply to them. Send this or `env`, not both."),
-    files: runFilesSchema.describe("Every file the run needs keyed by its path — the flow file, everything it imports, package.json and tsconfig.json. A runner holds no copy of your project, so what runs is exactly what is sent here."),
-    id: runnerIdSchema.describe("Id of the runner to run the flow on."),
-    selection: runSelectionSchema.optional().describe("Run only these lines, inside the page the runner is already on, instead of running the whole flow from a fresh browser. Omit to run the whole entry point."),
-    unchangedFiles: unchangedFilesSchema.optional().describe("Files this runner already holds from an earlier run, keyed by path with a hex SHA-256 of the content it should hold. Send this to make `files` only what changed. The runner refuses with `needs-full-sync` if it holds none of a referenced path, so it never runs something other than what was asked for. Omit it to send every file."),
-    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
-  }).refine((request) => request.env === undefined || request.environmentId === undefined, {
-    error: "Send env or environmentId, not both. An environment's variables are taken as they are stored, so there is no order in which the two would combine.",
-    path: ["environmentId"]
-  }).refine((request) => Object.hasOwn(request.files, request.entryPointPath), {
-    error: "The entry point must be one of the files.",
-    path: ["files"]
-  }).refine((request) => Object.hasOwn(request.files, runPackageJsonPath), {
-    error: `The files must include ${runPackageJsonPath}; the run's npm dependencies are read from it.`,
-    path: ["files"]
-  }).refine((request) => request.selection === undefined || Object.hasOwn(request.files, request.selection.path), {
-    error: "A selection must name a file carried in files.",
-    path: ["selection", "path"]
-  }).refine((request) => Object.keys(request.unchangedFiles ?? {}).every((path) => !Object.hasOwn(request.files, path)), {
-    error: "A path may be sent in files or referenced in unchangedFiles, not both.",
-    path: ["unchangedFiles"]
-  });
-  const failure = discriminatedUnion("failureReason", [
-    object({
-      failureReason: literal("runner-target-mismatch"),
-      outcome: literal("failure"),
-      requiredRunnerName: runnerNameSchema.describe("The runner family this flow's execution target needs."),
-      runnerName: runnerNameSchema.describe("The runner family the runner is actually running.")
-    }),
-    object({
-      failureReason: literal("needs-full-sync"),
-      missingPaths: array(runFilePathSchema).describe("Paths referenced in `unchangedFiles` that this runner does not hold. Send the run again with every file it needs in `files`."),
-      outcome: literal("failure")
-    }),
-    object({
-      failureReason: literal("runner-unreachable"),
-      outcome: literal("failure")
-    })
-  ]);
-  const output = discriminatedUnion("outcome", [
-    object({
-      bootstrappedRunner: boolean2().optional().describe("True when the runner had no live browser and one was started before the run, so a `selection` ran against a fresh page rather than the one an earlier run left. Absent means the runner was already warm. Only a request carrying `selection` can bootstrap, because a whole run starts its own browser either way."),
-      outcome: literal("success"),
-      runId: string2().describe("Id of the run, to follow it by. Read the `run-status` stream of the runner's journal for its outcome, and `run-logs` and `run-events` for its output.")
-    }),
-    failure
-  ]);
-  return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: true,
-      readOnlyHint: false
-    },
-    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.",
-    input,
-    kind: "write",
-    name: "runner.runFlow",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/runner/stopRun.js
-var makeStopRunOnRunnerContract = (ids) => {
-  const input = object({
-    id: runnerIdSchema.describe("Id of the runner to stop the run on."),
-    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
-  });
-  const output = discriminatedUnion("outcome", [
-    object({
-      outcome: literal("success"),
-      wasRunning: boolean2().describe("False when the runner had nothing to stop: the run had already finished, or none had been submitted. Not an error.")
-    }),
-    makeRunnerFailureSchema([runnerUnreachableFailureReason])
-  ]);
-  return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: false,
-      readOnlyHint: false
-    },
-    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.",
-    input,
-    kind: "write",
-    name: "runner.stopRun",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/runner/takeScreenshot.js
-var makeTakeScreenshotOnRunnerContract = (ids) => {
-  const input = object({
-    id: runnerIdSchema.describe("Id of the runner to take a screenshot of."),
-    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
-  });
-  const output = discriminatedUnion("outcome", [
-    object({
-      imageJpegBase64: screenshotImageSchema,
-      outcome: literal("success")
-    }),
-    makeRunnerFailureSchema([
-      ...screenFailureReasons,
-      runnerUnreachableFailureReason
-    ])
-  ]);
-  return {
-    annotations: {
-      destructiveHint: false,
-      openWorldHint: false,
-      readOnlyHint: false
-    },
-    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. ${screenNeedsARunDescription} ${screenNotReadyDescription} ${runnerHasNoScreenDescription} ${retryableRunnerUnreachableDescription}`,
-    input,
-    kind: "read",
-    name: "runner.takeScreenshot",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/tag/list.js
-var makeListTagsContract = (ids) => {
-  const input = object({
-    includeFlowIds: boolean2().default(false).describe("Also return the ids of the flows that carry each tag."),
-    names: array(string2().trim().min(1)).min(1).max(100).optional().describe("Only list tags with these names. Matching is case sensitive. Omit to list all tags."),
-    workspaceId: ids.workspace.optional().describe("The workspace to list tags from. Required when authenticating with an organization or user API key."),
-    ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 })
-  });
-  const output = object({
-    nextCursor: nextCursorSchema,
-    tags: array(makeTagResourceSchema().extend({
-      flowIds: array(ids.flow).optional().describe("Ids of the flows that carry the tag. Present only when includeFlowIds is set.")
-    })).describe("The team's tags, alphabetical by name.")
-  });
-  return {
-    annotations: {
-      destructiveHint: false,
-      openWorldHint: false,
-      readOnlyHint: true
-    },
-    description: "List the team's tags, alphabetical by name. Tag names select flows in run.create.",
-    input,
-    kind: "read",
-    name: "tag.list",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/configurationRules.js
-var checkAction = (action, ctx) => {
-  const namesFlows = action.flowIds.length + action.tagNames.length > 0;
-  if (action.kind === "generativeSuite") {
-    if (namesFlows) {
-      ctx.addIssue({
-        code: "custom",
-        message: "flowIds and tagNames do not apply when the action is generativeSuite.",
-        path: ["action", "flowIds"]
-      });
-    }
-    return;
-  }
-  if (action.instructions !== undefined) {
-    ctx.addIssue({
-      code: "custom",
-      message: "instructions apply to a generativeSuite action only.",
-      path: ["action", "instructions"]
-    });
-  }
-  if (!namesFlows) {
-    ctx.addIssue({
-      code: "custom",
-      message: "At least one flow or tag is required.",
-      path: ["action", "flowIds"]
-    });
-  }
-};
-var checkSchedule = (value, ctx) => {
-  if (value.cadence === "daily") {
-    for (const field of ["timeOfDay", "timezoneId"]) {
-      if (value[field] === undefined) {
-        ctx.addIssue({
-          code: "custom",
-          message: `${field} is required when cadence is daily.`,
-          path: [field]
-        });
-      }
-    }
-    if (value.minuteOfHour !== undefined) {
-      ctx.addIssue({
-        code: "custom",
-        message: "minuteOfHour applies to an hourly cadence only.",
-        path: ["minuteOfHour"]
-      });
-    }
-  } else {
-    for (const field of ["timeOfDay", "timezoneId"]) {
-      if (value[field] !== undefined) {
-        ctx.addIssue({
-          code: "custom",
-          message: `${field} applies to a daily cadence only.`,
-          path: [field]
-        });
-      }
-    }
-  }
-  if (value.action.kind === "generativeSuite") {
-    ctx.addIssue({
-      code: "custom",
-      message: "A schedule trigger cannot use a generativeSuite action.",
-      path: ["action", "kind"]
-    });
-    return;
-  }
-  checkAction(value.action, ctx);
-};
-var checkDeployment = (value, ctx) => {
-  if (value.environmentPattern !== undefined && value.environmentIds.length > 0) {
-    ctx.addIssue({
+    if (isShippableRunFilePath(path))
+      continue;
+    refinementContext.addIssue({
       code: "custom",
-      message: "Supply environmentIds or environmentPattern, not both.",
-      path: ["environmentPattern"]
+      message: runFilePathRefusal,
+      path: [path]
     });
   }
-  checkAction(value.action, ctx);
-};
-var checkTriggerConfiguration = (value, ctx) => value.kind === "schedule" ? checkSchedule(value, ctx) : checkDeployment(value, ctx);
-
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/create.js
-var makeCreateTriggerContract = (ids) => {
-  const commonFields = {
-    name: string2().trim().min(1).max(255),
-    workspaceId: ids.workspace.optional().describe("The workspace to create the trigger in. Required when authenticating with an organization or user API key.")
-  };
-  const input = discriminatedUnion("kind", [
+});
+var makeRunFlowOnRunnerContract = (ids) => {
+  const input = object({
+    entryPointPath: runFilePathSchema.describe("Path of the flow file to run, as it appears in `files`."),
+    env: runEnvironmentSchema.optional().describe("Environment variables to make available to the run."),
+    environmentId: ids.environmentRef.optional().describe("A QA Wolf environment whose variables the run is given, by id or alias. QA Wolf reads and decrypts them itself, so they never travel in the request and the count and length limits on `env` do not apply to them. Send this or `env`, not both."),
+    files: runFilesSchema.describe("Every file the run needs keyed by its path — the flow file, everything it imports, package.json and tsconfig.json. A runner holds no copy of your project, so what runs is exactly what is sent here."),
+    id: runnerIdSchema.describe("Id of the runner to run the flow on."),
+    selection: runSelectionSchema.optional().describe("Run only these lines, inside the page the runner is already on, instead of running the whole flow from a fresh browser. Omit to run the whole entry point."),
+    unchangedFiles: unchangedFilesSchema.optional().describe("Files this runner already holds from an earlier run, keyed by path with a hex SHA-256 of the content it should hold. Send this to make `files` only what changed. The runner refuses with `needs-full-sync` if it holds none of a referenced path, so it never runs something other than what was asked for. Omit it to send every file."),
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
+  }).refine((request) => request.env === undefined || request.environmentId === undefined, {
+    error: "Send env or environmentId, not both. An environment's variables are taken as they are stored, so there is no order in which the two would combine.",
+    path: ["environmentId"]
+  }).refine((request) => Object.hasOwn(request.files, request.entryPointPath), {
+    error: "The entry point must be one of the files.",
+    path: ["files"]
+  }).refine((request) => Object.hasOwn(request.files, runPackageJsonPath), {
+    error: `The files must include ${runPackageJsonPath}; the run's npm dependencies are read from it.`,
+    path: ["files"]
+  }).refine((request) => request.selection === undefined || Object.hasOwn(request.files, request.selection.path), {
+    error: "A selection must name a file carried in files.",
+    path: ["selection", "path"]
+  }).refine((request) => Object.keys(request.unchangedFiles ?? {}).every((path) => !Object.hasOwn(request.files, path)), {
+    error: "A path may be sent in files or referenced in unchangedFiles, not both.",
+    path: ["unchangedFiles"]
+  });
+  const failure = discriminatedUnion("failureReason", [
     object({
-      ...commonFields,
-      ...makeTriggerScheduleFields({
-        environmentId: ids.environmentRef,
-        flow: ids.flow
-      }),
-      kind: literal("schedule")
+      failureReason: literal("runner-target-mismatch"),
+      outcome: literal("failure"),
+      requiredRunnerName: runnerNameSchema.describe("The runner family this flow's execution target needs."),
+      runnerName: runnerNameSchema.describe("The runner family the runner is actually running.")
     }),
     object({
-      ...commonFields,
-      ...makeTriggerDeploymentFields(ids),
-      kind: literal("deployment")
+      failureReason: literal("needs-full-sync"),
+      missingPaths: array(runFilePathSchema).describe("Paths referenced in `unchangedFiles` that this runner does not hold. Send the run again with every file it needs in `files`."),
+      outcome: literal("failure")
+    }),
+    object({
+      failureReason: literal("runner-unreachable"),
+      outcome: literal("failure")
     })
-  ]).superRefine(checkTriggerConfiguration);
-  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+  ]);
+  const output = discriminatedUnion("outcome", [
+    object({
+      bootstrappedRunner: boolean2().optional().describe("True when the runner had no live browser and one was started before the run, so a `selection` ran against a fresh page rather than the one an earlier run left. Absent means the runner was already warm. Only a request carrying `selection` can bootstrap, because a whole run starts its own browser either way."),
+      outcome: literal("success"),
+      runId: string2().describe("Id of the run, to follow it by. Read the `run-status` stream of the runner's journal for its outcome, and `run-logs` and `run-events` for its output.")
+    }),
+    failure
+  ]);
   return {
     annotations: {
       destructiveHint: true,
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Create a trigger. A schedule trigger runs a named set of flows on a cadence; " + "a deployment trigger runs when a matching deployment is reported.",
+    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.",
     input,
     kind: "write",
-    name: "trigger.create",
+    name: "runner.runFlow",
     output
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/find.js
-var makeFindTriggersContract = (ids) => {
+// node_modules/@qawolf/api-contracts/dist/v1/runner/stopRun.js
+var makeStopRunOnRunnerContract = (ids) => {
   const input = object({
-    isPaused: boolean2().optional().describe("Only list paused, or only unpaused, triggers. Omit for both."),
-    workspaceId: ids.workspace.optional().describe("The workspace to list triggers from. Required when authenticating with an organization or user API key.")
-  });
-  const output = object({
-    triggers: array(makeTriggerResourceSchema(ids)).describe("The team's triggers, newest first.")
+    id: runnerIdSchema.describe("Id of the runner to stop the run on."),
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
   });
+  const output = discriminatedUnion("outcome", [
+    object({
+      outcome: literal("success"),
+      wasRunning: boolean2().describe("False when the runner had nothing to stop: the run had already finished, or none had been submitted. Not an error.")
+    }),
+    makeRunnerFailureSchema([runnerUnreachableFailureReason])
+  ]);
   return {
     annotations: {
-      destructiveHint: false,
+      destructiveHint: true,
       openWorldHint: false,
-      readOnlyHint: true
+      readOnlyHint: false
     },
-    description: "List the team's triggers, newest first.",
+    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.",
     input,
-    kind: "read",
-    name: "trigger.find",
+    kind: "write",
+    name: "runner.stopRun",
     output
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/get.js
-var makeGetTriggerContract = (ids) => {
-  const input = object({ triggerId: ids.trigger });
-  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+// node_modules/@qawolf/api-contracts/dist/v1/runner/takeScreenshot.js
+var makeTakeScreenshotOnRunnerContract = (ids) => {
+  const input = object({
+    id: runnerIdSchema.describe("Id of the runner to take a screenshot of."),
+    workspaceId: ids.workspace.optional().describe(runnerWorkspaceIdDescription)
+  });
+  const output = discriminatedUnion("outcome", [
+    object({
+      imageJpegBase64: screenshotImageSchema,
+      outcome: literal("success")
+    }),
+    makeRunnerFailureSchema([
+      ...screenFailureReasons,
+      runnerUnreachableFailureReason
+    ])
+  ]);
   return {
     annotations: {
       destructiveHint: false,
       openWorldHint: false,
-      readOnlyHint: true
+      readOnlyHint: false
     },
-    description: "Get one trigger by id.",
+    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. ${screenNeedsARunDescription} ${screenNotReadyDescription} ${runnerHasNoScreenDescription} ${retryableRunnerUnreachableDescription}`,
     input,
     kind: "read",
-    name: "trigger.get",
+    name: "runner.takeScreenshot",
     output
   };
 };
 
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/lifecycle.js
-var makePauseTriggerContract = (ids) => {
-  const input = object({ triggerId: ids.trigger });
-  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+// node_modules/@qawolf/api-contracts/dist/v1/runner/catalog.js
+var makeRunnerContracts = (ids) => ({
+  evaluateSnippet: makeEvaluateSnippetOnRunnerContract(ids),
+  get: makeGetRunnerContract(ids),
+  highlightSelector: makeHighlightSelectorOnRunnerContract(ids),
+  importPackage: makeImportPackageOnRunnerContract(ids),
+  inspect: makeInspectOnRunnerContract(ids),
+  inspectMobile: makeInspectMobileOnRunnerContract(ids),
+  launch: makeLaunchRunnerContract(ids),
+  list: makeListRunnersContract(ids),
+  performAction: makePerformActionOnRunnerContract(ids),
+  performActions: makePerformActionsOnRunnerContract(ids),
+  promoteSnapshot: makePromoteSnapshotOnRunnerContract(ids),
+  readJournal: makeReadRunnerJournalContract(ids),
+  ...makeRecordingContracts(ids),
+  runFlow: makeRunFlowOnRunnerContract(ids),
+  stopRun: makeStopRunOnRunnerContract(ids),
+  takeScreenshot: makeTakeScreenshotOnRunnerContract(ids),
+  terminate: makeTerminateRunnerContract(ids)
+});
+
+// node_modules/@qawolf/api-contracts/dist/v1/skill/index.js
+var skillName = string2().trim().min(1).max(255).describe("The skill's name as skill.list reports it, such as qawolf-onboarding. The qawolf- prefix is optional, so onboarding names the same skill.");
+var skillSummary = object({
+  description: string2().describe("When to use the skill, in the words the agent routes on."),
+  name: string2().describe("The skill's name. Read it with skill.get.")
+});
+var readOnlyAnnotations = {
+  destructiveHint: false,
+  openWorldHint: false,
+  readOnlyHint: true
+};
+var makeListSkillsContract = () => {
+  const input = object({});
+  const output = object({
+    skills: array(skillSummary).describe("Every skill the server serves, in catalog order.")
+  });
   return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: false,
-      readOnlyHint: false
-    },
-    description: "Pause a trigger so it stops firing. Pausing is idempotent. A team whose " + "triggers are all paused reports no trigger activity at all.",
+    annotations: readOnlyAnnotations,
+    description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.",
     input,
-    kind: "write",
-    name: "trigger.pause",
+    kind: "read",
+    name: "skill.list",
     output
   };
 };
-var makeResumeTriggerContract = (ids) => {
-  const input = object({ triggerId: ids.trigger });
-  const output = object({ trigger: makeTriggerResourceSchema(ids) });
+var makeGetSkillContract = () => {
+  const input = object({ name: skillName });
+  const output = skillSummary.extend({
+    instructions: string2().describe("The skill's SKILL.md, frontmatter included."),
+    references: array(object({
+      path: string2().describe("The file's path relative to the skill directory."),
+      text: string2().describe("The file's content.")
+    })).describe("The files the skill links to under its directory.")
+  });
   return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: true,
-      readOnlyHint: false
-    },
-    description: "Resume a paused trigger. A schedule trigger restarts from the next " + "upcoming slot: the slots it missed while paused do not run.",
+    annotations: readOnlyAnnotations,
+    description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.",
     input,
-    kind: "write",
-    name: "trigger.resume",
+    kind: "read",
+    name: "skill.get",
     output
   };
 };
-var makeDeleteTriggerContract = (ids) => {
-  const input = object({ triggerId: ids.trigger });
+var makeSkillContracts = () => ({
+  get: makeGetSkillContract(),
+  list: makeListSkillsContract()
+});
+
+// node_modules/@qawolf/api-contracts/dist/v1/tag/list.js
+var makeListTagsContract = (ids) => {
+  const input = object({
+    includeFlowIds: boolean2().default(false).describe("Also return the ids of the flows that carry each tag."),
+    names: array(string2().trim().min(1)).min(1).max(100).optional().describe("Only list tags with these names. Matching is case sensitive. Omit to list all tags."),
+    workspaceId: ids.workspace.optional().describe("The workspace to list tags from. Required when authenticating with an organization or user API key."),
+    ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 })
+  });
   const output = object({
-    triggerId: ids.trigger.describe("The id of the deleted trigger.")
+    nextCursor: nextCursorSchema,
+    tags: array(makeTagResourceSchema().extend({
+      flowIds: array(ids.flow).optional().describe("Ids of the flows that carry the tag. Present only when includeFlowIds is set.")
+    })).describe("The team's tags, alphabetical by name.")
   });
   return {
     annotations: {
-      destructiveHint: true,
+      destructiveHint: false,
       openWorldHint: false,
-      readOnlyHint: false
-    },
-    description: "Delete a trigger permanently. The runs it already created are kept. " + "To stop a trigger without losing it, use trigger.pause.",
-    input,
-    kind: "write",
-    name: "trigger.delete",
-    output
-  };
-};
-
-// node_modules/@qawolf/api-contracts/dist/v1/trigger/update.js
-var makeUpdateTriggerContract = (ids) => {
-  const commonFields = {
-    name: string2().trim().min(1).max(255),
-    triggerId: ids.trigger
-  };
-  const input = discriminatedUnion("kind", [
-    object({
-      ...commonFields,
-      ...makeTriggerScheduleFields({
-        environmentId: ids.environmentRef,
-        flow: ids.flow
-      }),
-      kind: literal("schedule")
-    }),
-    object({
-      ...commonFields,
-      ...makeTriggerDeploymentFields(ids),
-      kind: literal("deployment")
-    })
-  ]).superRefine(checkTriggerConfiguration);
-  const output = object({ trigger: makeTriggerResourceSchema(ids) });
-  return {
-    annotations: {
-      destructiveHint: true,
-      openWorldHint: true,
-      readOnlyHint: false
+      readOnlyHint: true
     },
-    description: "Replace a trigger's configuration. Every field is written, so read the " + "trigger first and send its configuration back with your changes applied. " + "Pausing is separate: use trigger.pause and trigger.resume.",
+    description: "List the team's tags, alphabetical by name. Tag names select flows in run.create.",
     input,
-    kind: "write",
-    name: "trigger.update",
+    kind: "read",
+    name: "tag.list",
     output
   };
 };
@@ -9387,7 +10197,11 @@ var makeContractsV1 = (ids) => {
       get: makeAgentGetContract(resolvedIds),
       send: makeAgentSendContract(resolvedIds)
     },
-    automate: makeAutomateContract(resolvedIds),
+    codeHostIntegration: {
+      find: makeFindCodeHostIntegrationsContract(resolvedIds),
+      listRepositories: makeListCodeHostRepositoriesContract(resolvedIds)
+    },
+    deployment: makeDeploymentContracts(resolvedIds),
     email: {
       find: makeFindEmailsContract(resolvedIds),
       get: makeGetEmailContract(resolvedIds),
@@ -9421,44 +10235,23 @@ var makeContractsV1 = (ids) => {
       removeFlows: makeRemoveFlowsFromIssueContract(resolvedIds),
       update: makeUpdateIssueContract(resolvedIds)
     },
+    legacyTrigger: makeLegacyTriggerContracts(resolvedIds),
     run: {
       create: makeCreateRunContract(resolvedIds),
       diagnose: makeDiagnoseRunContract(resolvedIds),
       find: makeFindRunsContract(resolvedIds),
       get: makeGetRunContract(resolvedIds),
       reattempt: makeReattemptRunContract(resolvedIds),
-      stop: makeStopRunContract(resolvedIds)
-    },
-    runner: {
-      evaluateSnippet: makeEvaluateSnippetOnRunnerContract(resolvedIds),
-      get: makeGetRunnerContract(resolvedIds),
-      highlightSelector: makeHighlightSelectorOnRunnerContract(resolvedIds),
-      importPackage: makeImportPackageOnRunnerContract(resolvedIds),
-      inspect: makeInspectOnRunnerContract(resolvedIds),
-      inspectMobile: makeInspectMobileOnRunnerContract(resolvedIds),
-      launch: makeLaunchRunnerContract(resolvedIds),
-      list: makeListRunnersContract(resolvedIds),
-      performAction: makePerformActionOnRunnerContract(resolvedIds),
-      promoteSnapshot: makePromoteSnapshotOnRunnerContract(resolvedIds),
-      readJournal: makeReadRunnerJournalContract(resolvedIds),
-      runFlow: makeRunFlowOnRunnerContract(resolvedIds),
-      stopRun: makeStopRunOnRunnerContract(resolvedIds),
-      takeScreenshot: makeTakeScreenshotOnRunnerContract(resolvedIds),
-      terminate: makeTerminateRunnerContract(resolvedIds)
+      stop: makeStopRunContract(resolvedIds),
+      triage: makeTriageRunContract(resolvedIds)
     },
+    runner: makeRunnerContracts(resolvedIds),
+    skill: makeSkillContracts(),
     tag: {
       create: makeCreateTagContract(resolvedIds),
       list: makeListTagsContract(resolvedIds)
     },
-    trigger: {
-      create: makeCreateTriggerContract(resolvedIds),
-      delete: makeDeleteTriggerContract(resolvedIds),
-      find: makeFindTriggersContract(resolvedIds),
-      get: makeGetTriggerContract(resolvedIds),
-      pause: makePauseTriggerContract(resolvedIds),
-      resume: makeResumeTriggerContract(resolvedIds),
-      update: makeUpdateTriggerContract(resolvedIds)
-    }
+    trigger: makeTriggerContracts(resolvedIds)
   };
 };
 var publicContractsV1 = makeContractsV1(defaultIdSchemas);
@@ -9820,6 +10613,37 @@ var interactMessages = {
   promoteSnapshotAnsweredUnknown: (failureReason) => `The runner answered "${failureReason}", which this version of the CLI does not know how to report. Upgrade with npm install -g @qawolf/cli.`
 };
 
+// src/core/messages/interactiveRunner/sequence.ts
+var sequenceMessages = {
+  actionsEmpty: `The sequence holds no actions. Pass a JSON array of at least one, for example '[{"type":"click","button":"left","x":480,"y":260},{"type":"type","text":"hello"}]'.`,
+  actionsInvalidAt: (index, error) => `Action ${index} in the sequence was refused: ${error}`,
+  stdinEmptySequence: 'Nothing arrived on stdin. Pipe the sequence in, or pass the JSON array as the argument instead of "-".',
+  actionsNotJsonArray: `The sequence must be a JSON array of actions, for example '[{"type":"click","button":"left","x":480,"y":260},{"type":"type","text":"hello"}]'.`,
+  actionsEachNeedsAPath: "--screenshot-mode each writes one frame per action, so it needs --screenshot <path>; each frame goes to that path with the action's index before the extension.",
+  actionsFinalNeedsAPath: "--screenshot-mode final asks the runner for one frame after the last action, so it needs --screenshot <path> to write it to. Leave the mode off to perform the actions without a frame.",
+  actionsScreenshotWithModeNone: "--screenshot-mode none asks the runner for no frame, so --screenshot would have nothing to write. Drop one of the two.",
+  actionsEachToStdout: "--screenshot-mode each writes one frame per action, which stdout cannot carry. Give --screenshot a file path.",
+  actionsFailedFramesWritten: (paths) => `${paths.length === 1 ? "Its screen was" : "Its screens were"} written to ${paths.join(", ")}, so look at ${paths.length === 1 ? "that" : "those"} rather than sending anything again.`,
+  actionsFailedScreenshotToStdout: "Its screen was written to stdout as a JPEG, so look at that rather than sending anything again.",
+  actionsPerformed: (count) => `Performed ${count} ${count === 1 ? "action" : "actions"}.`,
+  actionsPerformedOfTotal: (performed, total) => `Performed ${String(performed)} of ${pluralize(total, "action")}.`,
+  actionsFramesUnwritable: (unwritten) => `The runner answered, but ${pluralize(unwritten.length, "frame")} could not be written: ${unwritten.map(({ detail, path }) => `"${path}" (${detail})`).join(", ")}. Whatever the actions did has already happened, so do not send them again: take the screen with qawolf runner screenshot, giving --out a path this process can write to.`,
+  actionsFramesMissing: (indexes) => `The runner answered without the ${indexes.length === 1 ? "screen" : "screens"} after ${indexes.length === 1 ? "action" : "actions"} ${indexes.join(", ")}, so nothing was written for ${indexes.length === 1 ? "it" : "them"}. Whatever the actions did has already happened, so do not send them again: take the screen with qawolf runner screenshot instead.`,
+  actionsPerformedWithoutScreenshot: (count) => `Performed ${pluralize(count, "action")}, but the runner answered without the screen it was asked for. Whatever the actions did has already happened, so do not send them again: take the screen with qawolf runner screenshot instead. If this keeps happening, the platform or this CLI is behind the other: upgrade with npm install -g @qawolf/cli.`,
+  actionsPerformedFramesWritten: (count, paths) => `Performed ${pluralize(count, "action")} and wrote ${pluralize(paths.length, "screen")} to ${paths.join(", ")}.`,
+  actionsPerformedScreenshotToStdout: (count) => `Performed ${pluralize(count, "action")} and wrote the runner's screen to stdout as a JPEG. Stdout holds the image bytes alone, so this line is on stderr and the per-action results are not printed at all: give --screenshot a file path when you need to read them.`,
+  actionsPerformedScreenshotWritten: (count, path) => `Performed ${count} ${count === 1 ? "action" : "actions"} and wrote the runner's screen to ${path}.`,
+  actionsOverLimit: (sent, limit) => `The sequence holds ${pluralize(sent, "action")}, and one request carries at most ${String(limit)}. Send them in batches, ending each at the action that changes the page.`,
+  actionsNotAllSucceeded: (failed, total) => `${String(failed)} of ${pluralize(total, "action")} did not succeed.`,
+  actionsFailedWithoutAResult: (failureReason) => `did not succeed ("${failureReason}"), and the answer carried no result for it. Take a screenshot before repeating anything from it on.`,
+  actionsFailedAt: (index, type, why) => `Action ${index}${type === undefined ? "" : ` (${type})`} ${why}`,
+  actionsLeftUnperformed: (count) => `${count} ${count === 1 ? "action" : "actions"} after it ${count === 1 ? "was" : "were"} not attempted.`,
+  actionsMayHaveHappened: "It may have taken effect: take a screenshot before repeating anything from it on.",
+  actionsOutOfTime: "was not reached before the sequence ran out of its time.",
+  actionsPartlyApplied: (lastCompletedIndex) => `The sequence was partly applied: action ${String(lastCompletedIndex)} is the last one that took effect. Do not send it again as a whole; send only what still has to happen as a new request.`,
+  actionsUnconfirmed: (errorMessage) => `has an unknown effect: ${errorMessage}`
+};
+
 // src/core/messages/interactiveRunner/lifecycle.ts
 var pageAt = (url) => `Its runner page is at ${url}`;
 var noRunnerId = "No runner id. Pass --runner, set QAWOLF_RUNNER_ID, or run qawolf runner launch first.";
@@ -9900,7 +10724,8 @@ var interactiveRunnerMessages = {
   ...lifecycleMessages,
   ...listMessages,
   ...runMessages,
-  ...interactMessages
+  ...interactMessages,
+  ...sequenceMessages
 };
 // src/core/messages/runner.ts
 var maxListedNames = 5;
@@ -10043,6 +10868,9 @@ async function listRunners(ctx, deps) {
   };
 }
 
+// src/domains/interactiveRunner/deps.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
 // src/shell/interactiveRunner/collectRunFiles.ts
 import { join as join2 } from "node:path";
 
@@ -11297,6 +12125,7 @@ function makeInteractiveRunnerDeps(options) {
     cwd: options.cwd,
     env: options.env,
     makeRunnerId,
+    makeRecordingId: randomUUID2,
     readFile: (path) => options.fs.readFile(path),
     readStdin,
     runFilesManifest: makeRunFilesManifestStore({
@@ -11413,9 +12242,10 @@ function makeDefaultFs() {
 }
 
 // src/core/publicApi/notFoundSubject.ts
-var runnerRoutesThatNameNoRunner = new Set([
+var runnerRoutesWithoutLivePod = new Set([
   "runner.launch",
-  "runner.list"
+  "runner.list",
+  "runner.recordings"
 ]);
 var runRoutesThatResolveOneRun = new Set([
   "run.diagnose",
@@ -11437,7 +12267,7 @@ function field(input, name) {
   return typeof value === "string" ? value : undefined;
 }
 function notFoundSubject(contractName, input) {
-  if (contractName.startsWith("runner.") && !runnerRoutesThatNameNoRunner.has(contractName)) {
+  if (contractName.startsWith("runner.") && !runnerRoutesWithoutLivePod.has(contractName)) {
     return { kind: "runner", runnerId: field(input, "id") };
   }
   if (runRoutesThatResolveOneRun.has(contractName)) {
@@ -13977,12 +14807,63 @@ function createRunVerbs({ deps, platformClient }) {
   };
 }
 
+// src/domains/interactiveRunner/recordingRequests.ts
+async function recordOnRunner(ctx, runner, command) {
+  const contract = publicContractsV1.runner.record;
+  const parsed = contract.input.safeParse({ id: runner.runnerId, command });
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: "Invalid recording request. Runner ids must be valid and recording ids must be UUIDs.",
+      exitCode: exitCodes.invalidArgs
+    };
+  }
+  const result = await ctx.platformClient.callPublicApi(contract, parsed.data, runnerCallOptions);
+  return result.ok ? result : { ok: false, ...runnerRequestFailure(result, runner) };
+}
+async function readRunnerRecordings(ctx, runner, query) {
+  const contract = publicContractsV1.runner.recordings;
+  const parsed = contract.input.safeParse({ id: runner.runnerId, ...query });
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: "Invalid recordings request. Use a valid runner id, a UUID recording id, and a page token of at most 4096 characters.",
+      exitCode: exitCodes.invalidArgs
+    };
+  }
+  const result = await ctx.platformClient.callPublicApi(contract, parsed.data);
+  return result.ok ? result : { ok: false, ...runnerRequestFailure(result, runner) };
+}
+
+// src/runnerSdk/recordingVerbs.ts
+function createRecordingVerbs(context) {
+  return {
+    async record({
+      runnerId,
+      command
+    }) {
+      return toSdkResult(await recordOnRunner(context, givenRunner(runnerId), command));
+    },
+    async listRecordings({
+      runnerId,
+      recordingId,
+      pageToken
+    }) {
+      return toSdkResult(await readRunnerRecordings(context, givenRunner(runnerId), {
+        ...recordingId === undefined ? {} : { recordingId },
+        ...pageToken === undefined ? {} : { pageToken }
+      }));
+    }
+  };
+}
+
 // src/runnerSdk/index.ts
 function createRunnerSdk(options) {
   const context = createSdkContext(options);
   return {
     ...createLifecycleVerbs(context),
     ...createRunVerbs(context),
+    ...createRecordingVerbs(context),
     ...createPageVerbs(context),
     ...createProjectVerbs(context),
     async list() {
@@ -13995,4 +14876,4 @@ export {
   createRunnerSdk
 };
 
-//# debugId=C50E262AB8A599ED64756E2164756E21
+//# debugId=A7A37F8150999CFE64756E2164756E21