@company-semantics/contracts 0.107.0 → 0.109.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@company-semantics/contracts",
-  "version": "0.107.0",
+  "version": "0.109.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -82,6 +82,7 @@
     "release": "npx tsx scripts/release.ts",
     "prepublishOnly": "echo 'ERROR: Publishing is CI-only via tag push. Use pnpm release instead.' && exit 1",
     "test": "vitest run",
+    "generate:api": "pnpm generate:api-types",
     "generate:api-types": "openapi-typescript openapi/backend.yaml -o src/api/generated.ts",
     "generate:openapi-routes": "tsx scripts/generate-openapi-routes.ts",
     "generate:api-types:check": "openapi-typescript openapi/backend.yaml -o /tmp/cs-api-types-check.ts && diff -q src/api/generated.ts /tmp/cs-api-types-check.ts"

package/src/api/generated.ts

@@ -270,6 +270,65 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/user/preferences/dismissed-banners": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List dismissed banner IDs for the current user
+         * @description Returns the list of banner IDs that the authenticated user has dismissed.
+         *     Used to suppress previously-dismissed UI banners on page load.
+         */
+        get: operations["getDismissedBanners"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/user/preferences/dismissed-banners/{bannerId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Dismiss a banner for the current user */
+        post: operations["dismissBanner"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/user/resync-slack-avatar": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resync user avatar from Slack
+         * @description Manually resync the current user's avatar from their Slack profile.
+         *     Requires user to have a linked Slack identity and the org to have an active Slack connection.
+         */
+        post: operations["resyncSlackAvatar"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/connect/{provider}": {
         parameters: {
             query?: never;
@@ -444,6 +503,70 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/executions/{executionId}/undo": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Undo a completed execution
+         * @description Undoes a completed execution within its undo window.
+         *     The caller must be the same user who initiated the execution.
+         *     Idempotent: if undo was already performed, returns the existing result.
+         */
+        post: operations["undoExecution"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/executions/{executionId}/confirm": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Confirm a pending execution
+         * @description Confirms a pending execution. Serialized via advisory lock.
+         *     The caller must be the same user who initiated the execution.
+         */
+        post: operations["confirmExecution"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/executions/{executionId}/reject": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reject a pending execution
+         * @description Rejects a pending execution. Serialized via advisory lock.
+         *     The caller must be the same user who initiated the execution.
+         */
+        post: operations["rejectExecution"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/timeline": {
         parameters: {
             query?: never;
@@ -1156,6 +1279,50 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/workspace/resync-slack-logo": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resync workspace logo from Slack
+         * @description Manually resync the workspace logo from the connected Slack workspace icon.
+         *     Requires org.view_workspace capability and an active Slack connection.
+         */
+        post: operations["resyncSlackLogo"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/workspace/resolve-path": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resolve a tokenized URL path to hydrated navigation layers
+         * @description Resolves a tokenized workspace URL path to hydrated entity data.
+         *     Used by the frontend for cold-start deep linking and browser back/forward.
+         *     Path segments follow a [type, slug] pair grammar: "dept" before "team",
+         *     "team" requires preceding "dept", and "members" must be terminal.
+         */
+        post: operations["resolveWorkspacePath"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/account/sessions": {
         parameters: {
             query?: never;
@@ -1981,6 +2148,57 @@ export interface components {
                 displayName: string;
             };
         };
+        ResyncSlackLogoResponse: {
+            /** @constant */
+            success: true;
+            logoUrl: string | null;
+        };
+        ResyncSlackAvatarResponse: {
+            /** @constant */
+            success: true;
+            avatar: components["schemas"]["ResolvedAvatar"];
+        };
+        ResolvedAvatar: {
+            /** @enum {string} */
+            source: "slack" | "initials";
+            /** @description Slack profile image URL (present only if source is slack) */
+            url?: string;
+            /** @description User initials for fallback display */
+            initials: string;
+        };
+        ResolvedLayer: components["schemas"]["ResolvedLayerDept"] | components["schemas"]["ResolvedLayerTeam"] | components["schemas"]["ResolvedLayerMembers"];
+        ResolvedLayerDept: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "dept";
+            entity: components["schemas"]["ResolvedLayerEntity"];
+        };
+        ResolvedLayerTeam: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "team";
+            entity: components["schemas"]["ResolvedLayerEntity"];
+        };
+        ResolvedLayerMembers: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "members";
+            /** @enum {string} */
+            scope: "org" | "dept" | "team";
+        };
+        ResolvedLayerEntity: {
+            /** Format: uuid */
+            id: string;
+            name: string;
+            slug: string;
+            memberCount: number;
+        };
         UserOrgsResponse: {
             orgs: components["schemas"]["UserOrgMembership"][];
         };
@@ -2257,6 +2475,46 @@ export interface components {
                 message: string;
             }[];
         };
+        ExecutionLifecycleError: {
+            /** @enum {string} */
+            code: "EXECUTION_CONFLICT";
+            executionId: string;
+            currentState: string;
+        } | {
+            /** @enum {string} */
+            code: "EXECUTION_EXPIRED";
+            executionId: string;
+            /** Format: date-time */
+            expiredAt: string;
+        } | {
+            /** @enum {string} */
+            code: "EXECUTION_FORBIDDEN";
+            executionId: string;
+            requiredRole: string;
+        };
+        UndoResultData: {
+            /** @description Links back to original action */
+            actionId: string;
+            /** @description Original execution row ID */
+            executionId: string;
+            /** @description New undo audit row ID (append-only) */
+            undoExecutionId: string;
+            /** @enum {string} */
+            status: "success" | "failed";
+            error?: string;
+        };
+        ConfirmExecutionResponse: {
+            /** @enum {string} */
+            status: "executing" | "blocked_pending_approval" | "already_confirmed" | "awaiting_approval";
+            code?: string;
+            executionId?: string;
+            /** @description ExecutionResultData when execution completes inline */
+            result?: Record<string, never>;
+        };
+        RejectExecutionResponse: {
+            /** @enum {string} */
+            status: "cancelled";
+        };
         ExecutionSummary: {
             /** Format: uuid */
             executionId: string;
@@ -3284,45 +3542,28 @@ export interface operations {
             };
         };
     };
-    initiateOAuth: {
+    getDismissedBanners: {
         parameters: {
-            query?: {
-                /**
-                 * @deprecated
-                 * @description DEPRECATED: Organization ID derived from session.
-                 *     Query parameter accepted only in dev mode for backwards compatibility.
-                 *     Production: orgId is always derived from authenticated session.
-                 */
-                orgId?: string;
-            };
+            query?: never;
             header?: never;
-            path: {
-                provider: components["schemas"]["OAuthProvider"];
-            };
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Redirect to OAuth provider */
-            302: {
-                headers: {
-                    /** @description OAuth provider authorization URL */
-                    Location?: string;
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Invalid provider or missing/invalid orgId */
-            400: {
+            /** @description Dismissed banner IDs */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ErrorResponse"];
+                    "application/json": {
+                        bannerIds: string[];
+                    };
                 };
             };
-            /** @description OAuth initialization failed */
-            500: {
+            /** @description Not authenticated */
+            401: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -3332,94 +3573,231 @@ export interface operations {
             };
         };
     };
-    handleOAuthCallback: {
+    dismissBanner: {
         parameters: {
-            query?: {
-                /** @description Authorization code from provider */
-                code?: string;
-                /** @description State token for CSRF protection */
-                state?: string;
-                /** @description Error code from provider (if authorization denied) */
-                error?: string;
-                /** @description Human-readable error description from provider */
-                error_description?: string;
-            };
+            query?: never;
             header?: never;
             path: {
-                provider: components["schemas"]["OAuthProvider"];
+                bannerId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Authorization successful (HTML page) */
+            /** @description Banner dismissed */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/html": string;
+                    "application/json": {
+                        success: boolean;
+                    };
                 };
             };
-            /** @description Authorization failed or invalid request (HTML page) */
+            /** @description Invalid banner ID */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/html": string;
+                    "application/json": components["schemas"]["ErrorResponse"];
                 };
             };
-        };
-    };
-    getCapabilities: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description List of available tools */
-            200: {
+            /** @description Not authenticated */
+            401: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ToolDiscoveryResponse"];
+                    "application/json": components["schemas"]["ErrorResponse"];
                 };
             };
         };
     };
-    postAiChat: {
+    resyncSlackAvatar: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["ChatRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description SSE stream of chat responses */
+            /** @description Avatar resynced successfully */
             200: {
                 headers: {
-                    /** @description AI SDK stream protocol version */
-                    "x-vercel-ai-ui-message-stream"?: "v1";
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/event-stream": string;
+                    "application/json": components["schemas"]["ResyncSlackAvatarResponse"];
                 };
             };
-        };
-    };
-    getExecutionTimeline: {
-        parameters: {
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description User not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    initiateOAuth: {
+        parameters: {
+            query?: {
+                /**
+                 * @deprecated
+                 * @description DEPRECATED: Organization ID derived from session.
+                 *     Query parameter accepted only in dev mode for backwards compatibility.
+                 *     Production: orgId is always derived from authenticated session.
+                 */
+                orgId?: string;
+            };
+            header?: never;
+            path: {
+                provider: components["schemas"]["OAuthProvider"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Redirect to OAuth provider */
+            302: {
+                headers: {
+                    /** @description OAuth provider authorization URL */
+                    Location?: string;
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Invalid provider or missing/invalid orgId */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description OAuth initialization failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    handleOAuthCallback: {
+        parameters: {
+            query?: {
+                /** @description Authorization code from provider */
+                code?: string;
+                /** @description State token for CSRF protection */
+                state?: string;
+                /** @description Error code from provider (if authorization denied) */
+                error?: string;
+                /** @description Human-readable error description from provider */
+                error_description?: string;
+            };
+            header?: never;
+            path: {
+                provider: components["schemas"]["OAuthProvider"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Authorization successful (HTML page) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/html": string;
+                };
+            };
+            /** @description Authorization failed or invalid request (HTML page) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/html": string;
+                };
+            };
+        };
+    };
+    getCapabilities: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of available tools */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolDiscoveryResponse"];
+                };
+            };
+        };
+    };
+    postAiChat: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChatRequest"];
+            };
+        };
+        responses: {
+            /** @description SSE stream of chat responses */
+            200: {
+                headers: {
+                    /** @description AI SDK stream protocol version */
+                    "x-vercel-ai-ui-message-stream"?: "v1";
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+        };
+    };
+    getExecutionTimeline: {
+        parameters: {
             query?: never;
             header?: never;
             path: {
@@ -3630,6 +4008,192 @@ export interface operations {
             };
         };
     };
+    undoExecution: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Execution ID (UUID v4) */
+                executionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Undo result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UndoResultData"];
+                };
+            };
+            /** @description Invalid execution ID format or execution not in undoable state */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Insufficient permissions (not the initiating user) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+            /** @description Execution not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Execution in wrong state (e.g. undo window expired) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+        };
+    };
+    confirmExecution: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Execution ID (UUID v4) */
+                executionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Confirmation result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ConfirmExecutionResponse"];
+                };
+            };
+            /** @description Invalid execution ID format */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Insufficient permissions (not the initiating user) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+            /** @description Execution not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Execution not in pending_confirmation state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+            /** @description Confirmation has expired */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+        };
+    };
+    rejectExecution: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Execution ID (UUID v4) */
+                executionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Rejection result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RejectExecutionResponse"];
+                };
+            };
+            /** @description Invalid execution ID format */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Insufficient permissions (not the initiating user) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+            /** @description Execution not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Execution not in pending_confirmation state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExecutionLifecycleError"];
+                };
+            };
+        };
+    };
     getTimelineUI: {
         parameters: {
             query?: {
@@ -5194,6 +5758,127 @@ export interface operations {
             };
         };
     };
+    resyncSlackLogo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Logo resynced */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResyncSlackLogoResponse"];
+                };
+            };
+            /** @description Slack not connected */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No org.view_workspace capability */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    resolveWorkspacePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Flat tokenized segments, e.g. ["dept", "engineering", "team", "front-end"] */
+                    path: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Resolved layers */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        layers: components["schemas"]["ResolvedLayer"][];
+                    };
+                };
+            };
+            /** @description Invalid segment grammar */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No org.view_workspace capability */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Entity slug not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     listAccountSessions: {
         parameters: {
             query?: never;
@@ -5513,7 +6198,12 @@ export interface operations {
     };
     listChats: {
         parameters: {
-            query?: never;
+            query?: {
+                search?: string;
+                limit?: number;
+                offset?: number;
+                includePinned?: boolean;
+            };
             header?: never;
             path?: never;
             cookie?: never;

package/src/generated/openapi-routes.ts

@@ -23,9 +23,12 @@ export const openApiRoutes = {
   '/api/drive/files/recent': ['GET'],
   '/api/drive/files/{fileId}/content': ['GET'],
   '/api/executions': ['GET', 'POST'],
+  '/api/executions/{executionId}/confirm': ['POST'],
   '/api/executions/{executionId}/explanation': ['GET'],
+  '/api/executions/{executionId}/reject': ['POST'],
   '/api/executions/{executionId}/summary': ['GET'],
   '/api/executions/{executionId}/timeline': ['GET'],
+  '/api/executions/{executionId}/undo': ['POST'],
   '/api/goals/docs/{slug}': ['GET'],
   '/api/goals/docs/{slug}/content': ['PUT'],
   '/api/goals/docs/{slug}/sharing': ['GET'],
@@ -40,6 +43,8 @@ export const openApiRoutes = {
   '/api/org/cancel-deletion': ['POST'],
   '/api/org/delete': ['POST'],
   '/api/org/deletion-eligibility': ['GET'],
+  '/api/org/system-events': ['GET'],
+  '/api/org/system-events/{id}/acknowledge': ['POST'],
   '/api/org/transfer-eligibility': ['GET'],
   '/api/org/transfer-ownership': ['DELETE', 'POST'],
   '/api/org/transfer-ownership/accept': ['POST'],
@@ -59,7 +64,10 @@ export const openApiRoutes = {
   '/api/user/active-org': ['POST'],
   '/api/user/orgs': ['GET'],
   '/api/user/orgs/{orgId}/leave': ['POST'],
+  '/api/user/preferences/dismissed-banners': ['GET'],
+  '/api/user/preferences/dismissed-banners/{bannerId}': ['POST'],
   '/api/user/profile': ['PATCH'],
+  '/api/user/resync-slack-avatar': ['POST'],
   '/api/workspace': ['GET'],
   '/api/workspace/access': ['GET'],
   '/api/workspace/audit': ['GET'],
@@ -77,6 +85,8 @@ export const openApiRoutes = {
   '/api/workspace/members': ['GET'],
   '/api/workspace/members/{id}': ['DELETE'],
   '/api/workspace/members/{id}/role': ['PATCH'],
+  '/api/workspace/resolve-path': ['POST'],
+  '/api/workspace/resync-slack-logo': ['POST'],
   '/auth/logout': ['POST'],
   '/auth/me': ['GET'],
   '/auth/sso/callback': ['GET', 'POST'],
@@ -85,6 +95,7 @@ export const openApiRoutes = {
   '/auth/verify': ['POST'],
   '/connect/{provider}': ['GET'],
   '/healthz': ['GET'],
+  '/healthz/details': ['GET'],
   '/oauth/{provider}/callback': ['GET'],
 } as const;