@asaidimu/utils-workspace 7.0.0 → 7.0.2

package/index.d.mts

@@ -2,7 +2,132 @@ import * as _asaidimu_anansi from '@asaidimu/anansi';
 import { IndexDefinition, SchemaDefinition, SchemaChange, DataTransform, PredicateMap } from '@asaidimu/anansi';
 import { QueryFilter, PaginationOptions } from '@asaidimu/query';
 import { GoogleGenAI, GenerateContentParameters } from '@google/genai';
-import { LanguageModel, ContentPart } from 'ai';
+
+/**
+ * Severity levels for structured issues and errors.
+ */
+type Severity = "error" | "warning" | "info";
+/**
+ * Represents a detailed validation or operational problem.
+ * Designed to be machine-readable while remaining human-friendly.
+ */
+interface Issue {
+    /** Machine-readable identifier (e.g., "REQUIRED_FIELD_MISSING"). */
+    readonly code: string;
+    /** Human-readable description of the problem. */
+    readonly message: string;
+    /** Field path in a document or state (e.g., "users.0.email"). */
+    readonly path?: string;
+    /** Optional array index when the issue relates to a specific element. */
+    readonly index?: number;
+    /** Seriousness of the issue. Defaults to "error". */
+    readonly severity?: Severity;
+    /** Optional detailed explanation, can be multi-line. */
+    readonly description?: string;
+    /** Nested issues that caused this one. */
+    readonly cause?: readonly Issue[];
+}
+/**
+ * Standardized error code format: CATEGORY-XXX[-SUFFIX]
+ * Examples:
+ * - VAL-001 (Validation: required field missing)
+ * - DB-002-NF (Database: not found)
+ * - AUTH-003-DENIED (Auth: permission denied)
+ */
+interface ErrorCodeMetadata {
+    /** The formal error code (e.g., "VAL-001") */
+    readonly code: string;
+    /** Human-readable name for the error type */
+    readonly name: string;
+    /** Detailed description of when this error occurs */
+    readonly description: string;
+    /** Suggested action for handling or resolving the error */
+    readonly action?: string;
+    /** HTTP status code mapping (if applicable) */
+    readonly httpStatus?: number;
+    /** Category of the error */
+    readonly category: ErrorCategory;
+    /** Whether this error should be logged as warning vs error */
+    readonly logLevel?: "debug" | "info" | "warn" | "error";
+}
+type ErrorCategory = "validation" | "database" | "auth" | "business" | "system" | "network" | "concurrency" | "custom";
+/**
+ * SystemError is the primary error type for all operational and validation errors.
+ * Supports both predefined and custom error codes with full metadata.
+ */
+declare class SystemError extends Error {
+    readonly code: string;
+    readonly codeMetadata: ErrorCodeMetadata;
+    readonly severity: Severity;
+    readonly path?: string;
+    readonly operation?: string;
+    readonly issues: readonly Issue[];
+    readonly cause?: unknown;
+    constructor(params: {
+        code: string;
+        message?: string;
+        severity?: Severity;
+        path?: string;
+        operation?: string;
+        issues?: readonly Issue[];
+        cause?: unknown;
+        metadata?: Partial<Omit<ErrorCodeMetadata, "code">>;
+    });
+    /**
+     * Returns a new SystemError with the specified path.
+     */
+    withPath(path: string): SystemError;
+    /**
+     * Returns a new SystemError with the specified operation name.
+     */
+    withOperation(operation: string): SystemError;
+    /**
+     * Returns a new SystemError with the specified issue appended.
+     */
+    withIssue(issue: Issue): SystemError;
+    /**
+     * Returns a new SystemError with multiple issues appended.
+     */
+    withIssues(issues: readonly Issue[]): SystemError;
+    /**
+     * Returns a new SystemError wrapping the specified cause.
+     */
+    withCause(cause: unknown): SystemError;
+    /**
+     * Returns the HTTP status code for this error (if applicable).
+     */
+    getHttpStatus(): number | undefined;
+    /**
+     * Formats the error for logging with structured metadata.
+     */
+    toLogEntry(): Record<string, unknown>;
+    /**
+     * Produces a human-readable representation suitable for logging.
+     */
+    toString(): string;
+}
+/**
+ * Factory for creating a new SystemError with automatic metadata.
+ */
+declare function createError(code: string, message?: string): SystemError;
+/**
+ * A functional wrapper for operations that can fail.
+ * Encourages explicit error handling over try/catch blocks.
+ */
+type Result$1<T, E = SystemError> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+/**
+ * Type-safe helpers for creating Results.
+ */
+declare const Result$1: {
+    ok: <T>(value: T) => Result$1<T, never>;
+    fail: <E>(error: E) => Result$1<never, E>;
+};
 
 type SerializerResult<T> = {
     value: T | null;
@@ -123,97 +248,19 @@ declare const Branded: {
 };
 
 /**
- * Severity levels for structured issues and errors.
- */
-type Severity = "error" | "warning" | "info";
-/**
- * Represents a detailed validation or operational problem.
- * Designed to be machine-readable while remaining human-friendly.
- */
-interface Issue {
-    /** Machine-readable identifier (e.g., "REQUIRED_FIELD_MISSING"). */
-    readonly code: string;
-    /** Human-readable description of the problem. */
-    readonly message: string;
-    /** Field path in a document or state (e.g., "users.0.email"). */
-    readonly path?: string;
-    /** Optional array index when the issue relates to a specific element. */
-    readonly index?: number;
-    /** Seriousness of the issue. Defaults to "error". */
-    readonly severity?: Severity;
-    /** Optional detailed explanation, can be multi-line. */
-    readonly description?: string;
-    /** Nested issues that caused this one. */
-    readonly cause?: readonly Issue[];
-}
-/**
- * SystemError is the primary error type for all operational and validation errors.
- * It provides rich contextual information and supports immutable composition
- * through a fluent API.
- */
-declare class SystemError extends Error {
-    readonly code: string;
-    readonly severity: Severity;
-    readonly path?: string;
-    readonly operation?: string;
-    readonly issues: readonly Issue[];
-    readonly cause?: unknown;
-    constructor(params: {
-        code: string;
-        message: string;
-        severity?: Severity;
-        path?: string;
-        operation?: string;
-        issues?: readonly Issue[];
-        cause?: unknown;
-    });
-    /**
-     * Returns a new SystemError with the specified path.
-     * Path typically indicates the location in a data structure where the error occurred.
-     */
-    withPath(path: string): SystemError;
-    /**
-     * Returns a new SystemError with the specified operation name.
-     * Describes what was being attempted when the error occurred.
-     */
-    withOperation(operation: string): SystemError;
-    /**
-     * Returns a new SystemError with the specified issue appended.
-     */
-    withIssue(issue: Issue): SystemError;
-    /**
-     * Returns a new SystemError with multiple issues appended.
-     */
-    withIssues(issues: readonly Issue[]): SystemError;
-    /**
-     * Returns a new SystemError wrapping the specified cause.
-     */
-    withCause(cause: unknown): SystemError;
-    /**
-     * Produces a human-readable representation suitable for logging.
-     */
-    toString(): string;
-}
-/**
- * Factory for creating a new SystemError.
- */
-declare function createError(code: string, message: string): SystemError;
-/**
- * Predefined common error codes.
+ * Predefined common error codes, mapped to the standard ErrorCodes registry.
  */
 declare const CommonErrors: {
-    readonly NOT_FOUND: "NOT_FOUND";
-    readonly DUPLICATE_KEY: "DUPLICATE_KEY";
-    readonly INVALID_COMMAND: "INVALID_COMMAND";
-    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
-    readonly BACKEND_ERROR: "BACKEND_ERROR";
-    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
-    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
-    readonly CONCURRENCY_ERROR: "CONCURRENCY_ERROR";
-    /** Returned when an operation cannot proceed because a resource is locked. */
-    readonly RESOURCE_LOCKED: "RESOURCE_LOCKED";
-    /** Returned when an operation was explicitly aborted or the system is shutting down. */
-    readonly OPERATION_ABORTED: "OPERATION_ABORTED";
+    readonly NOT_FOUND: "DB-001-NF";
+    readonly DUPLICATE_KEY: "DB-002-DUP";
+    readonly INVALID_COMMAND: "BUS-001";
+    readonly PERMISSION_DENIED: "AUTH-001-DENIED";
+    readonly BACKEND_ERROR: "SYS-002";
+    readonly INTERNAL_ERROR: "SYS-001";
+    readonly VALIDATION_FAILED: "VAL-001";
+    readonly CONCURRENCY_ERROR: "CON-001";
+    readonly RESOURCE_LOCKED: "DB-003-LOCK";
+    readonly OPERATION_ABORTED: "BUS-002-ABORT";
 };
 
 /**
@@ -336,14 +383,25 @@ interface Event<T extends string = string, P = any, M extends Metadata = {}> {
     readonly meta: M;
 }
 /**
- * A pure function that calculates a state patch based on a command.
- * Reducers are the primary mechanism for state mutation in the CQRS loop.
+ * Represents the structured outcome of an Action.
+ * Allows an action to specify both a state patch and a computational result.
+ */
+interface ActionOutcome<S extends Record<string, any>, I extends Index, R = any> {
+    /** The speculative state patch to be applied to the system. */
+    patch?: DeepPartial<State<S, I>>;
+    /** The computational return value for the caller. */
+    result?: R;
+}
+/**
+ * A pure-ish function that calculates a state patch and/or a result based on a command.
+ * Actions are the primary mechanism for logic execution in the CQRS loop.
  *
  * @template S - The Domain State type.
  * @template I - The Index type.
  * @template C - The specific Command type being handled.
+ * @template R - The result type.
  */
-type Action<S extends Record<string, any>, I extends Index, C extends Command<any, any, any>> = (state: State<S, I>, command: C) => DeepPartial<State<S, I>> | Promise<DeepPartial<State<S, I>>>;
+type Action<S extends Record<string, any>, I extends Index, C extends Command<any, any, any>, R = any> = (state: State<S, I>, command: C) => Result<DeepPartial<State<S, I>> | ActionOutcome<S, I, R>, SystemError> | Promise<Result<DeepPartial<State<S, I>> | ActionOutcome<S, I, R>, SystemError>>;
 type ActionEntry<S extends Record<string, any>, I extends Index, C extends Command<any, any, any>> = {
     action: Action<S, I, C>;
     namespace: string;
@@ -363,8 +421,8 @@ type Middleware<S extends Record<string, any>, I extends Index> = (api: {
     /** Returns the current consistent snapshot of the state. */
     state: () => State<S, I>;
     /** Re-dispatches a command through the full pipeline. */
-    dispatch: <C extends Command<any, any, any>>(command: C) => Promise<Result<void, SystemError>>;
-}) => (next: (command: Command<any, any, any>) => Promise<Result<DeepPartial<State<S, I>>, SystemError>>) => (command: Command<any, any, any>) => Promise<Result<DeepPartial<State<S, I>>, SystemError>>;
+    dispatch: <C extends Command<any, any, any>, R = any>(command: C) => Promise<Result<R, SystemError>>;
+}) => (next: (command: Command<any, any, any>) => Promise<Result<ActionOutcome<S, I>, SystemError>>) => (command: Command<any, any, any>) => Promise<Result<ActionOutcome<S, I>, SystemError>>;
 /**
  * A collection of named registries that collectively know how to produce
  * a materialized index projection.
@@ -405,17 +463,8 @@ interface StateManager<T extends Record<string, any>> {
      * @returns The new full state tree after the patch is applied.
      */
     set(update: DeepPartial<T>): Promise<T>;
-    /**
-     * Subscribes to state changes.
-     * Useful for UI components or background workers that need to remain
-     * reactive to the evolving system state.
-     *
-     * @param listener - Function called whenever the state is updated.
-     * @returns An unsubscribe function.
-     */
-    subscribe(listener: (state: T) => void): () => void;
 }
-type StateReader<T extends Record<string, any>> = Pick<StateManager<T>, "get" | "subscribe">;
+type StateReader<T extends Record<string, any>> = Pick<StateManager<T>, "get">;
 
 /**
  * Buffers write operations across one or more stores and commits them atomically.
@@ -835,7 +884,7 @@ type TelemetryEvent = {
         } | null;
     };
 };
-interface DatabaseConfig {
+interface DatabaseConfig$1 {
     database: string;
     keyPath?: string;
     schemasStoreName?: string;
@@ -843,7 +892,7 @@ interface DatabaseConfig {
     predicates?: PredicateMap;
     validate?: boolean;
 }
-type StoreConfig = DatabaseConfig & {
+type StoreConfig = DatabaseConfig$1 & {
     collection: string;
 };
 
@@ -888,7 +937,7 @@ interface Store<T extends Metadata, K extends StoreKey<T>, S = T> {
      * Retrieves all entities from the store.
      * @returns Array of all entities (empty array if none exist)
      */
