@company-semantics/contracts 89.0.0 → 89.2.0

package/src/api/generated.ts

@@ -1675,7 +1675,7 @@ export interface paths {
         };
         /**
          * Read one analysis workflow’s generic lifecycle envelope
-         * @description The domain-agnostic projection a client polls: identity, registered type, activity-free lifecycle state, start and completion times, the opaque domain progress and result payloads (null until the domain adapter supplies them), a closed failure class on a failed workflow, and the capabilities the surface may offer — canStop from the generic layer, canContinue as the domain declares it. Org-scoped: a workflow in another workspace answers 404.
+         * @description The domain-agnostic projection a client polls: identity, registered type, activity-free lifecycle state, start and completion times, the opaque domain progress and result payloads (null until the domain adapter supplies them), a closed failure class on a failed workflow, the frozen typed outcome of the current execution epoch once it settles (null until then), and the capabilities the surface may offer — canStop from the generic layer, canContinue as the domain declares it. Org-scoped: a workflow in another workspace answers 404.
          */
         get: operations["getAnalysisWorkflow"];
         put?: never;
@@ -1706,6 +1706,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/analysis-workflows/{id}/settlement": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Deliver a settled analysis workflow’s outcome into its launching conversation now
+         * @description An ACCELERATOR, never required for correctness (control ADR-CTRL-540): every terminal transition records a settlement that the server delivers on its own — immediately after settling, and on the reconciler sweep. The app calls this when its poll sees the current execution epoch settle, so the settlement turn appears without waiting. Idempotent: a second call for the same epoch answers skipped or delivered and writes nothing new. Answers not_settled while the epoch is still moving. Org-scoped: a workflow in another workspace answers 404.
+         */
+        post: operations["deliverAnalysisWorkflowSettlement"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/company-md/tree": {
         parameters: {
             query?: never;
@@ -3908,6 +3928,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/factory/quality/corpus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Export the accepted production cases of one capability for a CI evaluation run
+         * @description The current revision of every production case a person accepted for the capability: anonymized input, human-written expected behavior and optional rubric, never lineage. Authenticated by the dedicated corpus export bearer (QUALITY_CORPUS_EXPORT_SECRET), never the Floor machine bearer; unset, every request is refused.
+         */
+        get: operations["getQualityCorpus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/internal-admin/impersonate/start": {
         parameters: {
             query?: never;
@@ -3959,6 +3999,278 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/internal-admin/quality/subjects": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every quality subject with its live references and latest decision */
+        get: operations["listQualitySubjects"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/subjects/{subjectKind}/{subjectKey}/timeline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** A subject's explained timeline: changes, plans, runs, decisions and actions */
+        get: operations["getQualitySubjectTimeline"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/escalations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Quality escalations in one state, oldest first */
+        get: operations["listQualityEscalations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/blocked": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Blocked quality runs that still hold an evaluation up, longest blocked first */
+        get: operations["listQualityBlockedRuns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/spend": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Evaluation spend in a month against the monthly cap */
+        get: operations["getQualitySpend"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/plans/{planId}/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Where a plan's evaluation stands and, once decided, its decision */
+        get: operations["getQualityPlanStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/escalations/{id}/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Settle an escalation with a person's superseding decision (promote or reject) */
+        post: operations["resolveQualityEscalation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/references/floor": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Pin a completed run as its subject's floor reference */
+        put: operations["pinQualityFloorReference"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/changes/manual": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Record a manual evaluation of a subject, plan it and ask for its runs */
+        post: operations["createQualityManualChange"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/candidates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The candidate review queue: candidates ready for review or parked */
+        get: operations["listQualityCandidates"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/candidates/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** A candidate's redacted material, suggestion, usefulness breakdown and accepted case */
+        get: operations["getQualityCandidate"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/candidates/{id}/accept": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Accept a candidate as a production case with a human-written expected behavior, and plan its reproduction check */
+        post: operations["acceptQualityCandidate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/candidates/{id}/reject": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Reject a candidate, with why */
+        post: operations["rejectQualityCandidate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/graders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every grader version with its calibration and the severities it may gate */
+        get: operations["listQualityGraders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/graders/{id}/label-queue": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** A judge's unlabeled samples with their case content; the judge's verdict is hidden */
+        get: operations["getQualityGraderLabelQueue"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/internal-admin/quality/graders/{id}/labels": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Label a judged sample, then recalibrate the judge; reveals the judge's verdict */
+        post: operations["submitQualityGraderLabel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/comments": {
         parameters: {
             query?: never;
@@ -4807,6 +5119,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/org/improve-with-usage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read whether the org consents to improve-with-usage
+         * @description Whether de-identified conversations from the org may be used to evaluate and improve the product, and who last changed it and when. Off until an owner or admin turns it on.
+         */
+        get: operations["getImproveWithUsage"];
+        /**
+         * Switch improve-with-usage consent on or off for the org
+         * @description On permits de-identified conversations from the org to enter the quality corpus. Off withdraws consent. The caller is recorded as the person who changed it, and each actual change is audited.
+         */
+        put: operations["putImproveWithUsage"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -6650,6 +6986,7 @@ export interface components {
             completedAt: string | null;
             progress: unknown | null;
             result: unknown | null;
+            outcome: unknown | null;
             error?: string;
             capabilities: {
                 canStop: boolean;
@@ -6669,6 +7006,10 @@ export interface components {
             /** @constant */
             reason: "not_running";
         };
+        DeliverWorkflowSettlementResponse: {
+            /** @enum {string} */
+            result: "delivered" | "deferred" | "busy" | "skipped" | "not_settled";
+        };
         CompanyMdListResponse: {
             items: {
                 id: string;
@@ -8410,6 +8751,22 @@ export interface components {
             } | null;
             surfaces: string[];
         };
+        QualityCorpusResponse: {
+            capability: string;
+            cases: {
+                caseId: string;
+                revision: string;
+                /** @enum {string} */
+                severity: "critical" | "major" | "minor";
+                weight: number;
+                invariantKey: string | null;
+                body: {
+                    input: unknown;
+                    expect: string;
+                    rubric?: string;
+                };
+            }[];
+        };
         ImpersonationSessionResponse: {
             session: {
                 impersonationSessionId: string;
@@ -9811,6 +10168,14 @@ export interface components {
         SourceSyncPutSettingsRequest: {
             enabled: boolean;
         };
+        ImproveWithUsageResponse: {
+            enabled: boolean;
+            changedAt: string | null;
+            changedByName: string | null;
+        };
+        PutImproveWithUsageRequest: {
+            enabled: boolean;
+        };
         /** @description Server-enforced collaboration size limits, published so clients can pre-check. */
         CollabSyncLimits: {
             maxUpdateBytes: number;
@@ -12713,6 +13078,42 @@ export interface operations {
             };
         };
     };
+    deliverAnalysisWorkflowSettlement: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description What the delivery attempt did */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeliverWorkflowSettlementResponse"];
+                };
+            };
+            /** @description The workflow id is not a uuid */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such workflow in this workspace */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     getCompanyMdTree: {
         parameters: {
             query?: {
@@ -16786,6 +17187,42 @@ export interface operations {
             };
         };
     };
+    getQualityCorpus: {
+        parameters: {
+            query: {
+                capability: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every accepted case of the capability, sorted by case id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["QualityCorpusResponse"];
+                };
+            };
+            /** @description Query invalid, or not a cataloged capability */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Missing or invalid corpus export bearer token */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     startImpersonation: {
         parameters: {
             query?: never;
@@ -16846,37 +17283,24 @@ export interface operations {
             };
         };
     };
-    listCommentThreads: {
+    listQualitySubjects: {
         parameters: {
-            query: {
-                subjectType: "company_md" | "strategy_doc" | "work_item" | "meeting_recording";
-                subjectId: string;
-                status?: "open" | "resolved";
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Every thread on the subject with its comments oldest-first */
+            /** @description Subjects with references (and pass rates) and latest decision */
             200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["CommentThreadListResponse"];
-                };
-            };
-            /** @description Invalid query parameters */
-            400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Subject not found, or the caller may not read it */
-            404: {
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -16884,36 +17308,42 @@ export interface operations {
             };
         };
     };
-    createCommentThread: {
+    getQualitySubjectTimeline: {
         parameters: {
-            query?: never;
+            query?: {
+                limit?: number;
+            };
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CreateCommentThreadRequest"];
+            path: {
+                subjectKind: string;
+                subjectKey: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
-            /** @description Thread created with its opening comment (one transaction) */
-            201: {
+            /** @description The subject, its live references and its timeline, newest first */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentThreadResponse"];
-                };
+                content?: never;
             };
-            /** @description Invalid body (including every anchor-corpus reject case) */
+            /** @description Validation error */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Subject not found, or the caller may not comment on it */
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such subject */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -16922,39 +17352,34 @@ export interface operations {
             };
         };
     };
-    replyToCommentThread: {
+    listQualityEscalations: {
         parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                threadId: string;
+            query?: {
+                state?: "open" | "resolved";
+                limit?: number;
             };
+            header?: never;
+            path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CommentReplyRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Reply written; reopened=true when it auto-reopened a resolved thread */
-            201: {
+            /** @description Escalations with their decision reason codes and subjects */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentReplyResponse"];
-                };
+                content?: never;
             };
-            /** @description Invalid body */
+            /** @description Validation error */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Thread not found, or the caller may not comment on its subject */
-            404: {
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -16962,28 +17387,33 @@ export interface operations {
             };
         };
     };
-    deleteComment: {
+    listQualityBlockedRuns: {
         parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                commentId: string;
+            query?: {
+                limit?: number;
             };
+            header?: never;
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Comment soft-deleted; response carries the redacted projection */
+            /** @description Blocked runs with their block reason and since when */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentResponse"];
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
                 };
+                content?: never;
             };
-            /** @description Comment not found, already deleted, or the caller may not delete it */
-            404: {
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -16991,39 +17421,33 @@ export interface operations {
             };
         };
     };
-    editComment: {
+    getQualitySpend: {
         parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                commentId: string;
+            query?: {
+                month?: string;
             };
+            header?: never;
+            path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["EditCommentRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Comment updated with edited_at stamped */
+            /** @description Month, spend, cap and remaining, in USD */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentResponse"];
-                };
+                content?: never;
             };
-            /** @description Invalid body */
+            /** @description Validation error */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Comment not found, deleted, or the caller is not its author */
-            404: {
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -17031,35 +17455,40 @@ export interface operations {
             };
         };
     };
-    resolveCommentThread: {
+    getQualityPlanStatus: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                threadId: string;
+                planId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Thread resolved with resolved_at + resolved_by stamped */
+            /** @description Evaluation state, block reason, decision and successor plan */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentThreadSummaryResponse"];
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
                 };
+                content?: never;
             };
-            /** @description Thread not found, or the caller may not comment on its subject */
-            404: {
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Not a comment thread: a suggestion is decided via accept or reject, never resolved */
-            409: {
+            /** @description No such plan */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -17067,35 +17496,742 @@ export interface operations {
             };
         };
     };
-    reopenCommentThread: {
+    resolveQualityEscalation: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                threadId: string;
+                id: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    outcome: "promote" | "reject";
+                    reason: string;
+                };
+            };
+        };
         responses: {
-            /** @description Thread reopened with the resolution stamp cleared */
+            /** @description The superseding decision, its action and the resolved escalation */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["CommentThreadSummaryResponse"];
+                content?: never;
+            };
+            /** @description Validation error (outcome, or a reason under 10 characters) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
                 };
+                content?: never;
             };
-            /** @description Thread not found, or the caller may not comment on its subject */
-            404: {
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Not a comment thread: a decided suggestion is terminal and never reopens */
-            409: {
+            /** @description No such escalation */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Already resolved, names no decision, or the decision was overridden */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    pinQualityFloorReference: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** Format: uuid */
+                    runId: string;
+                    reason: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The new live floor reference */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such run */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The run is not complete */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    createQualityManualChange: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    subjectKind: string;
+                    subjectKey: string;
+                    suites?: string[];
+                    samples: number;
+                    model?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The change and plan, and whether its runs were dispatched or blocked */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error, or a suite with no case of the subject */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such subject */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The subject has no suite to run */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listQualityCandidates: {
+        parameters: {
+            query?: {
+                state?: "ready_for_review" | "parked";
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Candidates in that state with their usefulness score; never lineage */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getQualityCandidate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Redacted material, the proposal as a suggestion (not ground truth), the usefulness breakdown, nearest cases and the accepted case with its reproduction check */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such candidate */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    acceptQualityCandidate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    capability: "grounded_doc_qa" | "context_doc_summary" | "org_structure_inference" | "source_discovery_relevance";
+                    /** @enum {string} */
+                    severity: "critical" | "major" | "minor";
+                    weight: number;
+                    /** @enum {string} */
+                    invariantKey?: "ABSENCE_CLAIM_REQUIRES_SUFFICIENT_EVIDENCE" | "WITHHELD_CONTENT_MUST_NOT_BE_INFERRED" | "OWNER_METADATA_MUST_BE_CONSIDERED" | "MUTATION_REQUIRES_AUTHORIZATION" | "ARTIFACT_RELATIVE_CLAIMS_REQUIRE_THE_ARTIFACT" | "NO_NARRATED_PERCEPTION" | "SOURCE_DISCOVERY_HARD_NEGATIVE_NEVER_SHOWN" | "SOURCE_DISCOVERY_MUST_FIND_NEVER_DROPPED" | "SOURCE_DISCOVERY_NONEXECUTION_NEVER_DROPS";
+                    input: unknown;
+                    expect: string;
+                    rubric?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The production case, its revision, and the change and plan that check it */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error: no expected behavior, too short, or the suggestion copied verbatim */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such candidate */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The candidate is not ready for review or parked */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    rejectQualityCandidate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    reason: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The candidate is rejected */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such candidate */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The candidate is not ready for review or parked */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listQualityGraders: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Grader versions with confusion matrices by severity and failure kind */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getQualityGraderLabelQueue: {
+        parameters: {
+            query?: {
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Samples waiting for a label, newest run first, without verdicts */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, or missing internal.manage_quality */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such judge */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    submitQualityGraderLabel: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** Format: uuid */
+                    runId: string;
+                    caseId: string;
+                    sample: number;
+                    humanPassed: boolean;
+                    humanFailureKind?: string | null;
+                };
+            };
+        };
+        responses: {
+            /** @description The label, the judge's verdict and the recomputed calibration */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not an internal admin, missing internal.manage_quality, or no CSRF token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No such judge, or the judge graded no such sample */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The sample is already labeled, or the judge gave no valid verdict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listCommentThreads: {
+        parameters: {
+            query: {
+                subjectType: "company_md" | "strategy_doc" | "work_item" | "meeting_recording";
+                subjectId: string;
+                status?: "open" | "resolved";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every thread on the subject with its comments oldest-first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentThreadListResponse"];
+                };
+            };
+            /** @description Invalid query parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Subject not found, or the caller may not read it */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    createCommentThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateCommentThreadRequest"];
+            };
+        };
+        responses: {
+            /** @description Thread created with its opening comment (one transaction) */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentThreadResponse"];
+                };
+            };
+            /** @description Invalid body (including every anchor-corpus reject case) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Subject not found, or the caller may not comment on it */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    replyToCommentThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CommentReplyRequest"];
+            };
+        };
+        responses: {
+            /** @description Reply written; reopened=true when it auto-reopened a resolved thread */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentReplyResponse"];
+                };
+            };
+            /** @description Invalid body */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Thread not found, or the caller may not comment on its subject */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    deleteComment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                commentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Comment soft-deleted; response carries the redacted projection */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentResponse"];
+                };
+            };
+            /** @description Comment not found, already deleted, or the caller may not delete it */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    editComment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                commentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EditCommentRequest"];
+            };
+        };
+        responses: {
+            /** @description Comment updated with edited_at stamped */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentResponse"];
+                };
+            };
+            /** @description Invalid body */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Comment not found, deleted, or the caller is not its author */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    resolveCommentThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread resolved with resolved_at + resolved_by stamped */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentThreadSummaryResponse"];
+                };
+            };
+            /** @description Thread not found, or the caller may not comment on its subject */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a comment thread: a suggestion is decided via accept or reject, never resolved */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    reopenCommentThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread reopened with the resolution stamp cleared */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommentThreadSummaryResponse"];
+                };
+            };
+            /** @description Thread not found, or the caller may not comment on its subject */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a comment thread: a decided suggestion is terminal and never reopens */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -18885,4 +20021,62 @@ export interface operations {
             };
         };
     };
+    getImproveWithUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The org’s improve-with-usage consent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImproveWithUsageResponse"];
+                };
+            };
+        };
+    };
+    putImproveWithUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PutImproveWithUsageRequest"];
+            };
+        };
+        responses: {
+            /** @description The consent as it now stands */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImproveWithUsageResponse"];
+                };
+            };
+            /** @description Invalid body */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The caller may not manage integrations, or is impersonating */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
 }