@axiom-lattice/core 4.2.0 → 4.2.2

package/dist/index.d.mts

@@ -8,9 +8,9 @@ import { BaseLanguageModelInput, LanguageModelLike } from '@langchain/core/langu
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { ChatResult } from '@langchain/core/outputs';
 import * as _axiom_lattice_protocols from '@axiom-lattice/protocols';
-import { LLMConfig, SemanticMetricsServerConfig, MetricMeta, MetricQueryResult, DataSource, SemanticMetricsQueryRequest, SemanticMetricsQueryResponse, TableQueryRequest, TableQueryResponse, ExecuteSqlQueryRequest, ExecuteSqlQueryResponse, MetricsServerType, MetricsServerConfig, ToolConfig, ToolExecutor, AgentConfig, MiddlewareType, GraphBuildOptions, MessageChunk, MessageChunkType, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, SkillStore, CollectionStore, WorkspaceStore, ProjectStore, DatabaseConfigStore, MetricsServerConfigStore, McpServerConfigStore, UserStore, TenantStore, UserTenantLinkStore, WorkflowTrackingStore, EvalStore, ChannelInstallationStore, BindingRegistry, MenuRegistry, A2AApiKeyStore, TaskStore, SharedResourceStore, ConnectionStore, TaskWorkItemStore, AgentWebAppStore, VectorStoreProvider, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest, AgentWebApp, CreateAgentWebAppInput, AgentWebAppStorePatch, AgentWebAppUpdateOptions, Skill, CreateSkillRequest, SkillStoreContext, DatabaseConfigEntry, CreateDatabaseConfigRequest, UpdateDatabaseConfigRequest, User, CreateUserRequest, UpdateUserRequest, Tenant, CreateTenantRequest, UpdateTenantRequest, UserTenantLink, CreateUserTenantLinkRequest, UpdateUserTenantLinkRequest, ChannelInstallation, ChannelInstallationType, CreateChannelInstallationRequest, UpdateChannelInstallationRequest, Binding, CreateBindingInput, A2AApiKeyRecord, CreateA2AApiKeyInput, A2AApiKeyEntry, CreateTaskRequest, TaskItem, TaskListFilter, UpdateTaskRequest, Collection, CreateCollectionRequest, UpdateCollectionRequest, MenuItem, CreateMenuItemInput, UpdateMenuItemInput, STTModelLatticeProtocol, STTConfig, STTClient, TranscriptionResult, LoggerLatticeProtocol, LoggerConfig, LoggerClient, LoggerContext, SkillConfig, SkillClient, McpTool, ResourceResolver, ResourceAddress, ShareVisibility, CreateShareRequest, ChannelAdapter, InterruptPolicy, TaskBeliefState, PluginMeta, Plugin, PluginMetaOutput, InternalStateField, InternalInput, InternalNode, InternalAgentNode, InternalMapNode, InternalDSL, ConnectionEntry } from '@axiom-lattice/protocols';
+import { LLMConfig, SemanticMetricsServerConfig, MetricMeta, MetricQueryResult, DataSource, SemanticMetricsQueryRequest, SemanticMetricsQueryResponse, TableQueryRequest, TableQueryResponse, ExecuteSqlQueryRequest, ExecuteSqlQueryResponse, MetricsServerType, MetricsServerConfig, ToolConfig, ToolExecutor, AgentConfig, MiddlewareType, GraphBuildOptions, MessageChunk, MessageChunkType, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, TrustedRunContext, QueuedExecutionMode, ThreadStore, AssistantStore, SkillStore, CollectionStore, WorkspaceStore, ProjectStore, DatabaseConfigStore, MetricsServerConfigStore, McpServerConfigStore, UserStore, TenantStore, UserTenantLinkStore, WorkflowTrackingStore, EvalStore, ChannelInstallationStore, BindingRegistry, MenuRegistry, A2AApiKeyStore, TaskStore, SharedResourceStore, ConnectionStore, TaskWorkItemStore, AgentWebAppStore, CapabilityBundleStore, ProjectRoomStore, ProjectMembershipStore, ProjectBotMembershipStore, ProjectRoomMessageStore, VectorStoreProvider, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest, AgentWebApp, CreateAgentWebAppInput, AgentWebAppStorePatch, AgentWebAppUpdateOptions, Project, CreateProjectRequest, UpdateProjectRequest, UpdateProjectCapabilityBundlesResult, CapabilityBundle, InternalCreateCapabilityBundleInput, InternalUpdateCapabilityBundleInput, CapabilityBundleDeleteResult, Skill, CreateSkillRequest, SkillStoreContext, DatabaseConfigEntry, CreateDatabaseConfigRequest, UpdateDatabaseConfigRequest, User, CreateUserRequest, UpdateUserRequest, Tenant, CreateTenantRequest, UpdateTenantRequest, UserTenantLink, CreateUserTenantLinkRequest, UpdateUserTenantLinkRequest, ChannelInstallation, ChannelInstallationType, CreateChannelInstallationInput, UpdateChannelInstallationRequest, Binding, CreateBindingInput, BindingMutablePatch, BindingListParams, A2AApiKeyRecord, CreateA2AApiKeyInput, A2AApiKeyEntry, TaskMutationSnapshot, CreateTaskRequest, TaskItem, TaskListFilter, TaskDependentListQuery, UpdateTaskRequest, Collection, CreateCollectionRequest, UpdateCollectionRequest, MenuItem, CreateMenuItemInput, UpdateMenuItemInput, ProjectRoom, ProjectMembership, ProjectBotMembership, ProjectRoomMessage, ProjectHumanRole, ProjectMembershipMutationResult, STTModelLatticeProtocol, STTConfig, STTClient, TranscriptionResult, LoggerLatticeProtocol, LoggerConfig, LoggerClient, LoggerContext, SkillConfig, SkillClient, PluginSkillDefinition, McpTool, ResourceResolver, ResourceAddress, ShareVisibility, CreateShareRequest, ChannelAdapter, InterruptPolicy, ProjectTaskLifecycleAction, TaskBeliefState, PluginMeta, Plugin, PluginMetaOutput, CapabilityPreview, CreateCapabilityBundleInput, UpdateCapabilityBundleInput, InternalStateField, InternalInput, InternalNode, InternalAgentNode, InternalMapNode, InternalDSL, ConnectionEntry } from '@axiom-lattice/protocols';
 export { _axiom_lattice_protocols as Protocols };
-export { AgentConfig, AgentType, GraphBuildOptions, MemoryType } from '@axiom-lattice/protocols';
+export { AgentConfig, AgentType, GraphBuildOptions, MemoryType, ProjectRoomTrustedRunContext, QueuedExecutionMode, TrustedRunContext, parseQueuedExecutionMode, parseTrustedRunContext } from '@axiom-lattice/protocols';
 import * as langchain from 'langchain';
 import { ReactAgent, AgentMiddleware } from 'langchain';
 import z, { z as z$1 } from 'zod';
@@ -1588,6 +1588,22 @@ interface SandboxInstance {
     getStatus(): Promise<"running" | "stopped" | "unknown">;
     readonly file: SandboxFileService;
     readonly shell: SandboxShellService;
+    /**
+     * Pack a directory into a provider-generated temporary ZIP file.
+     *
+     * Implementations may omit this capability. Local sandboxes accept only
+     * paths rooted at `/project`; the returned path can be downloaded and then
+     * deleted through the existing file service. Remote POSIX sandboxes run the
+     * same safe shell-zip strategy through their shell service and therefore also
+     * pack volume-backed folders visible inside the sandbox filesystem. The
+     * returned `path` is always a sandbox-visible sibling (e.g.
+     * `/project/data/reports.zip`).
+     */
+    packDirectory?(sourcePath: string): Promise<{
+        path: string;
+        filename: string;
+        size?: number;
+    }>;
 }
 
 type SandboxIsolationLevel = "global" | "agent" | "project";
@@ -2630,6 +2646,17 @@ declare enum QueueMode {
     FOLLOWUP = "followup",
     STEER = "steer"
 }
+/** Result returned after an Agent accepts a message for asynchronous execution. */
+interface AddMessageResult {
+    queued: boolean;
+    messageId: string;
+    executed: boolean;
+}
+/** Options accepted only by the privileged trusted Agent dispatcher. */
+interface TrustedMessageOptions {
+    trustedRunContext: TrustedRunContext;
+    executionMode: QueuedExecutionMode;
+}
 interface ThreadQueueConfig {
     mode: QueueMode;
     maxSize: number;
@@ -2643,6 +2670,8 @@ interface PendingMessage {
     priority?: number;
     command?: CommandParams<unknown>;
     custom_run_config?: unknown;
+    trusted_run_context?: TrustedRunContext;
+    execution_mode?: QueuedExecutionMode;
 }
 interface PendingQueueMessageInput {
     message?: string;
@@ -2670,37 +2699,41 @@ interface AddMessageParams {
     threadId: string;
     tenantId: string;
     assistantId: string;
-    workspaceId?: string;
-    projectId?: string;
+    workspaceId?: string | null;
+    projectId?: string | null;
     content: PendingMessageContent;
     type?: "human" | "system";
     priority?: number;
     command?: CommandParams<unknown>;
     custom_run_config?: unknown;
     id?: string;
+    trusted_run_context?: TrustedRunContext;
+    execution_mode?: QueuedExecutionMode;
 }
 interface ThreadInfo {
     tenantId: string;
     assistantId: string;
     threadId: string;
-    workspaceId?: string;
-    projectId?: string;
+    workspaceId?: string | null;
+    projectId?: string | null;
 }
+type QueueScope = Pick<ThreadInfo, "tenantId" | "assistantId" | "workspaceId" | "projectId">;
 /**
  * Interface for message queue storage
  * Implemented by pg-stores or other storage backends
  */
 interface IMessageQueueStore {
     addMessage(params: AddMessageParams): Promise<PendingMessage>;
+    addMessageIfCapacity(params: AddMessageParams, maxSize: number): Promise<boolean>;
     addMessageAtHead(params: AddMessageParams): Promise<PendingMessage>;
-    getPendingMessages(threadId: string): Promise<PendingMessage[]>;
-    getProcessingMessages(threadId: string): Promise<PendingMessage[]>;
-    getQueueSize(threadId: string): Promise<number>;
+    getPendingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]>;
+    getProcessingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]>;
+    getQueueSize(threadId: string, scope?: QueueScope): Promise<number>;
     getThreadsWithPendingMessages(): Promise<ThreadInfo[]>;
-    removeMessage(messageId: string): Promise<boolean>;
-    clearMessages(threadId: string): Promise<void>;
-    markProcessing(messageId: string): Promise<void>;
-    resetProcessingToPending(threadId: string): Promise<number>;
+    removeMessage(messageId: string, scope?: QueueScope): Promise<boolean>;
+    clearMessages(threadId: string, scope?: QueueScope): Promise<void>;
+    markProcessing(messageId: string, customRunConfig?: unknown, scope?: QueueScope): Promise<void>;
+    resetProcessingToPending(threadId: string, scope?: QueueScope): Promise<number>;
 }
 /**
  * Agent executor function type
@@ -2718,13 +2751,28 @@ type LangGraphStateChecker = (tenantId: string, assistantId: string, threadId: s
  * Returns an async iterable for streaming responses
  */
 type AgentStreamExecutor = (tenantId: string, assistantId: string, threadId: string, input: any) => AsyncIterable<any>;
+/** A JSON-safe value accepted within a structured message content part. */
+type MessageContentValue = null | boolean | number | string | {
+    [key: string]: MessageContentValue;
+} | MessageContentValue[];
+/** A provider-compatible structured message content part. */
+type MessageContentPart = {
+    [key: string]: MessageContentValue;
+};
+/**
+ * Queue-safe message content accepted by Agent inputs.
+ *
+ * Structured content remains JSON-serializable while supporting provider
+ * content parts such as `{ type: "text", text: "hello" }`.
+ */
+type MessageContent = string | [MessageContentPart, ...MessageContentPart[]];
 /**
  * Message-like structure for normalized message input
  * Supports both simple string content and structured message objects
  */
 interface MessageLike {
     role: "human" | "system" | "assistant" | "tool";
-    content: string;
+    content: MessageContent;
     id?: string;
     metadata?: Record<string, unknown>;
 }
@@ -2764,6 +2812,11 @@ type StoreTypeMap = {
     connection: ConnectionStore;
     taskWorkItem: TaskWorkItemStore;
     agentWebApp: AgentWebAppStore;
+    capabilityBundle: CapabilityBundleStore;
+    projectRoom: ProjectRoomStore;
+    projectMembership: ProjectMembershipStore;
+    projectBotMembership: ProjectBotMembershipStore;
+    projectRoomMessage: ProjectRoomMessageStore;
 };
 /**
  * Store type keys
@@ -3011,6 +3064,86 @@ declare class InMemoryAgentWebAppStore implements AgentWebAppStore {
     delete(tenantId: string, webAppId: string): Promise<boolean>;
 }
 
+/** Coordinates capability Bundle existence checks with Project updates in memory. */
+declare class InMemoryCapabilityBundleCoordinator {
+    private readonly bundleKeys;
+    private readonly revisions;
+    private readonly tenantUpdates;
+    /** Serializes Project and Bundle reference changes for one tenant. */
+    runProjectUpdate<T>(tenantId: string, projectId: string, update: () => Promise<T> | T): Promise<T>;
+    /** Records a tenant Bundle as present. */
+    add(tenantId: string, bundleId: string, revision?: string): void;
+    /** Removes a tenant Bundle. */
+    remove(tenantId: string, bundleId: string): void;
+    /** Checks all requested Bundle IDs without yielding to another operation. */
+    hasAll(tenantId: string, bundleIds: string[]): boolean;
+    hasAllAtRevisions(tenantId: string, bundleIds: string[], expected: Record<string, string>): boolean;
+    setRevision(tenantId: string, bundleId: string, revision: string): void;
+    private key;
+}
+
+/**
+ * InMemoryProjectStore
+ *
+ * In-memory implementation of ProjectStore
+ * Provides CRUD operations for project data stored in memory
+ */
+
+declare class InMemoryProjectStore implements ProjectStore {
+    readonly capabilityBundles: InMemoryCapabilityBundleCoordinator;
+    private projects;
+    constructor(capabilityBundles?: InMemoryCapabilityBundleCoordinator);
+    private initDefaultData;
+    private getKey;
+    getProjectsByWorkspace(tenantId: string, workspaceId: string): Promise<Project[]>;
+    getProjectById(tenantId: string, id: string): Promise<Project | null>;
+    createProject(tenantId: string, workspaceId: string, id: string, data: CreateProjectRequest): Promise<Project>;
+    /**
+     * Update an existing project
+     *
+     * @remarks
+     * - The `config` field uses **replace** semantics: if provided, it completely
+     *   overwrites the existing config. To preserve the current config, omit this field.
+     */
+    updateProject(tenantId: string, id: string, updates: UpdateProjectRequest): Promise<Project | null>;
+    deleteProject(tenantId: string, id: string): Promise<boolean>;
+    updateCapabilityBundleIds(tenantId: string, projectId: string, bundleIds: string[], expectedRevisions?: Record<string, string>): Promise<UpdateProjectCapabilityBundlesResult>;
+    isCapabilityBundleReferenced(tenantId: string, bundleId: string): Promise<boolean>;
+    /** Checks bundle references synchronously for in-process atomic coordination. */
+    isCapabilityBundleReferencedSync(tenantId: string, bundleId: string): boolean;
+    clear(): void;
+}
+
+/**
+ * Stores tenant-isolated capability bundles in process memory.
+ *
+ * Values are cloned on write and read so callers cannot mutate persisted
+ * middleware configuration through retained nested references.
+ *
+ * @example
+ * ```ts
+ * const store = new InMemoryCapabilityBundleStore(projectStore);
+ * const bundle = await store.create("tenant-1", input);
+ * ```
+ */
+declare class InMemoryCapabilityBundleStore implements CapabilityBundleStore {
+    private readonly projectStore;
+    private readonly coordinator;
+    private readonly bundles;
+    /** Creates an in-memory bundle store coordinated with its Project store. */
+    constructor(projectStore: InMemoryProjectStore, coordinator?: InMemoryCapabilityBundleCoordinator);
+    private key;
+    private hasKey;
+    listByTenant(tenantId: string): Promise<CapabilityBundle[]>;
+    getById(tenantId: string, id: string): Promise<CapabilityBundle | null>;
+    getManyByIds(tenantId: string, ids: string[]): Promise<CapabilityBundle[]>;
+    create(tenantId: string, input: InternalCreateCapabilityBundleInput): Promise<CapabilityBundle>;
+    update(tenantId: string, id: string, input: InternalUpdateCapabilityBundleInput): Promise<CapabilityBundle | {
+        status: "conflict";
+    } | null>;
+    deleteIfUnreferenced(tenantId: string, id: string): Promise<CapabilityBundleDeleteResult>;
+}
+
 /**
  * FileSystemSkillStore
  *
@@ -3427,10 +3560,10 @@ declare class InMemoryChannelInstallationStore implements ChannelInstallationSto
      *
      * @param tenantId - Tenant identifier
      * @param installationId - Unique installation ID (caller-defined)
-     * @param data - {@link CreateChannelInstallationRequest} containing channel type, name, config, and fallback settings
+     * @param data - {@link CreateChannelInstallationInput} containing channel type, name, config, and fallback settings
      * @returns The created {@link ChannelInstallation}
      */
