@qawolf/api-contracts 0.58.0 → 0.59.0

package/dist/v1/agent/get.d.ts

@@ -9,10 +9,11 @@ export declare const makeAgentGetContract: <ChatSessionId extends PublicIdSchema
         readonly openWorldHint: false;
         readonly readOnlyHint: true;
     };
-    readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+    readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
     readonly input: z.ZodObject<{
         cursor: z.ZodOptional<z.ZodString>;
         sessionId: ChatSessionId;
+        waitSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     readonly kind: "read";
     readonly name: "agent.get";
@@ -31,6 +32,12 @@ export declare const makeAgentGetContract: <ChatSessionId extends PublicIdSchema
             failed: "failed";
             cancelled: "cancelled";
         }>;
+        waitSeconds: z.ZodOptional<z.ZodNumber>;
+        wokeOn: z.ZodOptional<z.ZodEnum<{
+            reply: "reply";
+            status: "status";
+            timeout: "timeout";
+        }>>;
         url: z.ZodURL;
     }, z.core.$strip>;
 };

package/dist/v1/agent/get.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,eAAO,MAAM,oBAAoB,GAC/B,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDA,CAAC"}
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAMhD,eAAO,MAAM,oBAAoB,GAC/B,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEA,CAAC"}

package/dist/v1/agent/get.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { resource } from "../resource.js";
 import { agentReplySchema, agentSessionStatusSchema } from "./status.js";
