@axiom-lattice/core 4.2.1 → 4.2.3

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, CapabilityBundleStore, 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, 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, PluginSkillDefinition, McpTool, ResourceResolver, ResourceAddress, ShareVisibility, CreateShareRequest, ChannelAdapter, InterruptPolicy, TaskBeliefState, PluginMeta, Plugin, PluginMetaOutput, CapabilityPreview, CreateCapabilityBundleInput, UpdateCapabilityBundleInput, 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';
@@ -2646,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;
@@ -2659,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;
@@ -2694,6 +2707,8 @@ interface AddMessageParams {
     command?: CommandParams<unknown>;
     custom_run_config?: unknown;
     id?: string;
+    trusted_run_context?: TrustedRunContext;
+    execution_mode?: QueuedExecutionMode;
 }
 interface ThreadInfo {
     tenantId: string;
@@ -2798,6 +2813,10 @@ type StoreTypeMap = {
     taskWorkItem: TaskWorkItemStore;
     agentWebApp: AgentWebAppStore;
     capabilityBundle: CapabilityBundleStore;
+    projectRoom: ProjectRoomStore;
+    projectMembership: ProjectMembershipStore;
+    projectBotMembership: ProjectBotMembershipStore;
+    projectRoomMessage: ProjectRoomMessageStore;
 };
 /**
  * Store type keys
@@ -3541,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.
      *
@@ -3605,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.
      *
@@ -3636,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.
      *
@@ -3739,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;
     /**
@@ -3758,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
      */
@@ -3776,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)
      */
@@ -3841,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
@@ -7325,6 +7712,280 @@ declare class AgentManager {
     }, return_agent_state?: boolean): Promise<unknown>;
 }
 
+/** 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",
@@ -7387,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 {
@@ -7452,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';
@@ -7475,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.
  *
@@ -7542,7 +8245,6 @@ declare class Agent {
     private chunkBuffer;
     private abortController;
     private queueProcessorPromise?;
-    private checkpointRecoveryBlocked;
     assistant_id: string;
     thread_id: string;
     tenant_id: string;
@@ -7552,7 +8254,11 @@ declare class Agent {
     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.
@@ -7563,6 +8269,23 @@ 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;
     /**
@@ -7590,7 +8313,7 @@ declare class Agent {
         [Symbol.asyncIterator]: () => AsyncGenerator<MessageChunk, void, unknown>;
     };
     private buildExecutionRunConfig;
-    getLatticeClientAndRuntimeConfig(custom_run_config?: Record<string, unknown>, expectedRevision?: string): Promise<{
+    getLatticeClientAndRuntimeConfig(custom_run_config?: unknown, expectedRevision?: string): Promise<{
         runnable_agent: AgentClient;
         runConfig: Record<string, unknown>;
     }>;
@@ -7621,6 +8344,7 @@ declare class Agent {
         }[];
     }>;
     private agentExecutor;
+    private interruptedCommandExecutionContext;
     private interruptedCommandCapabilityRevision;
     getPendingMessages(): Promise<PendingMessage[]>;
     private queueScope;
@@ -7667,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)
@@ -7679,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.
      *
@@ -7698,6 +8418,10 @@ 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
@@ -7734,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.
      *
@@ -7746,11 +8471,15 @@ 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<ResumeTaskResult>;
     /**
@@ -7825,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
  *
@@ -7914,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 {
@@ -8000,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 {
@@ -8022,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.
  *
@@ -8037,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.
      *
@@ -8066,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>;
     /**
@@ -8146,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;
@@ -8160,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";
 
 /**
@@ -8469,6 +9451,35 @@ declare const documentLearningPlugin: Plugin;
 /** 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. */
@@ -8740,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.
@@ -9231,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, 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, 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, InMemoryCapabilityBundleStore, 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, 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 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, PostgresDatabase, type PreviewError, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, type QueueMessage, QueueMode, type QueuePendingEvent, type QueueScope, type ReconcileTaskDescriptionInput, type RejectInterruptedTaskInput, RemoteSandboxInstance, RemoteSandboxProvider, type RemoteSandboxProviderConfig, type Resolution, type ResolutionAction, type ResolveAgentFn, type ResolvedConfig, type ResumeTaskResult, 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 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, buildRemotePackDirectoryCommand, buildSandboxMetadataEnv, buildSkillFile, buildStateAnnotation, buildTableName, checkEmptyContent, clearEncryptionKeyCache, clearEvalRunService, collectionLatticeManager, compileInternal, compileWorkflow, computeSandboxName, configureStores, connectAllChannels, createAgentNode, createAgentTeam, createCapabilityGuardMiddleware, 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, ensurePluginSkillInSandbox, 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, getPluginSkillManifestVersion, getQueueLattice, getRuntimeCapabilityConfig, getRuntimeSkillSelection, getSTTClient, getSTTClientWithTenant, getSTTModelLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, getVectorStoreProvider, getWorkflowSignal, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, hasRuntimeCapabilityPolicy, invokeWithRetry, isBuiltInSkill, isPluginSkillAuthorizedInSandbox, isPluginSkillManagedInSandbox, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, listCollectionEntries, listSandboxProviderTypes, loggerLatticeManager, mcpManager, mergeCapabilityBundles, metricsServerManager, modelLatticeManager, normalizeSandboxName, parallelLimit, parseCronExpression, parseJudgeVerdict, parsePackSize, parseSkillFrontmatter, parseYaml, performStringReplacement, 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, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, serializePluginMeta, setBindingRegistry, setEvalRunService, setMenuRegistry, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, sttModelLatticeManager, toJsonSchema, toSafeStateExpr, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, unregisterWorkflowRun, updateFileData, validateAgentInput, validateCapabilityBundleInput, validateDSL, validateEncryptionKey, validatePackSourcePath, validatePath, validateRelativePath, 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 };