-    createInstallation(tenantId: string, installationId: string, data: CreateChannelInstallationRequest): Promise<ChannelInstallation>;
+    createInstallation(tenantId: string, installationId: string, data: CreateChannelInstallationInput): Promise<ChannelInstallation>;
     /**
      * Updates an existing channel installation. Config fields are shallow-merged.
      *
@@ -3491,6 +3624,14 @@ declare class InMemoryChannelInstallationStore implements ChannelInstallationSto
 
 declare class InMemoryBindingStore implements BindingRegistry {
     private bindings;
+    private createTail;
+    findById(tenantId: string, id: string): Promise<Binding | null>;
+    findBySubject(params: {
+        tenantId: string;
+        channel: string;
+        channelInstallationId: string;
+        senderId: string;
+    }): Promise<Binding | null>;
     /**
      * Resolves a binding for the given sender across a specific channel installation.
      *
@@ -3522,34 +3663,27 @@ declare class InMemoryBindingStore implements BindingRegistry {
      * @returns The updated {@link Binding}
      * @throws {Error} If the binding does not exist
      */
-    update(id: string, patch: Partial<Binding>): Promise<Binding>;
+    update(tenantId: string, id: string, patch: BindingMutablePatch): Promise<Binding>;
     /**
      * Deletes a binding by ID.
      *
      * @param id - Binding ID
      */
-    delete(id: string): Promise<void>;
+    delete(tenantId: string, id: string): Promise<void>;
     /**
      * Lists bindings filtered by tenant and optional channel/agent/installation.
      *
      * @param params - Filter and pagination parameters
      * @returns Array of matching {@link Binding} objects
      */