+import { agentWakeReasonSchema, maxAgentWaitSeconds } from "./wait.js";
 export const makeAgentGetContract = (ids) => {
     const input = z.object({
         cursor: z
@@ -9,6 +10,12 @@ export const makeAgentGetContract = (ids) => {
             .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: z
+            .number()
+            .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: z
@@ -20,6 +27,14 @@ export const makeAgentGetContract = (ids) => {
             .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: z
+            .number()
+            .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.",
     });
@@ -29,7 +44,7 @@ export const 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: '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",

package/dist/v1/agent/get.js.map

@@ -1 +1 @@
-{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAGlC,GAGD,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,MAAM,EAAE,CAAC;aACN,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,uGAAuG,CACxG;QACH,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,kCAAkC,CAAC;KACxE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,uIAAuI,CACxI;QACH,OAAO,EAAE,CAAC;aACP,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CACP,wKAAwK,CACzK;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;QAC1B,MAAM,EAAE,wBAAwB;KACjC,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,gzCAAgzC;QAClzC,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,WAAW;QACjB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAGlC,GAGD,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,MAAM,EAAE,CAAC;aACN,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,uGAAuG,CACxG;QACH,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,kCAAkC,CAAC;QACvE,WAAW,EAAE,CAAC;aACX,MAAM,EAAE;aACR,GAAG,EAAE;aACL,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,wHAAwH,mBAAmB,gDAAgD,CAC5L;KACJ,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,uIAAuI,CACxI;QACH,OAAO,EAAE,CAAC;aACP,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CACP,wKAAwK,CACzK;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;QAC1B,MAAM,EAAE,wBAAwB;QAChC,WAAW,EAAE,CAAC;aACX,MAAM,EAAE;aACR,GAAG,EAAE;aACL,QAAQ,EAAE;aACV,QAAQ,CACP,kGAAkG,CACnG;QACH,MAAM,EAAE,qBAAqB;aAC1B,QAAQ,EAAE;aACV,QAAQ,CACP,uLAAuL,CACxL;KACJ,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,o6CAAo6C;QACt6C,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,WAAW;QACjB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/agent/wait.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const maxAgentWaitSeconds = 45;
+export declare const agentWakeReasonSchema: z.ZodEnum<{
+    reply: "reply";
+    status: "status";
+    timeout: "timeout";
+}>;
+export type AgentWakeReason = z.infer<typeof agentWakeReasonSchema>;
+//# sourceMappingURL=wait.d.ts.map

package/dist/v1/agent/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/wait.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,eAAO,MAAM,qBAAqB;;;;EAI/B,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/v1/agent/wait.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const maxAgentWaitSeconds = 45;
+export const agentWakeReasonSchema = z
+    .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.');
+//# sourceMappingURL=wait.js.map

package/dist/v1/agent/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../../src/v1/agent/wait.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAEtC,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC;KACnC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;KACpC,QAAQ,CACP,yKAAyK,CAC1K,CAAC"}

package/dist/v1/deployment/find.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeFindDeploymentsContract: <DeploymentId extends PublicIdSchema, EnvironmentId extends PublicIdSchema, WorkspaceId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    environment: EnvironmentId;
+    workspace: WorkspaceId;
+}) => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+    readonly input: z.ZodObject<{
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        workspaceId: z.ZodOptional<WorkspaceId>;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "deployment.find";
+    readonly output: z.ZodObject<{
+        deployments: z.ZodArray<z.ZodObject<{
+            branch: z.ZodOptional<z.ZodString>;
+            commitAuthorName: z.ZodOptional<z.ZodString>;
+            commitMessage: z.ZodOptional<z.ZodString>;
+            commitSha: z.ZodOptional<z.ZodString>;
+            deployedAt: z.ZodISODateTime;
+            deployTarget: z.ZodOptional<z.ZodString>;
+            environmentId: EnvironmentId;
+            environmentName: z.ZodOptional<z.ZodString>;
+            id: DeploymentId;
+            provider: z.ZodOptional<z.ZodEnum<{
+                github: "github";
+                gitlab: "gitlab";
+                api: "api";
+            }>>;
+            status: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                pending: "pending";
+                failure: "failure";
+                inactive: "inactive";
+            }>>;
+            url: z.ZodURL;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=find.d.ts.map

package/dist/v1/deployment/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,eAAO,MAAM,2BAA2B,GACtC,YAAY,SAAS,cAAc,EACnC,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCA,CAAC"}

package/dist/v1/deployment/find.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { makePaginationInputFields, nextCursorSchema } from "../pagination.js";
+import { makeDeploymentResourceSchema } from "./resource.js";
+export const makeFindDeploymentsContract = (ids) => {
+    const input = z.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 = z.object({
+        deployments: z
+            .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,
+    };
+};
+//# sourceMappingURL=find.js.map

package/dist/v1/deployment/find.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.js","sourceRoot":"","sources":["../../../src/v1/deployment/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAE7D,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAIzC,GAID,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,WAAW,EAAE,GAAG,CAAC,SAAS;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,4GAA4G,CAC7G;QACH,GAAG,yBAAyB,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;KAClE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACtB,WAAW,EAAE,CAAC;aACX,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC;aACxC,QAAQ,CAAC,4CAA4C,CAAC;QACzD,UAAU,EAAE,gBAAgB;KAC7B,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,wTAAwT;QAC1T,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,iBAAiB;QACvB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/deployment/index.d.ts

@@ -0,0 +1,189 @@
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeDeploymentContracts: <DeploymentId extends PublicIdSchema, EnvironmentId extends PublicIdSchema, RunId extends PublicIdSchema, TriggerId extends PublicIdSchema, WorkspaceId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    environment: EnvironmentId;
+    run: RunId;
+    trigger: TriggerId;
+    workspace: WorkspaceId;
+}) => {
+    find: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+        readonly input: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            workspaceId: import("zod").ZodOptional<WorkspaceId>;
+        }, import("zod/v4/core").$strip>;
+        readonly kind: "read";
+        readonly name: "deployment.find";
+        readonly output: import("zod").ZodObject<{
+            deployments: import("zod").ZodArray<import("zod").ZodObject<{
+                branch: import("zod").ZodOptional<import("zod").ZodString>;
+                commitAuthorName: import("zod").ZodOptional<import("zod").ZodString>;
+                commitMessage: import("zod").ZodOptional<import("zod").ZodString>;
+                commitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                deployedAt: import("zod").ZodISODateTime;
+                deployTarget: import("zod").ZodOptional<import("zod").ZodString>;
+                environmentId: EnvironmentId;
+                environmentName: import("zod").ZodOptional<import("zod").ZodString>;
+                id: DeploymentId;
+                provider: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    github: "github";
+                    gitlab: "gitlab";
+                    api: "api";
+                }>>;
+                status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>>;
+                url: import("zod").ZodURL;
+            }, import("zod/v4/core").$strip>>;
+            nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    listTriggerEvaluations: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+        readonly input: import("zod").ZodObject<{
+            deploymentId: DeploymentId;
+        }, import("zod/v4/core").$strip>;
+        readonly kind: "read";
+        readonly name: "deployment.listTriggerEvaluations";
+        readonly output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            evaluations: import("zod").ZodArray<import("zod").ZodObject<{
+                triggerId: import("zod").ZodOptional<TriggerId>;
+                triggerName: import("zod").ZodString;
+                verdict: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    conditionSets: import("zod").ZodArray<import("zod").ZodObject<{
+                        conditions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"matched">;
+                        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"did-not-match">;
+                            reason: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>], "outcome">>;
+                        outcome: import("zod").ZodEnum<{
+                            matched: "matched";
+                            "did-not-match": "did-not-match";
+                        }>;
+                    }, import("zod/v4/core").$strip>>;
+                    outcome: import("zod").ZodLiteral<"matched">;
+                    run: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        runId: RunId;
+                        status: import("zod").ZodLiteral<"ran">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        status: import("zod").ZodLiteral<"starting">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        reason: import("zod").ZodString;
+                        status: import("zod").ZodLiteral<"did-not-run">;
+                        supersededByRunId: import("zod").ZodOptional<RunId>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        status: import("zod").ZodLiteral<"unknown">;
+                    }, import("zod/v4/core").$strip>], "status">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    conditionSets: import("zod").ZodArray<import("zod").ZodObject<{
+                        conditions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"matched">;
+                        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"did-not-match">;
+                            reason: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>], "outcome">>;
+                        outcome: import("zod").ZodEnum<{
+                            matched: "matched";
+                            "did-not-match": "did-not-match";
+                        }>;
+                    }, import("zod/v4/core").$strip>>;
+                    outcome: import("zod").ZodLiteral<"did-not-match">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    outcome: import("zod").ZodLiteral<"not-considered">;
+                    reason: import("zod").ZodEnum<{
+                        "trigger-paused": "trigger-paused";
+                        "not-a-deployment-trigger": "not-a-deployment-trigger";
+                    }>;
+                }, import("zod/v4/core").$strip>], "outcome">;
+            }, import("zod/v4/core").$strip>>;
+            state: import("zod").ZodLiteral<"evaluated">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            state: import("zod").ZodLiteral<"not-evaluated">;
+        }, import("zod/v4/core").$strip>], "state">;
+    };
+    reportStatus: {
+        readonly annotations: {
+            readonly destructiveHint: true;
+            readonly openWorldHint: true;
+            readonly readOnlyHint: false;
+        };
+        readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs. This route requires an organization or user API key.";
+        readonly input: import("zod").ZodObject<{
+            deployTarget: import("zod").ZodOptional<import("zod").ZodURL>;
+            environment: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                id: EnvironmentId;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                baseEphemeralEnvironment: import("zod").ZodOptional<import("zod").ZodString>;
+                ephemeral: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>]>>;
+            environmentVariables: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodObject<{
+                commitAuthorName: import("zod").ZodOptional<import("zod").ZodString>;
+                commitMessage: import("zod").ZodOptional<import("zod").ZodString>;
+                commitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                pullRequestNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                ref: import("zod").ZodOptional<import("zod").ZodString>;
+                repository: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            providerDeploymentId: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                success: "success";
+                pending: "pending";
+                failure: "failure";
+                inactive: "inactive";
+            }>;
+            workspaceId: WorkspaceId;
+        }, import("zod/v4/core").$strict>;
+        readonly kind: "write";
+        readonly name: "deployment.reportStatus";
+        readonly output: import("zod").ZodObject<{
+            deployment: import("zod").ZodObject<{
+                id: DeploymentId;
+                status: import("zod").ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>;
+                url: import("zod").ZodURL;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/v1/deployment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAMhD,eAAO,MAAM,uBAAuB,GAClC,YAAY,SAAS,cAAc,EACnC,aAAa,SAAS,cAAc,EACpC,KAAK,SAAS,cAAc,EAC5B,SAAS,SAAS,cAAc,EAChC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,WAAW,EAAE,aAAa,CAAC;IAC3B,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIC,CAAC"}

package/dist/v1/deployment/index.js

@@ -0,0 +1,9 @@
+import { makeFindDeploymentsContract } from "./find.js";
+import { makeListDeploymentTriggerEvaluationsContract } from "./listTriggerEvaluations.js";
+import { makeReportDeploymentStatusContract } from "./reportStatus.js";
+export const makeDeploymentContracts = (ids) => ({
+    find: makeFindDeploymentsContract(ids),
+    listTriggerEvaluations: makeListDeploymentTriggerEvaluationsContract(ids),
+    reportStatus: makeReportDeploymentStatusContract(ids),
+});
+//# sourceMappingURL=index.js.map

package/dist/v1/deployment/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v1/deployment/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,4CAA4C,EAAE,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EAAE,kCAAkC,EAAE,MAAM,mBAAmB,CAAC;AAEvE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAMrC,GAMD,EAAE,EAAE,CAAC,CAAC;IACL,IAAI,EAAE,2BAA2B,CAAC,GAAG,CAAC;IACtC,sBAAsB,EAAE,4CAA4C,CAAC,GAAG,CAAC;IACzE,YAAY,EAAE,kCAAkC,CAAC,GAAG,CAAC;CACtD,CAAC,CAAC"}

package/dist/v1/deployment/listTriggerEvaluations.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeListDeploymentTriggerEvaluationsContract: <DeploymentId extends PublicIdSchema, RunId extends PublicIdSchema, TriggerId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    run: RunId;
+    trigger: TriggerId;
+}) => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+    readonly input: z.ZodObject<{
+        deploymentId: DeploymentId;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "deployment.listTriggerEvaluations";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        evaluations: z.ZodArray<z.ZodObject<{
+            triggerId: z.ZodOptional<TriggerId>;
+            triggerName: z.ZodString;
+            verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                conditionSets: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"matched">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                        reason: z.ZodString;
+                    }, z.core.$strip>], "outcome">>;
+                    outcome: z.ZodEnum<{
+                        matched: "matched";
+                        "did-not-match": "did-not-match";
+                    }>;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"matched">;
+                run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    runId: RunId;
+                    status: z.ZodLiteral<"ran">;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"starting">;
+                }, z.core.$strip>, z.ZodObject<{
+                    reason: z.ZodString;
+                    status: z.ZodLiteral<"did-not-run">;
+                    supersededByRunId: z.ZodOptional<RunId>;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unknown">;
+                }, z.core.$strip>], "status">;
+            }, z.core.$strip>, z.ZodObject<{
+                conditionSets: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"matched">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                        reason: z.ZodString;
+                    }, z.core.$strip>], "outcome">>;
+                    outcome: z.ZodEnum<{
+                        matched: "matched";
+                        "did-not-match": "did-not-match";
+                    }>;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"did-not-match">;
+            }, z.core.$strip>, z.ZodObject<{
+                outcome: z.ZodLiteral<"not-considered">;
+                reason: z.ZodEnum<{
+                    "trigger-paused": "trigger-paused";
+                    "not-a-deployment-trigger": "not-a-deployment-trigger";
+                }>;
+            }, z.core.$strip>], "outcome">;
+        }, z.core.$strip>>;
+        state: z.ZodLiteral<"evaluated">;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"not-evaluated">;
+    }, z.core.$strip>], "state">;
+};
+//# sourceMappingURL=listTriggerEvaluations.d.ts.map

