@asaidimu/utils-workspace 7.0.0 → 7.0.1

package/index.d.mts

@@ -2,7 +2,6 @@ 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';
 
 type SerializerResult<T> = {
     value: T | null;
@@ -405,17 +404,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 +825,7 @@ type TelemetryEvent = {
         } | null;
     };
 };
-interface DatabaseConfig {
+interface DatabaseConfig$1 {
     database: string;
     keyPath?: string;
     schemasStoreName?: string;
@@ -843,7 +833,7 @@ interface DatabaseConfig {
     predicates?: PredicateMap;
     validate?: boolean;
 }
-type StoreConfig = DatabaseConfig & {
+type StoreConfig = DatabaseConfig$1 & {
     collection: string;
 };
 
@@ -888,7 +878,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.
@@ -1527,7 +1517,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 +1547,13 @@ declare function createAnonymousContext(): AuthContext<"anonymous">;
  */
 declare function createUserContext(userId: UUID, scopes?: string[], metadata?: UUID): AuthContext<"user">;
 
+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 +1579,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 +1680,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.
@@ -1982,193 +1973,194 @@ 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?: (value: Data) => Command<any>[];
 }
 
 /**
- * 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)
+ * Data shape for preference (instructional) content.
  */
-/** 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;
-
-/**
- * Durable storage for Content entities.
- */
-declare class ContentStore extends BaseStore<Content<any>, "id", ContentSummary<any>> {
-    constructor(collection: Collection<Content<any>>);
-    /**
-     * Distills a full Content entity into a lightweight summary for indexing.
-     */
-    summarize(entity: Content<any>): ContentSummary<any>;
 }
+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 */
+    callId: string;
+    /** Optional error message if the tool execution failed */
+    error?: string;
+}
+type PreferenceContent = Content<"preference", PreferenceData>;
+type ToolResultContent = Content<"tool:result", ToolResultData>;
 
 /**
- * The ContentModule manages all durable content and binary assets.
+ * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
  */
-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;
-                };
+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;
         }>;
-        "blob:record_remote_id": (_state: State<ContentCoreState, ContentIndex>, command: RecordBlobRemoteIdCommand) => Promise<{}>;
     };
+    /** 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"];
     /**
-     * Rebuilds the ContentIndex from durable storage.
+     * Hard rate limit capacity as enforced by the provider.
+     * Does not include runtime state (load, timeout).
      */
-    index(_: State<ContentCoreState, ContentIndex>): Promise<DeepPartial<ContentIndex>>;
+    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>;
+}
+/**
+ * A tool that can be called by an agent.
+ */
+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 of what the tool does. */
+    description: string;
+    /** JSON Schema fragment defining the tool's parameters. */
+    parameters: Record<string, unknown>;
+    /**
+     * The actual implementation function.
+     * This is executed by the system when the model requests this tool.
+     */
+    execute: (params: Params) => Promise<any>;
+}
+
 /**
  * Identifies whether a turn originated from the user, the assistant, a tool, or the system.
  */