-    list(): Promise<T[]>;
+    list(keys?: Array<T[K]>): Promise<T[]>;
     /**
      * Distills a full entity into a lightweight summary for indexing operations.
      * Used to optimize memory usage when working with large collections.
@@ -1057,13 +1106,13 @@ interface CommandRegistry<S extends Record<string, any>, I extends Index = {}> {
 interface CommandCoordinator<T extends string> {
     /**
      * Dispatches a single command through the auth → middleware → reducer
-     * → state pipeline.
+     * pipeline and commits the resulting state patch.
      *
      * @param ctx     - The verified identity and permissions of the actor.
      * @param command - The command carrying intent and payload.
-     * @returns       - A Result indicating success or a structured failure.
+     * @returns       - A Result containing the computational return value or a SystemError.
      */
-    dispatch<C extends Command<any, any, any>>(ctx: AuthContext<T>, command: C): Promise<Result<void, SystemError>>;
+    dispatch<C extends Command<any, any, any>, R = any>(ctx: AuthContext<T>, command: C): Promise<Result<R, SystemError>>;
     /**
      * Executes a sequence of steps as an atomic saga.
      *
@@ -1112,7 +1161,10 @@ interface IRegistry<T> {
     clear(): void;
     /** Creates a deep clone of the registry. */
     clone(): IRegistry<T>;
+    /** Returns a record of entrys keyed by a string key */
     entries(): Record<string, T>;
+    /** Returns number of items in registry */
+    count(): number;
 }
 /** The read/write contract for a registry. */
 type IRegistryReader<T> = Pick<IRegistry<T>, "get" | "list" | "entries" | "has">;
@@ -1264,12 +1316,13 @@ declare class Registry<T> implements IRegistry<T> {
      * Creates a deep clone of the registry.
      * @returns A new Registry instance with deeply cloned items
      */
-    clone(): Registry<T>;
+    clone(): IRegistry<T>;
     /**
      * Returns all registry entries as a plain object.
      * @returns Object with all registry key-value pairs
      */
     entries(): Record<string, T>;
+    count(): number;
 }
 
 /**
@@ -1298,7 +1351,7 @@ declare class ExecutionEngine<T extends string, S extends Record<string, any>, I
     get authorizer(): Authorizer<T, S, I>;
     register<C extends Command<any, any, any>>(namespace: string, type: C["type"], reducer: Action<S, I, C>): Result<void, SystemError>;
     use(middleware: Middleware<S, I>): void;
-    dispatch<C extends Command<any, any, any>>(ctx: AuthContext<T>, command: C): Promise<Result<void, SystemError>>;
+    dispatch<C extends Command<any, any, any>, R = any>(ctx: AuthContext<T>, command: C): Promise<Result<R, SystemError>>;
     transact(ctx: AuthContext<T>, steps: TransactionStep[]): Promise<Result<void, SystemError>>;
     /**
      * Core dispatch pipeline: auth → middleware chain → reducer → state.
@@ -1348,7 +1401,7 @@ declare class ExecutionEngine<T extends string, S extends Record<string, any>, I
 declare class KernelCoordinator<T extends string, S extends Record<string, any>, I extends Index = {}> implements CommandCoordinator<T>, AuthorizationProvider<T, S, I> {
     private readonly engine;
     private readonly serializer;
-    constructor(engine: ExecutionEngine<T, S, I>, serializer: Serializer<Result<void, SystemError>>);
+    constructor(engine: ExecutionEngine<T, S, I>, serializer: Serializer<Result<any, SystemError>>);
     get authorizer(): Authorizer<T, S, I>;
     /**
      * Dispatches a single command through the serialized execution pipeline.
@@ -1359,7 +1412,7 @@ declare class KernelCoordinator<T extends string, S extends Record<string, any>,
      * @param ctx     - The verified identity and permissions of the actor.
      * @param command - The command carrying intent and payload.
      */
-    dispatch<C extends Command<any, any, any>>(ctx: AuthContext<T>, command: C): Promise<Result<void, SystemError>>;
+    dispatch<C extends Command<any, any, any>, R = any>(ctx: AuthContext<T>, command: C): Promise<Result<R, SystemError>>;
     /**
      * Executes a multi-step transaction through the serialized pipeline.
      *
@@ -1527,7 +1580,7 @@ declare function createAuthContext<ActorType extends string, Meta extends Metada
 /**
  * Pre-built auth contexts for common scenarios.
  */