package/dist/v1/deployment/listTriggerEvaluations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listTriggerEvaluations.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/listTriggerEvaluations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAgHhD,eAAO,MAAM,4CAA4C,GACvD,YAAY,SAAS,cAAc,EACnC,KAAK,SAAS,cAAc,EAC5B,SAAS,SAAS,cAAc,EAChC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,SAAS,CAAC;CACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCA,CAAC"}

package/dist/v1/deployment/listTriggerEvaluations.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+const conditionKindSchema = z
+    .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.");
+const conditionVerdictSchema = z.discriminatedUnion("outcome", [
+    z.object({
+        kind: conditionKindSchema,
+        outcome: z.literal("matched"),
+    }),
+    z.object({
+        kind: conditionKindSchema,
+        outcome: z.literal("did-not-match"),
+        reason: z
+            .string()
+            .describe("Why the condition did not match this deployment, in plain language."),
+    }),
+]);
+const conditionSetsField = z
+    .array(z.object({
+    conditions: z
+        .array(conditionVerdictSchema)
+        .describe("One verdict per condition. Conditions in a set are ANDed; a set with no conditions matches every deployment."),
+    outcome: z
+        .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.");
+const makeRunOutcomeSchema = (ids) => z
+    .discriminatedUnion("status", [
+    z.object({
+        runId: ids.run.describe("The run the trigger created."),
+        status: z.literal("ran"),
+    }),
+    z.object({ status: z.literal("starting") }),
+    z.object({
+        reason: z
+            .string()
+            .describe("Why the matched trigger created no run, in plain language."),
+        status: z.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."),
+    }),
+    z.object({ status: z.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.");
+const makeVerdictSchema = (ids) => z
+    .discriminatedUnion("outcome", [
+    z.object({
+        conditionSets: conditionSetsField,
+        outcome: z.literal("matched"),
+        run: makeRunOutcomeSchema(ids),
+    }),
+    z.object({
+        conditionSets: conditionSetsField,
+        outcome: z.literal("did-not-match"),
+    }),
+    z.object({
+        outcome: z.literal("not-considered"),
+        reason: z
+            .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.");
+const makeEvaluationSchema = (ids) => z.object({
+    triggerId: ids.trigger
+        .optional()
+        .describe("Absent when the trigger has been deleted since."),
+    triggerName: z
+        .string()
+        .describe("The trigger's name when the deployment was evaluated."),
+    verdict: makeVerdictSchema(ids),
+});
+export const makeListDeploymentTriggerEvaluationsContract = (ids) => {
+    const input = z.object({ deploymentId: ids.deployment });
+    const output = z.discriminatedUnion("state", [
+        z.object({
+            evaluations: z
+                .array(makeEvaluationSchema(ids))
+                .describe("One verdict per trigger that existed when the deployment was evaluated."),
+            state: z.literal("evaluated"),
+        }),
+        z
+            .object({ state: z.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,
+    };
+};
+//# sourceMappingURL=listTriggerEvaluations.js.map

package/dist/v1/deployment/listTriggerEvaluations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listTriggerEvaluations.js","sourceRoot":"","sources":["../../../src/v1/deployment/listTriggerEvaluations.ts"],"names":[],"mappings":"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"}