@@ -2237,22 +2229,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 +2268,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 +2297,7 @@ interface SessionSummary {
     readonly id: UUID;
     readonly label: string;
     readonly role: string;
+    readonly model: string;
     readonly topics: string[];
     readonly preferences: string[];
     readonly content: string[];
@@ -2315,72 +2310,6 @@ interface SessionSummary {
     readonly metadata?: Record<string, any>;
 }
 
-/**
- * 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.
  */
@@ -2411,540 +2340,774 @@ 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<{
+declare class ContentStore extends BaseStore<Content<any>, "id", ContentSummary<any>> {
+    constructor(collection: Collection<Content<any>>);
+    /**
+     * Distills a full Content entity into a lightweight summary for indexing.
+     */
+    summarize(entity: Content<any>): ContentSummary<any>;
+}
+
+/**
+ * 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.
+ */
+type SnapshotTarget = {
+    kind: "turn-id";
+    id: UUID;
+} | {
+    kind: "turn";
+    turn: Turn;
+};
+type SnapshotErrorKind = "session-not-found" | "role-not-found";
+declare class SnapshotError extends Error {
+    readonly kind: SnapshotErrorKind;
+    constructor(kind: SnapshotErrorKind, message: string);
+}
+/**
+ * Wraps each effect dispatch outcome so callers can inspect per-effect
+ * failures without the sequence being aborted by a throw.
+ */
+type EffectResult = {
+    effect: Command<any>;
+    result: Result<any, any>;
+};
+/**
+ * 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;
+    private readonly kernel;
+    private readonly stores;
+    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;
-    }>;
-    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;
-        } | {
+        content: ContentStore;
+    });
+    /**
+     * Factory method to create a new Session instance.
+     */
+    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 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. */
+    index(): SessionSummary | undefined;
+    /** Returns the session's label. */
+    label(): string | undefined;
+    /** Returns the current role. */
+    role(): Role | undefined;
+    /** Returns the list of topics. */
+    topics(): string[];
+    /**
+     * 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. */
+    turns(): TurnNode[];
+    /** Returns all sibling turns of a given turn. */
+    siblings(turnId: UUID): TurnNode[];
+    /** Returns branching information for a turn. */
+    branchInfo(turnId: UUID): BranchInfo;
+    /** Retrieves a TurnNode by its ID. */
+    turn(turnId: UUID): TurnNode | undefined;
+    /** 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. */
+    setTopics(topics: string[]): Promise<Result<void, any>>;
+    /** Adds topics to the session (does not replace existing ones). */
+    addTopics(topics: string[]): Promise<Result<void, any>>;
+    /** Switches the active role for this session. */
+    switchRole(roleName: string): Promise<Result<void, any>>;
+    /** Updates the session's model identifier. */
+    setModel(model: string): Promise<Result<void, any>>;
+    /** Merges arbitrary metadata into the session's metadata object. */
+    updateMetadata(metadata: Record<string, any>): Promise<Result<void, any>>;
+    /** Replaces the session's preference list. */
+    setPreferences(preferenceIds: UUID[]): Promise<Result<void, any>>;
+    /** 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>>;
+    /** Records a user turn. */
+    recordUserTurn(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. */
+    branch(turn: Turn): Promise<Result<void, any>>;
+    /** Deletes a specific version of a turn. */
+    deleteTurn(turnId: UUID, version: number, newHead: TurnRef | null): Promise<Result<void, any>>;
+    /** Updates the status (success/unsuccessful) of a specific turn version. */
+    updateTurnStatus(turnId: UUID, version: number, status: Result<void, any>): Promise<Result<void, any>>;
+    /** Creates a new session as a fork of this one. */
+    fork(newSessionId: UUID, label: string, role?: string, topics?: string[]): Promise<Result<void, any>>;
+    /** Switches to the previous version of a turn. */
+    switchVersionLeft(turnId: UUID): Promise<Result<void, any>>;
+    /** Switches to the next version of a turn. */
+    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, SnapshotError>>;
+    /**
+     * 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.
+     */
+    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;
+}
+
+/**
+ * SessionManager orchestrates the lifecycle of Session instances.
+ * It provides methods for creating, opening, listing, and deleting sessions.
+ * Uses deduplication for concurrent open requests.
+ */
+declare class SessionManager {
+    private readonly kernel;
+    private readonly stores;
+    private openOnce;
+    constructor(kernel: IKernel<any, any, any>, stores: {
+        sessions: SessionStore;
+        turns: TurnStore;
+        content: ContentStore;
+    });
+    /**
+     * Opens a session by ID. Deduplicates concurrent open requests.
+     */
+    open(user: string, session: UUID): Promise<Session>;
+    /**
+     * Closes a session handle, removing it from the deduplication cache.
+     */
+    close(sessionId: UUID): void;
+    /**
+     * Deletes a session entirely.
+     */
+    delete(sessionId: UUID): Promise<Result<undefined, SystemError>>;
+    /**
+     * Checks if a session exists in the index.
+     */
+    has(sessionId: UUID): Promise<boolean>;
+    /**
+     * Creates a new conversation session and opens it.
+     */
+    create(user: string, params: {
+        label: string;
+        role: string;
+        model: string;
+        topics?: string[];
+        preferences?: UUID[];
+        metadata?: Record<string, any>;
+    }): Promise<Session>;
+    /**
+     * Lists all session metadata from the index.
+     */
+    list(): SessionSummary[];
+    /**
+     * Returns metadata for a specific session.
+     */
+    metadata(id: UUID): SessionSummary | undefined;
+}
+
+/**
+ * Agent Module Commands
+ */
+/** 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>;
+}>;
+/**
+ * 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>> {
+    /**
+     * Returns a system-prompt section describing all available tools.
+     */
+    description(): string;
+    /**
+     * Returns a JSON Schema array of all tool definitions.
+     * Useful for providers that support native tool-calling (like OpenAI/Gemini).
+     */
+    schemas(): any[];
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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<{
             index: {
-                sessions: {
-                    [x: string]: any;
+                roles: {
+                    [x: string]: RoleSummary | undefined;
                 };
             };
         }>;
-        "turn:branch": (state: State<any, SessionIndex>, command: BranchTurnCommand) => Promise<{
+        "role:update": (state: State<any, AgentIndex>, command: UpdateRoleCommand) => Promise<{
             index?: undefined;
         } | {
             index: {
-                sessions: {
-                    [x: string]: SessionSummary;
+                roles: {
+                    [name]: RoleSummary | undefined;
                 };
             };
         }>;
-        "turn:delete": (state: State<any, SessionIndex>, command: DeleteTurnCommand) => Promise<{
+        "role:delete": (state: State<any, AgentIndex>, command: DeleteRoleCommand) => Promise<{
             index?: undefined;
         } | {
             index: {
-                sessions: {
-                    [x: string]: SessionSummary;
+                roles: {
+                    [name]: any;
                 };
             };
         }>;
+        "tool:execute": (_state: State<any, AgentIndex>, command: ExecuteToolCommand) => Promise<any>;
     };
     /**
-     * Rebuilds the SessionIndex from durable storage.
+     * Rebuilds the AgentIndex from durable storage.
      */
-    index(_: State<any, SessionIndex>): Promise<DeepPartial<SessionIndex>>;
+    index(_: State<any, AgentIndex>): Promise<DeepPartial<AgentIndex>>;
 }
 
 /**
- * Configuration parameters for creating a new Workspace.
+ * 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.
  */
-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;
+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.
+     */
+    resolveMany(ids: UUID[], provider?: string): Promise<Result<Map<UUID, ResolvedBlob>, SystemError>>;
 }
+
 /**
- * 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.
+ * Content Module Commands
  */
-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 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;
 
 /**
- * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
+ * The ContentModule manages all durable content and binary assets.
  */
-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;
-            };
-        };
+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;
     }>;
-    /** 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;
+    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<{}>;
     };
-    /** 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).
+     * Rebuilds the ContentIndex from durable storage.
      */
-    capacity: ModelStatus["rate"]["capacity"];
+    index(_: State<ContentCoreState, ContentIndex>): Promise<DeepPartial<ContentIndex>>;
 }