-declare const SystemActor$1: {
+declare const SystemAuth: {
     /**
      * Create a system actor auth context with full permissions.
      * The system actor bypasses most authorization checks.
@@ -1557,6 +1610,140 @@ declare function createAnonymousContext(): AuthContext<"anonymous">;
  */
 declare function createUserContext(userId: UUID, scopes?: string[], metadata?: UUID): AuthContext<"user">;
 
+/**
+ * A ultra-compact, runtime-scoped tracking registry.
+ * Translates multi-segment semantic components or dynamic types
+ * into 1-token safe base36 structural short-hashes.
+ */
+declare class ShortKeyRegistry<T extends string = string> {
+    private readonly counters;
+    private readonly runtimeSalt;
+    constructor();
+    /**
+     * Generates a compact, non-colliding short token key.
+     * Compresses the target scope tracking increment into a deterministic signature.
+     */
+    next(scope: T): string;
+    /**
+     * Reset local execution indices for context window boundary updates.
+     */
+    clear(): void;
+}
+
+/**
+ * Utility class for common blob and binary data operations.
+ * Optimized for environments supporting Node.js, Browsers, and Edge runtimes.
+ */
+declare class BlobUtilities {
+    /**
+     * Computes the SHA-256 hash of a given Uint8Array.
+     * @param data The Uint8Array to hash.
+     * @returns A Promise that resolves to the SHA-256 hash as a hexadecimal string.
+     */
+    static computeSHA256(data: Uint8Array): Promise<string>;
+    /**
+     * Computes a CRC32 checksum of a given Uint8Array for fast data integrity verification.
+     * @param data The Uint8Array to checksum.
+     * @returns The CRC32 checksum as a hexadecimal string.
+     */
+    static computeCRC32(data: Uint8Array): string;
+    /**
+     * Converts a Uint8Array to a Base64 string.
+     * Uses native Buffer in Node.js/Deno, and falls back to a chunked btoa()
+     * implementation for Browsers and Edge environments to avoid stack overflows.
+     * @param buffer The Uint8Array to convert.
+     * @returns The Base64 encoded string.
+     */
+    static bufferToBase64(buffer: Uint8Array): string;
+    /**
+     * Converts a Base64 string back to a Uint8Array.
+     * @param base64 The Base64 encoded string.
+     * @returns The decoded Uint8Array.
+     */
+    static base64ToBuffer(base64: string): Uint8Array;
+    /**
+     * Generates a short, deterministic hash of a string.
+     * Returns a uniformly distributed, fixed-length base36 string.
+     * @param s The string to hash.
+     * @param length The desired length of base36 hash. Defaults to 4.
+     * @returns The short base36 hash string.
+     */
+    static shortHash(s: string, length?: number): string;
+    /**
+     * Converts a Blob to a Uint8Array.
+     * @param blob The Blob to convert.
+     * @returns A Promise that resolves to the Uint8Array.
+     */
+    static blobToUint8Array(blob: Blob): Promise<Uint8Array>;
+    /**
+     * Creates a Blob from a Uint8Array.
+     * @param data The Uint8Array to create the blob from.
+     * @param mimeType The MIME type of the blob (e.g., 'application/octet-stream').
+     * @returns The resulting Blob.
+     */
+    static uint8ArrayToBlob(data: Uint8Array, mimeType?: string): Blob;
+    /**
+     * Encodes a string into a Uint8Array using UTF-8.
+     * @param text The string to encode.
+     * @returns The encoded Uint8Array.
+     */
+    static textToUint8Array(text: string): Uint8Array;
+    /**
+     * Decodes a Uint8Array into a string using UTF-8.
+     * @param data The Uint8Array to decode.
+     * @returns The decoded string.
+     */
+    static uint8ArrayToText(data: Uint8Array): string;
+    /**
+     * Converts a Uint8Array to a URL-safe Base64 string.
+     * Replaces '+' with '-', '/' with '_', and removes trailing '=' padding.
+     * @param buffer The Uint8Array to convert.
+     * @returns The URL-safe Base64 encoded string.
+     */
+    static bufferToUrlSafeBase64(buffer: Uint8Array): string;
+    /**
+     * Converts a URL-safe Base64 string back to a Uint8Array.
+     * Restores padding and replaces characters back to standard Base64.
+     * @param base64 The URL-safe Base64 encoded string.
+     * @returns The decoded Uint8Array.
+     */
+    static urlSafeBase64ToBuffer(base64: string): Uint8Array;
+    /**
+     * Slices a Blob into chunks of a specified size.
+     * This is useful for uploading large files in parts or feeding data into LLM context windows.
+     * @param blob The Blob to slice.
+     * @param chunkSize The size of each chunk in bytes.
+     * @param options An optional configuration for the chunking process.
+     * @returns An async generator that yields Uint8Arrays of the binary data.
+     */
+    static chunkBlob(blob: Blob, chunkSize?: number): AsyncGenerator<Uint8Array>;
+    /**
+     * Wraps a Uint8Array with metadata providing business context for ERP systems.
+     * The metadata is stored as a JSON string at the start of the Blob, followed by the length of the length of the metadata length.
+     * @param buffer The binary data to wrap.
+     * @param metadata own a single object containing metadata keys/values.
+     * @returns A Uint8Array containing metadata and binary data.
+     */
+    static wrapBlobMetadata(buffer: Uint8Array, metadata: Record<string, any>): Uint8Array;
+    /**
+     * Unwraps a Uint8Array containing metadata wrapped by wrapBlobMetadata.
+     * @param wrappedBuffer own a Uint8Array containing metadata and metadata length.
+     * @returns An object containing the original binary data and the metadata object.
+     * @throws Error if the buffer is too small or contains invalid metadata length.
+     */
+    static unwrapBlobMetadata(wrappedBuffer: Uint8Array): {
+        data: Uint8Array;
+        metadata: Record<string, any>;
+    };
+}
+
+type DatabaseConfig = {
+    factory: StoreFactory;
+    database: string;
+    validate?: boolean;
+    predicates?: Record<string, any>;
+    schemas: Array<SchemaDefinition>;
+};
 /**
  * Robust implementation of WorkspaceDatabase using @asaidimu/database.
  * Manages the complete lifecycle of database connections and handles
@@ -1582,13 +1769,7 @@ declare class WorkspaceDatabase implements IWorkspaceDatabase {
      * @param config.validate - Whether to validate schema definitions
      * @param config.schemas - Core schemas to register (always loaded)
      */
-    constructor(config: {
-        factory: StoreFactory;
-        database: string;
-        validate?: boolean;
-        predicates?: Record<string, any>;
-        schemas: Array<SchemaDefinition>;
-    });
+    constructor(config: DatabaseConfig);
     /**
      * Opens the database connection and registers schemas.
      * Core schemas from config are always registered, followed by
@@ -1689,7 +1870,7 @@ declare abstract class BaseStore<T extends Metadata, K extends StoreKey<T>, S =
      *
      * @returns Array of entities (limited by this.limit)
      */
-    list(): Promise<T[]>;
+    list(keys?: Array<T[K]>): Promise<T[]>;
     /**
      * Converts a full entity into a lightweight summary for indexing.
      * Default implementation returns the full entity as the summary.
@@ -1824,7 +2005,7 @@ declare class ModuleAggregator<T extends string, S extends Record<string, any>,
 }
 
 type ContentCoreState = any;
-interface Blob extends Identifiable, Timestamped, Versioned {
+interface Blob$1 extends Identifiable, Timestamped, Versioned {
     readonly checksum: SHA256;
     readonly size: number;
     readonly mime: string;
@@ -1844,7 +2025,7 @@ interface Blob extends Identifiable, Timestamped, Versioned {
  * A lightweight reference to a blob.
  * Used in content blocks to avoid passing heavy metadata or binary data across boundaries.
  */
-type BlobRef = Pick<Blob, "id" | "checksum" | "mime" | "size">;
+type BlobRef = Pick<Blob$1, "id" | "checksum" | "mime" | "size">;
 type ResolvedBlob = {
     /** Indicates the blob data is available in the local memory space. */
     kind: "inline";
@@ -1982,191 +2163,201 @@ interface ContentDefinition<ContentType extends string, Data extends Record<stri
      * Used for displaying context in prompts, logs, or debugging.
      */
     format?: (block: Content<ContentType, Data>) => string | null;
-}
-
-/**
- * Hybrid BlobStore that coordinates between Anansi (metadata)
- * and BlobStorage (raw bytes).
- *
- * This implementation addresses the constraint that Anansi should
- * not store large binary payloads directly.
- */
-declare class BlobStore extends BaseStore<Blob, "id", Blob> {
-    private readonly storage;
-    constructor(collection: Collection<Blob>, storage: BlobStorage);
-    /**
-     * Overridden to hydrate the binary data from specialized storage.
-     */
-    get(id: UUID): Promise<Blob | null>;
-    /**
-     * Overridden to separate metadata and binary data during creation.
-     */
-    add(entity: Blob): Promise<void>;
-    /**
-     * Overridden to ensure bytes are purged when the record is deleted.
-     */
-    delete(id: UUID): Promise<boolean>;
-    /**
-     * Finds a blob by its content checksum.
-     */
-    findByChecksum(checksum: SHA256): Promise<Blob | null>;
-    /**
-     * Resolves a BlobRef to a ResolvedBlob (inline or remote) or null.
-     *
-     * Resolution precedence:
-     * 1. provider provided and remote mapping exists for that provider → remote blob
-     * 2. otherwise → local bytes
-     */
-    resolve(id: UUID, provider?: string): Promise<Result<ResolvedBlob | null, SystemError>>;
     /**
-     * Resolves multiple blobs concurrently.
+     * Scans a content block of this type for actionable side effects.
+     * Returns a list of Commands to be dispatched against the workspace.
      */
-    resolveMany(ids: UUID[], provider?: string): Promise<Result<Map<UUID, ResolvedBlob>, SystemError>>;
+    parse?: (block: Content<ContentType, Data>) => Command<any>[];
 }
 
 /**
- * Content Module Commands
+ * Data shape for preference (instructional) content.
  */
-type AddContentCommand = Command<"content:add", Content<any, any>>;
-type UpdateContentCommand = Command<"content:update", {
-    id: UUID;
-    updates: Partial<Content<any, any>>;
-}>;
-type DeleteContentCommand = Command<"content:delete", {
-    id: UUID;
-}>;
-/**
- * Blob Management Commands (Durable Registry)
- */
-/** Registers a new blob in the system. */
-type RegisterBlobCommand = Command<"blob:register", {
-    id: UUID;
+interface PreferenceData {
+    instruction: string;
+}
+interface BlobData {
+    id: string;
     checksum: SHA256;
     size: number;
     mime: string;
-    data: Uint8Array;
     filename?: string;
-    metadata?: Record<string, any>;
-}>;
-/** Increments the reference count of a blob to prevent garbage collection. */
-type RetainBlobCommand = Command<"blob:retain", {
-    id: UUID;
-}>;
-/** Decrements the reference count of a blob. */
-type ReleaseBlobCommand = Command<"blob:release", {
-    id: UUID;
-}>;
-/** Immediately removes a blob and its binary data. */
-type PurgeBlobCommand = Command<"blob:purge", {
-    id: UUID;
-}>;
-/** Records a mapping between a local blob and an external provider's ID. */
-type RecordBlobRemoteIdCommand = Command<"blob:record_remote_id", {
-    id: UUID;
-    providerId: string;
-    fileId: string;
-    timestamp?: Timestamp;
-}>;
-/**
- * Union of all Content and Blob commands.
- */
-type ContentCommand = AddContentCommand | UpdateContentCommand | DeleteContentCommand | RegisterBlobCommand | RetainBlobCommand | ReleaseBlobCommand | PurgeBlobCommand | RecordBlobRemoteIdCommand;
+}
+interface ToolResultData {
+    /** Name of the tool that produced this result */
+    name: string;
+    /** The output returned by the tool (any JSON-serializable value) */
+    result: unknown;
+    /** Identifier that links this result to the original tool-call */
+    key: string;
+    /** Optional error message if the tool execution failed */
+    error?: string;
+}
+type PreferenceContent = Content<"preference", PreferenceData>;
+type ToolResultContent = Content<"tool:result", ToolResultData>;
 
 /**
- * Durable storage for Content entities.
+ * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
  */
-declare class ContentStore extends BaseStore<Content<any>, "id", ContentSummary<any>> {
-    constructor(collection: Collection<Content<any>>);
+interface ModelStatus {
+    /** Provider name (e.g., "google", "anthropic", "openai"). */
+    provider: string;
+    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
+    model: string;
+    /** Whether the adapter is currently able to accept requests. */
+    ready: boolean;
+    /** Token window limits and current usage. */
+    window: {
+        /** Total context window size in tokens. */
+        size: number;
+        /** Maximum output tokens for this model. */
+        out: number;
+        /** Tokens remaining - estimated or as reported by the provider. */
+        free?: number;
+    };
+    /** Capability flags for this model. */
+    feature: {
+        /** Whether the model can process image inputs. */
+        vision: boolean;
+        /** Whether the model supports tool/function calling. */
+        tools: boolean;
+        /** Whether the model supports structured JSON output mode. */
+        json: boolean;
+        /** Whether the provider supports prompt caching. */
+        cache: boolean;
+        /** Whether the adapter supports streaming. */
+        streaming: boolean;
+        /** Whether the model supports extended thinking/reasoning tokens. */
+        thinking: boolean;
+    };
+    /** Pricing tiers for this model. */
+    pricing: Array<{
+        unit: "token" | "call" | "image";
+        /** Exponent: price is per 10^scale units. */
+        scale: number;
+        /** Price per unit in USD. */
+        cost: {
+            input: number;
+            output: number;
+            cache?: {
+                read: number;
+                write: number;
+            };
+        };
+    }>;
+    /** Current rate limit state. */
+    rate: {
+        /** Current saturation as a fraction of the most constrained limit (0.0 to 1.0). */
+        load: number;
+        /** Milliseconds until the next request is permitted. */
+        timeout?: number;
+        /** The hard limits enforced by the provider. */
+        capacity: Array<{
+            unit: "token" | "call" | string;
+            /** Maximum units allowed per period. */
+            max: number;
+            /** Period length in seconds. */
+            period: number;
+        }>;
+    };
+    /** Adapter-level notes, e.g. model deprecation warnings. */
+    notes?: string[];
+}
+interface ModelProfile {
+    /** Provider identifier, e.g. "google". */
+    provider: string;
+    /** Canonical model string as accepted by the API, e.g. "gemini-2.0-flash". */
+    name: string;
+    /** Display friendly name for the model, e.g "Gemini-2-flash" */
+    label: string;
+    /** Context window and output limits. */
+    window: ModelStatus["window"];
+    /** Capability flags. */
+    feature: ModelStatus["feature"];
+    /** Pricing tiers. */
+    pricing: ModelStatus["pricing"];
     /**
-     * Distills a full Content entity into a lightweight summary for indexing.
+     * Hard rate limit capacity as enforced by the provider.
+     * Does not include runtime state (load, timeout).
      */
-    summarize(entity: Content<any>): ContentSummary<any>;
+    capacity: ModelStatus["rate"]["capacity"];
+}
+/** Unique string identifier for a model (e.g., 'gemini-2.0-flash'). */
+type ModelName = string;
+/** Execution constraints applied to a specific model. */
+interface ModelConstraint {
+    /** Sampling temperature. 0.0 = deterministic, higher = more creative. */
+    temperature?: number;
+    /** Limits and stop boundaries for token generation. */
+    tokens: {
+        /** Maximum output tokens for this request. Overrides adapter defaults. */
+        max?: number;
+        /** Stop sequences — generation halts immediately when any of these are produced. */
+        stops?: string[];
+        /** Thinking/reasoning budget in tokens. (For supported models only). */
+        thought?: number;
+    };
+}
+/** Map of model names to their explicit, active constraints. */
+type ModelConstraints = Record<ModelName, ModelConstraint>;
+/** A system persona containing specific instructions and associated preferences. */
+interface Role extends Timestamped, Versioned {
+    /** Unique identifier name used system-wide (e.g. "software-architect"). */
+    name: string;
+    /** Human-readable display label shown in the UI. */
+    label: string;
+    /** Optional human-readable description of what this persona is intended for. */
+    description?: string;
+    /** The core instructions (system prompt base) establishing this persona's behavior. */
+    persona: string;
+    /** Array of Preference UUIDs explicitly bound to this role. */
+    preferences: UUID[];
+    /** Array of semantic Topics associated with this role to guide RAG retrieval. */
+    topics: string[];
+    /** Model constraints natively attached at the role level. */
+    constraints?: ModelConstraints;
 }
-
 /**
- * The ContentModule manages all durable content and binary assets.
+ * Summary of a Role for indexing.
  */
-declare class ContentModule implements Module<"user" | "system", ContentCoreState, ContentIndex, ContentCommand, {
-    content: ContentStore;
-    blobs: BlobStore;
-}> {
-    readonly name = "content";
-    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
-    registries: Record<string, Registry<any>>;
-    private _contentStore?;
-    private _blobStore?;
-    private _blobStorage;
-    constructor({ blobStorage, logger, }: {
-        blobStorage: BlobStorage;
-        logger: Logger$1;
-    });
-    stores: (db: any) => Promise<{
-        content: ContentStore;
-        blobs: BlobStore;
-    }>;
-    actions: {
-        "content:add": (_: State<ContentCoreState, ContentIndex>, command: AddContentCommand) => Promise<{
-            index: {
-                content: {
-                    items: {
-                        [x: string]: ContentSummary<any>;
-                    };
-                    keys: {
-                        [x: string]: string;
-                    };
-                };
-            };
-        }>;
-        "content:update": (state: State<ContentCoreState, ContentIndex>, command: UpdateContentCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                content: {
-                    items: {
-                        [x: string]: ContentSummary<any>;
-                    };
-                    keys: {};
-                };
-            };
-        }>;
-        "content:delete": (state: State<ContentCoreState, ContentIndex>, command: DeleteContentCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                content: {
-                    items: {
-                        [x: string]: any;
-                    };
-                    keys: {
-                        [x: number]: any;
-                    };
-                };
-            };
-        }>;
-        "blob:register": (state: State<ContentCoreState, ContentIndex>, command: RegisterBlobCommand) => Promise<{
-            index: {
-                content: {
-                    blobs: any;
-                };
-            };
-        }>;
-        "blob:retain": (_state: State<ContentCoreState, ContentIndex>, command: RetainBlobCommand) => Promise<{}>;
-        "blob:release": (_state: State<ContentCoreState, ContentIndex>, command: ReleaseBlobCommand) => Promise<{}>;
-        "blob:purge": (state: State<ContentCoreState, ContentIndex>, command: PurgeBlobCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                content: {
-                    blobs: any;
-                };
-            };
-        }>;
-        "blob:record_remote_id": (_state: State<ContentCoreState, ContentIndex>, command: RecordBlobRemoteIdCommand) => Promise<{}>;
+interface RoleSummary {
+    readonly name: string;
+    readonly label: string;
+    readonly description?: string;
+    readonly preferences: number;
+    readonly topics: readonly string[];
+    readonly constraints?: ModelConstraints;
+}
+/**
+ * Agent Index (Read Model projection)
+ */
+interface AgentIndex extends Index {
+    readonly roles: Record<string, RoleSummary>;
+}
+/**
+ * A tool that can be called by an agent.
+ * Descriptions and parameter structures serve both human engineers (for debugging/registry)
+ * and LLMs (for precise function execution routing).
+ */
+interface ToolDefinition<Name extends string = string, Params extends Record<string, any> = any> {
+    /** The unique name of the tool. Used in the model response to identify which tool to call. */
+    name: Name;
+    /** Human-readable description explaining what the tool does, its side effects, and when to use it. */
+    description: string;
+    /** JSON Schema fragment defining the tool's parameters. */
+    parameters?: Record<string, unknown>;
+    /** * Explicit execution arguments showcasing expected input profiles.
+     * Directly utilized to ground structured model inferences and guide developers.
+     */
+    example: {
+        input?: Params;
+        explanation: string;
     };
     /**
-     * Rebuilds the ContentIndex from durable storage.
+     * The actual implementation function.
+     * This is executed by the system when the model requests this tool.
      */
-    index(_: State<ContentCoreState, ContentIndex>): Promise<DeepPartial<ContentIndex>>;
+    execute: (params: Params) => Promise<any>;
 }
 
 /**
@@ -2237,22 +2428,22 @@ type TurnKey = Pick<Turn, "version" | "id" | "session">;
  */
 interface Turn extends Identifiable, Versioned, Timestamped {
     /** The UUID of the chat session this turn belongs to. */
-    readonly session: UUID;
+    session: UUID;
     /** The entity (user, model, system) that produced this turn's content. */
-    readonly actor: SystemActor;
+    actor: SystemActor;
     /** An ordered array of content blocks comprising the payload of this turn. */
-    readonly blocks: Content<any>[];
+    blocks: Content<any>[];
     /** Name of the role (persona) active at the exact time this turn occurred. */
-    readonly role?: string;
+    role?: string;
     /** Name of the model that produced this turn. */
-    readonly model?: string;
+    model?: string;
     /** Link to the preceding turn in the conversation tree, defining the DAG graph. */
-    readonly parent?: {
+    parent?: {
         readonly id: UUID;
         readonly version: number;
     };
     /** Extensible key-value store for turn-specific metadata. */
-    readonly metadata?: Record<string, any>;
+    metadata?: Record<string, any>;
 }
 /** Reference to a specific iteration of a turn. */
 type TurnRef = Pick<Turn, "id" | "version">;
@@ -2276,6 +2467,8 @@ interface Session$1 extends Identifiable, Timestamped {
     label: string;
     /** The active Role (persona) name guiding this specific session. */
     role: string;
+    /** Name of the model being used for inference in this session. */
+    model: string;
     /** Semantic topics governing what context and tools are active for this session. */
     topics: string[];
     /** Array of UUIDs pointing to explicitly active preferences for this session. */
@@ -2303,6 +2496,7 @@ interface SessionSummary {
     readonly id: UUID;
     readonly label: string;
     readonly role: string;
+    readonly model: string;
     readonly topics: string[];
     readonly preferences: string[];
     readonly content: string[];
@@ -2316,73 +2510,7 @@ interface SessionSummary {
 }
 
 /**
- * Creates a new conversation session.
- */
-type CreateSessionCommand = Command<"session:create", Omit<Session$1, "created" | "updated">>;
-/**
- * Updates an existing session's metadata or state.
- * This covers role switches, topic updates, preference changes, and head pointers.
- */
-type UpdateSessionCommand = Command<"session:update", {
-    id: UUID;
-    updates: Partial<Session$1>;
-}>;
-/**
- * Creates a new session by forking an existing one at a specific point.
- */
-type ForkSessionCommand = Command<"session:fork", {
-    id: UUID;
-    newId: UUID;
-    label: string;
-    role?: string;
-    topics?: string[];
-}>;
-/**
- * Deletes an entire conversation session and its history.
- */
-type DeleteSessionCommand = Command<"session:delete", {
-    id: UUID;
-}>;
-/**
- * Appends a new turn to a session.
- */
-type AddTurnCommand = Command<"turn:add", Omit<Turn, "created" | "updated">>;
-/**
- * Updates an existing turn record (e.g., correcting content in place).
- */
-type UpdateTurnCommand = Command<"turn:update", Omit<Turn, "created" | "updated">>;
-/**
- * Creates a new version of an existing turn (e.g., when the user edits their message).
- */
-type EditTurnCommand = Command<"turn:edit", {
-    id: UUID;
-    session: UUID;
-    version: number;
-    content: Content<any>[];
-    role?: string;
-    model?: string;
-}>;
-/**
- * Creates a new branch in the conversation history from a specific turn.
- */
-type BranchTurnCommand = Command<"turn:branch", Turn>;
-/**
- * Removes a specific version of a turn.
- */
-type DeleteTurnCommand = Command<"turn:delete", {
-    session: UUID;
-    id: UUID;
-    version: number;
-    /** The fallback position if deleting the current head. */
-    newHead?: TurnRef;
-}>;
-/**
- * Union of all Session and Turn commands.
- */
-type SessionCommand = CreateSessionCommand | UpdateSessionCommand | ForkSessionCommand | DeleteSessionCommand | AddTurnCommand | UpdateTurnCommand | EditTurnCommand | BranchTurnCommand | DeleteTurnCommand;
-
-/**
- * Durable storage for Session metadata.
+ * Durable storage for Session metadata.
  */
 declare class SessionStore extends BaseStore<Session$1, "id", SessionSummary> {
     constructor(collection: Collection<Session$1>);
@@ -2411,328 +2539,85 @@ declare class TurnStore extends BaseStore<Turn, "id"> {
     listBySession(sessionId: UUID): Promise<Turn[]>;
 }
 
+/** Complete snapshot of the session provided to the PromptBuilder. */
+interface SessionSnapshot {
+    /** Session identifier. */
+    id: UUID;
+    /** Top-level session definition fields. */
+    meta: SessionSummary;
+    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
+    model: string;
+    /** The active role — persona, instructions, role-level constraints. */
+    role: Role;
+    /** Unfiltered, unranked preferences attached strictly to the role or session. */
+    preferences: Content<any>[];
+    /** All context entries whose topics overlap with the session's active topics. */
+    content: Content<any>[];
+    /** Full active chain from TurnTree — oldest to newest. Untruncated. */
+    transcript: Turn[];
+    /** The session's active semantic topic set. */
+    topics: string[];
+    /** Global workspace instructions from Settings.prompt, if set. */
+    instructions?: string;
+    /** Model constraints structured by their hierarchical application level. */
+    constraints: {
+        /** Broadest constraints explicitly linked to the active role. */
+        role?: ModelConstraints;
+        /** Overriding constraints attached to the active session. */
+        session?: ModelConstraints;
+        /** The most explicit constraints captured at the last user turn. */
+        turn?: ModelConstraints;
+    };
+}
+/** UI helper for navigating between different versions of a turn (e.g. "2 of 5"). */
+interface BranchInfo {
+    /** Array of all available version numbers for a turn. */
+    versions: number[];
+    /** The array index currently being viewed. */
+    currentIndex: number;
+    /** The total count of available versions. */
+    total: number;
+    /** Indicates if an older version exists to navigate back to. */
+    hasPrev: boolean;
+    /** Indicates if a newer version exists to navigate forward to. */
+    hasNext: boolean;
+}
+
 /**
- * The SessionModule manages conversation sessions and their turn history.
+ * Durable storage for Content entities.
  */
-declare class SessionModule implements Module<"user" | "system", Record<string, any>, SessionIndex, SessionCommand, {
-    sessions: SessionStore;
-    turns: TurnStore;
-}> {
-    readonly name = "sessions";
-    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
-    private _sessionStore?;
-    private _turnStore?;
-    stores: (db: any) => Promise<{
-        sessions: SessionStore;
-        turns: TurnStore;
-    }>;
-    actions: {
-        "session:create": (_: State<any, SessionIndex>, command: CreateSessionCommand) => Promise<{
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "session:update": (state: State<any, SessionIndex>, command: UpdateSessionCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "session:fork": (state: State<any, SessionIndex>, command: ForkSessionCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "session:delete": (state: State<any, SessionIndex>, command: DeleteSessionCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: any;
-                };
-            };
-        }>;
-        "turn:add": (state: State<any, SessionIndex>, command: AddTurnCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "turn:update": (state: State<any, SessionIndex>, command: UpdateTurnCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "turn:edit": (state: State<any, SessionIndex>, command: EditTurnCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: any;
-                };
-            };
-        }>;
-        "turn:branch": (state: State<any, SessionIndex>, command: BranchTurnCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-        "turn:delete": (state: State<any, SessionIndex>, command: DeleteTurnCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                sessions: {
-                    [x: string]: SessionSummary;
-                };
-            };
-        }>;
-    };
+declare class ContentStore extends BaseStore<Content<any>, "id", ContentSummary<any>> {
+    constructor(collection: Collection<Content<any>>);
     /**
-     * Rebuilds the SessionIndex from durable storage.
+     * Distills a full Content entity into a lightweight summary for indexing.
      */
-    index(_: State<any, SessionIndex>): Promise<DeepPartial<SessionIndex>>;
+    summarize(entity: Content<any>): ContentSummary<any>;
 }
 
 /**
- * Configuration parameters for creating a new Workspace.
+ * Discriminated union for snapshot targets, replacing the ambiguous
+ * `UUID | Turn` overload. UUID and Turn both have string shapes that
+ * make a runtime `typeof` guard unsound.
  */
-interface CreateWorkspaceParams<T extends string, S extends Record<string, any>, I extends Index> {
-    /** The reactive state manager for the Materialized Index. */
-    state: StateManager<State<S, I>>;
-    /** The durable database connection. */
-    database: IWorkspaceDatabase;
-    /** Binary storage provider for content and assets. */
-    storage: BlobStorage;
-    /** Authorization logic for validating command execution. */
-    authorizer: Authorizer<T, S, I>;
-    /** Optional domain-specific modules to extend workspace functionality. */
-    extensions?: Module<T, S, I, any, any, any>[];
-    /** Optional logger instance for system-wide observability. */
-    logger?: Logger$1;
-}
+type SnapshotTarget = {
+    kind: "turn-id";
+    id: UUID;
+} | {
+    kind: "turn";
+    turn: Turn;
+};
 /**
- * createWorkspace is the primary factory for the new architecture.
- *
- * It instantiates the "Base Workspace" by pre-wiring core modules
- * (Content, Session, Workspace) and allowing users to pass their own
- * extension modules.
+ * Wraps each effect dispatch outcome so callers can inspect per-effect
+ * failures without the sequence being aborted by a throw.
  */
-declare function createWorkspace<T extends string, S extends Record<string, any>, I extends Index>(params: CreateWorkspaceParams<T, S, I>): Promise<{
-    /** The core coordination engine. Entry point for mutations. */
-    kernel: Kernel<T, S, I>;
-    /** Map of all module-instantiated stores for downstream manager setup. */
-    stores: Record<string, Store<any, any, any>>;
-    /** The aggregated registry and indexing engine. */
-    aggregator: ModuleAggregator<string, S, I>;
-}>;
-
+type EffectResult = {
+    effect: Command<any>;
+    result: Result<any, any>;
+};
 /**
- * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
- */
-interface ModelStatus {
-    /** Provider name (e.g., "google", "anthropic", "openai"). */
-    provider: string;
-    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
-    model: string;
-    /** Whether the adapter is currently able to accept requests. */
-    ready: boolean;
-    /** Token window limits and current usage. */
-    window: {
-        /** Total context window size in tokens. */
-        size: number;
-        /** Maximum output tokens for this model. */
-        out: number;
-        /** Tokens remaining - estimated or as reported by the provider. */
-        free?: number;
-    };
-    /** Capability flags for this model. */
-    feature: {
-        /** Whether the model can process image inputs. */
-        vision: boolean;
-        /** Whether the model supports tool/function calling. */
-        tools: boolean;
-        /** Whether the model supports structured JSON output mode. */
-        json: boolean;
-        /** Whether the provider supports prompt caching. */
-        cache: boolean;
-        /** Whether the adapter supports streaming. */
-        streaming: boolean;
-        /** Whether the model supports extended thinking/reasoning tokens. */
-        thinking: boolean;
-    };
-    /** Pricing tiers for this model. */
-    pricing: Array<{
-        unit: "token" | "call" | "image";
-        /** Exponent: price is per 10^scale units. */
-        scale: number;
-        /** Price per unit in USD. */
-        cost: {
-            input: number;
-            output: number;
-            cache?: {
-                read: number;
-                write: number;
-            };
-        };
-    }>;
-    /** Current rate limit state. */
-    rate: {
-        /** Current saturation as a fraction of the most constrained limit (0.0 to 1.0). */
-        load: number;
-        /** Milliseconds until the next request is permitted. */
-        timeout?: number;
-        /** The hard limits enforced by the provider. */
-        capacity: Array<{
-            unit: "token" | "call" | string;
-            /** Maximum units allowed per period. */
-            max: number;
-            /** Period length in seconds. */
-            period: number;
-        }>;
-    };
-    /** Adapter-level notes, e.g. model deprecation warnings. */
-    notes?: string[];
-}
-interface ModelProfile {
-    /** Provider identifier, e.g. "google". */
-    provider: string;
-    /** Canonical model string as accepted by the API, e.g. "gemini-2.0-flash". */
-    name: string;
-    /** Display friendly name for the model, e.g "Gemini-2-flash" */
-    label: string;
-    /** Context window and output limits. */
-    window: ModelStatus["window"];
-    /** Capability flags. */
-    feature: ModelStatus["feature"];
-    /** Pricing tiers. */
-    pricing: ModelStatus["pricing"];
-    /**
-     * Hard rate limit capacity as enforced by the provider.
-     * Does not include runtime state (load, timeout).
-     */
-    capacity: ModelStatus["rate"]["capacity"];
-}
-/** Unique string identifier for a model (e.g., 'gemini-2.0-flash'). */
-type ModelName = string;
-/** Execution constraints applied to a specific model. */
-interface ModelConstraint {
-    /** Sampling temperature. 0.0 = deterministic, higher = more creative. */
-    temperature?: number;
-    /** Limits and stop boundaries for token generation. */
-    tokens: {
-        /** Maximum output tokens for this request. Overrides adapter defaults. */
-        max?: number;
-        /** Stop sequences — generation halts immediately when any of these are produced. */
-        stops?: string[];
-        /** Thinking/reasoning budget in tokens. (For supported models only). */
-        thought?: number;
-    };
-}
-/** Map of model names to their explicit, active constraints. */
-type ModelConstraints = Record<ModelName, ModelConstraint>;
-/** A system persona containing specific instructions and associated preferences. */
-interface Role extends Timestamped, Versioned {
-    /** Unique identifier name used system-wide (e.g. "software-architect"). */
-    name: string;
-    /** Human-readable display label shown in the UI. */
-    label: string;
-    /** Optional human-readable description of what this persona is intended for. */
-    description?: string;
-    /** The core instructions (system prompt base) establishing this persona's behavior. */
-    persona: string;
-    /** Array of Preference UUIDs explicitly bound to this role. */
-    preferences: UUID[];
-    /** Array of semantic Topics associated with this role to guide RAG retrieval. */
-    topics: string[];
-    /** Model constraints natively attached at the role level. */
-    constraints?: ModelConstraints;
-}
-/**
- * Summary of a Role for indexing.
- */
-interface RoleSummary {
-    readonly name: string;
-    readonly label: string;
-    readonly description?: string;
-    readonly preferences: number;
-    readonly topics: readonly string[];
-    readonly constraints?: ModelConstraints;
-}
-/**
- * Agent Index (Read Model projection)
- */
-interface AgentIndex extends Index {
-    readonly roles: Record<string, RoleSummary>;
-}
-
-/** Complete snapshot of the session provided to the PromptBuilder. */
-interface SessionSnapshot {
-    /** Session identifier. */
-    id: UUID;
-    /** Top-level session definition fields. */
-    meta: SessionSummary;
-    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
-    model?: string;
-    /** The active role — persona, instructions, role-level constraints. */
-    role: Role;
-    /** Unfiltered, unranked preferences attached strictly to the role or session. */
-    preferences: Content<any>[];
-    /** All context entries whose topics overlap with the session's active topics. */
-    content: Content<any>[];
-    /** Full active chain from TurnTree — oldest to newest. Untruncated. */
-    transcript: Turn[];
-    /** The session's active semantic topic set. */
-    topics: string[];
-    /** Global workspace instructions from Settings.prompt, if set. */
-    instructions?: string;
-    /** Model constraints structured by their hierarchical application level. */
-    constraints: {
-        /** Broadest constraints explicitly linked to the active role. */
-        role?: ModelConstraints;
-        /** Overriding constraints attached to the active session. */
-        session?: ModelConstraints;
-        /** The most explicit constraints captured at the last user turn. */
-        turn?: ModelConstraints;
-    };
-}
-/** UI helper for navigating between different versions of a turn (e.g. "2 of 5"). */
-interface BranchInfo {
-    /** Array of all available version numbers for a turn. */
-    versions: number[];
-    /** The array index currently being viewed. */
-    currentIndex: number;
-    /** The total count of available versions. */
-    total: number;
-    /** Indicates if an older version exists to navigate back to. */
-    hasPrev: boolean;
-    /** Indicates if a newer version exists to navigate forward to. */
-    hasNext: boolean;
-}
-
-/**
- * Session is a session‑scoped coordinator. It holds no in‑memory state
- * of its own beyond the TurnTree. All entity state is read from the
- * kernel index on every call to guarantee freshness.
+ * Session is a session‑scoped coordinator. It holds no in‑memory state
+ * of its own beyond the TurnTree. All entity state is read from the
+ * kernel index on every call to guarantee freshness.
  */
 declare class Session {
     readonly id: UUID;
@@ -2741,9 +2626,12 @@ declare class Session {
     private tree;
     private turnRepository;
     private context;
+    private assistantContext;
+    private _closed;
     constructor(userId: UUID, id: UUID, kernel: IKernel<any, any, any>, stores: {
         sessions: SessionStore;
         turns: TurnStore;
+        content: ContentStore;
     });
     /**
      * Factory method to create a new Session instance.
@@ -2751,27 +2639,38 @@ declare class Session {
     static create(userId: UUID, sessionId: UUID, kernel: IKernel<any, any, any>, stores: {
         sessions: SessionStore;
         turns: TurnStore;
+        content: ContentStore;
     }): Promise<Session>;
     /**
      * Synchronises the session's in‑memory state with the persistent stores.
      */
     sync(): Promise<void>;
     /**
-     * Closes the session and cleans up subscriptions.
+     * Closes the session and marks it inactive.
+     * Extend this method when subscriptions or external resources are added.
      */
     close(): void;
+    /** Whether the session has been closed. */
+    get isClosed(): boolean;
     /** Returns the session's unique identifier. */
     sessionId(): UUID;
     /** Returns the session metadata from the kernel index. */
-    meta(): SessionSummary | undefined;
+    index(): SessionSummary | undefined;
     /** Returns the session's label. */
     label(): string | undefined;
     /** Returns the current role. */
-    role(): Promise<Role | undefined>;
+    role(): Role | undefined;
     /** Returns the list of topics. */
     topics(): string[];
-    /** Returns the list of active preferences. */
-    preferences(): Promise<Content<"preference", any>[]>;
+    /**
+     * Returns the list of active preferences.
+     *
+     * Resolves each ref from the session index against the content key map
+     * before falling back to treating it as a direct ID. Refs that resolve
+     * to a non-preference type are silently skipped (they were never valid
+     * preferences for this session).
+     */
+    preferences(): Promise<PreferenceContent[]>;
     /** Returns the current head (last turn) or null if empty. */
     head(): TurnRef | null;
     /** Returns the active chain of turns as an array of TurnNode. */
@@ -2782,10 +2681,12 @@ declare class Session {
     branchInfo(turnId: UUID): BranchInfo;
     /** Retrieves a TurnNode by its ID. */
     turn(turnId: UUID): TurnNode | undefined;
-    /** Retrieves the full turn history. */
+    /** Retrieves the full turn history from the store. */
     transcript(): Promise<Turn[]>;
     /** Fetches the full Session entity. */
     data(): Promise<Session$1 | null>;
+    /** Returns the current model identifier. */
+    model(): string | undefined;
     /** Changes the session's display label. */
     rename(label: string): Promise<Result<void, any>>;
     /** Replaces the session's topic list. */
@@ -2800,18 +2701,24 @@ declare class Session {
     updateMetadata(metadata: Record<string, any>): Promise<Result<void, any>>;
     /** Replaces the session's preference list. */
     setPreferences(preferenceIds: UUID[]): Promise<Result<void, any>>;
-    /** Replaces the session's context list. */
-    private setContents;
     /** Adds context keys to the session. */
     linkContent(keys: string[] | string): Promise<Result<void, any>>;
     /** Removes context keys from the session. */
     unlinkContent(keys: string | string[]): Promise<Result<void, any>>;
-    /** Adds a turn to the session. */
-    private addTurn;
     /** Records a user turn. */
     recordUserTurn(turn: Turn): Promise<Result<void, any>>;
-    /** Records an assistant turn, processing tool calls. */
-    recordAssistantTurn(context: AuthContext<SystemActor>, turn: Turn): Promise<Result<void, any>>;
+    /** Records a system turn. */
+    recordSystemTurn(turn: Turn): Promise<Result<void, any>>;
+    /** Records an assistant turn. */
+    recordAssistantTurn(turn: Turn): Promise<Result<void, any>>;
+    /**
+     * Runs all assistant effect commands, dispatching each independently.
+     *
+     * Uses `Promise.allSettled` so a failure in one effect does not prevent
+     * subsequent effects from running. Each outcome is returned alongside its
+     * originating command so callers can inspect per-effect failures.
+     */
+    runAssistantEffects(effects: Array<Command<any>>): Promise<EffectResult[]>;
     /** Edits an existing turn, creating a new version. */
     editTurn(turnId: UUID, newBlocks: Content<any>[], role?: string, model?: string): Promise<Result<void, any>>;
     /** Adds a branch turn. */
@@ -2828,10 +2735,38 @@ declare class Session {
     switchVersionRight(turnId: UUID): Promise<Result<void, any>>;
     /**
      * Assembles a SessionSnapshot for prompt building.
+     *
+     * Returns a typed `Result` rather than `undefined` so callers can
+     * distinguish between a missing session and a missing role — both of
+     * which were previously silent `undefined` returns.
+     *
+     * @param target - Optional discriminated target to build the snapshot
+     *   against. Omit to use the current head of the active chain.
+     */
+    snapshot(target?: SnapshotTarget): Promise<Result<SessionSnapshot, SystemError>>;
+    /**
+     * Throws if the session has been closed, giving mutations a consistent
+     * early-exit rather than propagating odd errors from the coordinator.
+     */
+    private assertActive;
+    /**
+     * Thin wrapper around `kernel.coordinator.dispatch` that stamps
+     * the current timestamp, keeping call sites free of the boilerplate.
      */
-    snapshot(target?: UUID | Turn): Promise<SessionSnapshot | undefined>;
+    private dispatch;
+    /** Adds a turn to the session under the given auth context. */
+    private addTurn;
     private refreshTurnTree;
+    /**
+     * Loads content items from the kernel index by the IDs stored in the
+     * session summary. Stale references — IDs present in the session but
+     * absent from the index — are logged as warnings rather than silently
+     * dropped, since missing context items can degrade model output without
+     * any visible signal.
+     */
     private loadContent;
+    /** Replaces the session's content key list. */
+    private setContents;
     private switchVersion;
     private findSubtreeTip;
 }
@@ -2848,6 +2783,7 @@ declare class SessionManager {
     constructor(kernel: IKernel<any, any, any>, stores: {
         sessions: SessionStore;
         turns: TurnStore;
+        content: ContentStore;
     });
     /**
      * Opens a session by ID. Deduplicates concurrent open requests.
@@ -2871,6 +2807,7 @@ declare class SessionManager {
     create(user: string, params: {
         label: string;
         role: string;
+        model: string;
         topics?: string[];
         preferences?: UUID[];
         metadata?: Record<string, any>;
@@ -2886,74 +2823,484 @@ declare class SessionManager {
 }
 
 /**
- * A fluent builder for creating Turn objects in the new architecture.
+ * Agent Module Commands
  */
-declare class TurnBuilder {
-    private _turn;
-    constructor(actor: SystemActor, session: UUID, initialTurn?: Turn);
-    private createBlock;
-    addText(text: string, options?: {
-        key?: string;
-        label?: string;
-        topics?: string[];
-    }): TurnBuilder;
-    addToolUse(name: string, input: Record<string, unknown>, options?: {
-        key?: string;
-    }): TurnBuilder;
-    addToolResult(useId: UUID, content: string | Record<string, unknown>, isError?: boolean, options?: {
-        key?: string;
-    }): TurnBuilder;
-    addThinking(thinking: string, options?: {
-        key?: string;
-    }): TurnBuilder;
-    addBlock(block: Content<any, any>): TurnBuilder;
-    deleteBlock(blockId: UUID): TurnBuilder;
-    withId(id: UUID): TurnBuilder;
-    withVersion(version: number): TurnBuilder;
-    withTimestamp(timestamp: Timestamp): TurnBuilder;
-    withParent(parent: TurnRef): TurnBuilder;
-    withRole(role: string): TurnBuilder;
-    withModel(model: string): TurnBuilder;
-    withMetadata(metadata: Record<string, any>): TurnBuilder;
-    build(): Turn;
+/** Adds a new role to the system. */
+type AddRoleCommand = Command<"role:add", Role>;
+/** Updates an existing role. */
+type UpdateRoleCommand = Command<"role:update", {
+    name: string;
+    updates: Partial<Omit<Role, "name">>;
+}>;
+/** Deletes a role from the system. */
+type DeleteRoleCommand = Command<"role:delete", {
+    name: string;
+}>;
+/**
+ * Executes a specific tool.
+ * This is usually dispatched by the inference pipeline or a Saga
+ * after identifying a tool-call block.
+ */
+type ExecuteToolCommand = Command<"tool:execute", {
+    name: string;
+    parameters: Record<string, any>;
+    key: string;
+}>;
+/**
+ * Union of all Agent commands.
+ */
+type AgentCommand = AddRoleCommand | UpdateRoleCommand | DeleteRoleCommand | ExecuteToolCommand;
+
+/**
+ * Registry for managing ToolDefinitions.
+ * Enables the Kernel and Inference Pipeline to discover and execute tools.
+ */
+declare class ToolRegistry extends Registry<ToolDefinition<any>> {
     /**
-     * Builds a `TurnNode` from the current turn.
+     * Returns a token-optimized system-prompt section describing available tools
+     * using a neutral, standardized example tool block blueprint.
      */
-    node(): TurnNode;
+    description(): string;
+    /**
+     * Generates the strict structured array blocks for your response schema.
+     * This is where the aggregation happens effortlessly!
+     */
+    schema(): any[];
+    /**
+     * Returns a JSON Schema array of all tool definitions.
+     * Useful for providers that support native tool-calling (like OpenAI/Gemini).
+     */
+    schemas(): any[];
 }
 
-declare class TurnRepository {
-    private readonly turnStore;
-    private readonly sessionStore;
-    constructor(turnStore: TurnStore, sessionStore: SessionStore);
-    loadAllTurns(sessionId: UUID): Promise<Turn[]>;
-    loadHead(sessionId: UUID): Promise<TurnRef | null>;
+/**
+ * Durable storage for Role entities.
+ */
+declare class RoleStore extends BaseStore<Role, "name", RoleSummary> {
+    constructor(collection: Collection<Role>);
+    /**
+     * Distills a full Role entity into a lightweight summary for indexing.
+     */
+    summarize(role: Role): RoleSummary;
 }
 
-declare class TurnTree {
-    private readonly nodes;
-    private readonly _head;
-    private constructor();
-    static build(sessionId: UUID, repository: TurnRepository, headOverride?: TurnRef | null): Promise<TurnTree>;
-    head(): TurnRef | null;
-    chain(): TurnNode[];
+/**
+ * The AgentModule manages system personas (roles) and their constraints.
+ */
+declare class AgentModule implements Module<"user" | "system", Record<string, any>, AgentIndex, AgentCommand, {
+    roles: RoleStore;
+}> {
+    readonly name = "agent";
+    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
+    readonly registries: Record<string, ToolRegistry>;
+    private _roleStore?;
+    private readonly logger;
+    constructor(opts: {
+        logger: Logger$1;
+    });
+    stores: (db: any) => Promise<{
+        roles: RoleStore;
+    }>;
+    actions: {
+        "role:add": (_state: State<any, AgentIndex>, command: AddRoleCommand) => Promise<Result<{
+            index: {
+                roles: {
+                    [x: string]: RoleSummary | undefined;
+                };
+            };
+        }, never>>;
+        "role:update": (state: State<any, AgentIndex>, command: UpdateRoleCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "role:delete": (state: State<any, AgentIndex>, command: DeleteRoleCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "tool:execute": (_state: State<any, AgentIndex>, command: ExecuteToolCommand) => Promise<{
+            readonly ok: false;
+            readonly error: SystemError;
+        } | {
+            readonly ok: true;
+            readonly value: {
+                result: any;
+            };
+        }>;
+    };
     /**
-     * Returns a chronological chain of TurnNodes ending at the specified turn.
+     * Rebuilds the AgentIndex from durable storage.
      */
-    chainFrom(turnId: string): TurnNode[];
-    getTurnSiblings(turnId: string): TurnNode[];
-    branchInfo(turnId: UUID): BranchInfo;
-    graph(): Readonly<Record<UUID, TurnNode>>;
+    index(_: State<any, AgentIndex>): Promise<DeepPartial<AgentIndex>>;
+}
+
+/**
+ * Hybrid BlobStore that coordinates between Anansi (metadata)
+ * and BlobStorage (raw bytes).
+ *
+ * This implementation addresses the constraint that Anansi should
+ * not store large binary payloads directly.
+ */
+declare class BlobStore extends BaseStore<Blob$1, "id", Blob$1> {
+    private readonly storage;
+    constructor(collection: Collection<Blob$1>, storage: BlobStorage);
+    /**
+     * Overridden to hydrate the binary data from specialized storage.
+     */
+    get(id: UUID): Promise<Blob$1 | null>;
+    /**
+     * Overridden to separate metadata and binary data during creation.
+     */
+    add(entity: Blob$1): Promise<void>;
+    /**
+     * Overridden to ensure bytes are purged when the record is deleted.
+     */
+    delete(id: UUID): Promise<boolean>;
+    /**
+     * Finds a blob by its content checksum.
+     */
+    findByChecksum(checksum: SHA256): Promise<Blob$1 | null>;
+    /**
+     * Resolves a BlobRef to a ResolvedBlob (inline or remote) or null.
+     *
+     * Resolution precedence:
+     * 1. provider provided and remote mapping exists for that provider → remote blob
+     * 2. otherwise → local bytes
+     */
+    resolve(id: UUID, provider?: string): Promise<Result<ResolvedBlob | null, SystemError>>;
+    /**
+     * Resolves multiple blobs concurrently.
+     */
+    resolveMany(ids: UUID[], provider?: string): Promise<Result<Map<UUID, ResolvedBlob>, SystemError>>;
+}
+
+/**
+ * Content Module Commands
+ */
+type AddContentCommand = Command<"content:add", Content<any, any>>;
+type UpdateContentCommand = Command<"content:update", {
+    id: UUID;
+    updates: Partial<Content<any, any>>;
+}>;
+type DeleteContentCommand = Command<"content:delete", {
+    id: UUID;
+}>;
+/**
+ * Blob Management Commands (Durable Registry)
+ */
+/** Registers a new blob in the system. */
+type RegisterBlobCommand = Command<"blob:register", {
+    id: UUID;
+    checksum: SHA256;
+    size: number;
+    mime: string;
+    data: Uint8Array;
+    filename?: string;
+    metadata?: Record<string, any>;
+}>;
+/** Increments the reference count of a blob to prevent garbage collection. */
+type RetainBlobCommand = Command<"blob:retain", {
+    id: UUID;
+}>;
+/** Decrements the reference count of a blob. */
+type ReleaseBlobCommand = Command<"blob:release", {
+    id: UUID;
+}>;
+/** Immediately removes a blob and its binary data. */
+type PurgeBlobCommand = Command<"blob:purge", {
+    id: UUID;
+}>;
+/** Records a mapping between a local blob and an external provider's ID. */
+type RecordBlobRemoteIdCommand = Command<"blob:record_remote_id", {
+    id: UUID;
+    providerId: string;
+    fileId: string;
+    timestamp?: Timestamp;
+}>;
+/**
+ * Union of all Content and Blob commands.
+ */
+type ContentCommand = AddContentCommand | UpdateContentCommand | DeleteContentCommand | RegisterBlobCommand | RetainBlobCommand | ReleaseBlobCommand | PurgeBlobCommand | RecordBlobRemoteIdCommand;
+
+/**
+ * The ContentModule manages all durable content and binary assets.
+ */
+declare class ContentModule implements Module<"user" | "system", ContentCoreState, ContentIndex, ContentCommand, {
+    content: ContentStore;
+    blobs: BlobStore;
+}> {
+    readonly name = "content";
+    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
+    registries: Record<string, Registry<any>>;
+    private _contentStore?;
+    private _blobStore?;
+    private _blobStorage;
+    constructor({ blobStorage, logger, }: {
+        blobStorage: BlobStorage;
+        logger: Logger$1;
+    });
+    stores: (db: any) => Promise<{
+        content: ContentStore;
+        blobs: BlobStore;
+    }>;
+    actions: {
+        "content:add": (_: State<ContentCoreState, ContentIndex>, command: AddContentCommand) => Promise<Result<{
+            index: {
+                content: {
+                    items: {
+                        [x: string]: ContentSummary<any>;
+                    };
+                    keys: {
+                        [x: string]: string;
+                    };
+                };
+            };
+        }, never>>;
+        "content:update": (state: State<ContentCoreState, ContentIndex>, command: UpdateContentCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "content:delete": (state: State<ContentCoreState, ContentIndex>, command: DeleteContentCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "blob:register": (state: State<ContentCoreState, ContentIndex>, command: RegisterBlobCommand) => Promise<Result<{
+            index: {
+                content: {
+                    blobs: any;
+                };
+            };
+        }, never>>;
+        "blob:retain": (_state: State<ContentCoreState, ContentIndex>, command: RetainBlobCommand) => Promise<Result<{}, never>>;
+        "blob:release": (_state: State<ContentCoreState, ContentIndex>, command: ReleaseBlobCommand) => Promise<Result<{}, never>>;
+        "blob:purge": (state: State<ContentCoreState, ContentIndex>, command: PurgeBlobCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "blob:record_remote_id": (_state: State<ContentCoreState, ContentIndex>, command: RecordBlobRemoteIdCommand) => Promise<Result<{}, never>>;
+    };
+    /**
+     * Rebuilds the ContentIndex from durable storage.
+     */
+    index(_: State<ContentCoreState, ContentIndex>): Promise<DeepPartial<ContentIndex>>;
+}
+
+/**
+ * Creates a new conversation session.
+ */
+type CreateSessionCommand = Command<"session:create", Omit<Session$1, "created" | "updated">>;
+/**
+ * Updates an existing session's metadata or state.
+ * This covers role switches, topic updates, preference changes, and head pointers.
+ */
+type UpdateSessionCommand = Command<"session:update", {
+    id: UUID;
+    updates: Partial<Session$1>;
+}>;
+/**
+ * Creates a new session by forking an existing one at a specific point.
+ */
+type ForkSessionCommand = Command<"session:fork", {
+    id: UUID;
+    newId: UUID;
+    label: string;
+    role?: string;
+    topics?: string[];
+}>;
+/**
+ * Deletes an entire conversation session and its history.
+ */
+type DeleteSessionCommand = Command<"session:delete", {
+    id: UUID;
+}>;
+/**
+ * Appends a new turn to a session.
+ */
+type AddTurnCommand = Command<"turn:add", Omit<Turn, "created" | "updated">>;
+/**
+ * Updates an existing turn record (e.g., correcting content in place).
+ */
+type UpdateTurnCommand = Command<"turn:update", Omit<Turn, "created" | "updated">>;
+/**
+ * Creates a new version of an existing turn (e.g., when the user edits their message).
+ */
+type EditTurnCommand = Command<"turn:edit", {
+    id: UUID;
+    session: UUID;
+    version: number;
+    content: Content<any>[];
+    role?: string;
+    model?: string;
+}>;
+/**
+ * Creates a new branch in the conversation history from a specific turn.
+ */
+type BranchTurnCommand = Command<"turn:branch", Turn>;
+/**
+ * Removes a specific version of a turn.
+ */
+type DeleteTurnCommand = Command<"turn:delete", {
+    session: UUID;
+    id: UUID;
+    version: number;
+    /** The fallback position if deleting the current head. */
+    newHead?: TurnRef;
+}>;
+/**
+ * Union of all Session and Turn commands.
+ */
+type SessionCommand = CreateSessionCommand | UpdateSessionCommand | ForkSessionCommand | DeleteSessionCommand | AddTurnCommand | UpdateTurnCommand | EditTurnCommand | BranchTurnCommand | DeleteTurnCommand;
+
+/**
+ * The SessionModule manages conversation sessions and their turn history.
+ */
+declare class SessionModule implements Module<"user" | "system", Record<string, any>, SessionIndex, SessionCommand, {
+    sessions: SessionStore;
+    turns: TurnStore;
+}> {
+    readonly name = "sessions";
+    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
+    private _sessionStore?;
+    private _turnStore?;
+    stores: (db: any) => Promise<{
+        sessions: SessionStore;
+        turns: TurnStore;
+    }>;
+    actions: {
+        "session:create": (_: State<any, SessionIndex>, command: CreateSessionCommand) => Promise<Result<{
+            index: {
+                sessions: {
+                    [x: string]: SessionSummary;
+                };
+            };
+        }, never>>;
+        "session:update": (state: State<any, SessionIndex>, command: UpdateSessionCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "session:fork": (state: State<any, SessionIndex>, command: ForkSessionCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "session:delete": (state: State<any, SessionIndex>, command: DeleteSessionCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "turn:add": (state: State<any, SessionIndex>, command: AddTurnCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "turn:update": (state: State<any, SessionIndex>, command: UpdateTurnCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "turn:edit": (state: State<any, SessionIndex>, command: EditTurnCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "turn:branch": (state: State<any, SessionIndex>, command: BranchTurnCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+        "turn:delete": (state: State<any, SessionIndex>, command: DeleteTurnCommand) => Promise<{
+            readonly ok: false;
+            readonly error: never;
+        } | {
+            readonly ok: true;
+            readonly value: {};
+        }>;
+    };
+    /**
+     * Rebuilds the SessionIndex from durable storage.
+     */
+    index(_: State<any, SessionIndex>): Promise<DeepPartial<SessionIndex>>;
+}
+
+/**
+ * Configuration parameters for creating a new Workspace.
+ */
+interface CreateWorkspaceParams<T extends string, S extends Record<string, any>, I extends Index> {
+    /** The reactive state manager for the Materialized Index. */
+    state: StateManager<State<S, I>>;
+    /** The durable database connection. */
+    database: Omit<DatabaseConfig, "schemas">;
+    /** Binary storage provider for content and assets. */
+    storage: BlobStorage;
+    /** Authorization logic for validating command execution. */
+    authorizer: Authorizer<T, S, I>;
+    /** Optional domain-specific modules to extend workspace functionality. */
+    extensions?: Module<T, S, I, any, any, any>[];
+    /** Optional logger instance for system-wide observability. */
+    logger?: Logger$1;
 }
+/**
+ * createWorkspace is the primary factory for the new architecture.
+ *
+ * It instantiates the "Base Workspace" by pre-wiring core modules
+ * (Content, Session, Workspace) and allowing users to pass their own
+ * extension modules.
+ */
+declare function createWorkspace<T extends string, S extends Record<string, any>, I extends Index>(params: CreateWorkspaceParams<T, S, I>): Promise<{
+    /** The core coordination engine. Entry point for mutations. */
+    kernel: Kernel<T, S, I>;
+    /** Map of all module-instantiated stores for downstream manager setup. */
+    stores: Record<string, Store<any, any, any>>;
+    /** The aggregated registry and indexing engine. */
+    aggregator: ModuleAggregator<string, S, I>;
+}>;
 
+declare const ToolCallRegex: RegExp;
 /**
  * Registry for managing ContentDefinitions.
  * Enables the Kernel to delegate type-specific logic to registered handlers.
  */
 declare class ContentRegistry extends Registry<ContentDefinition<any>> {
+    private readonly shortKeys;
     constructor(opts: {
         logger: Logger$1;
+        empty?: boolean;
     });
+    /**
+     * Gets an item by its key.
+     * @param key - The key of the item to retrieve
+     * @returns The item if found, undefined otherwise
+     */
+    get(key: string): ContentDefinition<any> | undefined;
     /**
      * Returns the system-prompt section describing all emittable block types.
      */
@@ -2961,12 +3308,12 @@ declare class ContentRegistry extends Registry<ContentDefinition<any>> {
     /**
      * Returns a plain JSON Schema object scoped to emittable block definitions.
      */
-    schema(filter?: ContentFilter): Record<string, unknown>;
+    schema(filter?: ContentFilter, extra?: Record<string, unknown>[]): Record<string, unknown>;
     /**
-     * Returns the default mode for a registered content type.
-     * @param type - The content type string (e.g., "text", "thinking")
-     * @returns The ContentMode if the type is registered, undefined otherwise.
+     * Updates an existing item with new properties.
+     * Special handling for 'mappings' to ensure provider mappings are merged rather than overwritten.
      */
+    update(key: string, updates: Partial<ContentDefinition<any>>): Result$1<void, SystemError>;
     mode(type: string): ContentMode | undefined;
     /**
      * Converts a raw JSON object from a model response into a workspace content block.
@@ -2977,6 +3324,16 @@ declare class ContentRegistry extends Registry<ContentDefinition<any>> {
         type: string;
         [key: string]: any;
     }, providerId?: string): Content<any>;
+    /**
+     * Scans a list of content blocks for actionable side effects.
+     * Aggregates all commands from blocks whose definitions have a parse function.
+     */
+    process(blocks: Content<any>[]): Command<any>[];
+    /**
+     * Convert a content block of this type into a human‑readable string.
+     * Used for displaying context in prompts, logs, or debugging.
+     */
+    format(block: Content<any, any>): string | null;
     /**
      * Creates a fully compliant Content object from raw model output.
      * Assigns a new UUID, version 0, and current created/updated timestamps.
@@ -3040,6 +3397,13 @@ interface Prompt {
     role: Role;
     /** Model constraints to be merged by the adapter. */
     constraints: Record<string, ModelConstraint>;
+    /**
+     * Tool results for the most recent assistant turn that made tool calls.
+     * Keyed by callId, only includes results that are present in the transcript
+     * (i.e., the tool has already been executed).
+     * Empty object if the last assistant turn has no tool calls or no results yet.
+     */
+    results: Array<ToolResultContent>;
     /**
      * Non-fatal warnings generated during the build phase.
      */
@@ -3074,7 +3438,7 @@ interface AssemblerExtension extends PromptSection {
  * Provider-agnostic system prompt assembler.
  */
 interface SystemPromptAssembler {
-    readonly registry: ContentRegistry;
+    readonly content: ContentRegistry;
     build<P, C>(provider: string, prompt: Prompt, mapTurn: (args: {
         turn: Turn;
         parts: P[];
@@ -3082,11 +3446,8 @@ interface SystemPromptAssembler {
         system: string;
         transcript: C[];
         sections: PromptSection[];
+        schema: any;
     }>;
-    parse(provider: string, raw: Array<{
-        type: string;
-        [key: string]: any;
-    }>): Content<any>[];
     join(sections: PromptSection[]): string;
 }
 
@@ -3148,6 +3509,8 @@ interface InferenceContext {
         /** Tokens remaining in the context window after this prompt. */
         remaining?: number;
     };
+    /** the schema of the response structure */
+    schema: Record<string, any>;
     /**
      * Sends this prompt to the model.
      * @returns The parsed assistant Turn plus any execution side-effects.
@@ -3158,14 +3521,25 @@ interface InferenceContext {
         thought?: {
             tokens: number;
         };
-    }): Promise<Result<PromptResult, SystemError>>;
+    }): Promise<Result<InferenceResults, SystemError>>;
 }
 /**
- * The result of `PreparedPrompt.execute()`.
+ * The result of `InferenceContext.execute()`.
  */
-interface PromptResult {
+interface InferenceResults {
+    /** The assistant turn, fully parsed into content blocks. */
     turn: Turn;
-    effects: any[];
+    /**
+     * Discrete side effects (Commands) derived from the turn.
+     * e.g. [AddTopicCommand, UpdateRoleCommand, RunToolCommand]
+     */
+    effects: Command<any>[];
+    /**
+     * Indicates the status of this inference step.
+     * 'final': The model has provided a concluding response.
+     * 'action': The model has requested actions (tools) that require execution.
+     */
+    status?: "final" | "action";
 }
 /**
  * Bridge between a Prompt and a specific LLM provider's SDK.
@@ -3272,10 +3646,11 @@ interface Logger {
     info?: (message: string, ...args: unknown[]) => void;
 }
 declare class PromptAssembler implements SystemPromptAssembler {
+    readonly content: ContentRegistry;
+    private readonly tools;
     private resolver;
-    readonly registry: ContentRegistry;
     private readonly logger;
-    constructor(registry: ContentRegistry, resolver: BlobResolver, logger?: Logger);
+    constructor(content: ContentRegistry, tools: ToolRegistry, resolver: BlobResolver, logger?: Logger);
     build<P, C>(provider: string, prompt: Prompt, mapTurn: (args: {
         turn: Turn;
         parts: P[];
@@ -3283,89 +3658,241 @@ declare class PromptAssembler implements SystemPromptAssembler {
         system: string;
         sections: PromptSection[];
         transcript: C[];
+        schema: any;
     }>;
+    private buildSchema;
     private buildSections;
-    parse(provider: string, rawBlocks: Array<{
-        type: string;
-        [key: string]: any;
-    }>): Content<any>[];
     join(sections: PromptSection[]): string;
 }
 
 /**
- * Agent Module Commands
+ * ContentItem is an "active" model for a single content entry.
+ * It provides methods for updating and deleting the content,
+ * encapsulating the kernel dispatch logic.
  */
-/** Adds a new role to the system. */
-type AddRoleCommand = Command<"role:add", Role>;
-/** Updates an existing role. */
-type UpdateRoleCommand = Command<"role:update", {
-    name: string;
-    updates: Partial<Omit<Role, "name">>;
-}>;
-/** Deletes a role from the system. */
-type DeleteRoleCommand = Command<"role:delete", {
-    name: string;
-}>;
+declare class ContentItem<T extends string = string, D extends Record<string, any> = any> {
+    private readonly kernel;
+    private readonly context;
+    readonly summary: ContentSummary<T>;
+    constructor(kernel: IKernel<any, any, any>, context: AuthContext<SystemActor>, summary: ContentSummary<T>);
+    get id(): UUID;
+    get key(): string;
+    get type(): T;
+    get label(): string | undefined;
+    get topics(): readonly string[];
+    /**
+     * Fetches the full entity data for this content item.
+     */
+    full(): Promise<Content<T, D> | null>;
+    /**
+     * Updates the content metadata or value.
+     */
+    update(updates: Partial<Content<T, D>>): Promise<Result<void, any>>;
+    /**
+     * Deletes the content from the workspace.
+     */
+    delete(): Promise<Result<void, any>>;
+}
+
+type ContentSearchFilter = {
+    type?: string;
+    topics?: string[];
+    search?: string;
+};
+
 /**
- * Union of all Agent commands.
+ * Workspace is a model for global workspace operations like managing roles,
+ * preferences, and context.
  */
-type AgentCommand = AddRoleCommand | UpdateRoleCommand | DeleteRoleCommand;
+declare class Workspace {
+    private readonly kernel;
+    private readonly context;
+    constructor(kernel: IKernel<any, any, any>, context: AuthContext<SystemActor>);
+    roles(): Promise<Role[]>;
+    role(name: string): Promise<Role | null>;
+    createRole({ name, label, persona, description, preferences, topics, }: Pick<Role, "name" | "label" | "preferences" | "description" | "persona" | "topics">): Promise<Result<void, any>>;
+    updateRole(name: string, updates: Partial<Pick<Role, "label" | "description" | "persona" | "preferences" | "topics">>): Promise<Result<void, any>>;
+    deleteRole(name: string): Promise<Result<void, any>>;
+    /**
+     * Retrieves a specific content item by ID.
+     */
+    getContent(id: UUID): Promise<ContentItem | null>;
+    /**
+     * Lists and filters content across all types.
+     */
+    listContent(filter?: ContentSearchFilter): Promise<ContentItem[]>;
+    /**
+     * Discovers all unique topics across the library.
+     */
+    getTopics(): Promise<string[]>;
+    addPreference({ key, instruction, topics, label, }: {
+        key: string;
+        instruction: string;
+        topics: string[];
+        label?: string;
+    }): Promise<Result<void, any>>;
+    addContent(key: string, content: any, topics: string[], label?: string): Promise<Result<void, any>>;
+    registerBlob(data: Uint8Array, mime: string, filename?: string): Promise<Result<{
+        id: UUID;
+        ref: BlobRef;
+    }, any>>;
+}
 
 /**
- * Durable storage for Role entities.
+ * A fluent builder for creating Turn objects, aligned with the ContentRegistry.
  */
-declare class RoleStore extends BaseStore<Role, "name", RoleSummary> {
-    constructor(collection: Collection<Role>);
+declare class TurnBuilder {
+    private _turn;
+    private registry;
+    constructor(registry: ContentRegistry, actor: SystemActor, session: UUID, initialTurn?: Turn);
+    private createBlock;
+    addText(text: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addPreference(instruction: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addJson(data: Record<string, unknown>, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addBlob(blob: BlobData, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addImage(ref: BlobRef, altText?: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addDocument(ref: BlobRef, title?: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addThinking(thinking: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addToolCall(name: string, parameters: Record<string, unknown>, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addToolResult(key: string, name: string, result: unknown, error?: string, options?: {
+        key?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
     /**
-     * Distills a full Role entity into a lightweight summary for indexing.
+     * Adds a historical tool report block (read‑only archival record).
+     * @param key - Unique key linking to the original tool call.
+     * @param name - Name of the tool that was invoked.
+     * @param parameters - Arguments passed to the tool.
+     * @param result - The result value (if successful). Provide only when `error` is omitted.
+     * @param error - The error message (if failed). Provide only when `result` is omitted.
+     * @param options - Optional block metadata (`label`, `topics`).
      */
-    summarize(role: Role): RoleSummary;
+    addToolReport(key: string, name: string, parameters: Record<string, unknown>, result?: unknown, error?: string, options?: {
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addBlock(block: Content<any, any>): TurnBuilder;
+    deleteBlock(blockId: UUID): TurnBuilder;
+    withId(id: UUID): TurnBuilder;
+    withVersion(version: number): TurnBuilder;
+    withTimestamp(timestamp: Timestamp): TurnBuilder;
+    withParent(parent: TurnRef): TurnBuilder;
+    withRole(role: string): TurnBuilder;
+    withModel(model: string): TurnBuilder;
+    withMetadata(metadata: Record<string, any>): TurnBuilder;
+    build(): Turn;
+    node(): TurnNode;
+}
+/**
+ * Factory for creating TurnBuilder instances with a shared registry.
+ */
+declare class TurnBuilderFactory {
+    private registry;
+    constructor(registry: ContentRegistry);
+    new(actor: SystemActor, session: UUID, initialTurn?: Turn): TurnBuilder;
+}
+
+declare class TurnRepository {
+    private readonly turnStore;
+    private readonly sessionStore;
+    constructor(turnStore: TurnStore, sessionStore: SessionStore);
+    loadAllTurns(sessionId: UUID): Promise<Turn[]>;
+    loadHead(sessionId: UUID): Promise<TurnRef | null>;
+}
+
+declare class TurnTree {
+    private readonly nodes;
+    private readonly _head;
+    private constructor();
+    static build(sessionId: UUID, repository: TurnRepository, headOverride?: TurnRef | null): Promise<TurnTree>;
+    head(): TurnRef | null;
+    chain(): TurnNode[];
+    /**
+     * Returns a chronological chain of TurnNodes ending at the specified turn.
+     */
+    chainFrom(turnId: string): TurnNode[];
+    getTurnSiblings(turnId: string): TurnNode[];
+    branchInfo(turnId: UUID): BranchInfo;
+    graph(): Readonly<Record<UUID, TurnNode>>;
 }
 
 /**
- * The AgentModule manages system personas (roles) and their constraints.
+ * Simplified bootstrap parameters for a quick-start workspace.
  */
-declare class AgentModule implements Module<"user" | "system", Record<string, any>, AgentIndex, AgentCommand, {
-    roles: RoleStore;
-}> {
-    readonly name = "agent";
-    readonly schemas: _asaidimu_anansi.SchemaDefinition[];
-    private _roleStore?;
-    stores: (db: any) => Promise<{
-        roles: RoleStore;
-    }>;
-    actions: {
-        "role:add": (_state: State<any, AgentIndex>, command: AddRoleCommand) => Promise<{
-            index: {
-                roles: {
-                    [x: string]: RoleSummary | undefined;
-                };
-            };
-        }>;
-        "role:update": (state: State<any, AgentIndex>, command: UpdateRoleCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                roles: {
-                    [name]: RoleSummary | undefined;
-                };
-            };
-        }>;
-        "role:delete": (state: State<any, AgentIndex>, command: DeleteRoleCommand) => Promise<{
-            index?: undefined;
-        } | {
-            index: {
-                roles: {
-                    [name]: any;
-                };
-            };
-        }>;
-    };
+interface BootstrapParams<T extends string = any, S extends Record<string, any> = any, I extends Index = any> {
+    database: Omit<DatabaseConfig, "schemas">;
+    state: StateManager<State<S, I>>;
+    authorizer?: Authorizer<T, S, I>;
+    storage?: any;
+    userId?: UUID;
+    /** Custom content block definitions to register. */
+    blocks?: ContentDefinition<any>[];
+    /** Custom tools to register. */
+    tools?: ToolDefinition<any>[];
+    /** LLM adapters to register (e.g. { google: new GoogleAdapter() }). */
+    adapters?: (services: {
+        assembler: PromptAssembler;
+        turns: TurnBuilderFactory;
+    }, registry: DomainRegistry) => Promise<Record<string, LLMAdapter>>;
+    /** Optional extension modules. */
+    extensions?: Module<T, S, I, any, any, any>[];
+    /** Optional logger instance for system-wide observability. */
+    logger?: Logger$1;
+}
+/**
+ * Bootstrapper provides a high-level API to quickly stand up a functional
+ * workspace and session without manually wiring modules and stores.
+ */
+declare class Bootstrapper {
     /**
-     * Rebuilds the AgentIndex from durable storage.
+     * Quick-starts a workspace with core modules (Agent, Content, Session, Core).
      */
-    index(_: State<any, AgentIndex>): Promise<DeepPartial<AgentIndex>>;
+    static workspace(params: BootstrapParams): Promise<{
+        kernel: Kernel<any, any, any>;
+        registries: Record<string, IRegistryReader<any>>;
+        stores: Record<string, Store<any, any, any>>;
+        workspace: Workspace;
+        sessions: SessionManager;
+        llm: LLM;
+        assembler: PromptAssembler;
+        userId: string;
+        turns: TurnBuilderFactory;
+    }>;
 }
+type BootstrappedWorkspace = Awaited<ReturnType<typeof Bootstrapper.workspace>>;
 
 declare const GOOGLE_MODELS: Array<ModelProfile>;
 /** Everyday workhorse models: Flash variants + larger Gemma 4s. */
@@ -3378,10 +3905,12 @@ declare const GOOGLE_MODELS_EMBEDDING: Array<ModelProfile>;
 declare class GoogleGenAIAdapter implements LLMAdapter {
     private readonly client;
     private readonly assembler;
+    private readonly turns;
     private readonly registry;
     private readonly model;
     private readonly _models;
-    constructor(client: GoogleGenAI, assembler: SystemPromptAssembler, registry: ContentRegistry, options?: {
+    private readonly logger;
+    constructor(client: GoogleGenAI, assembler: SystemPromptAssembler, turns: TurnBuilderFactory, registry: ContentRegistry, logger: Logger$1, options?: {
         model: string;
         models: Array<ModelProfile>;
     });
@@ -3394,118 +3923,14 @@ declare class GoogleGenAIAdapter implements LLMAdapter {
     models(): ModelProfile[];
 }
 
-declare const index$1_GOOGLE_MODELS: typeof GOOGLE_MODELS;
-declare const index$1_GOOGLE_MODELS_COMMON: typeof GOOGLE_MODELS_COMMON;
-declare const index$1_GOOGLE_MODELS_EMBEDDING: typeof GOOGLE_MODELS_EMBEDDING;
-declare const index$1_GOOGLE_MODELS_PRO: typeof GOOGLE_MODELS_PRO;
-type index$1_GoogleGenAIAdapter = GoogleGenAIAdapter;
-declare const index$1_GoogleGenAIAdapter: typeof GoogleGenAIAdapter;
-declare namespace index$1 {
-  export { index$1_GOOGLE_MODELS as GOOGLE_MODELS, index$1_GOOGLE_MODELS_COMMON as GOOGLE_MODELS_COMMON, index$1_GOOGLE_MODELS_EMBEDDING as GOOGLE_MODELS_EMBEDDING, index$1_GOOGLE_MODELS_PRO as GOOGLE_MODELS_PRO, index$1_GoogleGenAIAdapter as GoogleGenAIAdapter };
-}
-
-/**
- * VercelAIAdapter bridges the Workspace Prompt with Vercel's AI SDK.
- * It uses a LanguageModel instance to perform inference.
- *
- * This adapter handles the mapping between Workspace ModelProfiles and Vercel's
- * model instances, ensuring features like thinking/reasoning and streaming
- * are correctly enabled based on profile capabilities.
- */
-declare class VercelAIAdapter implements LLMAdapter {
-    private readonly model;
-    private readonly assembler;
-    private readonly registry;
-    private readonly profile;
-    constructor(model: LanguageModel, assembler: SystemPromptAssembler, registry: ContentRegistry, profile: ModelProfile);
-    private registerMappings;
-    /**
-     * Returns the status of the model, merging static profile data with
-     * runtime readiness.
-     */
-    status(): Promise<ModelStatus>;
-    resolve(params: {
-        prompt: Prompt;
-    } & Record<string, any>): Promise<InferenceContext>;
-    private mapResponse;
-    static provider(): string;
-    models(): ModelProfile[];
-}
-
-/**
- * Mappings for Vercel AI SDK (ContentPart).
- * Translates workspace blocks into Vercel's universal content part format.
- */
-declare const mappings: (registry: ContentRegistry) => {
-    text: {
-        to: ({ block, }: {
-            block: Content<"text", {
-                text: string;
-            }>;
-        }) => ContentPart<any>;
-        from: (raw: any) => Content<"text", {
-            text: any;
-        }>;
-    };
-    preference: {
-        to: ({ block, }: {
-            block: Content<"preference", {
-                instruction: string;
-            }>;
-        }) => ContentPart<any>;
-        from: (raw: any) => Content<"preference", {
-            instruction: any;
-        }>;
-    };
-    json: {
-        to: ({ block, }: {
-            block: Content<"json", Record<string, unknown>>;
-        }) => ContentPart<any>;
-        from: (raw: any) => Content<"json", any>;
-    };
-    image: {
-        to: ({ block, resolve, }: {
-            block: Content<"image", {
-                ref: any;
-                altText?: string;
-            }>;
-            resolve: (ref: any) => Promise<any>;
-        }) => Promise<ContentPart<any> | null>;
-        from: (raw: any) => Content<"image", {
-            ref: any;
-            altText: any;
-        }>;
-    };
-    document: {
-        to: ({ block, resolve, }: {
-            block: Content<"document", {
-                ref: any;
-                title?: string;
-            }>;
-            resolve: (ref: any) => Promise<any>;
-        }) => Promise<ContentPart<any> | null>;
-        from: (raw: any) => Content<"document", {
-            ref: any;
-            title: any;
-        }>;
-    };
-    thinking: {
-        to: ({ block, }: {
-            block: Content<"thinking", {
-                thinking: string;
-            }>;
-        }) => ContentPart<any> | null;
-        from: (raw: any) => Content<"thinking", {
-            thinking: any;
-        }>;
-    };
-};
-
-type index_VercelAIAdapter = VercelAIAdapter;
-declare const index_VercelAIAdapter: typeof VercelAIAdapter;
-declare const index_mappings: typeof mappings;
+declare const index_GOOGLE_MODELS: typeof GOOGLE_MODELS;
+declare const index_GOOGLE_MODELS_COMMON: typeof GOOGLE_MODELS_COMMON;
+declare const index_GOOGLE_MODELS_EMBEDDING: typeof GOOGLE_MODELS_EMBEDDING;
+declare const index_GOOGLE_MODELS_PRO: typeof GOOGLE_MODELS_PRO;
+type index_GoogleGenAIAdapter = GoogleGenAIAdapter;
+declare const index_GoogleGenAIAdapter: typeof GoogleGenAIAdapter;
 declare namespace index {
-  export { index_VercelAIAdapter as VercelAIAdapter, index_mappings as mappings };
+  export { index_GOOGLE_MODELS as GOOGLE_MODELS, index_GOOGLE_MODELS_COMMON as GOOGLE_MODELS_COMMON, index_GOOGLE_MODELS_EMBEDDING as GOOGLE_MODELS_EMBEDDING, index_GOOGLE_MODELS_PRO as GOOGLE_MODELS_PRO, index_GoogleGenAIAdapter as GoogleGenAIAdapter };
 }
 
 interface IndexedDBBlobConfig {
@@ -3554,4 +3979,4 @@ declare class MemoryBlobStorage implements BlobStorage {
     exportAllBytes(): Promise<Array<[SHA256, Uint8Array]>>;
 }
 
-export { type Action, type ActionEntry, type AgentIndex, AgentModule, type AssemblerExtension, type AuthContext, AuthContextBuilder, type AuthorizationProvider, type Authorizer, BaseStore, type Blob, type BlobRef, type BlobResolver, type BlobStorage, type BranchInfo, Branded, type Command, type CommandCoordinator, type CommandRegistry, CommonErrors, ConsoleLogger, type Content, type ContentCoreState, type ContentDefinition, type ContentFilter, type ContentIndex, type ContentMapper, type ContentMode, ContentModule, ContentRegistry, type ContentRetriever, type ContentSummary, type CreateWorkspaceCommand, type CreateWorkspaceParams, DELETE_SYMBOL, type DeepPartial, type DomainRegistry, type Entity, type Event, index$1 as GoogleAdapter, type IKernel, type IRegistry, type IRegistryReader, type IWorkspaceDatabase, type Identifiable, type Index, type IndexedDBBlobConfig, IndexedDBBlobStorage, type InferenceContext, type Issue, Kernel, type KernelConfig, LLM, type LLMAdapter, type LLMAdapterStatic, type LogEntry, type LogLevel, type Logger$1 as Logger, MemoryBlobStorage, type Metadata, type Middleware, type ModelConstraint, type ModelConstraints, type ModelName, type ModelProfile, type ModelStatus, type Module, ModuleAggregator, type ProjectMetadata, type Prompt, PromptAssembler, type PromptBuilder, type PromptBuilderOptions, type PromptResult, type PromptSection, Registry, type ResolvedBlob, Result, type Role, type RoleSummary, type SHA256, type Selector, Session, type SessionIndex, SessionManager, SessionModule, type SessionSnapshot, type SessionSummary, type Severity, type State, type StateManager, type StateReader, type Store, type StoreKey, type SyncWorkspaceCommand, SystemActor$1 as SystemActor, SystemError, type SystemPromptAssembler, type Taggable, type Timestamp, type Timestamped, type TransactionStep, type Turn, TurnBuilder, type TurnNode, type TurnProcessor, TurnTree, type URI, type UUID, index as VercelAdapter, type Versioned, type WorkspaceCommand, WorkspaceDatabase, type WorkspaceIndex, WorkspaceModule, type WorkspaceSettings, type WorkspaceState, createAnonymousContext, createAuthContext, createError, createLogger, createUserContext, createWorkspace, deepClone, del, logger, merge };
+export { type Action, type ActionEntry, type ActionOutcome, type AgentIndex, AgentModule, type AssemblerExtension, type AuthContext, AuthContextBuilder, type AuthorizationProvider, type Authorizer, BaseStore, type Blob$1 as Blob, type BlobRef, type BlobResolver, type BlobStorage, BlobUtilities, type BootstrapParams, type BootstrappedWorkspace, Bootstrapper, type BranchInfo, Branded, type Command, type CommandCoordinator, type CommandRegistry, CommonErrors, ConsoleLogger, type Content, type ContentCoreState, type ContentDefinition, type ContentFilter, type ContentIndex, type ContentMapper, type ContentMode, ContentModule, ContentRegistry, type ContentRetriever, type ContentSummary, type CreateWorkspaceCommand, type CreateWorkspaceParams, DELETE_SYMBOL, type DatabaseConfig, type DeepPartial, type DomainRegistry, type EffectResult, type Entity, type Event, index as GoogleAdapter, type IKernel, type IRegistry, type IRegistryReader, type IWorkspaceDatabase, type Identifiable, type Index, type IndexedDBBlobConfig, IndexedDBBlobStorage, type InferenceContext, type InferenceResults, type Issue, Kernel, type KernelConfig, LLM, type LLMAdapter, type LLMAdapterStatic, type LogEntry, type LogLevel, type Logger$1 as Logger, MemoryBlobStorage, type Metadata, type Middleware, type ModelConstraint, type ModelConstraints, type ModelName, type ModelProfile, type ModelStatus, type Module, ModuleAggregator, type ProjectMetadata, type Prompt, PromptAssembler, type PromptBuilder, type PromptBuilderOptions, type PromptSection, Registry, type ResolvedBlob, Result, type Role, type RoleSummary, type SHA256, type Selector, Session, type SessionIndex, SessionManager, SessionModule, type SessionSnapshot, type SessionSummary, type Severity, ShortKeyRegistry, type SnapshotTarget, type State, type StateManager, type StateReader, type Store, type StoreKey, type SyncWorkspaceCommand, SystemAuth, SystemError, type SystemPromptAssembler, type Taggable, type Timestamp, type Timestamped, ToolCallRegex, type ToolDefinition, type TransactionStep, type Turn, TurnBuilderFactory, type TurnNode, type TurnProcessor, TurnTree, type URI, type UUID, type Versioned, type WorkspaceCommand, WorkspaceDatabase, type WorkspaceIndex, WorkspaceModule, type WorkspaceSettings, type WorkspaceState, createAnonymousContext, createAuthContext, createError, createLogger, createUserContext, createWorkspace, deepClone, del, logger, merge };