-    list(params: {
-        channel?: string;
-        agentId?: string;
-        tenantId: string;
-        channelInstallationId?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<Binding[]>;
+    list(params: BindingListParams): Promise<Binding[]>;
     /**
      * Bulk-imports bindings.
      *
      * @param bindings - Array of {@link CreateBindingInput}
      * @returns Array of created {@link Binding} objects
      */
-    import(bindings: CreateBindingInput[]): Promise<Binding[]>;
+    import(tenantId: string, bindings: CreateBindingInput[]): Promise<Binding[]>;
     /**
      * Exports all bindings for a tenant.
      *
@@ -3593,18 +3727,21 @@ declare class InMemoryA2AApiKeyStore implements A2AApiKeyStore {
 declare class InMemoryThreadMessageQueueStore implements IMessageQueueStore {
     private messages;
     private messageIdCounter;
+    private capacityTail;
     private generateId;
     private getMessagesForThread;
+    private inScope;
     addMessage(params: AddMessageParams): Promise<PendingMessage>;
+    addMessageIfCapacity(params: AddMessageParams, maxSize: number): Promise<boolean>;
     addMessageAtHead(params: AddMessageParams): Promise<PendingMessage>;
-    getPendingMessages(threadId: string): Promise<PendingMessage[]>;
-    getProcessingMessages(threadId: string): Promise<PendingMessage[]>;
-    getQueueSize(threadId: string): Promise<number>;
+    getPendingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]>;
+    getProcessingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]>;
+    getQueueSize(threadId: string, scope?: QueueScope): Promise<number>;
     getThreadsWithPendingMessages(): Promise<ThreadInfo[]>;
-    removeMessage(messageId: string): Promise<boolean>;
-    clearMessages(threadId: string): Promise<void>;
-    markProcessing(messageId: string): Promise<void>;
-    resetProcessingToPending(threadId: string): Promise<number>;
+    removeMessage(messageId: string, scope?: QueueScope): Promise<boolean>;
+    clearMessages(threadId: string, scope?: QueueScope): Promise<void>;
+    markProcessing(messageId: string, customRunConfig?: unknown, scope?: QueueScope): Promise<void>;
+    resetProcessingToPending(threadId: string, scope?: QueueScope): Promise<number>;
 }
 
 /**
@@ -3622,6 +3759,16 @@ declare class InMemoryTaskStore implements TaskStore {
     private cloneTask;
     private nextUpdatedAt;
     private canAdvanceUpdatedAt;
+    /**
+     * Runs a synchronous operation only while the exact task mutation snapshot matches.
+     *
+     * @param tenantId Tenant identifier.
+     * @param id Task identifier.
+     * @param snapshot Exact task mutation snapshot.
+     * @param operation Synchronous operation run without an await boundary.
+     * @returns Operation result, or `null` when the snapshot differs.
+     */
+    runIfSnapshot<T>(tenantId: string, id: string, snapshot: TaskMutationSnapshot, operation: () => T): T | null;
     private recognizedUpdates;
     private applyUpdates;
     /**
@@ -3641,6 +3788,8 @@ declare class InMemoryTaskStore implements TaskStore {
      * List tasks matching filter criteria
      */
     list(filter: TaskListFilter): Promise<TaskItem[]>;
+    /** Lists dependent tasks in an exact project scope. */
+    listDependents(query: TaskDependentListQuery): Promise<TaskItem[]>;
     /**
      * Update an existing task
      */
@@ -3659,12 +3808,16 @@ declare class InMemoryTaskStore implements TaskStore {
     updateIfStatusNotIn(tenantId: string, id: string, updates: UpdateTaskRequest, blockedStatuses: TaskItem["status"][]): Promise<TaskItem | null>;
     /** Atomically update a task only when status and updatedAt match a read snapshot. */
     updateIfStatusAndUpdatedAt(tenantId: string, id: string, updates: UpdateTaskRequest, expectedStatuses: TaskItem["status"][], expectedUpdatedAt: Date | string): Promise<TaskItem | null>;
+    /** Atomically update only while status, timestamp, owner, and Project scope match. */
+    updateIfSnapshot(tenantId: string, id: string, updates: UpdateTaskRequest, snapshot: TaskMutationSnapshot): Promise<TaskItem | null>;
     /** Atomically update a child only when both child and parent snapshots match. */
     updateIfStatusUpdatedAtAndParentUpdatedAt(tenantId: string, id: string, updates: UpdateTaskRequest, expectedStatuses: TaskItem["status"][], expectedUpdatedAt: Date | string, parentId: string, expectedParentUpdatedAt: Date | string): Promise<TaskItem | null>;
     /**
      * Delete a task by ID
      */
     delete(tenantId: string, id: string): Promise<boolean>;
+    /** Atomically delete only while status, timestamp, owner, and Project scope match. */
+    deleteIfSnapshot(tenantId: string, id: string, snapshot: TaskMutationSnapshot): Promise<boolean>;
     /**
      * Clear all tasks for a tenant (useful for testing)
      */
@@ -3724,6 +3877,357 @@ declare class InMemoryMenuStore implements MenuRegistry {
     clear(): void;
 }
 
+/** Error raised when a room-scoped idempotency key already identifies another in-memory message. */
+declare class DuplicateProjectRoomMessageIdempotencyKeyError extends Error {
+    /**
+     * Creates a duplicate room message idempotency key error.
+     *
+     * @param tenantId - Tenant in which the key is already present.
+     * @param roomId - Room in which the key is already present.
+     * @param idempotencyKey - Conflicting room-scoped idempotency key.
+     */
+    constructor(tenantId: string, roomId: string, idempotencyKey: string);
+}
+interface InMemoryProjectRoomTransaction {
+    getRoom(tenantId: string, projectId: string): ProjectRoom | undefined;
+    setRoom(room: ProjectRoom): void;
+    getMembership(tenantId: string, id: string): ProjectMembership | undefined;
+    getMemberships(): ProjectMembership[];
+    setMembership(membership: ProjectMembership): void;
+    getBotMembership(tenantId: string, id: string): ProjectBotMembership | undefined;
+    getBotMembershipByAssistant(tenantId: string, projectId: string, assistantId: string): ProjectBotMembership | undefined;
+    getBotMemberships(): ProjectBotMembership[];
+    setBotMembership(membership: ProjectBotMembership): void;
+    getMessage(tenantId: string, id: string): ProjectRoomMessage | undefined;
+    getMessageByIdempotency(tenantId: string, roomId: string, idempotencyKey: string): ProjectRoomMessage | undefined;
+    getMessages(): ProjectRoomMessage[];
+    setMessage(message: ProjectRoomMessage): void;
+    nextTimestamp(previous?: Date): Date;
+}
+/**
+ * Coordinates atomic access to in-memory project-room aggregate state.
+ *
+ * Stores sharing this coordinator serialize all reads and writes through a
+ * callback-scoped transaction. Transaction access expires when the callback
+ * settles, preventing callers from retaining unlocked state access. The same
+ * transaction can be extended with bot and message operations as those stores
+ * join the aggregate.
+ *
+ * @example
+ * ```ts
+ * const coordinator = new InMemoryProjectRoomCoordinator();
+ * const rooms = new InMemoryProjectRoomStore(coordinator);
+ * const memberships = new InMemoryProjectMembershipStore(coordinator);
+ * ```
+ */
+declare class InMemoryProjectRoomCoordinator {
+    private readonly clock;
+    private mutation;
+    private readonly rooms;
+    private readonly memberships;
+    private readonly botMemberships;
+    private readonly botMembershipIdsByAssistant;
+    private readonly messages;
+    private readonly messageIdsByIdempotency;
+    /**
+     * Creates a coordinator.
+     *
+     * @param clock - Clock used to timestamp aggregate entities. It must return a valid finite `Date`.
+     */
+    constructor(clock?: () => Date);
+    /**
+     * Runs one operation under the aggregate's exclusive mutation lock.
+     *
+     * @param operation - Work receiving transaction-scoped, clone-safe state access.
+     * @returns The operation result after releasing the lock.
+     * @remarks The transaction throws if used after the callback settles, including after rejection.
+     */
+    runExclusive<T>(operation: (transaction: InMemoryProjectRoomTransaction) => T | Promise<T>): Promise<T>;
+}
+
+/**
+ * Stores canonical, tenant-isolated project main rooms in process memory.
+ *
+ * @example
+ * ```ts
+ * const store = new InMemoryProjectRoomStore();
+ * const room = await store.ensureMainRoom(input);
+ * ```
+ */
+declare class InMemoryProjectRoomStore implements ProjectRoomStore {
+    private readonly coordinator;
+    /**
+     * Creates a room store backed by an aggregate coordinator.
+     *
+     * @param coordinator - Coordinator shared with related project-room stores.
+     */
+    constructor(coordinator?: InMemoryProjectRoomCoordinator);
+    /**
+     * Creates the main room when absent and returns the canonical room.
+     *
+     * @param input - Candidate identity and presentation for the project's main room.
+     * @returns A defensive copy of the canonical main room.
+     */
+    ensureMainRoom(input: {
+        id: string;
+        tenantId: string;
+        workspaceId: string;
+        projectId: string;
+        name: string;
+    }): Promise<ProjectRoom>;
+    /**
+     * Finds a tenant-scoped project's canonical main room.
+     *
+     * @param tenantId - Tenant owning the project.
+     * @param projectId - Project whose room is requested.
+     * @returns A defensive room copy, or `null` when none exists.
+     */
+    getMainRoom(tenantId: string, projectId: string): Promise<ProjectRoom | null>;
+}
+
+/**
+ * Stores tenant-isolated human project memberships in process memory.
+ *
+ * Membership lists are deterministic: records are ordered by `joinedAt` ASC,
+ * then by `id` ASC. Mutations share the project-room coordinator lock.
+ *
+ * @example
+ * ```ts
+ * const coordinator = new InMemoryProjectRoomCoordinator();
+ * const store = new InMemoryProjectMembershipStore(coordinator);
+ * await store.createInitialOwner(input);
+ * ```
+ */
+declare class InMemoryProjectMembershipStore implements ProjectMembershipStore {
+    private readonly coordinator;
+    /**
+     * Creates a membership store backed by an aggregate coordinator.
+     *
+     * @param coordinator - Coordinator shared with related project-room stores.
+     */
+    constructor(coordinator?: InMemoryProjectRoomCoordinator);
+    /**
+     * Lists all retained memberships for one tenant-scoped project.
+     *
+     * @param tenantId - Tenant owning the project.
+     * @param projectId - Project whose memberships are requested.
+     * @returns Defensive copies ordered by `joinedAt` ASC, then `id` ASC.
+     */
+    list(tenantId: string, projectId: string): Promise<ProjectMembership[]>;
+    /**
+     * Finds one user's retained membership in a tenant-scoped project.
+     *
+     * @param tenantId - Tenant owning the project.
+     * @param projectId - Project to search.
+     * @param userId - User whose membership is requested.
+     * @returns A defensive membership copy, or `null` when absent.
+     */
+    findByUser(tenantId: string, projectId: string, userId: string): Promise<ProjectMembership | null>;
+    /**
+     * Creates a membership while enforcing tenant/project/user and tenant/ID uniqueness.
+     *
+     * @param input - Membership fields excluding coordinator-generated timestamps.
+     * @returns A defensive copy of the created membership.
+     */
+    create(input: Omit<ProjectMembership, "joinedAt" | "updatedAt">): Promise<ProjectMembership>;
+    /**
+     * Atomically creates the first active owner for an empty project.
+     *
+     * @param input - Initial owner identity without generated role, status, or timestamps.
+     * @returns `created`, an idempotent `existing`, or `already_initialized`.
+     */
+    createInitialOwner(input: Omit<ProjectMembership, "role" | "status" | "joinedAt" | "updatedAt">): Promise<{
+        kind: "created" | "existing";
+        membership: ProjectMembership;
+    } | {
+        kind: "already_initialized";
+    }>;
+    /**
+     * Updates a membership role using tenant-scoped optimistic concurrency.
+     *
+     * @param input - Tenant, membership ID, target role, and expected revision.
+     * @returns The update outcome, including conflict and final-owner protection.
+     */
+    updateRole(input: {
+        tenantId: string;
+        id: string;
+        role: ProjectHumanRole;
+        expectedUpdatedAt: Date;
+    }): Promise<ProjectMembershipMutationResult>;
+    /**
+     * Marks a membership removed using tenant-scoped optimistic concurrency.
+     *
+     * @param input - Tenant, membership ID, and expected revision.
+     * @returns The removal outcome, including conflict and final-owner protection.
+     */
+    remove(input: {
+        tenantId: string;
+        id: string;
+        expectedUpdatedAt: Date;
+    }): Promise<ProjectMembershipMutationResult>;
+    private hasOtherActiveOwner;
+}
+
+/** Error raised when a new bot membership reuses an existing tenant-scoped ID. */
+declare class ProjectBotMembershipIdConflictError extends Error {
+    /**
+     * Creates a bot membership ID conflict error.
+     *
+     * @param tenantId - Tenant in which the ID is already present.
+     * @param id - Conflicting membership ID.
+     */
+    constructor(tenantId: string, id: string);
+}
+/**
+ * Stores tenant-isolated project bot memberships in process memory.
+ *
+ * Durable assistant identity, coordinator role, and room mention constraints
+ * are checked atomically through the shared project-room coordinator.
+ *
+ * @example
+ * ```ts
+ * const coordinator = new InMemoryProjectRoomCoordinator();
+ * const store = new InMemoryProjectBotMembershipStore(coordinator);
+ * await store.save(input);
+ * ```
+ */
+declare class InMemoryProjectBotMembershipStore implements ProjectBotMembershipStore {
+    private readonly coordinator;
+    /**
+     * Creates a bot membership store backed by an aggregate coordinator.
+     *
+     * @param coordinator - Coordinator shared with related project-room stores.
+     */
+    constructor(coordinator?: InMemoryProjectRoomCoordinator);
+    /**
+     * Lists retained bot memberships for a tenant-scoped project.
+     *
+     * @param tenantId - Tenant owning the project.
+     * @param projectId - Project whose roster is requested.
+     * @returns Defensive copies ordered by `joinedAt` ASC, then `id` ASC.
+     */
+    list(tenantId: string, projectId: string): Promise<ProjectBotMembership[]>;
+    /**
+     * Finds a bot membership by its tenant-scoped ID.
+     *
+     * @param tenantId - Tenant owning the membership.
+     * @param id - Membership ID.
+     * @returns A defensive membership copy, or `null` when absent.
+     */
+    findById(tenantId: string, id: string): Promise<ProjectBotMembership | null>;
+    /**
+     * Finds the durable membership for an assistant in a tenant-scoped project.
+     *
+     * @param tenantId - Tenant owning the project.
+     * @param projectId - Project to search.
+     * @param assistantId - Assistant identity to find.
+     * @returns A defensive membership copy, or `null` when absent.
+     */
+    findByAssistant(tenantId: string, projectId: string, assistantId: string): Promise<ProjectBotMembership | null>;
+    /**
+     * Saves a new membership or reactivates the assistant's durable membership.
+     *
+     * @param input - Candidate membership without coordinator-generated timestamps.
+     * @returns The saved membership or a coordinator/mention uniqueness conflict.
+     */
+    save(input: Omit<ProjectBotMembership, "joinedAt" | "updatedAt">): Promise<{
+        kind: "created" | "updated" | "reactivated";
+        membership: ProjectBotMembership;
+    } | {
+        kind: "coordinator_conflict" | "mention_conflict";
+    }>;
+    /**
+     * Updates mutable bot membership fields using tenant-scoped optimistic concurrency.
+     *
+     * @param input - Tenant, membership ID, exact field patch, and expected revision.
+     * @returns The updated membership or the applicable lookup, revision, or uniqueness conflict.
+     */
+    update(input: {
+        tenantId: string;
+        id: string;
+        patch: Partial<Pick<ProjectBotMembership, "role" | "title" | "responsibility" | "mentionName" | "status">>;
+        expectedUpdatedAt: Date;
+    }): Promise<{
+        kind: "updated";
+        membership: ProjectBotMembership;
+    } | {
+        kind: "not_found" | "conflict" | "coordinator_conflict" | "mention_conflict";
+    }>;
+    private findConstraintConflict;
+}
+
+/** Error raised when a room message reuses an existing tenant-scoped ID. */
+declare class ProjectRoomMessageIdConflictError extends Error {
+    /**
+     * Creates a room message ID conflict error.
+     *
+     * @param tenantId - Tenant in which the ID is already present.
+     * @param id - Conflicting message ID.
+     */
+    constructor(tenantId: string, id: string);
+}
+/**
+ * Stores tenant-isolated project room messages in process memory.
+ *
+ * Message creation and room-scoped idempotency are serialized by the shared
+ * project-room coordinator. Lists use stable newest-first cursor ordering.
+ *
+ * @example
+ * ```ts
+ * const store = new InMemoryProjectRoomMessageStore();
+ * const created = await store.create(input);
+ * ```
+ */
+declare class InMemoryProjectRoomMessageStore implements ProjectRoomMessageStore {
+    private readonly coordinator;
+    /**
+     * Creates a message store backed by an aggregate coordinator.
+     *
+     * @param coordinator - Coordinator shared with related project-room stores.
+     */
+    constructor(coordinator?: InMemoryProjectRoomCoordinator);
+    /**
+     * Creates a project room message.
+     *
+     * @param input - Message fields excluding the coordinator-generated timestamp.
+     * @returns A defensive copy of the created message.
+     */
+    create(input: Omit<ProjectRoomMessage, "createdAt">): Promise<ProjectRoomMessage>;
+    /**
+     * Creates or returns the canonical message for a tenant/room idempotency key.
+     *
+     * @param input - Message candidate and required room-scoped idempotency key.
+     * @returns A defensive copy of the original or newly created message.
+     */
+    createIdempotent(input: Omit<ProjectRoomMessage, "createdAt"> & {
+        idempotencyKey: string;
+    }): Promise<ProjectRoomMessage>;
+    /**
+     * Lists room messages using stable newest-first pagination.
+     *
+     * @param input - Tenant/room scope, optional exclusive cursor, and requested limit.
+     * @returns Defensive message copies ordered by `createdAt` DESC, then `id` DESC; limit is clamped to 1..100.
+     */
+    list(input: {
+        tenantId: string;
+        roomId: string;
+        before?: {
+            createdAt: Date;
+            id: string;
+        };
+        limit: number;
+    }): Promise<ProjectRoomMessage[]>;
+    /**
+     * Finds a message by its tenant-scoped ID.
+     *
+     * @param tenantId - Tenant owning the message.
+     * @param id - Message ID.
+     * @returns A defensive message copy, or `null` when absent.
+     */
+    findById(tenantId: string, id: string): Promise<ProjectRoomMessage | null>;
+    private createInTransaction;
+}
+
 /**
  * Embeddings Lattice Interface
  * Defines the structure of an embeddings lattice entry
@@ -4440,14 +4944,56 @@ declare function getBuiltInSkillNames(): string[];
  * Check if a skill name refers to a built-in skill.
  */
 declare function isBuiltInSkill(name: string): boolean;
+
+declare const SAFE_PATH_COMPONENT: RegExp;
+/**
+ * Ensure a versioned plugin skill bundle is available in a runtime sandbox.
+ *
+ * @param sandbox - Runtime sandbox receiving the bundle files.
+ * @param pluginType - Plugin that owns the skill.
+ * @param skillName - Skill name used for its sandbox directory.
+ * @param definition - Versioned markdown and text-resource bundle.
+ * @param lockKey - Stable skills-volume identity, normally the tenant ID. Calls
+ *   sharing a skills volume must use the same value; different tenants must use
+ *   different values.
+ * @returns A promise that resolves after the bundle and manifest are written.
+ *
+ * @example
+ * ```ts
+ * await ensurePluginSkillInSandbox(
+ *   sandbox,
+ *   "acme",
+ *   "acme-guide",
+ *   {
+ *     version: "1.2.0",
+ *     content: "---\nname: acme-guide\ndescription: Acme usage\n---\n",
+ *     resources: {
+ *       "templates/request.json": { content: '{"method":"POST"}' },
+ *     },
+ *   },
+ *   "agent-runtime"
+ * );
+ * ```
+ */
+declare function ensurePluginSkillInSandbox(sandbox: SandboxInstance, pluginType: string, skillName: string, definition: PluginSkillDefinition, lockKey: string): Promise<void>;
 /**
- * Register a skill as a built-in skill at runtime.
- * Used by PluginRegistry to expose plugin procedural skills
- * through the same unified API as static built-in skills.
+ * Check whether a sandbox skill directory is owned by the plugin synchronizer.
  *
- * Duplicate registrations are ignored (first wins).
+ * @param sandbox - Runtime sandbox containing the skill manifest.
+ * @param skillName - Skill directory name to inspect.
+ * @returns True when the manifest identifies the skill as plugin-managed.
+ */
+declare function isPluginSkillManagedInSandbox(sandbox: SandboxInstance, skillName: string): Promise<boolean>;
+/** Check whether a manifest-owned skill has the expected live plugin owner. */
+declare function isPluginSkillAuthorizedInSandbox(sandbox: SandboxInstance, skillName: string, pluginType: string): Promise<boolean>;
+/** Return the synchronized manifest version for a skill, if plugin-managed. */
+declare function getPluginSkillManifestVersion(sandbox: SandboxInstance, skillName: string): Promise<string | undefined>;
+/**
+ * Keep every path component safe for the shell-interpolated Daytona mkdir
+ * command: ASCII letters, digits, dot, underscore, and hyphen only; no empty,
+ * dot, or parent components, separators, whitespace, or shell metacharacters.
  */
-declare function registerBuiltinSkill(name: string, content: string): void;
+declare function validateRelativePath(value: string, kind: string): void;
 
 /**
  * CollectionLatticeManager
@@ -4488,7 +5034,7 @@ declare function buildTableName(tenantId: string, name: string): string;
 /**
  * Get or create a tenant-isolated VectorStore for a collection.
  */
-declare function getOrCreateCollectionVectorStore(name: string, embeddingKey: string, tenantId: string, providerKey?: string): Promise<any>;
+declare function getOrCreateCollectionVectorStore(name: string, embeddingKey: string, tenantId: string, providerKey?: string): Promise<VectorStore>;
 /**
  * Get entry count for a collection.
  * Tries vector store's native method first, falls back to provider.
@@ -5058,6 +5604,24 @@ declare class MicrosandboxRemoteInstance implements SandboxInstance {
     stop(): Promise<void>;
     kill(): Promise<void>;
     getStatus(): Promise<"running" | "stopped" | "unknown">;
+    /**
+     * Pack a sandbox folder into a sibling ZIP through the microsandbox shell.
+     *
+     * The command runs inside the POSIX container, so mounted volume-backed
+     * folders are packed from their on-disk location just like any other sandbox
+     * folder.  Paths use the external virtual convention (`/project/...`) and the
+     * command is cwd-independent because the microsandbox shell service does not
+     * honor `exec_dir`.  The returned archive path can be downloaded and deleted
+     * through the existing file service.
+     *
+     * @param sourcePath - Sandbox-visible absolute source folder path rooted at `/project`
+     * @returns The sibling archive path, download filename, and exact byte size
+     */
+    packDirectory(sourcePath: string): Promise<{
+        path: string;
+        filename: string;
+        size?: number;
+    }>;
     readonly file: SandboxFileService;
     readonly shell: SandboxShellService;
 }
@@ -5074,10 +5638,129 @@ declare class RemoteSandboxInstance implements SandboxInstance {
     stop(): Promise<void>;
     kill(): Promise<void>;
     getStatus(): Promise<"running" | "stopped" | "unknown">;
+    /**
+     * Pack a sandbox folder into a sibling ZIP through the remote shell service.
+     *
+     * The command runs inside the remote POSIX sandbox, so mounted volume-backed
+     * folders are packed from their on-disk location just like any other sandbox
+     * folder.  The returned archive path is the sandbox-visible sibling (e.g.
+     * `/project/data/reports.zip`) and can be downloaded and deleted through the
+     * existing file service.
+     *
+     * @param sourcePath - Sandbox-visible absolute source folder path rooted at `/project`
+     * @returns The sibling archive path, download filename, and exact byte size
+     */
+    packDirectory(sourcePath: string): Promise<{
+        path: string;
+        filename: string;
+        size?: number;
+    }>;
     readonly file: SandboxFileService;
     readonly shell: SandboxShellService;
 }
 
+/**
+ * Shared packing policy for `SandboxInstance.packDirectory`.
+ *
+ * Local and remote sandbox instances agree on the same source-path contract
+ * (must be rooted at `/project`, no traversal, no backslashes) and the same
+ * entry/size limits.  Remote instances additionally run the whole safe shell
+ * strategy (in-shell preflight, exclusive sibling lock, randomized temporary
+ * directory, trap cleanup, atomic no-clobber finalize) through their existing
+ * shell service, because Node cannot open a sandbox file handle remotely.
+ */
+declare const MAX_PACK_ENTRIES = 10000;
+declare const MAX_PACK_FILE_BYTES: number;
+declare const MAX_PACK_TOTAL_BYTES: number;
+/** Maximum wall-clock time for one remote/local folder pack shell invocation. */
+declare const PACK_DIRECTORY_TIMEOUT_SECONDS: number;
+/** Result of validating a pack source path. */
+interface PackSourceInfo {
+    /** Basename of the source folder, e.g. `reports`. */
+    rootName: string;
+    /** Download archive name, e.g. `reports.zip`. */
+    filename: string;
+    /** Sandbox-visible sibling archive path, e.g. `/project/data/reports.zip`. */
+    archivePath: string;
+}
+/**
+ * Validate a sandbox folder path that may be packed.
+ *
+ * Accepts only absolute paths rooted at `/project` (the project root) with no
+ * empty/`.`/`..` components and no backslashes.  Rejects anything else with a
+ * descriptive error before any shell command is sent.
+ *
+ * @param sourcePath - Sandbox-visible absolute source folder path
+ * @returns Derived source basename, archive filename, and sibling archive path
+ * @example
+ * ```ts
+ * const { rootName, filename, archivePath } = validatePackSourcePath("/project/data/reports");
+ * // rootName: "reports", filename: "reports.zip", archivePath: "/project/data/reports.zip"
+ * ```
+ */
+declare function validatePackSourcePath(sourcePath: string): PackSourceInfo;
+/**
+ * Build the complete `/bin/sh` command that packs one sandbox folder.
+ *
+ * The command is cwd-independent: it `cd`s to `parentDir` and packs
+ * `./<sourceName>` into a randomized sibling temporary directory, so it works
+ * both through `shell.execCommand({ exec_dir })` and through shells that ignore
+ * `exec_dir` entirely.  It performs a metadata-only preflight (no file content
+ * reads) that rejects symlinks, FIFO/socket/device entries, entry-count
+ * overflow, and per-file/total size overflow before invoking `zip`.  The final
+ * archive is committed with an atomic hard-link `ln` so an existing sibling
+ * (file, directory, or symlink) is never overwritten, and an exclusive `mkdir`
+ * lock plus an `EXIT` trap remove only artifacts owned by this invocation.  The
+ * last stdout line reports the exact archive size as `PACK_SIZE=<bytes>`.
+ *
+ * The command targets `/bin/sh` with the common Linux find extensions used by
+ * GNU and busybox (`-print0`, the `c` byte suffix for `-size`); it is not
+ * guaranteed to run on other POSIX-only `sh` implementations.  The sandbox
+ * image must provide `zip` (Info-ZIP) on `PATH`.
+ *
+ * @param parentDir - Absolute physical path of the source folder's parent
+ * @param sourceName - Source folder basename
+ * @param archiveName - Archive filename (`<sourceName>.zip`)
+ * @returns A `/bin/sh`-compatible command string
+ * @example
+ * ```ts
+ * buildRemotePackDirectoryCommand("/workspace/project/data", "reports", "reports.zip");
+ * ```
+ */
+declare function buildRemotePackDirectoryCommand(parentDir: string, sourceName: string, archiveName: string): string;
+/**
+ * Extract the exact packed archive byte size from a remote pack command output.
+ *
+ * @param output - Combined shell stdout/stderr
+ * @returns The archive size in bytes, or `undefined` when the command did not
+ * report one (for example when preflight or `zip` failed)
+ */
+declare function parsePackSize(output: string): number | undefined;
+/**
+ * Run a remote `packDirectory` through a shell service.
+ *
+ * Validates the source path, executes the shared safe shell-zip command from
+ * `physicalParentDir`, and returns the sandbox-visible sibling archive path,
+ * download filename, and exact byte size parsed from the shell output.  Errors
+ * (invalid source, preflight failure, `zip` failure, missing size) throw with a
+ * descriptive message.
+ *
+ * @param shell - Sandbox shell service that executes the command remotely
+ * @param sourcePath - Sandbox-visible absolute source folder path
+ * @param physicalParentDir - Physical absolute parent directory of the source on
+ * the remote host (already resolved for the instance's path convention)
+ * @returns The packed archive location and metadata
+ * @example
+ * ```ts
+ * const packed = await runRemotePackDirectory(instance.shell, "/project/data/reports", "/workspace/project/data");
+ * ```
+ */
+declare function runRemotePackDirectory(shell: SandboxShellService, sourcePath: string, physicalParentDir: string): Promise<{
+    path: string;
+    filename: string;
+    size: number;
+}>;
+
 declare class E2BInstance implements SandboxInstance {
     private native;
     readonly name: string;
@@ -5123,6 +5806,11 @@ declare class LocalSandboxInstance implements SandboxInstance {
     stop(): Promise<void>;
     kill(): Promise<void>;
     getStatus(): Promise<"running" | "stopped" | "unknown">;
+    packDirectory(sourcePath: string): Promise<{
+        path: string;
+        filename: string;
+        size?: number;
+    }>;
     readonly file: SandboxFileService;
     readonly shell: SandboxShellService;
     private walkDir;
@@ -7024,13 +7712,294 @@ declare class AgentManager {
     }, return_agent_state?: boolean): Promise<unknown>;
 }
 
-/** Execution state of a thread. */
-declare enum ThreadStatus {
+/** Exact tenant, workspace, Project, and Room coordinates for roster authorization. */
+interface ProjectTaskRosterScope {
+    tenantId: string;
+    workspaceId: string;
+    projectId: string;
+    roomId: string;
+}
+/** Exact caller and target roster identities required for a Project task assignment. */
+interface ProjectTaskAssignmentScope extends ProjectTaskRosterScope {
+    callerMembershipId: string;
+    callerAssistantId: string;
+    targetMembershipId: string;
+    targetAssistantId: string;
+}
+/** Stable authorization denial codes emitted by the Project task owner policy. */
+type ProjectTaskOwnerPolicyCode = "PROJECT_TASK_CALLER_INACTIVE" | "PROJECT_TASK_OWNER_INACTIVE";
+/** Stable authorization failure that does not expose membership-store details. */
+declare class ProjectTaskOwnerPolicyError extends Error {
+    readonly code: ProjectTaskOwnerPolicyCode;
+    /**
+     * Creates a stable Project task roster authorization failure.
+     *
+     * @param code Machine-readable caller or owner denial code.
+     * @param message Generic denial description safe to expose to callers.
+     */
+    constructor(code: ProjectTaskOwnerPolicyCode, message: string);
+}
+/**
+ * Requires Project task callers and owners to be active members of one exact durable roster.
+ *
+ * Store values are treated as untrusted boundary data and snapshotted without invoking
+ * accessors before identity or scope checks are performed.
+ *
+ * @example
+ * ```ts
+ * const policy = createProjectTaskOwnerPolicy();
+ * const { caller, target } = await policy.requireAssignment(scope);
+ * ```
+ */
+declare class ProjectTaskOwnerPolicy {
+    private readonly memberships;
+    /**
+     * Creates a policy backed by the Project bot membership protocol.
+     *
+     * @param memberships Minimal durable roster lookup methods used by the policy.
+     */
+    constructor(memberships: Pick<ProjectBotMembershipStore, "findById" | "findByAssistant">);
+    /**
+     * Requires the current caller to be active under its exact membership, Assistant, and scope.
+     *
+     * @param input Exact roster scope plus caller identity.
+     * @returns A descriptor-safe snapshot of the active caller membership.
+     */
+    requireCaller(input: ProjectTaskRosterScope & {
+        callerMembershipId: string;
+        callerAssistantId: string;
+    }): Promise<ProjectBotMembership>;
+    /**
+     * Requires the target owner to be active under its exact membership, Assistant, and scope.
+     *
+     * @param input Exact roster scope plus target identity.
+     * @returns A descriptor-safe snapshot of the active target membership.
+     */
+    requireOwner(input: ProjectTaskRosterScope & {
+        targetMembershipId: string;
+        targetAssistantId: string;
+    }): Promise<ProjectBotMembership>;
+    /**
+     * Requires both sides of an assignment, validating the caller before accessing the target.
+     *
+     * @param input Exact roster scope and both membership/Assistant identities.
+     * @returns Descriptor-safe active caller and target membership snapshots.
+     */
+    requireAssignment(input: ProjectTaskAssignmentScope): Promise<{
+        caller: ProjectBotMembership;
+        target: ProjectBotMembership;
+    }>;
+}
+/**
+ * Creates the default Project task owner policy from Store Lattice.
+ *
+ * @returns A policy using only the `default:projectBotMembership` store.
+ * @remarks Register the default Project bot membership store before calling this factory.
+ */
+declare function createProjectTaskOwnerPolicy(): ProjectTaskOwnerPolicy;
+
+declare const reassignmentAuthorizationBrand: unique symbol;
+/** Opaque host-issued proof that a Project task reassignment boundary was validated. */
+interface ProjectTaskReassignmentAuthorization {
+    readonly [reassignmentAuthorizationBrand]: true;
+}
+/** Exact assignment and Task Thread coordinates validated by a trusted host. */
+interface ProjectTaskReassignmentAuthorizationInput {
+    tenantId: string;
+    workspaceId: string;
+    projectId: string;
+    roomId: string;
+    taskId: string;
+    callerMembershipId: string;
+    callerAssistantId: string;
+    targetMembershipId: string;
+    targetAssistantId: string;
+    expectedThreadId?: string;
+    newThreadId: string;
+}
+/** Input supplied to the host's durable Task Thread validator. */
+interface ProjectTaskReassignmentThreadValidationInput extends ProjectTaskReassignmentAuthorizationInput {
+    caller: ProjectBotMembership;
+    target: ProjectBotMembership;
+}
+/** Host-owned validation function for reassignment Thread identity and scope. */
+type ProjectTaskReassignmentThreadValidator = (input: ProjectTaskReassignmentThreadValidationInput) => Promise<void>;
+/** Trusted host API that issues opaque reassignment authorization tokens. */
+interface ProjectTaskReassignmentAuthorizer {
+    /** Validates current roster and Thread truth, then issues a process-local opaque token. */
+    authorize(input: ProjectTaskReassignmentAuthorizationInput): Promise<ProjectTaskReassignmentAuthorization>;
+}
+/**
+ * Creates a trusted host reassignment authorizer.
+ *
+ * @param policy Exact active-roster policy used caller-first.
+ * @param threadValidator Host validator for the proposed Task Thread metadata.
+ * @returns An authorizer that emits process-local opaque tokens after both validations succeed.
+ * @remarks Tokens are process-local capabilities. Distributed deployments must authorize and execute
+ * under their machine/project mutex and accept the residual membership race across processes.
+ */
+declare function createProjectTaskReassignmentAuthorizer(policy: ProjectTaskOwnerPolicy, threadValidator: ProjectTaskReassignmentThreadValidator): ProjectTaskReassignmentAuthorizer;
+
+/**
+ * Immutable data identifying one committed canonical Project task lifecycle transition.
+ *
+ * @remarks `eventKey` identifies the persisted WorkItem and `updatedAt` identifies the winning task snapshot.
+ */
+interface TaskLifecycleNotification {
+    tenantId: string;
+    workspaceId: string;
+    projectId: string;
+    taskId: string;
+    threadId?: string;
+    status: TaskItem["status"];
+    action: ProjectTaskLifecycleAction;
+    eventKey: string;
+    updatedAt: string;
+}
+/**
+ * Async observer invoked for a canonical Project task lifecycle transition.
+ *
+ * @param event Isolated own-data snapshot for one committed transition.
+ * @returns A promise settled when listener processing is complete.
+ */
+type TaskLifecycleListener = (event: TaskLifecycleNotification) => void | Promise<void>;
+/**
+ * Publishes descriptor-safe lifecycle snapshots to an isolated listener snapshot.
+ *
+ * @example
+ * ```ts
+ * const unsubscribe = taskLifecycleNotifier.subscribe(async (event) => project(event));
+ * unsubscribe();
+ * ```
+ *
+ * @remarks Listener failures are collected so every listener receives the event. A rejected
+ * publish reports failure to the lifecycle caller but cannot undo the committed transition.
+ * Delivery is strict FIFO per tenant/task. Subscribers must bound their own work because publish
+ * intentionally awaits every listener settlement before the next event for that task can start.
+ */
+declare class TaskLifecycleNotifier {
+    private readonly listeners;
+    private readonly tails;
+    /**
+     * Registers an async lifecycle listener.
+     *
+     * @param listener Observer to invoke for later publications.
+     * @returns An idempotent unsubscribe callback.
+     */
+    subscribe(listener: TaskLifecycleListener): () => void;
+    /**
+     * Awaits all listeners with independent copies of one validated event snapshot.
+     *
+     * @param event Canonical transition identity to publish.
+     * @returns A promise that resolves after every listener succeeds.
+     * @throws Error when the event is malformed or one or more listeners reject.
+     */
+    publish(event: TaskLifecycleNotification): Promise<void>;
+    private deliver;
+}
+/** Process-global notifier used by every lifecycle service unless explicitly injected. */
+declare const taskLifecycleNotifier: TaskLifecycleNotifier;
+
+/** Exact canonical identity of one newly committed pending Agent Project task. */
+interface ProjectTaskAdmissionNotification {
+    tenantId: string;
+    workspaceId: string;
+    projectId: string;
+    taskId: string;
+    ownerId: string;
+    updatedAt: string;
+}
+/**
+ * Observer invoked with an isolated canonical Project task admission snapshot.
+ *
+ * @param event Exact newly persisted Agent Project task identity.
+ * @returns Nothing or a promise that settles when listener admission is accepted.
+ */
+type ProjectTaskAdmissionListener = (event: ProjectTaskAdmissionNotification, signal: AbortSignal) => void | Promise<void>;
+/** Delivery bounds for process-local Project task admission hints. */
+interface ProjectTaskAdmissionNotifierOptions {
+    listenerTimeoutMs?: number;
+}
+/**
+ * Publishes process-local hints that newly persisted Agent Project tasks need reconciliation.
+ *
+ * @remarks Delivery is FIFO per Tenant/Task and awaits every listener settlement. Callers that
+ * persist tasks must invoke `publish` fire-and-forget and contain rejection because this hint is
+ * not durable lifecycle authority.
+ */
+declare class ProjectTaskAdmissionNotifier {
+    private readonly listeners;
+    private readonly tails;
+    private readonly listenerTimeoutMs;
+    /**
+     * Creates a bounded Project task admission notifier.
+     *
+     * @param options Optional positive listener timeout; defaults to five seconds.
+     */
+    constructor(options?: ProjectTaskAdmissionNotifierOptions);
+    /**
+     * Registers a Project task admission listener.
+     *
+     * @param listener Observer to invoke for later publications.
+     * @returns An idempotent unsubscribe callback.
+     */
+    subscribe(listener: ProjectTaskAdmissionListener): () => void;
+    /**
+     * Publishes one validated Project task admission snapshot.
+     *
+     * @param event Canonical committed task identity to publish.
+     * @returns A promise settled after every snapshotted listener settles.
+     */
+    publish(event: ProjectTaskAdmissionNotification): Promise<void>;
+    private deliver;
+    private deliverTo;
+}
+/** Process-global Project task admission notifier used by governed creation paths. */
+declare const projectTaskAdmissionNotifier: ProjectTaskAdmissionNotifier;
+
+/** Exact Tenant and Project scope for collaboration mutations. */
+interface ProjectMutationScope {
+    tenantId: string;
+    projectId: string;
+}
+/**
+ * Process-local FIFO mutex shared by every Core and Gateway Project mutation path.
+ *
+ * @remarks
+ * When an operation needs both a Project task machine mutex and this mutex, it
+ * must acquire the machine mutex first. Project-only membership, roster, human,
+ * and ordinary Task mutations acquire only this mutex.
+ */
+declare class ProjectMutationMutex {
+    private readonly queues;
+    private readonly active;
+    /** Runs one mutation after all earlier mutations for the same Tenant and Project. */
+    runExclusive<T>(scope: ProjectMutationScope, operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    /** Returns the number of operations queued behind the current holder. */
+    pending(scope: ProjectMutationScope): number;
+    private acquire;
+    private release;
+}
+/** Process-global Project mutation mutex shared by Core tools and Gateway services. */
+declare const projectMutationMutex: ProjectMutationMutex;
+
+/** Package-private capability used by trusted host dispatch infrastructure. */
+declare const TRUSTED_AGENT_DISPATCH: unique symbol;
+
+/** Execution state of a thread. */
+declare enum ThreadStatus {
     IDLE = "idle",
     BUSY = "busy",
     INTERRUPTED = "interrupted",
     ERROR = "error"
 }
+/** Result of attempting to recover a persisted checkpoint. */
+interface ResumeTaskResult {
+    /** Graph status observed after the recovery attempt. */
+    status: ThreadStatus;
+    /** Whether processing rows are settled and pending queue work may continue. */
+    settled: boolean;
+}
 /**
  * Snapshot of a thread's current state including queue and status.
  *
@@ -7079,8 +8048,8 @@ interface QueueMessage {
             modified_at: string;
         }>;
     };
-    command?: CommandParams<any>;
-    custom_run_config?: any;
+    command?: CommandParams<unknown>;
+    custom_run_config?: unknown;
 }
 /** Emitted when a thread transitions between {@link ThreadStatus} values. */
 interface ThreadStatusChangedEvent {
@@ -7144,6 +8113,43 @@ interface MessageFailedEvent {
     error: string;
     timestamp: Date;
 }
+/**
+ * Emitted when a message was interrupted mid-execution (e.g. graph interrupt
+ * waiting for human input or tool approval).
+ *
+ * The `state` snapshot captures the LangGraph state at the point of interruption.
+ */
+interface MessageInterruptedEvent {
+    type: 'message:interrupted';
+    messageId: string;
+    timestamp: Date;
+    duration?: number;
+    state?: any;
+}
+/**
+ * Emitted once after an Agent execution reaches normal idle completion with a fresh text reply.
+ *
+ * `inputMessageId` is the primary delivery correlation ID. `consumedInputMessageIds` lists every
+ * queue input settled by the execution, including all inputs in a COLLECT batch. The stable
+ * `outputMessageId` is always `reply:${inputMessageId}`; provider/model IDs are diagnostic only.
+ *
+ * @remarks
+ * Phase 2 replaces the earlier provider-ID delivery contract. Consumers must deduplicate delivery
+ * with `outputMessageId`, clean correlation state with `consumedInputMessageIds`, and must not infer
+ * reply text from `state`. This is an accepted pre-release breaking contract change.
+ *
+ * @since Phase 2 pre-release
+ */
+interface ReplyReadyEvent {
+    type: 'reply:ready';
+    timestamp: Date;
+    inputMessageId: string;
+    consumedInputMessageIds: string[];
+    outputMessageId: string;
+    providerOutputMessageId?: string;
+    outputText: string;
+    state: unknown;
+}
 /** Emitted when the thread has drained its queue and returned to idle. */
 interface ThreadIdleEvent {
     type: 'thread:idle';
@@ -7167,6 +8173,11 @@ interface QueuePendingEvent {
     isHighPriority: boolean;
 }
 
+/** Raised when immediate delegated worker authority is passed to a persistent queue. */
+declare class DelegatedScopeNotQueueableError extends Error {
+    readonly code: "DELEGATED_SCOPE_NOT_QUEUEABLE";
+    constructor();
+}
 /**
  * Parameters that uniquely identify an agent thread instance.
  *
@@ -7177,8 +8188,8 @@ interface AgentThreadInterface {
     assistant_id: string;
     thread_id: string;
     tenant_id: string;
-    workspace_id?: string;
-    project_id?: string;
+    workspace_id?: string | null;
+    project_id?: string | null;
     custom_run_config?: any;
 }
 /**
@@ -7233,14 +8244,21 @@ declare class Agent {
     private stateChecker;
     private chunkBuffer;
     private abortController;
+    private queueProcessorPromise?;
     assistant_id: string;
     thread_id: string;
     tenant_id: string;
     workspace_id: string;
     project_id: string;
+    private queue_workspace_id;
+    private queue_project_id;
     custom_run_config: any;
     queueMode: ThreadQueueConfig;
-    private isWaitingForQueueEnd;
+    private queueProcessorRetryTimer?;
+    private queueProcessorRetryAttempt;
+    private queueProcessorGeneration;
+    private queueWakeRequested;
+    private recoveryBlockedKey?;
     asyncTasks: AsyncTaskRecord[];
     /**
      * Constructs an Agent instance.
@@ -7251,7 +8269,25 @@ declare class Agent {
      * @param params - {@link AgentThreadInterface}
      */
     constructor({ assistant_id, thread_id, tenant_id, workspace_id, project_id, custom_run_config, }: AgentThreadInterface);
+    /**
+     * Accepts host-authenticated queue metadata through the package-private symbol capability.
+     *
+     * @param queueMessage - Public message payload to sanitize and enqueue.
+     * @param options - Trusted context and execution mode supplied by privileged host code.
+     * @returns The asynchronous queue acceptance result.
+     */
+    [TRUSTED_AGENT_DISPATCH](queueMessage: QueueMessage, options: TrustedMessageOptions): Promise<AddMessageResult>;
+    private rejectDelegatedQueueAuthority;
+    private validateTrustedRunContext;
+    private processingExecutionContext;
+    private pendingExecutionContext;
+    private processingRowKey;
+    private blockRecovery;
+    private clearRecoveryBlock;
+    private rethrowClaimedExecutionError;
+    private executionRunConfig;
     private getHumanPendingContent;
+    private queuedInputMessages;
     /**
      * Initialize with message queue store
      */
@@ -7276,13 +8312,16 @@ declare class Agent {
     chunkStream(message_id: string, stopTypes?: MessageChunkType[]): {
         [Symbol.asyncIterator]: () => AsyncGenerator<MessageChunk, void, unknown>;
     };
-    getLatticeClientAndRuntimeConfig(custom_run_config?: any): Promise<{
+    private buildExecutionRunConfig;
+    getLatticeClientAndRuntimeConfig(custom_run_config?: unknown, expectedRevision?: string): Promise<{
         runnable_agent: AgentClient;
-        runConfig: any;
+        runConfig: Record<string, unknown>;
     }>;
+    private getLatticeClient;
     invoke(queueMessage: QueueMessage, signal?: AbortSignal): Promise<{
         messages: any;
     }>;
+    private validateMessageInput;
     /**
      * Like {@link invoke} but returns the full LangGraph state (all annotations)
      * instead of only messages. Messages are serialized to dicts; other state
@@ -7305,7 +8344,10 @@ declare class Agent {
         }[];
     }>;
     private agentExecutor;
+    private interruptedCommandExecutionContext;
+    private interruptedCommandCapabilityRevision;
     getPendingMessages(): Promise<PendingMessage[]>;
+    private queueScope;
     private agentStreamExecutor;
     private consumeAgentStream;
     /**
@@ -7349,9 +8391,8 @@ declare class Agent {
      * **Format**: Supports both `input.message` (legacy string) and `input.messages[]`
      * (array of `{ role, content }` objects). The array form takes precedence.
      *
-     * The `custom_run_config` field is round-tripped through the queue and emitted
-     * back in {@link ReplyReadyEvent}, enabling callers to attach routing metadata
-     * (e.g. `_replyTarget` for channel reply).
+     * Safe caller `custom_run_config` fields are round-tripped through queue execution only.
+     * They are not exposed by {@link ReplyReadyEvent}; reserved host metadata keys are stripped.
      *
      * @param queueMessage - The message to enqueue
      * @param mode - Optional queue mode override (defaults to thread's current mode)
@@ -7361,15 +8402,12 @@ declare class Agent {
      * ```ts
      * await agent.addMessage({
      *   input: { message: "Hello" },
-     *   custom_run_config: { _replyTarget: { adapterChannel: "lark", rawTarget: { chatId: "xxx" } } },
+     *   custom_run_config: { requestId: "request-1" },
      * });
      * ```
      */
-    addMessage(queueMessage: QueueMessage, mode?: QueueMode): Promise<{
-        queued: boolean;
-        messageId: string;
-        executed: boolean;
-    }>;
+    addMessage(queueMessage: QueueMessage, mode?: QueueMode): Promise<AddMessageResult>;
+    private enqueueMessage;
     /**
      * Start the queue processor if it is not already running.
      *
@@ -7380,6 +8418,11 @@ declare class Agent {
      * loop with a fresh {@link AbortController}.
      */
     startQueueProcessorIfNeeded(): Promise<void>;
+    private startQueueProcessor;
+    private finishQueueProcessor;
+    private scheduleQueueProcessorRetry;
+    private cancelQueueProcessorRetry;
+    private runQueueProcessor;
     /**
      * Remove pending message
      */
@@ -7415,9 +8458,10 @@ declare class Agent {
      * Checks LangGraph's `state.tasks` for interrupts and `state.next` for
      * pending steps.
      *
+     * @param state - Optional authoritative snapshot to classify without rereading the graph.
      * @returns {@link ThreadStatus} — `IDLE`, `BUSY`, or `INTERRUPTED`
      */
-    getRunStatus(): Promise<ThreadStatus>;
+    getRunStatus(state?: unknown): Promise<ThreadStatus>;
     /**
      * Resume processing after a server restart.
      *
@@ -7427,13 +8471,17 @@ declare class Agent {
      * rather than replayed.
      *
      * Skips threads that are in `INTERRUPTED` state (the interruption was
-     * intentional).  IDLE threads simply clean up and restart the queue
-     * processor for any remaining pending messages.
+     * intentional). IDLE and ERROR threads settle their durable processing rows
+     * before starting the queue processor for any remaining pending messages.
      *
      * Called during gateway startup to recover threads that were mid-execution
      * when the server went down.
+     *
+     * @returns The authoritative graph status after recovery. `BUSY` and
+     * `INTERRUPTED` mean the processing rows remain authoritative and pending
+     * queue work must not start; `IDLE` and `ERROR` mean those rows were settled.
      */
-    resumeTask(): Promise<void>;
+    resumeTask(): Promise<ResumeTaskResult>;
     /**
      * Fully abort all activity on this thread.
      *
@@ -7506,6 +8554,118 @@ declare class Agent {
     updateAsyncTaskStatus(taskId: string, status: AsyncTaskRecord['status']): void;
 }
 
+/**
+ * Privileged in-process boundary for dispatching messages with host-authenticated metadata.
+ *
+ * @remarks
+ * In-process host imports are trusted deployment code. This boundary prevents remote,
+ * model, and tool callers from acquiring trusted metadata authority; it does not defend
+ * against hostile JavaScript installed in the host process.
+ */
+interface TrustedAgentMessageDispatcher {
+    /**
+     * Dispatches a queue message with validated host metadata.
+     *
+     * @param scope - Agent thread scope resolved by the host.
+     * @param message - Public queue message payload.
+     * @param options - Trusted metadata and execution behavior.
+     * @returns The Agent queue acceptance result.
+     */
+    dispatch(scope: AgentThreadInterface, message: QueueMessage, options: TrustedMessageOptions): Promise<AddMessageResult>;
+}
+/**
+ * Creates the privileged dispatcher used by host-owned orchestration services.
+ *
+ * @param resolve - Resolves the Agent instance for an authoritative thread scope.
+ * @returns A dispatcher that invokes Agent's package-private symbol capability.
+ */
+declare function createTrustedAgentMessageDispatcher(resolve: (scope: AgentThreadInterface) => Agent): TrustedAgentMessageDispatcher;
+
+/** Fully scoped input for a trusted Agent-authored project room message. */
+interface RoomAgentMessageInput {
+    tenantId: string;
+    workspaceId: string;
+    projectId: string;
+    roomId: string;
+    membershipId: string;
+    assistantId: string;
+    text: string;
+    sourceRoomMessageId: string;
+    sourceId: string;
+    idempotencyKey: string;
+}
+/** Minimal correlated reply input whose scope is derived from validated durable rows. */
+interface RoomAgentReplyInput {
+    tenantId: string;
+    membershipId: string;
+    text: string;
+    sourceRoomMessageId: string;
+    inputMessageId: string;
+    sourceId: string;
+    idempotencyKey: string;
+}
+/**
+ * Observes a canonical Agent-authored room message after durable persistence.
+ *
+ * @param message Detached clone of the canonical persisted message.
+ * @returns Nothing, or a promise whose rejection is contained by the writer.
+ */
+type RoomAgentMessageCommitted = (message: ProjectRoomMessage) => void | Promise<void>;
+/**
+ * Reports a contained post-commit observer failure without exposing message content.
+ *
+ * @param event Safe canonical message ID and fixed failure code.
+ * @returns Nothing; reporter exceptions are also contained by the writer.
+ */
+type RoomAgentMessageCallbackFailure = (event: {
+    messageId: string;
+    code: "ROOM_MESSAGE_COMMIT_CALLBACK_FAILED";
+}) => void;
+/**
+ * Persists Agent-authored room messages across strict, untrusted store boundaries.
+ *
+ * Inputs are synchronously snapshotted without invoking accessors. Source messages,
+ * memberships, and canonical create results must be exact plain data records.
+ *
+ * @example
+ * ```ts
+ * const writer = new RoomAgentMessageService({ memberships, messages });
+ * await writer.post(input);
+ * ```
+ */
+declare class RoomAgentMessageService {
+    private readonly deps;
+    /**
+     * Creates a room writer over the durable membership and message stores.
+     *
+     * @param deps Store methods, optional deterministic ID factory, and detached post-commit hooks.
+     */
+    constructor(deps: {
+        memberships: Pick<ProjectBotMembershipStore, "findById">;
+        messages: Pick<ProjectRoomMessageStore, "findById" | "createIdempotent">;
+        idFactory?: () => string;
+        onMessageCommitted?: RoomAgentMessageCommitted;
+        onCallbackFailure?: RoomAgentMessageCallbackFailure;
+    });
+    /**
+     * Persists a fully scoped Agent response after validating its human source and active membership.
+     *
+     * @param input Exact trusted scope and response payload.
+     * @returns A deep clone of the canonical idempotent room message.
+     */
+    post(input: RoomAgentMessageInput): Promise<ProjectRoomMessage>;
+    /**
+     * Persists a channel reply while deriving all scope from validated durable records.
+     *
+     * @param input Exact correlation IDs, tenant, target membership, and response text.
+     * @returns A deep clone of the canonical idempotent room message.
+     */
+    postReply(input: RoomAgentReplyInput): Promise<ProjectRoomMessage>;
+    private persistDerived;
+    private persist;
+    private notifyCommitted;
+}
+
 /**
  * Agent Instance Manager
  *
@@ -7561,8 +8721,8 @@ declare const agentInstanceManager: AgentInstanceManager;
  * A single structured belief report attached to a task completion.
  *
  * Mirrors the `manage_task.beliefImpact` tool field: the reporting task claims
- * that, after execution, the named Belief Key is true with `after` percent
- * probability, supported by `basis` evidence.
+ * that, after execution, the named Belief Key has `after` percent evidence
+ * support, accompanied by a qualitative status and evidence in `basis`.
  */
 interface BeliefImpactInput {
     key: string;
@@ -7582,6 +8742,7 @@ interface LifecycleWarning {
 type LifecycleResult = {
     success: true;
     task: TaskItem;
+    mutated: boolean;
     evidenceId?: string;
     eventKey?: string;
     warnings?: LifecycleWarning[];
@@ -7594,11 +8755,33 @@ type LifecycleResult = {
     eventKey?: string;
     warnings?: LifecycleWarning[];
 };
+/**
+ * Exact winner metadata returned only by {@link TaskLifecycleService.startTask}.
+ *
+ * @remarks `transitioned` is true only for the invocation that won the pending snapshot CAS.
+ */
+type StartLifecycleResult = {
+    success: true;
+    task: TaskItem;
+    mutated: boolean;
+    transitioned: boolean;
+    eventKey?: string;
+    warnings?: LifecycleWarning[];
+} | {
+    success: false;
+    transitioned: false;
+    code: string;
+    error: string;
+    hint?: string;
+    eventKey?: string;
+    warnings?: LifecycleWarning[];
+};
 /** Stores and clock used by {@link TaskLifecycleService}. */
 interface TaskLifecycleServiceDeps {
     taskStore: TaskStore;
     workItemStore: TaskWorkItemStore;
     now?: () => Date;
+    notifier?: TaskLifecycleNotifier;
 }
 /** Input shared by direct completion and completion repair. */
 interface AgentTaskCompletionInput {
@@ -7680,6 +8863,22 @@ interface InterruptTaskInput {
     summary: string;
     actor: string;
     threadId?: string;
+    /** Required exact task IDs when the interruption waits on external dependencies. */
+    dependencyTaskIds?: string[];
+}
+/** Parsed, canonical external-dependency interruption persisted by the lifecycle service. */
+interface ExternalDependencyInterruption {
+    type: "external_dependency";
+    summary: string;
+    requestedAt: string;
+    dependencyTaskIds: string[];
+}
+/** Exact roster, task, and Thread coordinates for a governed Project task reassignment. */
+interface ReassignProjectTaskInput {
+    tenantId: string;
+    taskId: string;
+    authorization: ProjectTaskReassignmentAuthorization;
+    actor: string;
 }
 /** Canonical identity and Belief State snapshot bound to completion evidence. */
 interface BeliefOwnerSnapshot {
@@ -7702,6 +8901,23 @@ interface BeliefOwnerSnapshot {
     };
     parentUpdatedAt?: string;
 }
+/**
+ * Returns whether a task belongs to the trusted, nondefault Project lifecycle.
+ *
+ * @param task Task snapshot whose durable scope and trusted origin are inspected.
+ * @returns True only for nondefault Project Room or Project Task origins.
+ */
+declare function isProjectLifecycleTask(task: TaskItem): task is TaskItem & {
+    workspaceId: string;
+    projectId: string;
+};
+/**
+ * Parses a descriptor-safe canonical external-dependency interruption.
+ *
+ * @param value Untrusted persisted interruption value.
+ * @returns A cloned interruption with trimmed unique IDs, or undefined when malformed.
+ */
+declare function parseExternalDependency(value: unknown): ExternalDependencyInterruption | undefined;
 /**
  * Owns atomic agent-task completion, review, repair, and belief reconciliation.
  *
@@ -7717,6 +8933,7 @@ interface BeliefOwnerSnapshot {
 declare class TaskLifecycleService {
     private readonly deps;
     private readonly now;
+    private readonly notifier;
     /**
      * Creates a lifecycle service with injected stores and an optional test clock.
      *
@@ -7746,11 +8963,13 @@ declare class TaskLifecycleService {
     /** Atomically fails an active agent task and records an idempotent status event. */
     failTask(input: FailTaskInput): Promise<LifecycleResult>;
     /** Atomically starts a pending agent task and records an idempotent status event. */
-    startTask(input: StartTaskInput): Promise<LifecycleResult>;
+    startTask(input: StartTaskInput): Promise<StartLifecycleResult>;
     /** Atomically retries a failed agent task and records an idempotent status event. */
     retryTask(input: StartTaskInput): Promise<LifecycleResult>;
     /** Atomically cancels a nonterminal agent task and records an idempotent status event. */
     cancelTask(input: CancelTaskInput): Promise<LifecycleResult>;
+    /** Atomically transfers a stopped Project task to another active roster owner and Task Thread. */
+    reassignProjectTask(input: ReassignProjectTaskInput): Promise<LifecycleResult>;
     /** Atomically records a governed blocking interruption for an in-progress agent task. */
     interruptTask(input: InterruptTaskInput): Promise<LifecycleResult>;
     /**
@@ -7826,6 +9045,10 @@ declare class TaskLifecycleService {
     private transitionAgentTask;
     private statusEventKey;
     private writeStatusEvent;
+    private notifyWinningTransition;
+    private validateExternalDependencies;
+    private externalDependencyReadiness;
+    private finishExternalDependencyInterruption;
     private clearAuditMarker;
     private writeReviewActivity;
     private createEvent;
@@ -7840,6 +9063,85 @@ declare class TaskLifecycleService {
  */
 declare function createTaskLifecycleService(deps?: TaskLifecycleServiceDeps): TaskLifecycleService;
 
+/** Describes one isolated Agent invocation for persistent task execution. */
+interface TaskAgentInvocation {
+    tenantId: string;
+    workspaceId?: string;
+    projectId?: string;
+    taskId: string;
+    agentId: string;
+    threadId: string;
+    message: string;
+    /** Internal authority passed only to the delegated worker runtime. */
+    delegatedTaskId: string;
+    taskExecutionRole: "worker";
+}
+/** Injected persistence and Agent runtime dependencies for task execution. */
+interface TaskExecutionServiceDeps {
+    taskStore: TaskStore;
+    workItemStore: TaskWorkItemStore;
+    invokeAgent: (input: TaskAgentInvocation) => Promise<unknown>;
+    resolveAgent: (tenantId: string, agentId: string) => Promise<boolean>;
+    createThreadId?: () => string;
+}
+/** Identifies a persistent task, target Agent, caller, and runtime scope. */
+interface StartTaskExecutionInput {
+    tenantId: string;
+    workspaceId?: string;
+    projectId?: string;
+    taskId: string;
+    agentId: string;
+    actor: string;
+    callerThreadId?: string;
+}
+/** Successful isolated execution observation recorded for later reconciliation. */
+interface TaskExecutionSuccess {
+    success: true;
+    taskId: string;
+    agentId: string;
+    threadId: string;
+    observation: unknown;
+    executionResultId: string;
+    warnings?: LifecycleWarning[];
+}
+/** Typed validation, lifecycle, or Agent invocation failure. */
+interface TaskExecutionFailure {
+    success: false;
+    code: string;
+    error: string;
+    taskId?: string;
+    agentId?: string;
+    threadId?: string;
+    executionResultId?: string;
+    blockedBy?: string[];
+    invocationError?: string;
+    warnings?: LifecycleWarning[];
+}
+/** Result returned by a persistent task execution attempt. */
+type TaskExecutionResult = TaskExecutionSuccess | TaskExecutionFailure;
+/**
+ * Creates a synchronous persistent-task execution service from injected stores and Agent adapters.
+ *
+ * @param deps Task stores, target resolution, isolated invocation, and optional thread ID generation.
+ * @returns A service whose `start` method validates, starts, dispatches, and records an observation.
+ *
+ * @example
+ * ```ts
+ * const service = createTaskExecutionService({ taskStore, workItemStore, resolveAgent, invokeAgent });
+ * const result = await service.start({ tenantId, taskId, agentId, actor });
+ * ```
+ *
+ * @remarks A returned observation is execution evidence only. This service never completes or fails the TaskItem.
+ */
+declare function createTaskExecutionService(deps: TaskExecutionServiceDeps): {
+    start: (input: StartTaskExecutionInput) => Promise<TaskExecutionResult>;
+};
+
+/** Internal authority for immediate delegated worker execution. */
+declare const DELEGATED_WORKER_SCOPE_TOKEN: unique symbol;
+/** Reports whether a run configuration contains the private delegated token key. */
+declare function hasDelegatedWorkerToken(runConfig: Record<string, unknown> & Partial<Record<typeof DELEGATED_WORKER_SCOPE_TOKEN, unknown>>): boolean;
+
 declare const AGENT_TASK_EVENT = "agent:execute";
 
 /**
@@ -7980,6 +9282,27 @@ declare class CustomMiddlewareRegistry {
     static list(): string[];
 }
 
+/**
+ * Catalog metadata for a single registered plugin skill.
+ * Used to expose plugin skills through the read-only system skill catalog.
+ */
+interface PluginSkillCatalogItem {
+    /** Skill id (plugin skill key). */
+    id: string;
+    /** Skill name parsed from SKILL.md frontmatter. */
+    name: string;
+    /** Skill description parsed from SKILL.md frontmatter. */
+    description: string;
+    /** Plugin skill bundle version. */
+    version: string;
+    /** Owning plugin type. */
+    pluginType: string;
+    /** Safe relative paths of bundled resources with their MIME types. */
+    resourcePaths: Array<{
+        path: string;
+        mimeType?: string;
+    }>;
+}
 /**
  * Plugin registry.
  *
@@ -7994,12 +9317,37 @@ declare class PluginRegistry {
     static unregister(key: string): boolean;
     /** Get plugin instance */
     static get(key: string): Plugin | undefined;
+    /** Get a plugin skill definition and its owning plugin type. */
+    static getSkill(name: string): {
+        pluginType: string;
+        definition: PluginSkillDefinition;
+    } | undefined;
+    /** Find the registered owner of the exact enabled skill definition. */
+    static getSkillOwner(name: string, definition: PluginSkillDefinition): {
+        pluginType: string;
+        definition: PluginSkillDefinition;
+    } | undefined;
+    /** Find a skill using the explicitly enabled plugin owner. */
+    static getSkillForPlugin(pluginType: string, name: string): {
+        pluginType: string;
+        definition: PluginSkillDefinition;
+    } | undefined;
     /** Check if registered */
     static has(key: string): boolean;
     /** List all registered plugin keys */
     static list(): string[];
     /** Serialize all registered plugins to API-ready meta list */
     static listMeta(): PluginMetaOutput[];
+    /**
+     * Catalog metadata for all registered plugin skills, regardless of whether
+     * the owning plugin is enabled for a given agent.
+     *
+     * Pure/synchronous — no sandbox, no tenant context. Name/description are
+     * parsed from each SKILL.md definition's frontmatter.
+     *
+     * @returns Catalog entries keyed by plugin skill id.
+     */
+    static listSkills(): PluginSkillCatalogItem[];
 }
 
 /**
@@ -8014,10 +9362,76 @@ declare function serializePluginMeta(plugin: Plugin): PluginMetaOutput;
 
 declare const BUILTIN_PLUGINS: Plugin[];
 
+/** Stable failure codes emitted when capability bundles cannot be composed. */
+type CapabilityBundleMergeErrorCode = "CAPABILITY_BUNDLE_DUPLICATE_ID" | "CAPABILITY_BUNDLE_EMPTY_ALLOWED_TOOLS" | "CAPABILITY_BUNDLE_INVALID_CONFIG" | "CAPABILITY_BUNDLE_NULL_VALUE" | "CAPABILITY_BUNDLE_UNSAFE_KEY";
+/** Describes invalid capability bundle input rejected by the pure merger. */
+declare class CapabilityBundleMergeError extends Error {
+    /** Stable machine-readable reason for the failure. */
+    readonly code: CapabilityBundleMergeErrorCode;
+    /** Bundle containing the invalid value, when known. */
+    readonly bundleId?: string;
+    /** Capability containing the invalid value, when known. */
+    readonly capabilityType?: string;
+    /** JSON Pointer path to the invalid capability field, when known. */
+    readonly fieldPath?: string;
+    /**
+     * Creates a capability bundle composition error.
+     *
+     * @param code - Stable machine-readable failure code.
+     * @param message - Human-readable failure description.
+     * @param context - Structured location of the invalid input.
+     */
+    constructor(code: CapabilityBundleMergeErrorCode, message: string, context?: {
+        bundleId?: string;
+        capabilityType?: string;
+        fieldPath?: string;
+    });
+}
+/**
+ * Composes ordered capability bundles into a detached runtime preview.
+ *
+ * Capability identity and display fields come from the first occurrence of a
+ * type. Runtime fields are merged in bundle order with provenance and distinct
+ * ordinary replacements recorded in the preview.
+ *
+ * @param bundles - Capability bundles in composition precedence order.
+ * @returns A deterministic, detached capability preview.
+ * @throws {CapabilityBundleMergeError} When bundle IDs repeat or consumed input contains null, empty tool selections, or unsafe keys.
+ * @example
+ * ```ts
+ * const preview = mergeCapabilityBundles([baseBundle, projectBundle]);
+ * ```
+ * @remarks
+ * Bundle order defines precedence: later explicit ordinary values replace earlier values.
+ * Capability output order follows each type's first appearance.
+ */
+declare function mergeCapabilityBundles(bundles: readonly CapabilityBundle[]): CapabilityPreview;
+/**
+ * Stateless facade for composing capability bundles in dependency-injected services.
+ *
+ * @example
+ * ```ts
+ * const merger = new CapabilityBundleMerger();
+ * const preview = merger.merge([baseBundle, projectBundle]);
+ * ```
+ * @remarks
+ * Pass bundles in ascending precedence order. The facade retains no state between calls.
+ */
+declare class CapabilityBundleMerger {
+    /**
+     * Composes ordered capability bundles.
+     *
+       * @param bundles - Capability bundles in composition precedence order.
+       * @returns A deterministic, detached capability preview.
+       * @remarks Later bundles take precedence while capability type order remains first-seen.
+       */
+    merge(bundles: readonly CapabilityBundle[]): CapabilityPreview;
+}
+
 /**
  * Capability Learning Plugin
  *
- * Provides a document-learner agent and learn-capability procedural skill.
+ * Provides a document-learner agent and source-to-capability learning workflow.
  * The agent guides users through turning source material (documents, API
  * specs, conversations, spreadsheets) into structured skill systems with
  * evaluations — following a supervised learning paradigm.
@@ -8034,8 +9448,70 @@ declare const documentLearningPlugin: Plugin;
  * when connectAll is enabled.
  */
 
+/** Built-in Document Parser plugin definition. */
 declare const documentParserPlugin: Plugin;
 
+/**
+ * Semantic Metrics Middleware & Plugin (connection-backed, /api/v1).
+ *
+ * Exposes datasource exploration, meta publishing, and runtime query tools.
+ * Credentials are resolved via the framework-injected `_resolvedConnections`.
+ */
+
+/**
+ * Create the Semantic Metrics middleware exposing three action-dispatch tools.
+ *
+ * @param config - Plugin config; reads `config._resolvedConnections` (framework-injected).
+ * @returns Middleware with the datasource/meta/runtime tool set.
+ */
+declare function createSemanticMetricsMiddleware(config: Record<string, unknown>): AgentMiddleware;
+/** Built-in Semantic Metrics plugin definition. */
+declare const semanticMetricsPlugin: Plugin;
+
+/**
+ * Creates the always-available, fail-closed Project Room tool middleware.
+ *
+ * The tools derive all identity from host-injected trusted run context. They do
+ * not accept tenant, room, membership, Agent, or Thread identifiers from callers.
+ *
+ * @returns Middleware exposing trusted room posting and roster listing tools.
+ */
+declare function createProjectRoomMiddleware(): AgentMiddleware;
+/** Built-in Project Room plugin metadata and middleware factory. */
+declare const projectRoomPlugin: Plugin;
+
+/** Stable reasons for rejecting capability bundle input. */
+type CapabilityBundleValidationErrorCode = "CAPABILITY_BUNDLE_EMPTY_FIELD" | "CAPABILITY_BUNDLE_INELIGIBLE_CAPABILITY" | "CAPABILITY_BUNDLE_INVALID_CAPABILITY" | "CAPABILITY_BUNDLE_DUPLICATE_CAPABILITY" | "CAPABILITY_BUNDLE_EMPTY_ALLOWED_TOOLS" | "CAPABILITY_BUNDLE_UNKNOWN_TOOL" | "CAPABILITY_BUNDLE_TOOLS_UNAVAILABLE" | "CAPABILITY_BUNDLE_NULL_VALUE" | "CAPABILITY_BUNDLE_UNSAFE_KEY" | "CAPABILITY_BUNDLE_NESTED_REFERENCE" | "CAPABILITY_BUNDLE_INVALID_CONFIG" | "CAPABILITY_BUNDLE_CYCLIC_CONFIG" | "CAPABILITY_BUNDLE_CONFIG_TOO_DEEP" | "CAPABILITY_BUNDLE_CONFIG_TOO_LARGE" | "CAPABILITY_BUNDLE_NON_JSON_VALUE" | "CAPABILITY_BUNDLE_CREDENTIALS_FORBIDDEN";
+/** Describes invalid capability bundle input with a stable code and location. */
+declare class CapabilityBundleValidationError extends Error {
+    /** Stable machine-readable reason. */
+    readonly code: CapabilityBundleValidationErrorCode;
+    /** Capability type containing the invalid value, when known. */
+    readonly capabilityType?: string;
+    /** JSON Pointer to the invalid value. */
+    readonly fieldPath?: string;
+    /** Creates a structured capability bundle validation error. */
+    constructor(code: CapabilityBundleValidationErrorCode, message: string, context?: {
+        capabilityType?: string;
+        fieldPath?: string;
+    });
+}
+/**
+ * Validates create or partial-update capability bundle input without mutating it.
+ *
+ * @param input - Bundle fields supplied by a create or update request.
+ * @param options - Set `partial` for update semantics; omitted fields are allowed.
+ * @returns Nothing when valid; throws {@link CapabilityBundleValidationError} otherwise.
+ * @example
+ * ```ts
+ * validateCapabilityBundleInput({ name: "Data", capabilities: [] });
+ * validateCapabilityBundleInput({ name: "Renamed" }, { partial: true });
+ * ```
+ */
+declare function validateCapabilityBundleInput(input: unknown, options?: {
+    partial?: boolean;
+}): asserts input is CreateCapabilityBundleInput | UpdateCapabilityBundleInput;
+
 /**
  * Create middleware that provides widget rendering capabilities.
  *
@@ -8125,6 +9601,145 @@ interface UnknownToolHandlerConfig {
  */
 declare function createUnknownToolHandlerMiddleware(config?: UnknownToolHandlerConfig): AgentMiddleware;
 
+/** Describes how a tool argument selects a capability-scoped resource. */
+interface CapabilityResourceSelector {
+    /** Tool argument containing the selected resource key. */
+    argumentField: string;
+    /** Capability runtime config field containing allowed resource keys. */
+    configField: string;
+    /** Capability runtime config flag that grants access to all resources. */
+    allowAllField?: "connectAll" | "readAll";
+    /** Whether allow-all mode permits omission for a discovery-style tool. */
+    allowMissingWhenAll?: boolean;
+}
+/** Metadata linking one emitted tool to its capability policy. */
+interface CapabilityToolMetadata {
+    /** Middleware type used as the capability runtime policy key. */
+    capabilityType: string;
+    /** Optional resource selector enforced when the tool call supplies it. */
+    resourceSelector?: CapabilityResourceSelector;
+}
+/** Stable failure code for ambiguous emitted tool-to-capability mappings. */
+declare const CAPABILITY_TOOL_NAME_CONFLICT: "CAPABILITY_TOOL_NAME_CONFLICT";
+/** Error raised when one emitted tool name is mapped to incompatible policies. */
+declare class CapabilityToolNameConflictError extends Error {
+    readonly toolName: string;
+    readonly existingCapabilityType: string;
+    readonly conflictingCapabilityType: string;
+    /** Stable machine-readable error code. */
+    readonly code: "CAPABILITY_TOOL_NAME_CONFLICT";
+    /** Creates an emitted tool-name conflict error. */
+    constructor(toolName: string, existingCapabilityType: string, conflictingCapabilityType: string);
+}
+/**
+ * Registers tool-to-capability metadata for one middleware construction.
+ *
+ * @remarks Create one registry per middleware chain. Stored and returned metadata
+ * is frozen so callers cannot mutate policy mappings across requests.
+ *
+ * @example Standard plugins do not need a resource selector mapping; the
+ * generic guard uses `connectionKey` with `meta.type` as the connection type.
+ * Legacy built-ins retain explicit selectors through the compatibility map.
+ * ```ts
+ * const registry = new CapabilityToolRegistry();
+ * registry.registerMiddleware("crm", crmMiddleware);
+ * ```
+ */
+declare class CapabilityToolRegistry {
+    private readonly metadataByTool;
+    private readonly standardConnectionTools;
+    /**
+     * Registers one tool mapping.
+     *
+     * @param name - Actual emitted tool name.
+     * @param metadata - Capability and optional resource-selector metadata.
+     * @returns Nothing.
+     */
+    private registerInternal;
+    /**
+     * Registers one tool mapping.
+     *
+     * @param name - Actual emitted tool name.
+     * @param metadata - Capability and optional legacy resource-selector metadata.
+     * @param tool - Optional emitted tool whose schema may declare `connectionKey`.
+     * @returns Nothing.
+     * @remarks Standard connection authorization is captured only for tools whose
+     * schema declares `connectionKey`; legacy selectors remain explicit metadata.
+     */
+    register(name: string, metadata: CapabilityToolMetadata, tool?: unknown): void;
+    /**
+     * Registers all tools actually exposed by a middleware instance.
+     *
+     * @param capabilityType - Runtime middleware policy key.
+     * @param middleware - Constructed middleware after tool filtering.
+     * @param resourceSelectors - Optional resource mappings keyed by emitted tool name.
+     * @returns Nothing.
+     */
+    registerMiddleware(capabilityType: string, middleware: AgentMiddleware, resourceSelectors?: Readonly<Record<string, CapabilityResourceSelector>>): void;
+    /**
+     * Gets immutable metadata for a registered tool.
+     *
+     * @param name - Tool name requested by the model.
+     * @returns Frozen metadata, or `undefined` when the tool is not mapped.
+     */
+    get(name: string): CapabilityToolMetadata | undefined;
+    /**
+     * Reports whether standard connection authorization was captured at registration time.
+     *
+     * @param name - Tool name.
+     * @returns Whether the tool belongs to an eligible standard connection plugin.
+     */
+    isStandardConnectionTool(name: string): boolean;
+}
+
+/**
+ * Returns one capability's runtime configuration for the current invocation.
+ *
+ * @param executionConfig - LangChain execution configuration or another unknown input.
+ * @param capabilityType - Middleware type used as the runtime capability key.
+ * @returns The capability config record, or `undefined` when the runtime shape is absent or invalid.
+ */
+declare function getRuntimeCapabilityConfig(executionConfig: unknown, capabilityType: string): Record<string, unknown> | undefined;
+/**
+ * Reports whether a capability policy exists in the current runtime snapshot.
+ *
+ * @param executionConfig - LangChain execution configuration or another unknown input.
+ * @param capabilityType - Middleware type used as the runtime capability key.
+ * @returns Whether the runtime contains a policy record for the capability.
+ */
+declare function hasRuntimeCapabilityPolicy(executionConfig: unknown, capabilityType: string): boolean;
+/** Runtime skill selector extracted from a capability snapshot. */
+interface RuntimeSkillSelection {
+    /** Whether the invocation contains an explicit skill capability policy. */
+    hasPolicy: boolean;
+    /** Whether the resolved skill capability is enabled. */
+    enabled: boolean;
+    /** Explicitly selected skill names, including an empty deny-all list. */
+    skills?: string[];
+    /** Whether the runtime policy requests all skills within the static ceiling. */
+    readAll: boolean;
+}
+/**
+ * Returns the runtime skill selection for one invocation.
+ *
+ * @param executionConfig - LangChain execution configuration or another unknown input.
+ * @returns A detached selector that preserves absent policy versus explicit empty selection.
+ */
+declare function getRuntimeSkillSelection(executionConfig: unknown): RuntimeSkillSelection;
+
+/** Stable machine-readable capability guard denial codes. */
+type CapabilityGuardDenialCode = "CAPABILITY_DISABLED" | "CAPABILITY_DENIED" | "RESOURCE_NOT_ALLOWED";
+/**
+ * Creates a tool-call guard backed by server-derived capability runtime policy.
+ *
+ * @param registry - Per-middleware-chain mappings for actual emitted tools.
+ * @returns A middleware with only a `wrapToolCall` hook.
+ * @remarks Unmapped tools and missing policies pass through. This middleware does
+ * not replace unknown-tool handling and deliberately does not implement
+ * `wrapModelCall`.
+ */
+declare function createCapabilityGuardMiddleware(registry: CapabilityToolRegistry): AgentMiddleware;
+
 interface SchedulerMiddlewareOptions {
     defaultMaxRetries?: number;
 }
@@ -8136,6 +9751,119 @@ interface TaskMiddlewareConfig {
 }
 declare function createTaskMiddleware(options?: TaskMiddlewareConfig): AgentMiddleware;
 
+/** Maximum UTF-8 bytes retained for each scalar string in a task response fallback. */
+declare const TASK_RESPONSE_SCALAR_MAX_BYTES = 4096;
+/** Maximum existing warnings copied into a task mutation serialization fallback. */
+declare const TASK_RESPONSE_PRIOR_WARNING_LIMIT = 100;
+/** Maximum warnings after mandatory serialization and reconciliation warnings are appended. */
+declare const TASK_RESPONSE_FINAL_WARNING_LIMIT = 102;
+type SafeRecord = Record<string, unknown>;
+/** Result of parsing and bounded normalization for one task response. */
+type TaskResponseParseResult = {
+    kind: "parse_failure";
+} | {
+    kind: "parsed_non_object";
+} | {
+    kind: "parsed_object";
+    success: boolean | undefined;
+    normalization: "succeeded";
+    normalized: SafeRecord;
+} | {
+    kind: "parsed_object";
+    success: boolean | undefined;
+    normalization: "failed";
+};
+/**
+ * Builds a detached, prototype-safe fallback for a successful task mutation.
+ *
+ * @param taskId Persisted task identity to preserve.
+ * @param mutationCommitted Whether the primary mutation actually committed.
+ * @param metadata Lifecycle and warning metadata to copy as bounded scalars.
+ * @returns A null-prototype partial-success record safe for captured JSON serialization.
+ */
+declare function buildTaskMutationFallback(taskId: string, mutationCommitted: boolean, metadata?: SafeRecord): SafeRecord;
+/**
+ * Serializes a successful task mutation, falling back without revisiting a hostile task.
+ *
+ * @param taskId Persisted task identity.
+ * @param task Task snapshot included in the normal response.
+ * @param mutationCommitted Whether the primary mutation committed.
+ * @param metadata Lifecycle metadata included in the normal response and detached fallback.
+ * @returns A JSON response preserving normal shape or a scalar-only partial success.
+ */
+declare function serializeTaskMutationSuccess(taskId: string, task: unknown, mutationCommitted: boolean, metadata?: SafeRecord): string;
+/**
+ * Serializes a read-only task-bearing response with a stable typed failure fallback.
+ *
+ * @param value Complete get/list response value.
+ * @returns Normal JSON or `TASK_RESPONSE_SERIALIZATION_FAILED` without unsafe task IDs.
+ */
+declare function serializeTaskReadResponse(value: unknown): string;
+/**
+ * Parses and normalizes a task response through captured JSON and bounded JSON-safe conversion.
+ *
+ * @param response JSON task response.
+ * @returns A discriminated parse result with top-level success and optional normalized record.
+ */
+declare function parseTaskResponse(response: string): TaskResponseParseResult;
+/**
+ * Builds a small factual response when successful response normalization fails.
+ *
+ * @param taskId Task associated with the response.
+ * @param mutationCommitted Actual primary mutation fact.
+ * @returns A null-prototype partial success with a protected normalization warning.
+ */
+declare function buildTaskNormalizationFallback(taskId: string, mutationCommitted: boolean): SafeRecord;
+/**
+ * Serializes the small factual response used after successful normalization failure.
+ *
+ * @param taskId Task associated with the response.
+ * @param mutationCommitted Actual primary mutation fact.
+ * @returns Captured-stringify JSON partial success.
+ */
+declare function serializeTaskNormalizationFallback(taskId: string, mutationCommitted: boolean): string;
+/**
+ * Reads an own task-response field without trusting inherited properties or accessors.
+ *
+ * @param response Normalized task response record.
+ * @param field Field to read.
+ * @returns The own field value, or undefined when absent/inaccessible.
+ */
+declare function ownTaskResponseField(response: SafeRecord, field: string): unknown;
+/**
+ * Extracts a bounded own string ID from a task without propagating hostile access errors.
+ *
+ * @param task Task-like runtime value.
+ * @returns Bounded task ID, or undefined when it cannot be read safely.
+ */
+declare function safeTaskResponseId(task: unknown): string | undefined;
+/**
+ * Appends a bounded reconciliation warning to normalized response data.
+ *
+ * @param response Existing JSON response.
+ * @param taskId Task whose reconciliation failed.
+ * @param error Reconciliation error to summarize safely.
+ * @param mutationCommitted Actual primary mutation fact for emergency fallback construction.
+ * @returns Captured-stringify JSON with a protected warning array and bounded cardinality.
+ */
+declare function appendReconciliationWarning(parsedResponse: TaskResponseParseResult, taskId: string, error: unknown, mutationCommitted: boolean): string;
+/** Input for factual task mutation response post-processing. */
+interface PostProcessTaskMutationResponseInput {
+    response: string;
+    taskId: string;
+    executionResultId?: string;
+    mutationCommitted: boolean;
+    validationError?: unknown;
+    reconcile: (normalizedResponse: SafeRecord) => Promise<void>;
+}
+/**
+ * Applies one-pass parsing, factual fallback, validation warnings, and exact reconciliation.
+ *
+ * @param input Response plus internally known mutation and reconciliation facts.
+ * @returns Original or bounded JSON response after reconciliation post-processing.
+ */
+declare function postProcessTaskMutationResponse(input: PostProcessTaskMutationResponseInput): Promise<string>;
+
 type ResolveAgentFn = (ref?: string, responseFormat?: Record<string, unknown>, stepType?: string) => Promise<AgentClient>;
 /**
  * Build a LangGraph Annotation.Root from DSL state.fields.
@@ -8627,4 +10355,70 @@ declare class IdRemapper {
     remapSkillIds(graphDefinition: Record<string, unknown>, skillRemap: Record<string, string>): Record<string, unknown>;
 }
 
-export { AGENT_TASK_EVENT, type AddMessageParams, Agent, type AgentClient, type AgentExecutor, AgentInstanceManager, type AgentLattice, AgentLatticeManager, type AgentLifecycleEventName, AgentManager, type AgentStreamExecutor, type AgentTaskCompletionInput, type AgentThreadInterface, type ApproveInterruptedTaskInput, BUILTIN_PLUGINS, BUILTIN_SKILLS, type BackendFactory, type BackendProtocol, type BufferStats, type CacheEntry, type CalibrationProbe, type CaseRunResult, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, CollectionLatticeManager, type ColumnInfo, CompositeBackend, type ConflictItem, type ConnectAllChannelsOptions, ConnectionRegistry, ConsoleLoggerClient, type CreateSandboxProviderConfig, type CronFields, CustomMetricsClient, type CustomMiddlewareFactory, CustomMiddlewareRegistry, DEFAULT_CALIBRATION_PROBES, type DatabaseConfig, type DatabaseType, DaytonaInstance, DaytonaProvider, type DaytonaProviderConfig, DefaultScheduleClient, type DeleteResult, DependencyResolver, E2BInstance, E2BProvider, type E2BProviderConfig, EMPTY_CONTENT_WARNING, type EditResult, type EmbeddingsInfo, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type EnsureMicrosandboxInput, type EvalRunService, type ExportBundle, type ExportContext, type ExportJob, type ExportableEntity, type ExportableEntityDefinition, ExportableEntityRegistry, type ExportableFile, type ExportableTypeInfo, type FileData, type FileInfo, FileSystemSkillStore, type FileSystemSkillStoreOptions, FilesystemBackend, type FsEntry, type GrepMatch, type IMessageQueueStore, type IMetricsServerClient, type ISqlDatabase, IdRemapper, type ImportApplyResolution, type ImportApplyResult, type ImportEntityResult, type ImportEntityStatus, type ImportPreviewResult, InMemoryA2AApiKeyStore, InMemoryAgentWebAppStore, InMemoryAssistantStore, InMemoryBindingStore, InMemoryChannelInstallationStore, InMemoryChunkBuffer, InMemoryCollectionStore, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryMenuStore, InMemoryTaskListStore, InMemoryTaskStore, InMemoryTenantStore, InMemoryThreadMessageQueueStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, type InsertionItem, type JudgeVerdict, LINE_NUMBER_WIDTH, type LangGraphStateChecker, type LatticeAgentStepConfig, LatticeEval, type LatticeEvalBatchReport, type LatticeEvalCase, type LatticeEvalCaseType, type LatticeEvalCaseWithTemplate, type LatticeEvalConfig, type LatticeEvalLogEvent, type LatticeEvalLogLevel, LatticeEvalProject, type LatticeEvalProjectType, type LatticeEvalResult, type LatticeEvalRubric, LatticeEvalSuite, type LatticeEvalSuiteType, type LatticeEvalTemplate, type LifecycleResult, type LifecycleWarning, LocalSandboxInstance, LocalSandboxProvider, type LocalSandboxProviderConfig, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type MessageCompletedEvent, type MessageFailedEvent, type MessageStartedEvent, MessageType, MetricsServerManager, MicrosandboxRemoteInstance, MicrosandboxRemoteProvider, type MicrosandboxRemoteProviderClient, type MicrosandboxRemoteProviderConfig, MicrosandboxServiceClient, type MicrosandboxServiceClientConfig, type MicrosandboxShellExecInput, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, MysqlDatabase, type OutputType, type PendingMessage, PersonalAssistantConfig, PinoLoggerClient, PluginRegistry, PostgresDatabase, type PreviewError, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, QueueMode, type QueuePendingEvent, type ReconcileTaskDescriptionInput, type RejectInterruptedTaskInput, RemoteSandboxInstance, RemoteSandboxProvider, type RemoteSandboxProviderConfig, type Resolution, type ResolutionAction, type ResolveAgentFn, type ResolvedConfig, type RunSandboxConfig, type RuntimeModelConfig, type STTModelInfo, STTModelLattice, type STTModelLatticeInterface, STTModelLatticeManager, type SandboxFileInfo, type SandboxFileService, SandboxFilesystem, type SandboxInstance, type SandboxIsolationLevel, SandboxLatticeManager, type SandboxManagerProtocol, type SandboxProvider, type SandboxProviderFactory, type SandboxProviderType, type SandboxShellService, SandboxSkillStore, type SandboxSkillStoreOptions, type SandboxVolumeDefinition, type ScheduleLattice, ScheduleLatticeManager, type SchedulerMiddlewareOptions, SemanticMetricsClient, type SharePayload, SimpleMemoryVectorStore, type SkillLattice, SkillLatticeManager, type SkillMeta, type SkillResource, SqlDatabaseManager, type StateAndStore, StateBackend, StoreBackend, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, type SubmitTaskReviewInput, TOOL_RESULT_TOKEN_LIMIT, TRUNCATION_GUIDANCE, type TableInfo, type TableSchema, type TaskEvent, TaskLifecycleService, type TaskLifecycleServiceDeps, type TaskListStore, type TaskSpec, TaskStatus, type TaskUpdatable, TeamAgentGraphBuilder, type TeamConfig, type TeamMiddlewareOptions, type TeamTask, type TeammateSpec, type TeammateToolsOptions, type ThreadBuffer, type ThreadBufferConfig, type ThreadBusyEvent, type ThreadIdleEvent, type ThreadInfo, type ThreadQueueConfig, type ThreadState, ThreadStatus, type ThreadStatusChangedEvent, TokenCache, type ToolDefinition, type ToolLattice, ToolLatticeManager, type UnknownToolHandlerConfig, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type VectorStoreProviderLattice, VectorStoreProviderManager, VolumeFilesystem, type VolumeFsClient, type WorkflowValidationError, type WriteResult, abortWorkflowRun, agentInstanceManager, agentLatticeManager, buildGrepResultsDict, buildInput, buildNamedVolumeName, buildSandboxMetadataEnv, buildSkillFile, buildStateAnnotation, buildTableName, checkEmptyContent, clearEncryptionKeyCache, clearEvalRunService, collectionLatticeManager, compileInternal, compileWorkflow, computeSandboxName, configureStores, connectAllChannels, createAgentNode, createAgentTeam, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createMapNode, createModelSelectorMiddleware, createNodeHandler, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createResourceAddress, createSandboxProvider, createSchedulerMiddleware, createSharePayload, createTaskLifecycleService, createTaskMiddleware, createTeamMiddleware, createTeammateTools, createUnknownToolHandlerMiddleware, createWidgetMiddleware, decrypt, describeCronExpression, documentLearningPlugin, documentParserPlugin, embeddingsLatticeManager, encrypt, ensureBuiltinAgentsForTenant, evaluateLatticeCaseWithLogs, eventBus, eventBus as eventBusDefault, extractFetcherError, extractOutput, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, generateToken, getAgentClient, getAgentConfig, getAllAgentConfigs, getAllBuiltInSkillMetas, getAllToolDefinitions, getBindingRegistry, getBuiltInSkillContent, getBuiltInSkillMeta, getBuiltInSkillNames, getCheckpointSaver, getChunkBuffer, getCollectionEntryCount, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getEvalRunService, getLoggerLattice, getMenuRegistry, getModelLattice, getNextCronTime, getOrCreateCollectionVectorStore, getQueueLattice, getSTTClient, getSTTClientWithTenant, getSTTModelLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, getVectorStoreProvider, getWorkflowSignal, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, invokeWithRetry, isBuiltInSkill, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, listCollectionEntries, listSandboxProviderTypes, loggerLatticeManager, mcpManager, metricsServerManager, modelLatticeManager, normalizeSandboxName, parallelLimit, parseCronExpression, parseJudgeVerdict, parseSkillFrontmatter, parseYaml, performStringReplacement, queueLatticeManager, registerAgentLattice, registerAgentLatticeWithTenant, registerAgentLattices, registerBuiltinSkill, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerSTTModelLattice, registerSandboxProviderType, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, registerVectorStoreProvider, registerWorkflowRun, removeCollectionVectorStore, renderTemplate, resolveJudgeModelKey, resolvePath, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, serializePluginMeta, setBindingRegistry, setEvalRunService, setMenuRegistry, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, sttModelLatticeManager, toJsonSchema, toSafeStateExpr, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, unregisterWorkflowRun, updateFileData, validateAgentInput, validateDSL, validateEncryptionKey, validatePath, validateSkillName, validateToolInput, vectorStoreLatticeManager, vectorStoreProviderManager };
+/**
+ * Generates a deterministic project ID for a direct human room.
+ *
+ * The ID is deterministic because the same pair of users always produces the same ID,
+ * which enables idempotent room creation.
+ *
+ * @param tenantId - The tenant ID
+ * @param workspaceId - The workspace ID
+ * @param userId1 - First user's ID
+ * @param userId2 - Second user's ID
+ * @returns A deterministic project ID with prefix "direct_human_"
+ *
+ * @example
+ * ```ts
+ * const id = generateDirectHumanProjectId("tenant-1", "workspace-1", "user-a", "user-b");
+ * // Always returns the same ID regardless of argument order
+ * ```
+ */
+declare function generateDirectHumanProjectId(tenantId: string, workspaceId: string, userId1: string, userId2: string): string;
+/**
+ * Generates a deterministic project ID for a direct bot room.
+ *
+ * The ID is deterministic because the same user + bot pair always produces the same ID,
+ * which enables idempotent room creation.
+ *
+ * @param tenantId - The tenant ID
+ * @param workspaceId - The workspace ID
+ * @param userId - The user's ID
+ * @param assistantId - The bot/assistant's ID
+ * @returns A deterministic project ID with prefix "direct_bot_"
+ *
+ * @example
+ * ```ts
+ * const id = generateDirectBotProjectId("tenant-1", "workspace-1", "user-1", "assistant-1");
+ * ```
+ */
+declare function generateDirectBotProjectId(tenantId: string, workspaceId: string, userId: string, assistantId: string): string;
+/**
+ * Parses a direct room project ID to extract its type.
+ *
+ * @param projectId - The project ID to parse
+ * @returns The type of direct room, or null if not a direct room
+ *
+ * @example
+ * ```ts
+ * parseDirectRoomType("direct_human_abc123"); // "human"
+ * parseDirectRoomType("direct_bot_xyz789"); // "bot"
+ * parseDirectRoomType("normal-project-id"); // null
+ * ```
+ */
+declare function parseDirectRoomType(projectId: string): "human" | "bot" | null;
+/**
+ * Checks if a project ID represents a direct room.
+ *
+ * @param projectId - The project ID to check
+ * @returns True if this is a direct room project ID
+ *
+ * @example
+ * ```ts
+ * isDirectRoom("direct_human_abc123"); // true
+ * isDirectRoom("direct_bot_xyz789"); // true
+ * isDirectRoom("normal-project-id"); // false
+ * ```
+ */
+declare function isDirectRoom(projectId: string): boolean;
+
+export { AGENT_TASK_EVENT, type AddMessageParams, type AddMessageResult, Agent, type AgentClient, type AgentExecutor, AgentInstanceManager, type AgentLattice, AgentLatticeManager, type AgentLifecycleEventName, AgentManager, type AgentStreamExecutor, type AgentTaskCompletionInput, type AgentThreadInterface, type ApproveInterruptedTaskInput, BUILTIN_PLUGINS, BUILTIN_SKILLS, type BackendFactory, type BackendProtocol, type BufferStats, CAPABILITY_TOOL_NAME_CONFLICT, type CacheEntry, type CalibrationProbe, CapabilityBundleMergeError, type CapabilityBundleMergeErrorCode, CapabilityBundleMerger, CapabilityBundleValidationError, type CapabilityBundleValidationErrorCode, type CapabilityGuardDenialCode, type CapabilityResourceSelector, type CapabilityToolMetadata, CapabilityToolNameConflictError, CapabilityToolRegistry, type CaseRunResult, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, CollectionLatticeManager, type ColumnInfo, CompositeBackend, type ConflictItem, type ConnectAllChannelsOptions, ConnectionRegistry, ConsoleLoggerClient, type CreateSandboxProviderConfig, type CronFields, CustomMetricsClient, type CustomMiddlewareFactory, CustomMiddlewareRegistry, DEFAULT_CALIBRATION_PROBES, type DatabaseConfig, type DatabaseType, DaytonaInstance, DaytonaProvider, type DaytonaProviderConfig, DefaultScheduleClient, DelegatedScopeNotQueueableError, type DeleteResult, DependencyResolver, DuplicateProjectRoomMessageIdempotencyKeyError, E2BInstance, E2BProvider, type E2BProviderConfig, EMPTY_CONTENT_WARNING, type EditResult, type EmbeddingsInfo, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type EnsureMicrosandboxInput, type EvalRunService, type ExportBundle, type ExportContext, type ExportJob, type ExportableEntity, type ExportableEntityDefinition, ExportableEntityRegistry, type ExportableFile, type ExportableTypeInfo, type ExternalDependencyInterruption, type FileData, type FileInfo, FileSystemSkillStore, type FileSystemSkillStoreOptions, FilesystemBackend, type FsEntry, type GrepMatch, type IMessageQueueStore, type IMetricsServerClient, type ISqlDatabase, IdRemapper, type ImportApplyResolution, type ImportApplyResult, type ImportEntityResult, type ImportEntityStatus, type ImportPreviewResult, InMemoryA2AApiKeyStore, InMemoryAgentWebAppStore, InMemoryAssistantStore, InMemoryBindingStore, InMemoryCapabilityBundleStore, InMemoryChannelInstallationStore, InMemoryChunkBuffer, InMemoryCollectionStore, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryMenuStore, InMemoryProjectBotMembershipStore, InMemoryProjectMembershipStore, InMemoryProjectRoomCoordinator, InMemoryProjectRoomMessageStore, InMemoryProjectRoomStore, InMemoryTaskListStore, InMemoryTaskStore, InMemoryTenantStore, InMemoryThreadMessageQueueStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, type InsertionItem, type JudgeVerdict, LINE_NUMBER_WIDTH, type LangGraphStateChecker, type LatticeAgentStepConfig, LatticeEval, type LatticeEvalBatchReport, type LatticeEvalCase, type LatticeEvalCaseType, type LatticeEvalCaseWithTemplate, type LatticeEvalConfig, type LatticeEvalLogEvent, type LatticeEvalLogLevel, LatticeEvalProject, type LatticeEvalProjectType, type LatticeEvalResult, type LatticeEvalRubric, LatticeEvalSuite, type LatticeEvalSuiteType, type LatticeEvalTemplate, type LifecycleResult, type LifecycleWarning, LocalSandboxInstance, LocalSandboxProvider, type LocalSandboxProviderConfig, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, MAX_PACK_ENTRIES, MAX_PACK_FILE_BYTES, MAX_PACK_TOTAL_BYTES, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type MessageCompletedEvent, type MessageContent, type MessageContentPart, type MessageContentValue, type MessageFailedEvent, type MessageInterruptedEvent, type MessageLike, type MessageStartedEvent, MessageType, MetricsServerManager, MicrosandboxRemoteInstance, MicrosandboxRemoteProvider, type MicrosandboxRemoteProviderClient, type MicrosandboxRemoteProviderConfig, MicrosandboxServiceClient, type MicrosandboxServiceClientConfig, type MicrosandboxShellExecInput, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, MysqlDatabase, type OutputType, PACK_DIRECTORY_TIMEOUT_SECONDS, type PackSourceInfo, type PendingMessage, PersonalAssistantConfig, PinoLoggerClient, PluginRegistry, type PostProcessTaskMutationResponseInput, PostgresDatabase, type PreviewError, ProjectBotMembershipIdConflictError, ProjectMutationMutex, type ProjectMutationScope, ProjectRoomMessageIdConflictError, type ProjectTaskAdmissionListener, type ProjectTaskAdmissionNotification, ProjectTaskAdmissionNotifier, type ProjectTaskAdmissionNotifierOptions, type ProjectTaskAssignmentScope, ProjectTaskOwnerPolicy, type ProjectTaskOwnerPolicyCode, ProjectTaskOwnerPolicyError, type ProjectTaskReassignmentAuthorization, type ProjectTaskReassignmentAuthorizationInput, type ProjectTaskReassignmentAuthorizer, type ProjectTaskReassignmentThreadValidationInput, type ProjectTaskReassignmentThreadValidator, type ProjectTaskRosterScope, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, type QueueMessage, QueueMode, type QueuePendingEvent, type QueueScope, type ReassignProjectTaskInput, type ReconcileTaskDescriptionInput, type RejectInterruptedTaskInput, RemoteSandboxInstance, RemoteSandboxProvider, type RemoteSandboxProviderConfig, type ReplyReadyEvent, type Resolution, type ResolutionAction, type ResolveAgentFn, type ResolvedConfig, type ResumeTaskResult, type RoomAgentMessageCallbackFailure, type RoomAgentMessageCommitted, type RoomAgentMessageInput, RoomAgentMessageService, type RoomAgentReplyInput, type RunSandboxConfig, type RuntimeModelConfig, type RuntimeSkillSelection, SAFE_PATH_COMPONENT, type STTModelInfo, STTModelLattice, type STTModelLatticeInterface, STTModelLatticeManager, type SandboxFileInfo, type SandboxFileService, SandboxFilesystem, type SandboxInstance, type SandboxIsolationLevel, SandboxLatticeManager, type SandboxManagerProtocol, type SandboxProvider, type SandboxProviderFactory, type SandboxProviderType, type SandboxShellService, SandboxSkillStore, type SandboxSkillStoreOptions, type SandboxVolumeDefinition, type ScheduleLattice, ScheduleLatticeManager, type SchedulerMiddlewareOptions, SemanticMetricsClient, type SharePayload, SimpleMemoryVectorStore, type SkillLattice, SkillLatticeManager, type SkillMeta, type SkillResource, SqlDatabaseManager, type StartLifecycleResult, type StartTaskExecutionInput, type StateAndStore, StateBackend, StoreBackend, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, type SubmitTaskReviewInput, TASK_RESPONSE_FINAL_WARNING_LIMIT, TASK_RESPONSE_PRIOR_WARNING_LIMIT, TASK_RESPONSE_SCALAR_MAX_BYTES, TOOL_RESULT_TOKEN_LIMIT, TRUNCATION_GUIDANCE, type TableInfo, type TableSchema, type TaskAgentInvocation, type TaskEvent, type TaskExecutionFailure, type TaskExecutionResult, type TaskExecutionServiceDeps, type TaskExecutionSuccess, type TaskLifecycleListener, type TaskLifecycleNotification, TaskLifecycleNotifier, TaskLifecycleService, type TaskLifecycleServiceDeps, type TaskListStore, type TaskResponseParseResult, type TaskSpec, TaskStatus, type TaskUpdatable, TeamAgentGraphBuilder, type TeamConfig, type TeamMiddlewareOptions, type TeamTask, type TeammateSpec, type TeammateToolsOptions, type ThreadBuffer, type ThreadBufferConfig, type ThreadBusyEvent, type ThreadIdleEvent, type ThreadInfo, type ThreadQueueConfig, type ThreadState, ThreadStatus, type ThreadStatusChangedEvent, TokenCache, type ToolDefinition, type ToolLattice, ToolLatticeManager, type TrustedAgentMessageDispatcher, type TrustedMessageOptions, type UnknownToolHandlerConfig, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type VectorStoreProviderLattice, VectorStoreProviderManager, VolumeFilesystem, type VolumeFsClient, type WorkflowValidationError, type WriteResult, abortWorkflowRun, agentInstanceManager, agentLatticeManager, appendReconciliationWarning, buildGrepResultsDict, buildInput, buildNamedVolumeName, buildRemotePackDirectoryCommand, buildSandboxMetadataEnv, buildSkillFile, buildStateAnnotation, buildTableName, buildTaskMutationFallback, buildTaskNormalizationFallback, checkEmptyContent, clearEncryptionKeyCache, clearEvalRunService, collectionLatticeManager, compileInternal, compileWorkflow, computeSandboxName, configureStores, connectAllChannels, createAgentNode, createAgentTeam, createCapabilityGuardMiddleware, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createMapNode, createModelSelectorMiddleware, createNodeHandler, createProjectRoomMiddleware, createProjectTaskOwnerPolicy, createProjectTaskReassignmentAuthorizer, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createResourceAddress, createSandboxProvider, createSchedulerMiddleware, createSemanticMetricsMiddleware, createSharePayload, createTaskExecutionService, createTaskLifecycleService, createTaskMiddleware, createTeamMiddleware, createTeammateTools, createTrustedAgentMessageDispatcher, createUnknownToolHandlerMiddleware, createWidgetMiddleware, decrypt, describeCronExpression, documentLearningPlugin, documentParserPlugin, embeddingsLatticeManager, encrypt, ensureBuiltinAgentsForTenant, ensurePluginSkillInSandbox, evaluateLatticeCaseWithLogs, eventBus, eventBus as eventBusDefault, extractFetcherError, extractOutput, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, generateDirectBotProjectId, generateDirectHumanProjectId, generateToken, getAgentClient, getAgentConfig, getAllAgentConfigs, getAllBuiltInSkillMetas, getAllToolDefinitions, getBindingRegistry, getBuiltInSkillContent, getBuiltInSkillMeta, getBuiltInSkillNames, getCheckpointSaver, getChunkBuffer, getCollectionEntryCount, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getEvalRunService, getLoggerLattice, getMenuRegistry, getModelLattice, getNextCronTime, getOrCreateCollectionVectorStore, getPluginSkillManifestVersion, getQueueLattice, getRuntimeCapabilityConfig, getRuntimeSkillSelection, getSTTClient, getSTTClientWithTenant, getSTTModelLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, getVectorStoreProvider, getWorkflowSignal, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, hasDelegatedWorkerToken, hasRuntimeCapabilityPolicy, invokeWithRetry, isBuiltInSkill, isDirectRoom, isPluginSkillAuthorizedInSandbox, isPluginSkillManagedInSandbox, isProjectLifecycleTask, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, listCollectionEntries, listSandboxProviderTypes, loggerLatticeManager, mcpManager, mergeCapabilityBundles, metricsServerManager, modelLatticeManager, normalizeSandboxName, ownTaskResponseField, parallelLimit, parseCronExpression, parseDirectRoomType, parseExternalDependency, parseJudgeVerdict, parsePackSize, parseSkillFrontmatter, parseTaskResponse, parseYaml, performStringReplacement, postProcessTaskMutationResponse, projectMutationMutex, projectRoomPlugin, projectTaskAdmissionNotifier, queueLatticeManager, registerAgentLattice, registerAgentLatticeWithTenant, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerSTTModelLattice, registerSandboxProviderType, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, registerVectorStoreProvider, registerWorkflowRun, removeCollectionVectorStore, renderTemplate, resolveJudgeModelKey, resolvePath, runRemotePackDirectory, safeTaskResponseId, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, semanticMetricsPlugin, serializePluginMeta, serializeTaskMutationSuccess, serializeTaskNormalizationFallback, serializeTaskReadResponse, setBindingRegistry, setEvalRunService, setMenuRegistry, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, sttModelLatticeManager, taskLifecycleNotifier, toJsonSchema, toSafeStateExpr, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, unregisterWorkflowRun, updateFileData, validateAgentInput, validateCapabilityBundleInput, validateDSL, validateEncryptionKey, validatePackSourcePath, validatePath, validateRelativePath, validateSkillName, validateToolInput, vectorStoreLatticeManager, vectorStoreProviderManager };