-/** 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. */
+
+/**
+ * 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;
-    /** 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;
-}
+    role?: string;
+    topics?: string[];
+}>;
 /**
- * Summary of a Role for indexing.
+ * Deletes an entire conversation session and its history.
  */
-interface RoleSummary {
-    readonly name: string;
-    readonly label: string;
-    readonly description?: string;
-    readonly preferences: number;
-    readonly topics: readonly string[];
-    readonly constraints?: ModelConstraints;
-}
+type DeleteSessionCommand = Command<"session:delete", {
+    id: UUID;
+}>;
 /**
- * Agent Index (Read Model projection)
+ * Appends a new turn to a session.
  */
-interface AgentIndex extends Index {
-    readonly roles: Record<string, RoleSummary>;
-}
-
-/** Complete snapshot of the session provided to the PromptBuilder. */
-interface SessionSnapshot {
-    /** Session identifier. */
+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;
-    /** 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. */
+    session: UUID;
+    version: number;
     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;
-}
-
+    role?: string;
+    model?: string;
+}>;
 /**
- * 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.
+ * Creates a new branch in the conversation history from a specific turn.
  */
-declare class Session {
-    readonly id: UUID;
-    private readonly kernel;
-    private readonly stores;
-    private tree;
-    private turnRepository;
-    private context;
-    constructor(userId: UUID, id: UUID, kernel: IKernel<any, any, any>, stores: {
-        sessions: SessionStore;
-        turns: TurnStore;
-    });
-    /**
-     * Factory method to create a new Session instance.
-     */
-    static create(userId: UUID, sessionId: UUID, kernel: IKernel<any, any, any>, stores: {
-        sessions: SessionStore;
-        turns: TurnStore;
-    }): Promise<Session>;
-    /**
-     * Synchronises the session's in‑memory state with the persistent stores.
-     */
-    sync(): Promise<void>;
-    /**
-     * Closes the session and cleans up subscriptions.
-     */
-    close(): void;
-    /** Returns the session's unique identifier. */
-    sessionId(): UUID;
-    /** Returns the session metadata from the kernel index. */
-    meta(): SessionSummary | undefined;
-    /** Returns the session's label. */
-    label(): string | undefined;
-    /** Returns the current role. */
-    role(): Promise<Role | undefined>;
-    /** Returns the list of topics. */
-    topics(): string[];
-    /** Returns the list of active preferences. */
-    preferences(): Promise<Content<"preference", any>[]>;
-    /** Returns the current head (last turn) or null if empty. */
-    head(): TurnRef | null;
-    /** Returns the active chain of turns as an array of TurnNode. */
-    turns(): TurnNode[];
-    /** Returns all sibling turns of a given turn. */
-    siblings(turnId: UUID): TurnNode[];
-    /** Returns branching information for a turn. */
-    branchInfo(turnId: UUID): BranchInfo;
-    /** Retrieves a TurnNode by its ID. */
-    turn(turnId: UUID): TurnNode | undefined;
-    /** Retrieves the full turn history. */
-    transcript(): Promise<Turn[]>;
-    /** Fetches the full Session entity. */
-    data(): Promise<Session$1 | null>;
-    /** Changes the session's display label. */
-    rename(label: string): Promise<Result<void, any>>;
-    /** Replaces the session's topic list. */
-    setTopics(topics: string[]): Promise<Result<void, any>>;
-    /** Adds topics to the session (does not replace existing ones). */
-    addTopics(topics: string[]): Promise<Result<void, any>>;
-    /** Switches the active role for this session. */
-    switchRole(roleName: string): Promise<Result<void, any>>;
-    /** Updates the session's model identifier. */
-    setModel(model: string): Promise<Result<void, any>>;
-    /** Merges arbitrary metadata into the session's metadata object. */
-    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>>;
-    /** 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. */
-    branch(turn: Turn): Promise<Result<void, any>>;
-    /** Deletes a specific version of a turn. */
-    deleteTurn(turnId: UUID, version: number, newHead: TurnRef | null): Promise<Result<void, any>>;
-    /** Updates the status (success/unsuccessful) of a specific turn version. */
-    updateTurnStatus(turnId: UUID, version: number, status: Result<void, any>): Promise<Result<void, any>>;
-    /** Creates a new session as a fork of this one. */
-    fork(newSessionId: UUID, label: string, role?: string, topics?: string[]): Promise<Result<void, any>>;
-    /** Switches to the previous version of a turn. */
-    switchVersionLeft(turnId: UUID): Promise<Result<void, any>>;
-    /** Switches to the next version of a turn. */
-    switchVersionRight(turnId: UUID): Promise<Result<void, any>>;
-    /**
-     * Assembles a SessionSnapshot for prompt building.
-     */
-    snapshot(target?: UUID | Turn): Promise<SessionSnapshot | undefined>;
-    private refreshTurnTree;
-    private loadContent;
-    private switchVersion;
-    private findSubtreeTip;
-}
-
+type BranchTurnCommand = Command<"turn:branch", Turn>;
 /**
- * SessionManager orchestrates the lifecycle of Session instances.
- * It provides methods for creating, opening, listing, and deleting sessions.
- * Uses deduplication for concurrent open requests.
+ * Removes a specific version of a turn.
  */
