@thinkai/tai-api-contract 2.76.0 → 2.78.0

package/dist/generated/openapi.d.ts

@@ -2643,6 +2643,298 @@ export interface paths {
         patch: operations["patchProject"];
         trace?: never;
     };
+    "/workspaces/{workspaceId}/code-chat/indexes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List code indexes for the workspace */
+        get: operations["listCodeChatIndexes"];
+        put?: never;
+        /** Start indexing a connected repository */
+        post: operations["createCodeChatIndex"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/indexes/sync": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Enqueue indexing for all (or selected) readiness GitHub repos */
+        post: operations["syncCodeChatIndexes"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/indexes/{indexId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get code index status */
+        get: operations["getCodeChatIndex"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/threads": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List code chat threads for the current user */
+        get: operations["listCodeChatThreads"];
+        put?: never;
+        /** Create a code chat thread against a ready index */
+        post: operations["createCodeChatThread"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/threads/{threadId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a code chat thread with messages */
+        get: operations["getCodeChatThread"];
+        put?: never;
+        post?: never;
+        /** Delete a code chat thread and its messages */
+        delete: operations["deleteCodeChatThread"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/threads/{threadId}/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Send a message and receive an assistant reply */
+        post: operations["postCodeChatMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/indexes/{indexId}/wiki": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List wiki pages for an index (generates skeleton if missing) */
+        get: operations["listCodeChatWikiPages"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/indexes/{indexId}/wiki/{slug}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a wiki page by slug */
+        get: operations["getCodeChatWikiPage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/indexes/{indexId}/wiki/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Regenerate wiki pages from the stored code graph */
+        post: operations["generateCodeChatWiki"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/symbols": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Find symbols across the ready corpus */
+        post: operations["analyzeCodeChatSymbols"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/references": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Find references for a symbol */
+        post: operations["analyzeCodeChatReferences"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/blast-radius": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Analyze blast radius (intra or gated cross-repo) */
+        post: operations["analyzeCodeChatBlastRadius"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/semantic-diff": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Map changed paths onto graph symbols and blast hints */
+        post: operations["analyzeCodeChatSemanticDiff"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/recommendations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Test impact and BDD/contract recommendations */
+        post: operations["analyzeCodeChatRecommendations"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/visualize": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Structured graph diagrams (SVG-ready nodes/edges) or Obsidian-style atlas stubs */
+        post: operations["analyzeCodeChatVisualize"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/analyze/cross-edges": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Resolve heuristic cross-process edges across ready repos */
+        post: operations["analyzeCodeChatCrossEdges"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/code-chat/tools/get_context_pack": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** MCP/agent tool — compact context pack from the corpus */
+        post: operations["codeChatGetContextPack"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/workspaces/{workspaceId}/notifications": {
         parameters: {
             query?: never;
@@ -6796,6 +7088,10 @@ export interface components {
             mergedPrs: number;
             /** @description True when the engineer is a GitHub contributor not mapped to an org-chart team. */
             isUnmapped?: boolean;
+            /** @description Cursor/Claude/Copilot seat external id when AI usage exists — use for AI usage detail deep links. */
+            aiUsageExternalId?: string;
+            /** @description AI provider id matching aiUsageExternalId (highest spend provider for the person in the window). */
+            aiUsageProvider?: string;
         };
         InsightsRecommendationsRoiQuadrant: {
             medianSpendUsd: number;
@@ -6926,27 +7222,324 @@ export interface components {
             recommendations: components["schemas"]["InsightsRecommendationsPageBundleRecommendations"];
             _meta: components["schemas"]["InsightsResponseMeta"];
         };
-    };
-    responses: {
-        /** @description Missing or invalid bearer token */
-        Unauthorized: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "application/json": components["schemas"]["ErrorMessageDto"];
-            };
-        };
-        /** @description Authenticated but not allowed */
-        Forbidden: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "application/json": components["schemas"]["ErrorMessageDto"];
-            };
-        };
-        /** @description HRIS sync or ZenHR OAuth refresh already in progress for this workspace */
+        /** @enum {string} */
+        CodeChatIndexStatus: "pending" | "indexing" | "ready" | "failed";
+        /** @enum {string|null} */
+        CodeChatIndexer: "graphify" | "builtin" | null;
+        CodeChatIndexDto: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            workspaceId: string;
+            /** Format: uuid */
+            repoId: string;
+            providerSlug: string;
+            repoName: string;
+            status: components["schemas"]["CodeChatIndexStatus"];
+            indexer?: components["schemas"]["CodeChatIndexer"];
+            nodeCount: number;
+            edgeCount: number;
+            commitSha?: string | null;
+            errorMessage?: string | null;
+            /** Format: date-time */
+            indexedAt?: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+            /** @description True when the indexed graph stores durable code excerpts (required for useful chat answers). */
+            hasCodeExcerpts?: boolean;
+        };
+        CodeChatIndexListDto: {
+            items: components["schemas"]["CodeChatIndexDto"][];
+        };
+        CodeChatCreateIndexBodyDto: {
+            /** Format: uuid */
+            repoId: string;
+        };
+        CodeChatSyncIndexesBodyDto: {
+            /** @description Optional subset; omit or empty to enqueue all readiness GitHub repos. */
+            repoIds?: string[];
+        };
+        CodeChatSyncIndexesResultDto: {
+            enqueued: number;
+            items?: components["schemas"]["CodeChatIndexDto"][];
+        };
+        CodeChatThreadDto: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            workspaceId: string;
+            /** Format: uuid */
+            indexId?: string | null;
+            /** @description Empty means all ready repos in the workspace. */
+            repoIds: string[];
+            revisionRef?: string | null;
+            title: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        CodeChatThreadListDto: {
+            items: components["schemas"]["CodeChatThreadDto"][];
+        };
+        CodeChatCreateThreadBodyDto: {
+            /**
+             * Format: uuid
+             * @description Legacy single-index bind; prefer repoIds for workspace scope.
+             */
+            indexId?: string;
+            /** @description Empty or omitted = all ready repos. */
+            repoIds?: string[];
+            revisionRef?: string;
+            title?: string;
+        };
+        CodeChatCitationDto: {
+            path: string;
+            label: string;
+            score: number;
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+            providerSlug?: string;
+            commitSha?: string | null;
+            startLine?: number;
+            endLine?: number;
+            /** @enum {string} */
+            confidence?: "fact" | "inference" | "possibility" | "unknown";
+        };
+        CodeChatMessageDto: {
+            /** Format: uuid */
+            id: string;
+            /** @enum {string} */
+            role: "user" | "assistant";
+            content: string;
+            citations: components["schemas"]["CodeChatCitationDto"][];
+            /** Format: date-time */
+            createdAt: string;
+        };
+        CodeChatThreadDetailDto: components["schemas"]["CodeChatThreadDto"] & {
+            messages: components["schemas"]["CodeChatMessageDto"][];
+        };
+        CodeChatPostMessageBodyDto: {
+            content: string;
+        };
+        CodeChatMessageReplyDto: components["schemas"]["CodeChatMessageDto"] & {
+            /** @enum {string} */
+            mode: "llm" | "retrieval";
+        };
+        CodeChatWikiPageDto: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            indexId: string;
+            /** Format: uuid */
+            workspaceId: string;
+            slug: string;
+            title: string;
+            bodyMd: string;
+            sortOrder: number;
+            sourcePaths: string[];
+            diagramMermaid?: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        CodeChatWikiPageListDto: {
+            items: components["schemas"]["CodeChatWikiPageDto"][];
+        };
+        CodeChatSymbolQueryBodyDto: {
+            query: string;
+            repoIds?: string[];
+        };
+        CodeChatSymbolHitDto: {
+            id: string;
+            name: string;
+            path: string;
+            kind: string;
+            summary?: string;
+            startLine?: number;
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+            commitSha?: string | null;
+        };
+        CodeChatSymbolHitListDto: {
+            items: components["schemas"]["CodeChatSymbolHitDto"][];
+        };
+        CodeChatReferenceQueryBodyDto: {
+            symbol: string;
+            repoIds?: string[];
+        };
+        CodeChatReferenceHitDto: {
+            fromId: string;
+            fromLabel: string;
+            toId: string;
+            toLabel: string;
+            relation: string;
+            /** @enum {string} */
+            certainty: "EXTRACTED" | "INFERRED";
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+        };
+        CodeChatReferenceHitListDto: {
+            items: components["schemas"]["CodeChatReferenceHitDto"][];
+        };
+        CodeChatBlastRadiusBodyDto: {
+            symbol: string;
+            repoIds?: string[];
+            crossRepo?: boolean;
+        };
+        CodeChatBlastRadiusResultDto: {
+            /** @enum {string} */
+            mode: "intra_repo" | "cross_repo";
+            /** @enum {string} */
+            completeness: "partial" | "unknown";
+            gateNote?: string;
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+            originId?: string;
+            originLabel?: string;
+            truncated?: boolean;
+            edgesUsed?: number;
+            nodes?: {
+                [key: string]: unknown;
+            }[];
+        };
+        CodeChatSemanticDiffBodyDto: {
+            changedPaths: string[];
+            /** Format: uuid */
+            indexId?: string;
+            repoIds?: string[];
+            baseCommit?: string;
+            headCommit?: string;
+        };
+        CodeChatSemanticDiffResultDto: {
+            baseCommit?: string;
+            headCommit?: string;
+            files: {
+                path: string;
+                /** @enum {string} */
+                changeType: "added" | "removed" | "modified";
+                symbolsTouched: string[];
+                summary: string;
+            }[];
+            blastHints: {
+                symbol: string;
+                affectedCount: number;
+            }[];
+        };
+        CodeChatRecommendationsBodyDto: {
+            repoIds?: string[];
+            changedPaths?: string[];
+            symbol?: string;
+        };
+        CodeChatRecommendationsResultDto: {
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+            testImpact: {
+                [key: string]: unknown;
+            }[];
+            recommendations: {
+                [key: string]: unknown;
+            }[];
+        };
+        CodeChatVisualizeBodyDto: {
+            /** @enum {string} */
+            kind?: "dependency" | "blast" | "atlas";
+            symbol?: string;
+            repoIds?: string[];
+        };
+        CodeChatVisualizeResultDto: {
+            /** Format: uuid */
+            repoId?: string;
+            diagram?: {
+                /** @enum {string} */
+                format: "graph" | "mermaid";
+                title: string;
+                /** @description Mermaid source kept for export/copy */
+                source: string;
+                /** @description Set when dependency edges could not be resolved and a fallback view is shown. */
+                note?: string;
+                nodes: {
+                    id: string;
+                    label: string;
+                    kind?: string;
+                }[];
+                edges: {
+                    from: string;
+                    to: string;
+                    label?: string;
+                }[];
+            };
+            atlas?: {
+                path?: string;
+                body?: string;
+            }[];
+        };
+        CodeChatCrossEdgesBodyDto: {
+            repoIds?: string[];
+        };
+        CodeChatCrossEdgesResultDto: {
+            items: {
+                [key: string]: unknown;
+            }[];
+            /** @enum {string} */
+            completeness: "partial" | "unknown";
+            gateNote?: string;
+        };
+        CodeChatContextPackBodyDto: {
+            question?: string;
+            symbol?: string;
+            maxTokensApprox?: number;
+            repoIds?: string[];
+        };
+        CodeChatContextPackDto: {
+            /** Format: uuid */
+            repoId?: string;
+            repoName?: string;
+            commitSha?: string | null;
+            summary: string;
+            symbols: {
+                [key: string]: unknown;
+            }[];
+            references: {
+                [key: string]: unknown;
+            }[];
+            blastRadiusPreview?: {
+                [key: string]: unknown;
+            };
+            citations: {
+                [key: string]: unknown;
+            }[];
+            snippets: string[];
+        };
+    };
+    responses: {
+        /** @description Missing or invalid bearer token */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorMessageDto"];
+            };
+        };
+        /** @description Authenticated but not allowed */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorMessageDto"];
+            };
+        };
+        /** @description HRIS sync or ZenHR OAuth refresh already in progress for this workspace */
         ZenHrSyncInProgress: {
             headers: {
                 [name: string]: unknown;
@@ -7384,6 +7977,41 @@ export type InsightsRecommendationDto = components['schemas']['InsightsRecommend
 export type InsightsRecommendationsListResponse = components['schemas']['InsightsRecommendationsListResponse'];
 export type InsightsRecommendationsPageBundleRecommendations = components['schemas']['InsightsRecommendationsPageBundleRecommendations'];
 export type InsightsRecommendationsPageBundleResponse = components['schemas']['InsightsRecommendationsPageBundleResponse'];
+export type CodeChatIndexStatus = components['schemas']['CodeChatIndexStatus'];
+export type CodeChatIndexer = components['schemas']['CodeChatIndexer'];
+export type CodeChatIndexDto = components['schemas']['CodeChatIndexDto'];
+export type CodeChatIndexListDto = components['schemas']['CodeChatIndexListDto'];
+export type CodeChatCreateIndexBodyDto = components['schemas']['CodeChatCreateIndexBodyDto'];
+export type CodeChatSyncIndexesBodyDto = components['schemas']['CodeChatSyncIndexesBodyDto'];
+export type CodeChatSyncIndexesResultDto = components['schemas']['CodeChatSyncIndexesResultDto'];
+export type CodeChatThreadDto = components['schemas']['CodeChatThreadDto'];
+export type CodeChatThreadListDto = components['schemas']['CodeChatThreadListDto'];
+export type CodeChatCreateThreadBodyDto = components['schemas']['CodeChatCreateThreadBodyDto'];
+export type CodeChatCitationDto = components['schemas']['CodeChatCitationDto'];
+export type CodeChatMessageDto = components['schemas']['CodeChatMessageDto'];
+export type CodeChatThreadDetailDto = components['schemas']['CodeChatThreadDetailDto'];
+export type CodeChatPostMessageBodyDto = components['schemas']['CodeChatPostMessageBodyDto'];
+export type CodeChatMessageReplyDto = components['schemas']['CodeChatMessageReplyDto'];
+export type CodeChatWikiPageDto = components['schemas']['CodeChatWikiPageDto'];
+export type CodeChatWikiPageListDto = components['schemas']['CodeChatWikiPageListDto'];
+export type CodeChatSymbolQueryBodyDto = components['schemas']['CodeChatSymbolQueryBodyDto'];
+export type CodeChatSymbolHitDto = components['schemas']['CodeChatSymbolHitDto'];
+export type CodeChatSymbolHitListDto = components['schemas']['CodeChatSymbolHitListDto'];
+export type CodeChatReferenceQueryBodyDto = components['schemas']['CodeChatReferenceQueryBodyDto'];
+export type CodeChatReferenceHitDto = components['schemas']['CodeChatReferenceHitDto'];
+export type CodeChatReferenceHitListDto = components['schemas']['CodeChatReferenceHitListDto'];
+export type CodeChatBlastRadiusBodyDto = components['schemas']['CodeChatBlastRadiusBodyDto'];
+export type CodeChatBlastRadiusResultDto = components['schemas']['CodeChatBlastRadiusResultDto'];
+export type CodeChatSemanticDiffBodyDto = components['schemas']['CodeChatSemanticDiffBodyDto'];
+export type CodeChatSemanticDiffResultDto = components['schemas']['CodeChatSemanticDiffResultDto'];
+export type CodeChatRecommendationsBodyDto = components['schemas']['CodeChatRecommendationsBodyDto'];
+export type CodeChatRecommendationsResultDto = components['schemas']['CodeChatRecommendationsResultDto'];
+export type CodeChatVisualizeBodyDto = components['schemas']['CodeChatVisualizeBodyDto'];
+export type CodeChatVisualizeResultDto = components['schemas']['CodeChatVisualizeResultDto'];
+export type CodeChatCrossEdgesBodyDto = components['schemas']['CodeChatCrossEdgesBodyDto'];
+export type CodeChatCrossEdgesResultDto = components['schemas']['CodeChatCrossEdgesResultDto'];
+export type CodeChatContextPackBodyDto = components['schemas']['CodeChatContextPackBodyDto'];
+export type CodeChatContextPackDto = components['schemas']['CodeChatContextPackDto'];
 export type ResponseUnauthorized = components['responses']['Unauthorized'];
 export type ResponseForbidden = components['responses']['Forbidden'];
 export type ResponseZenHrSyncInProgress = components['responses']['ZenHrSyncInProgress'];
@@ -14345,6 +14973,679 @@ export interface operations {
             401: components["responses"]["Unauthorized"];
         };
     };
+    listCodeChatIndexes: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Index list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatIndexListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createCodeChatIndex: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatCreateIndexBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Indexing accepted */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatIndexDto"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    syncCodeChatIndexes: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["CodeChatSyncIndexesBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Sync accepted */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatSyncIndexesResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getCodeChatIndex: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                indexId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Index */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatIndexDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    listCodeChatThreads: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatThreadListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createCodeChatThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatCreateThreadBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Thread created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatThreadDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Index not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getCodeChatThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread with messages */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatThreadDetailDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    deleteCodeChatThread: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    postCodeChatMessage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                threadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatPostMessageBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Assistant message */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatMessageReplyDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Index not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listCodeChatWikiPages: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                indexId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Wiki page list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatWikiPageListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getCodeChatWikiPage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                indexId: string;
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Wiki page */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatWikiPageDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    generateCodeChatWiki: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                indexId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Generated wiki pages */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatWikiPageListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Index not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatSymbols: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatSymbolQueryBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Symbol hits */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatSymbolHitListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatReferences: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatReferenceQueryBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Reference hits */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatReferenceHitListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatBlastRadius: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatBlastRadiusBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Blast radius result (always marked partial/unknown until eval gates) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatBlastRadiusResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Symbol not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatSemanticDiff: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatSemanticDiffBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Semantic diff analysis */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatSemanticDiffResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatRecommendations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatRecommendationsBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Recommendations */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatRecommendationsResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatVisualize: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatVisualizeBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Visualization payload */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatVisualizeResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    analyzeCodeChatCrossEdges: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["CodeChatCrossEdgesBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Cross-process edge candidates */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatCrossEdgesResultDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Need two ready indexes */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    codeChatGetContextPack: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeChatContextPackBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Context pack */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeChatContextPackDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Corpus not ready */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     listNotifications: {
         parameters: {
             query?: {