aimeat 1.33.2 → 1.35.0

package/dist/src/generated/api-types.d.ts

@@ -538,7 +538,8 @@ export interface paths {
          *       * **Owner session (cookie):** send the httpOnly `aimeat_rt` refresh cookie (set at
          *         login) plus the `X-AIMEAT-Refresh: 1` header (CSRF guard). The refresh token is
          *         rotated one-time-use with a short grace window and a new cookie is set; replaying
-         *         a consumed token revokes the whole session. Returns `{ token, expires_in }`.
+         *         a consumed token revokes the whole session. Returns `{ token, expires_in, display_name }`
+         *         (the owner's current display name, so the client login pill picks up profile edits).
          *       * **Legacy (Bearer):** send a valid Bearer access token (agents / pre-cookie clients).
          */
         post: operations["refreshToken"];
@@ -973,6 +974,106 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/secretary/clarify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Secretary asks the owner clarifying questions (ask-don't-hallucinate)
+         * @description When a Secretary "Do it" task lacks facts only the owner can supply, the Secretary asks rather than guesses: this sends a batch of structured questions (a federated AskUserQuestion) from the secretary agent to the owner's inbox and records a pending "produce" job. The autonomous tick resumes the job — producing the deliverable grounded in the owner's answers — once they reply. Owner-only.
+         */
+        post: operations["secretaryClarify"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/secretary/brief": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Propose grounded Work Briefs for the active context's structural gaps
+         * @description The light-vs-heavy seam. The cheap node-local Secretary no longer authors content one-shot (that hallucinated). It detects STRUCTURAL gaps (empty/thin workspaces, stale content, off-target KPIs) and assembles a grounded Work Brief — Current picture + real Discovery sources + exact record schemas + the appdev MCP playbook — that a Builder (a connected big AI via the MCP tools) executes. Deterministic (no paid AI call), idempotent (deduped against open briefs by gap), additive (never touches content). Optional `ws` scopes to one workspace. Owner-only.
+         */
+        post: operations["secretaryBrief"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/secretary/briefs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the open Work Briefs (proposed/dispatched) for the brief tray
+         * @description Owner-scoped private memory; includes the full brief markdown + MCP hints so the view renders without a second fetch. Owner-only.
+         */
+        get: operations["secretaryBriefsList"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/secretary/brief/{id}/dispatch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Dispatch a Work Brief to a connected Builder (queue a task it runs via MCP)
+         * @description Queues the brief as an agent task a connected Builder picks up and runs via the appdev MCP tools (lane b). The target must be one of THIS owner's connected agents and not the Secretary or a node-local specialist. Marks the brief 'dispatched'. Owner-only.
+         */
+        post: operations["secretaryBriefDispatch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/secretary/brief/{id}/done": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resolve a Work Brief (handled or no longer relevant)
+         * @description Marks the brief 'done' so it leaves the tray and the tick won't re-propose the same gap. Owner-only.
+         */
+        post: operations["secretaryBriefDone"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/agents/device-authorize": {
         parameters: {
             query?: never;
@@ -1658,7 +1759,7 @@ export interface paths {
         put?: never;
         /**
          * Run one AI completion on the caller's own provider key + budget
-         * @description App/extension-level AI completion. Runs on the owner's encrypted OpenRouter (or compatible) key with their daily/per-app budget enforced. Callable by an owner JWT, or an agent JWT holding the `ai:use` scope. Optionally accepts `images` (data: or https URLs) for a vision-capable model. Long calls: clients should use a large request timeout and no retries.
+         * @description App/extension-level AI completion. Runs on the owner's encrypted OpenRouter (or compatible) key with their daily/per-app budget enforced. Callable by an owner JWT, or any token carrying the `ai:use` scope — an agent JWT, or an app-grant token from a sandboxed app on the isolated app origin. Optionally accepts `images` (data: or https URLs) for a vision-capable model. Long calls: clients should use a large request timeout and no retries.
          */
         post: operations["aiComplete"];
         delete?: never;
@@ -1667,6 +1768,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/ai/available": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Probe whether AI is configured for the caller's owner
+         * @description Lightweight boolean probe used by apps to decide whether to show AI affordances. Returns `{ available }` — true when the owner has an OpenRouter key configured (or a keyless self-hosted provider). Gated identically to `/v1/ai/complete` (an owner JWT, or any token with the `ai:use` scope), so a sandboxed app can gate its UI without owner-only access to `/v1/ai/settings`.
+         */
+        get: operations["aiAvailable"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/librarian/search": {
         parameters: {
             query?: never;
@@ -4445,6 +4566,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/admin/apps/{owner}/{filename}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Permanently delete an app (operator hard delete)
+         * @description Operator-only. Removes the app entirely from the node — every version row across every bucket
+         *     for that owner+filename, the download counter, and the screenshot. Targets ANY owner. This is
+         *     irreversible; the moderation hide (POST .../moderate) is the soft, reversible alternative.
+         */
+        delete: operations["deleteAppAdmin"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/apps/{filename}": {
         parameters: {
             query?: never;
@@ -4463,11 +4606,13 @@ export interface paths {
         options?: never;
         head?: never;
         /**
-         * Update an app you own (access code and/or parked state)
+         * Update an app you own (name, description, access code and/or parked state)
          * @description Update metadata on an app you own. Each field is independent and applied only when present
          *     in the body, so a `parked`-only request never clears the access code (and vice-versa).
-         *     Parking hides the app from the public catalogue/gallery/search while keeping it fully usable
-         *     by you (and your agents); unparking restores it to the catalogue.
+         *     `name`/`description` rename or re-describe the app in place on its latest version — the
+         *     display name is metadata only, so the stable `owner/filename` download URL never changes
+         *     (no re-publish needed). Parking hides the app from the public catalogue/gallery/search while
+         *     keeping it fully usable by you (and your agents); unparking restores it to the catalogue.
          */
         patch: operations["updateApp"];
         trace?: never;
@@ -6338,6 +6483,52 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/organisms/{id}/archive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Archive organism content (read-only, hidden from AI materials)
+         * @description Flag an organism, a workspace, a record-table/document-space, or a single record as archived.
+         *     Archived content becomes READ-ONLY and is EXCLUDED by default from the AI-facing materials
+         *     (structure overview, workspace read, organism search) — keeping the working set focused — yet
+         *     stays findable via archive search (`?archived=only`) and `?includeArchived=true`, and resolvable
+         *     by key. Archiving a container CASCADES to its contents. Creator/admin only.
+         */
+        post: operations["archiveOrganismContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/organisms/{id}/unarchive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Unarchive organism content (smart restore)
+         * @description Reverse an archive. Uses SMART RESTORE: restores ONLY the content that THIS target's archival
+         *     flagged (its `archivedRoot`), leaving any item that was archived separately still archived.
+         *     Same body shape and creator/admin gate as POST /v1/organisms/{id}/archive.
+         */
+        post: operations["unarchiveOrganismContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/organisms/{id}/revert": {
         parameters: {
             query?: never;
@@ -10673,6 +10864,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/specialists/{name}/run": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Run a specialist's queued tasks now (node-side, owner key)
+         * @description Execute up to `limit` of the specialist's QUEUED agent tasks immediately on the node, using the owner's OpenRouter key and the specialist's brain + the quality contract (grounded, no fabrication). Each produced deliverable is written to the specialist's memory and the task is marked done. The Secretary tick also runs this on schedule (it directs its specialists); spending-paused/error leaves a task queued to retry. Owner-only.
+         */
+        post: operations["runSpecialist"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/specialists/{name}/policy": {
         parameters: {
             query?: never;
@@ -13805,7 +14016,15 @@ export interface components {
             id?: string;
             order?: number;
             title?: string;
+            /** @description Raw i18n key (agentOnboarding.stepDescriptions.{id}); see descriptionText for the resolved string. */
             description?: string;
+            /**
+             * @description Localised, human-readable resolution of `description`. Present on the GET /onboarding
+             *     and aimeat_onboarding_status payloads (REST resolves via Accept-Language; MCP uses the
+             *     node default locale). Added so connector/agent consumers without the i18n bundle never
+             *     see a raw key.
+             */
+            descriptionText?: string;
             /** @enum {string} */
             status?: "pending" | "passed" | "failed" | "skipped";
             required?: boolean;
@@ -13814,6 +14033,58 @@ export interface components {
             /** @enum {string} */
             validationMethod?: "automatic" | "api_call" | "owner_confirm";
             failureReason?: string;
+            /** @description Machine-readable how-to-complete descriptor (null when the step id has no mapping). */
+            howTo?: components["schemas"]["OnboardingStepHowTo"] | null;
+        };
+        /**
+         * @description Authoritative machine-readable "how to complete this step" descriptor. A connector drives
+         *     each pending step from this (call `tool` with `args`) instead of fabricating a non-existent
+         *     `aimeat_onboarding_<stepId>` tool. The only onboarding-prefixed tools that exist are the five
+         *     aimeat_onboarding_* tools; every other step is completed by calling its mapped real tool.
+         */
+        OnboardingStepHowTo: {
+            /**
+             * @description Who performs the action -- the agent calls a tool, or the server validates passively.
+             * @enum {string}
+             */
+            actor?: "agent" | "server";
+            /** @description true when the server auto-ticks the step by reading real state (no dedicated confirm call). */
+            automatic?: boolean;
+            /** @description Mirrors `required` -- true when this step gates onboarding completion. */
+            gatesCompletion?: boolean;
+            /** @enum {string} */
+            validationMethod?: "automatic" | "api_call" | "owner_confirm";
+            /** @description Exact MCP tool to call, or null for passive/server steps. */
+            tool?: string | null;
+            /** @description Optional local-connector convenience tool with the same effect (e.g. aimeat_offers_publish). */
+            toolAlias?: string;
+            /** @description Underlying REST route for non-MCP clients; null for passive steps. */
+            restEndpoint?: {
+                /** @enum {string} */
+                method?: "GET" | "POST" | "PUT" | "PATCH";
+                path?: string;
+            } | null;
+            /** @description Copyable argument template. `{name}` is substituted server-side; `{test_task_id}` is filled from hints.test_task_id. */
+            args?: {
+                [key: string]: unknown;
+            };
+            /** @description For tool === null steps, the condition under which the server auto-passes the step. */
+            passiveNote?: string;
+        };
+        /** @description Reachability summary. Completion gates only on required steps; optional steps never block. */
+        OnboardingSummary: {
+            required_total?: number;
+            required_passed?: number;
+            required_remaining?: number;
+            optional_total?: number;
+            optional_passed?: number;
+            optional_remaining?: number;
+            /** @description true once every required step has passed -- the agent can stop here. */
+            completable?: boolean;
+            /** @description First not-yet-passed required step id, or null when none remain. */
+            next_required_step?: string | null;
+            /** @description Ids of pending optional steps (never block completion). */
+            optional_pending?: string[];
         };
         /** @description An opt-in budget/run guard on a schedule. type 'max_runs' or 'daily_limit' in v1. */
         ScheduleConstraint: {
@@ -15864,6 +16135,229 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    secretaryClarify: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    contextId: string;
+                    contextName?: string;
+                    action: {
+                        summary: string;
+                        why?: string;
+                    };
+                    questions: {
+                        id: string;
+                        header: string;
+                        prompt: string;
+                        options: {
+                            id: string;
+                            label: string;
+                        }[];
+                        multiSelect?: boolean;
+                        allowOther?: boolean;
+                        required?: boolean;
+                    }[];
+                    /** @description The grounding facts stored on the job for the tick to produce from. */
+                    facts?: string;
+                    organismId?: string;
+                    wsId?: string;
+                    /** @description Optional intro shown above the questions. */
+                    body?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Questions sent; produce job stored */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            messageId?: string;
+                            conversationId?: string;
+                            /** @example asked */
+                            status?: string;
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Could not deliver the questions to the inbox */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    secretaryBrief: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Optional workspace id to scope the brief to. */
+                    ws?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Work briefs proposed (0 when no new gaps) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            proposed?: number;
+                            workspaces?: number;
+                            briefs?: {
+                                id?: string;
+                                objective?: string;
+                                ws?: string;
+                                wsName?: string;
+                                gaps?: number;
+                                /** @example proposed */
+                                status?: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+            /** @description No active Secretary context with an organism to brief (NO_CONTEXT) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    secretaryBriefsList: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Open Work Briefs, newest first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            briefs?: Record<string, never>[];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    secretaryBriefDispatch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The Builder agent GAII (or name) to dispatch to. */
+                    targetAgent: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Brief dispatched; task queued */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            dispatched?: boolean;
+                            taskId?: string;
+                            to?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Missing targetAgent, or the target is not a valid Builder (INVALID_TARGET) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Work brief not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    secretaryBriefDone: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Brief resolved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            done?: boolean;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Work brief not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     deviceAuthorize: {
         parameters: {
             query?: never;
@@ -17336,6 +17830,20 @@ export interface operations {
             403: components["responses"]["AimeatError"];
         };
     };
+    aiAvailable: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["AimeatError"];
+            403: components["responses"]["AimeatError"];
+        };
+    };
     librarianSearch: {
         parameters: {
             query: {
@@ -21439,6 +21947,39 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    deleteAppAdmin: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                owner: string;
+                filename: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description App deleted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            owner?: string;
+                            filename?: string;
+                            deleted?: boolean;
+                            note?: string;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     deleteApp: {
         parameters: {
             query?: {
@@ -21477,6 +22018,10 @@ export interface operations {
         requestBody: {
             content: {
                 "application/json": {
+                    /** @description 1-120 chars; new display name (URL is unchanged) */
+                    name?: string;
+                    /** @description 1-2000 chars; new description (cannot be empty) */
+                    description?: string;
                     /** @description 4-64 chars to set protection; empty/null removes it */
                     access_code?: string | null;
                     /** @description true hides the app from the public catalogue; false republishes it */
@@ -21494,6 +22039,8 @@ export interface operations {
                     "application/json": components["schemas"]["AimeatEnvelope"] & {
                         data?: {
                             filename?: string;
+                            name?: string;
+                            description?: string;
                             protected?: boolean;
                             parked?: boolean;
                             download_url?: string;
@@ -24008,6 +24555,10 @@ export interface operations {
             query?: {
                 /** @description Workspace id. An organism holds many workspaces, each scoped under `organism.{id}.w.{ws}.*` (manifest at `organism.{id}.w.{ws}.meta.manifest`). The workspace list lives at `organism.{id}.meta.workspaces`. Omitting `ws` reads the legacy organism-level root. */
                 ws?: string;
+                /** @description Include archived (read-only, normally hidden) content. Default false. */
+                includeArchived?: boolean;
+                /** @description `only` reads ONLY archived content (the explicit archive view). */
+                archived?: "only";
             };
             header?: never;
             path: {
@@ -24135,6 +24686,8 @@ export interface operations {
             query?: {
                 /** @description `md` returns the raw text/markdown body; omit for the JSON envelope. */
                 format?: "md";
+                /** @description List archived workspaces too. Default false — archived workspaces are summarised as a count (`archivedWorkspaces`) + a footer, keeping them out of the AI working set. */
+                includeArchived?: boolean;
             };
             header?: never;
             path: {
@@ -25059,6 +25612,13 @@ export interface operations {
             };
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            /** @description The target organism/workspace is archived (read-only) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Draft does not match the schema */
             422: {
                 headers: {
@@ -25068,6 +25628,80 @@ export interface operations {
             };
         };
     };
+    archiveOrganismContent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Organism ID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * @description What to archive
+                     * @enum {string}
+                     */
+                    level: "organism" | "workspace" | "space" | "record";
+                    /** @description Workspace id (required for workspace/space/record) */
+                    ws?: string;
+                    /** @description objectType namespace (required for level "space"), e.g. shared.tasks */
+                    namespace?: string;
+                    /** @description Instance base memory key (required for level "record") */
+                    key?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Archived (returns { archived, level, root }) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    unarchiveOrganismContent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Organism ID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    level: "organism" | "workspace" | "space" | "record";
+                    ws?: string;
+                    namespace?: string;
+                    key?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Restored (returns { restored, level, root }) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     revertOrganismRecordToDraft: {
         parameters: {
             query?: never;
@@ -28033,6 +28667,10 @@ export interface operations {
                 q: string;
                 /** @description Limit the search to a single workspace id */
                 ws?: string;
+                /** @description `only` = archive search (archived content only). Default excludes archived. */
+                archived?: "only";
+                /** @description true = search active AND archived content together. */
+                includeArchived?: boolean;
             };
             header?: never;
             path: {
@@ -31724,6 +32362,41 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    runSpecialist: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @default 5 */
+                    limit?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description Tasks run */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            ran?: number;
+                            deliverableKeys?: string[];
+                        };
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
     updateSpecialistPolicy: {
         parameters: {
             query?: never;
@@ -33157,10 +33830,19 @@ export interface operations {
                     "application/json": components["schemas"]["AimeatEnvelope"] & {
                         data?: {
                             onboarding: components["schemas"]["AgentOnboardingRecord"];
+                            /**
+                             * @description Flow-scoped map of stepId -> OnboardingStepHowTo for the steps in this
+                             *     agent's onboarding flow. The authoritative how-to-complete contract a
+                             *     connector drives from (call howTo.tool with howTo.args per pending step).
+                             */
+                            step_guide?: {
+                                [key: string]: components["schemas"]["OnboardingStepHowTo"];
+                            };
+                            summary?: components["schemas"]["OnboardingSummary"];
                             /**
                              * @description Next-step guidance for the agent. May include
-                             *     `next_step` (step id), `message` (human-readable),
-                             *     `test_task_id`, `test_task_active`.
+                             *     `next_step` (step id; now prefers the next required step),
+                             *     `message` (human-readable), `test_task_id`, `test_task_active`.
                              */
                             hints?: {
                                 [key: string]: unknown;