-declare class SessionManager {
-    private readonly kernel;
-    private readonly stores;
-    private openOnce;
-    constructor(kernel: IKernel<any, any, any>, stores: {
-        sessions: SessionStore;
-        turns: TurnStore;
-    });
-    /**
-     * Opens a session by ID. Deduplicates concurrent open requests.
-     */
-    open(user: string, session: UUID): Promise<Session>;
-    /**
-     * Closes a session handle, removing it from the deduplication cache.
-     */
-    close(sessionId: UUID): void;
-    /**
-     * Deletes a session entirely.
-     */
-    delete(sessionId: UUID): Promise<Result<undefined, SystemError>>;
-    /**
-     * Checks if a session exists in the index.
-     */
-    has(sessionId: UUID): Promise<boolean>;
-    /**
-     * Creates a new conversation session and opens it.
-     */
-    create(user: string, params: {
-        label: string;
-        role: string;
-        topics?: string[];
-        preferences?: UUID[];
-        metadata?: Record<string, any>;
-    }): Promise<Session>;
-    /**
-     * Lists all session metadata from the index.
-     */
-    list(): SessionSummary[];
-    /**
-     * Returns metadata for a specific session.
-     */
-    metadata(id: UUID): SessionSummary | undefined;
-}
-
+type DeleteTurnCommand = Command<"turn:delete", {
+    session: UUID;
+    id: UUID;
+    version: number;
+    /** The fallback position if deleting the current head. */
+    newHead?: TurnRef;
+}>;
 /**
- * A fluent builder for creating Turn objects in the new architecture.
+ * Union of all Session and Turn 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;
-    /**
-     * Builds a `TurnNode` from the current turn.
-     */
-    node(): TurnNode;
-}
-
-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>;
-}
+type SessionCommand = CreateSessionCommand | UpdateSessionCommand | ForkSessionCommand | DeleteSessionCommand | AddTurnCommand | UpdateTurnCommand | EditTurnCommand | BranchTurnCommand | DeleteTurnCommand;
 
-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 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<{
+            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;
+                };
+            };
+        }>;
+    };
     /**
-     * Returns a chronological chain of TurnNodes ending at the specified turn.
+     * Rebuilds the SessionIndex from durable storage.
      */
-    chainFrom(turnId: string): TurnNode[];
-    getTurnSiblings(turnId: string): TurnNode[];
-    branchInfo(turnId: UUID): BranchInfo;
-    graph(): Readonly<Record<UUID, TurnNode>>;
+    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>;
+}>;
 
 /**
  * Registry for managing ContentDefinitions.
@@ -2977,6 +3140,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 +3213,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.
+     */
+    tools: Array<ToolResultContent>;
     /**
      * Non-fatal warnings generated during the build phase.
      */
@@ -3083,10 +3263,6 @@ interface SystemPromptAssembler {
         transcript: C[];
         sections: PromptSection[];
     }>;
-    parse(provider: string, raw: Array<{
-        type: string;
-        [key: string]: any;
-    }>): Content<any>[];
     join(sections: PromptSection[]): string;
 }
 
@@ -3158,14 +3334,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.
@@ -3285,86 +3472,223 @@ declare class PromptAssembler implements SystemPromptAssembler {
         transcript: C[];
     }>;
     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;
+        callId?: string;
+        label?: string;
+        topics?: string[];
+    }): TurnBuilder;
+    addToolResult(callId: string, name: string, result: unknown, error?: string, options?: {
+        key?: string;
+        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[];
     /**
-     * Distills a full Role entity into a lightweight summary for indexing.
+     * Returns a chronological chain of TurnNodes ending at the specified turn.
      */
-    summarize(role: Role): RoleSummary;
+    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;
+    }>;
 }
 
 declare const GOOGLE_MODELS: Array<ModelProfile>;
@@ -3378,10 +3702,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 tools?;
     private readonly model;
     private readonly _models;
-    constructor(client: GoogleGenAI, assembler: SystemPromptAssembler, registry: ContentRegistry, options?: {
+    constructor(client: GoogleGenAI, assembler: SystemPromptAssembler, turns: TurnBuilderFactory, registry: ContentRegistry, tools?: ToolRegistry | undefined, options?: {
         model: string;
         models: Array<ModelProfile>;
     });
@@ -3394,118 +3720,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 +3776,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 AgentIndex, AgentModule, type AssemblerExtension, type AuthContext, AuthContextBuilder, type AuthorizationProvider, type Authorizer, BaseStore, type Blob, type BlobRef, type BlobResolver, type BlobStorage, type BootstrapParams, 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, SnapshotError, type SnapshotErrorKind, type SnapshotTarget, type State, type StateManager, type StateReader, type Store, type StoreKey, type SyncWorkspaceCommand, SystemAuth, SystemError, type SystemPromptAssembler, type Taggable, type Timestamp, type Timestamped, 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 };