@pluno/product-agent-web 0.1.220 → 0.1.221

package/README.md

@@ -10,6 +10,14 @@ npm install @pluno/product-agent-web
 
 Keep your Product Agent `secret_key` on your server. Browser code should only receive a short-lived session `token`, or call your own authenticated token endpoint.
 
+## Host-rendered chat notices
+
+The default widget handle exposes `host`. Hosts may append presentation-only elements with
+`slot="bottom-notices"` (account, authentication, connection or device notices above the composer) or
+`slot="conversation-notices"` (conversation-local notices inline). Remove these elements when their
+existing owner clears the notice; the slots do not store state or decide eligibility. The main-web React
+shell uses portals into these slots. Do not use them as a second transcript or interaction owner.
+
 ## Headless SDK
 
 ```ts

package/dist/activeUsersCounter.d.ts

@@ -1,11 +1,4 @@
-type ActiveUsersCounterOptions = {
-    backendUrl?: string;
-    fetcher?: typeof fetch;
-    loader?: () => Promise<ActiveUsersCounterValue>;
-};
 export type ActiveUsersCounterValue = {
     count: number;
     refreshAfterMs: number;
 };
-export declare function startActiveUsersCounter(onUpdate: (value: number) => void, options?: ActiveUsersCounterOptions): () => void;
-export {};

package/dist/adapters/web/activeUsers.d.ts

@@ -0,0 +1,4 @@
+import type { PAEffectHandlers } from "../../core/kernel/effects";
+import type { PAActiveUsersEffects } from "../../core/active-users/reducer";
+export declare function createActiveUsersPorts(load: () => Promise<number>, random?: () => number, displayRandom?: () => number): PAEffectHandlers<PAActiveUsersEffects>;
+export declare function fetchActiveUsersCount(backendUrl: string, fetcher?: (input: URL, init?: RequestInit) => Promise<Response>): Promise<number>;

package/dist/adapters/web/backendHttp.d.ts

@@ -0,0 +1,12 @@
+import { type ProductAgentSocketAuth } from './socketIOTransport';
+export declare class ProductAgentHttpTransport {
+    private readonly options;
+    private readonly requests;
+    readonly auth: ProductAgentSocketAuth;
+    constructor(options: {
+        backendUrl: string;
+        auth: ProductAgentSocketAuth;
+    });
+    dispose(): void;
+    request<T = unknown>(path: string, params?: Record<string, unknown>, body?: unknown, method?: string, namespace?: 'runtime' | 'extension' | 'embed'): Promise<T>;
+}

package/dist/adapters/web/backendTransport.d.ts

@@ -0,0 +1,54 @@
+import { ProductAgentHttpTransport } from './backendHttp';
+import { ProductAgentSocketIOTransport, type ProductAgentSocketAuth } from './socketIOTransport';
+type WireEvent = Record<string, any> & {
+    type: string;
+};
+type Options = {
+    backendUrl: string;
+    auth: ProductAgentSocketAuth;
+    pageUrl: () => string;
+    currentSession: (page?: Record<string, any>) => string | null;
+    contextKey?: (event: WireEvent) => string;
+    sessionReferences: () => readonly string[];
+};
+export declare class ProductAgentBackendTransport extends EventTarget {
+    private readonly options;
+    readyState: number;
+    private readonly transport;
+    readonly httpTransport: ProductAgentHttpTransport;
+    private readonly contextRevisions;
+    private promptRevision;
+    private initialized;
+    private bootstrapped;
+    private credentialBootstrap;
+    private readonly beforeBootstrap;
+    private readonly memberships;
+    private readonly pendingMemberships;
+    private readonly toolReceipts;
+    private readonly acceptedMessages;
+    private hydration;
+    private hydrations;
+    constructor(options: Options);
+    get directoryRooms(): Pick<ProductAgentSocketIOTransport, 'retain' | 'release'>;
+    replaceCredentials(auth: ProductAgentSocketAuth, authorityChanged: boolean, bootstrap?: Record<string, any> | null): void;
+    pause(): void;
+    close(): void;
+    private finishClose;
+    send(data: string): void;
+    private receive;
+    acceptMessage(message: Event): void;
+    private rejectToolReceipts;
+    private deliver;
+    private buffer;
+    private fail;
+    private http;
+    private dispatch;
+    private isCurrent;
+    synchronizeReferences(): void;
+    private restoreReference;
+    private retain;
+    private hydrate;
+}
+export { ProductAgentHttpTransport } from './backendHttp';
+export { createDirectoryPorts, ProductAgentDirectoryObservationAdapter } from './directoryAdapters';
+export { ProductAgentDirectoryScopeAdapter, createWebDirectoryPersistence } from './directoryScope';

package/dist/adapters/web/directoryAdapters.d.ts

@@ -0,0 +1,85 @@
+import type { PARequestId, PASessionId } from '../../core/kernel/state';
+import type { PAConversationMetadata, PADirectoryAuthority, PADirectoryPorts, PADirectoryQuery } from '../../core/session-directory/contracts';
+import { ProductAgentSessionRecoveryPoller } from '../../sessionRecoveryPolling';
+import type { PAClientRuntime } from '../../runtime/composition';
+import { ProductAgentHttpTransport } from './backendHttp';
+import type { ProductAgentSocketIOTransport } from './socketIOTransport';
+export declare const DIRECTORY_POLL_INTERVALS: {
+    readonly activeIntervalMs: 3000;
+    readonly idleIntervalMs: 15000;
+    readonly maxFailureIntervalMs: 30000;
+};
+type AuthorityBoundary = {
+    authority: PADirectoryAuthority;
+    currentAuthority: () => {
+        authorityId: string | null;
+        generation: number;
+    };
+};
+export declare function normalizeDirectoryQuery(query: PADirectoryQuery): PADirectoryQuery;
+export declare function readDirectoryMetadata(http: ProductAgentHttpTransport, sessionId: string): Promise<PAConversationMetadata>;
+export declare function waitForDirectoryMutation(options: {
+    runtime: PAClientRuntime;
+    authority: PADirectoryAuthority;
+    sessionId: string;
+    field: "title" | "pinned";
+    requestId: PARequestId;
+    isDisposed: () => boolean;
+    failureMessage: string;
+}): Promise<void>;
+export declare function createDirectoryPorts(options: AuthorityBoundary & {
+    http: ProductAgentHttpTransport;
+    pageUrl: () => string;
+    now: () => number;
+    onError?: (error: unknown) => void;
+}): PADirectoryPorts;
+type RecoveryHandle = Pick<ProductAgentSessionRecoveryPoller<unknown>, 'start' | 'stop' | 'refresh'>;
+export type PADirectoryRecoveryHandles = {
+    transcript: RecoveryHandle;
+    activity: RecoveryHandle;
+};
+export declare class ProductAgentDirectoryObservationAdapter {
+    private readonly options;
+    private readonly queryRequests;
+    private readonly queryWaiters;
+    private readonly refreshAfterRequest;
+    private readonly observations;
+    private readonly unsubscribe;
+    private readonly owner;
+    private disposed;
+    private readonly boundary;
+    constructor(options: {
+        runtime: PAClientRuntime;
+        authority: PADirectoryAuthority;
+        http: ProductAgentHttpTransport;
+        socket: Pick<ProductAgentSocketIOTransport, 'retain' | 'release'>;
+        recovery: (sessionId: string) => PADirectoryRecoveryHandles;
+        isActiveTurn: (sessionId: string) => boolean;
+        nextRequestId: () => string;
+        onError: (error: unknown) => void;
+        wakeup: {
+            start: () => void;
+            stop: () => void;
+        };
+        enabled?: () => boolean;
+        observedQueries: () => readonly PADirectoryQuery[];
+    });
+    reconcile(): void;
+    metadata(value: PAConversationMetadata): void;
+    open(query: PADirectoryQuery, mode?: 'replace' | 'append', cursor?: string | null): Promise<void>;
+    requestPage(query: PADirectoryQuery, mode?: 'replace' | 'append', cursor?: string | null): Promise<readonly PASessionId[]>;
+    private enqueueQuery;
+    private readPage;
+    refresh(query: PADirectoryQuery, loadAllPages?: boolean): Promise<void>;
+    private refreshObservedQuery;
+    private refreshPages;
+    private waitForQuery;
+    focus(): Promise<void>;
+    private observedQueryStates;
+    private isObserved;
+    refreshObservedQueries(): Promise<void>;
+    reconnect(): Promise<void>;
+    private report;
+    dispose(): void;
+}
+export {};

package/dist/adapters/web/directoryScope.d.ts

@@ -0,0 +1,42 @@
+import type { PAClientScopeId, PAConversationScopeId, PASessionId } from '../../core/kernel/state';
+import type { PADirectoryAuthority } from '../../core/session-directory/contracts';
+import type { PAClientRuntime } from '../../runtime/composition';
+export type PADirectoryBindingCheckpoint = Readonly<{
+    version: 1;
+    authorityId: string;
+    browserSessionId: string;
+    bindings: readonly Readonly<{
+        clientScopeId: PAClientScopeId;
+        conversationScopeId: PAConversationScopeId;
+        sessionId: PASessionId | null;
+        provisionalId: string | null;
+    }>[];
+    mains: Readonly<Record<string, PAClientScopeId>>;
+}>;
+export type PADirectoryBindingPersistence = {
+    read: () => Promise<unknown>;
+    write: (value: PADirectoryBindingCheckpoint) => Promise<void>;
+    sessionId: () => string;
+    liveClients: () => Promise<readonly string[]>;
+};
+export declare class ProductAgentDirectoryScopeAdapter {
+    private readonly options;
+    constructor(options: {
+        runtime: PAClientRuntime;
+        authority: PADirectoryAuthority;
+        random: () => number;
+        persistence: PADirectoryBindingPersistence;
+    });
+    private state;
+    private current;
+    private replacement;
+    private choose;
+    bind(clientScopeId: PAClientScopeId, conversationScopeId: PAConversationScopeId, sessionId: PASessionId, reason?: 'user' | 'tool'): Promise<void>;
+    detach(clientScopeId: PAClientScopeId): Promise<void>;
+    provisional(clientScopeId: PAClientScopeId, conversationScopeId: PAConversationScopeId, provisionalId: string): Promise<void>;
+    accepted(conversationScopeId: PAConversationScopeId, provisionalId: string, sessionId: PASessionId): Promise<void>;
+    persist(): Promise<void>;
+    restore(expectedSessionId?: string | null): Promise<boolean>;
+}
+export declare function createWebDirectoryPersistence(storage: Pick<Storage, 'getItem' | 'setItem'>, clientScopeId: PAClientScopeId, authorityId: string, newId?: () => string): PADirectoryBindingPersistence;
+export declare function createBrowserDirectoryPersistence(clientScopeId: PAClientScopeId, authorityId: string, newId?: () => string): PADirectoryBindingPersistence;

package/dist/adapters/web/modelScope.d.ts

@@ -0,0 +1,3 @@
+import type { PAClientScopeId } from "../../core/kernel/state";
+export declare function getWebModelScopeId(storage: Pick<Storage, "getItem" | "setItem">, namespace: string, newId: () => string): PAClientScopeId;
+export declare function getBrowserModelScopeId(namespace: string, newId: () => string): PAClientScopeId;

package/dist/adapters/web/socketIOTransport.d.ts

@@ -0,0 +1,72 @@
+export type ProductAgentSocketAuth = {
+    protocol: 1;
+    token: string;
+    client_id: string;
+    client_kind: "web" | "embed" | "extension";
+    role: "session_surface" | "embedded_executor" | "browser_broker";
+    transport_id?: string;
+    community_id?: string;
+    automation_run_id?: string;
+    local_runtime_client_id?: string;
+    extension_id?: string;
+    extension_version?: string;
+};
+type Ready = {
+    protocol: number;
+    role: string;
+    metadata_ready: boolean;
+    display_projection_ready: boolean;
+    capabilities: string[];
+};
+type Options = {
+    backendUrl: string;
+    auth: ProductAgentSocketAuth;
+    onReady: (ready: Ready) => void;
+    onDisconnect: (intentional: boolean) => void;
+    onEvent: (name: string, event: unknown) => void;
+    onToolCall: (event: unknown) => boolean | Promise<boolean>;
+    onError: (error: ProductAgentSocketError) => void;
+    requestTimeoutMs?: number;
+    reconnect?: boolean;
+};
+export declare class ProductAgentSocketError extends Error {
+    readonly code: string;
+    readonly outcomeUnknown: boolean;
+    readonly detail?: unknown | undefined;
+    constructor(message: string, code: string, outcomeUnknown?: boolean, detail?: unknown | undefined);
+}
+export declare class ProductAgentSocketIOTransport {
+    private readonly options;
+    private readonly socket;
+    private generation;
+    private active;
+    private ready;
+    private admitted;
+    private activating;
+    private rejectedToken;
+    private retired;
+    private replacingCredentials;
+    private readonly bindings;
+    private readonly pending;
+    private operations;
+    private queuedOperations;
+    private uploadingResult;
+    constructor(options: Options);
+    connect(): void;
+    replaceCredentials(auth: ProductAgentSocketAuth, authorityChanged: boolean): void;
+    suspend(): void;
+    disconnect(): void;
+    dispose(): void;
+    retain(sessionId: string, owner: string): Promise<void>;
+    release(sessionId: string, owner: string): Promise<void>;
+    rpc(type: string, payload: Record<string, unknown>): Promise<unknown>;
+    private activate;
+    private activationFailed;
+    private synchronize;
+    private enqueue;
+    private assertReady;
+    private uploadResult;
+    private request;
+    private invalidate;
+}
+export {};

package/dist/chatPresentation.d.ts

@@ -0,0 +1,2 @@
+export declare const EMPTY_CONVERSATION_MESSAGE = "Looks like no message is sent yet";
+export declare function getChatErrorPlacement(code: string | null | undefined): "bottom_notice" | "conversation";

package/dist/core/active-users/reducer.d.ts

@@ -0,0 +1,47 @@
+import { type PAQueryState } from "../kernel/state";
+import type { PAEffect, PAEffectResultEvent } from "../kernel/effects";
+export declare const ACTIVE_USERS_POLL_MS = 10000;
+export declare const ACTIVE_USERS_DISPLAY_MS = 1000;
+export type PAActiveUsersState = Readonly<{
+    authenticated: boolean;
+    generation: number;
+    sequence: number;
+    displaySequence: number;
+    backendCount: number | null;
+    query: PAQueryState<"activeUsers", number>;
+}>;
+export type PAActiveUsersCommand = Readonly<{
+    type: "activeUsers.authenticate";
+    authenticated: boolean;
+}>;
+export type PAActiveUsersEffects = {
+    "activeUsers.load": {
+        input: {
+            generation: number;
+        };
+        output: {
+            count: number;
+            updatedAt: number;
+            offset: number;
+        };
+    };
+    "activeUsers.displayWait": {
+        input: {
+            milliseconds: number;
+        };
+        output: {
+            offset: number;
+        };
+    };
+    "activeUsers.wait": {
+        input: {
+            milliseconds: number;
+        };
+        output: null;
+    };
+};
+export declare function createActiveUsersState(): PAActiveUsersState;
+export declare function reduceActiveUsers(state: PAActiveUsersState, event: PAActiveUsersCommand | PAEffectResultEvent<PAActiveUsersEffects>): {
+    state: PAActiveUsersState;
+    effects: PAEffect<PAActiveUsersEffects>[];
+};

package/dist/core/index.d.ts

@@ -12,3 +12,8 @@ export * from "./model-selection/contracts";
 export * from "./ports";
 export * from "./protocol/errors";
 export * from "./protocol/json";
+export * from "./session-directory/contracts";
+export * from "./session-directory/state";
+export * from "./session-directory/reducer";
+export * from "./session-directory/selectors";
+export * from "./session-directory/membership";

package/dist/core/model-selection/commands.d.ts

@@ -0,0 +1,22 @@
+import type { PAClientScopeId } from "../kernel/state";
+import type { PAProductAgentModel } from "./contracts";
+export type PAModelCommand = Readonly<{
+    clientScopeId: PAClientScopeId;
+}> & (Readonly<{
+    type: "model.scope_open";
+    sessionId: string | null;
+    defaultModel: PAProductAgentModel | undefined;
+    selectedModel?: PAProductAgentModel;
+}> | Readonly<{
+    type: "composer.select_model";
+    model: PAProductAgentModel;
+}> | Readonly<{
+    type: "model.scope_navigate";
+    sessionId: string | null;
+}> | Readonly<{
+    type: "model.submission_capture";
+    clientMessageId: string;
+    requestedModel?: PAProductAgentModel;
+}> | Readonly<{
+    type: "model.scope_close";
+}>);

package/dist/core/model-selection/contracts.d.ts

@@ -1,6 +1,8 @@
 import type { PAClientScopeId } from "../kernel/state";
-export type PAProductAgentModel = "anthropic/claude-opus-5" | "anthropic/claude-sonnet-5" | "deepseek/deepseek-chat-v3.1" | "deepseek/deepseek-v4-flash" | "gpt-5.4-nano" | "gpt-5.4-mini" | "gpt-5.4" | "gpt-5.6-luna" | "gpt-5.6-terra" | "gpt-5.6-sol";
+export declare const PA_PRODUCT_AGENT_MODELS: readonly ["anthropic/claude-opus-5", "anthropic/claude-sonnet-5", "deepseek/deepseek-chat-v3.1", "deepseek/deepseek-v4-flash", "gpt-5.4-nano", "gpt-5.4-mini", "gpt-5.4", "gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"];
+export type PAProductAgentModel = (typeof PA_PRODUCT_AGENT_MODELS)[number];
 export type PAComposerModelSelection = Readonly<{
     clientScopeId: PAClientScopeId;
     requestedModel: PAProductAgentModel;
 }>;
+export declare const isPAProductAgentModel: (value: unknown) => value is PAProductAgentModel;

package/dist/core/model-selection/events.d.ts

@@ -0,0 +1,15 @@
+import type { PAClientScopeId } from "../kernel/state";
+import type { PAProductAgentModel } from "./contracts";
+import type { PATurnModelRouting } from "./state";
+export type PAModelEvent = Readonly<{
+    clientScopeId: PAClientScopeId;
+    sessionId: string;
+}> & (Readonly<{
+    type: "model.history_received";
+    model?: PAProductAgentModel;
+}> | Readonly<{
+    type: "model.routing_accepted";
+    clientMessageId: string;
+    routing: PATurnModelRouting;
+    updatedAt?: number;
+}>);

package/dist/core/model-selection/reducer.d.ts

@@ -0,0 +1,4 @@
+import type { PAModelCommand } from "./commands";
+import type { PAModelEvent } from "./events";
+import type { PAModelSelectionState } from "./state";
+export declare function reduceModelSelection(state: PAModelSelectionState, input: PAModelCommand | PAModelEvent): PAModelSelectionState;

package/dist/core/model-selection/selectors.d.ts

@@ -0,0 +1,10 @@
+import type { PAClientScopeId } from "../kernel/state";
+import type { PAModelScope, PAModelSelectionState } from "./state";
+export declare const selectNextTurnModel: (scope: PAModelScope) => "anthropic/claude-opus-5" | "anthropic/claude-sonnet-5" | "deepseek/deepseek-chat-v3.1" | "deepseek/deepseek-v4-flash" | "gpt-5.4-nano" | "gpt-5.4-mini" | "gpt-5.4" | "gpt-5.6-luna" | "gpt-5.6-terra" | "gpt-5.6-sol" | undefined;
+export declare const selectModelScope: (state: PAModelSelectionState, clientScopeId: PAClientScopeId) => Readonly<{
+    sessionId: string | null;
+    defaultModel: import("./contracts").PAProductAgentModel | undefined;
+    historyModel?: import("./contracts").PAProductAgentModel;
+    selectedModel?: import("./contracts").PAProductAgentModel;
+    submissions: Readonly<Record<string, import("./state").PAModelSubmission>>;
+}>;

package/dist/core/model-selection/state.d.ts

@@ -0,0 +1,22 @@
+import type { PAProductAgentModel } from "./contracts";
+export type PATurnModelRouting = Readonly<{
+    requestedModel: PAProductAgentModel;
+    effectiveModel: PAProductAgentModel;
+    provider: "openrouter" | "azure" | "openai";
+}>;
+export type PAModelSubmission = Readonly<{
+    requestedModel: PAProductAgentModel | undefined;
+    routing?: PATurnModelRouting;
+    routingUpdatedAt?: number;
+}>;
+export type PAModelScope = Readonly<{
+    sessionId: string | null;
+    defaultModel: PAProductAgentModel | undefined;
+    historyModel?: PAProductAgentModel;
+    selectedModel?: PAProductAgentModel;
+    submissions: Readonly<Record<string, PAModelSubmission>>;
+}>;
+export type PAModelSelectionState = Readonly<{
+    scopes: Readonly<Record<string, PAModelScope>>;
+}>;
+export declare const createModelSelectionState: () => PAModelSelectionState;

package/dist/core/protocol/modelRouting.d.ts

@@ -0,0 +1,2 @@
+import type { PATurnModelRouting } from "../model-selection/state";
+export declare function decodeAcceptedModelRouting(value: unknown): PATurnModelRouting | undefined;

package/dist/core/session-directory/contracts.d.ts

@@ -0,0 +1,202 @@
+import type { PAEffectHandlers } from "../kernel/effects";
+import type { PAAuthorityId, PAClientScopeId, PAConversationScopeId, PAQueryState, PARequestId, PASessionId, PAViewId } from "../kernel/state";
+import type { PATransportedError } from "../protocol/errors";
+import type { PAJsonValue } from "../protocol/json";
+export type PAConversationMetadata = Readonly<{
+    conversation_id: PASessionId;
+    version: number;
+    conversation: Readonly<{
+        id: PASessionId;
+        user_id: string;
+        community_id: string | null;
+        product_variant: "personal" | "customer_embedded";
+        created_at: string;
+        last_activity_at: string;
+        pinned: boolean;
+        title: string | null;
+        title_source: "generated" | "user";
+    }>;
+    automation_id: string | null;
+    automation_run_id: string | null;
+    first_user_message?: string | null;
+    current_page?: PAJsonValue;
+    is_active?: boolean | null;
+}>;
+export type PADirectoryOptimisticEntry = Readonly<{
+    id: string;
+    clientMessageId: string;
+    sessionId: PASessionId | null;
+    firstUserMessage: string;
+    currentPage: PAJsonValue;
+    createdAt: string;
+    isActive: boolean;
+}>;
+export type PAConversationDirectoryPage = Readonly<{
+    entries: readonly PAConversationMetadata[];
+    next_cursor: string | null;
+}>;
+export type PADirectoryAuthority = Readonly<{
+    authorityId: PAAuthorityId;
+    generation: number;
+}>;
+export type PADirectoryQuery = Readonly<{
+    kind: "recent" | "pinned";
+    origin: string | null;
+    limit: number;
+}>;
+export type PADirectoryQueryState = PAQueryState<string, readonly PASessionId[]> & Readonly<{
+    query: PADirectoryQuery;
+    requestSequence: number;
+    mode: "replace" | "append";
+    invalidated: boolean;
+    startedAtMetadataRevision: number;
+    startedAtActivityRevisionBySessionId: Readonly<Record<string, number>>;
+    pageData: readonly PASessionId[];
+}>;
+export type PADirectoryPatch = Readonly<{
+    title?: string;
+    pinned?: boolean;
+}>;
+export type PADirectoryMutation = Readonly<{
+    requestId: PARequestId;
+    value: string | boolean;
+    status: "pending" | "failed";
+    error: PATransportedError | null;
+}>;
+export type PAMembership = Readonly<{
+    members: readonly PAClientScopeId[];
+    mainClientScopeId: PAClientScopeId | null;
+}>;
+export type PAMainReplacement = Readonly<{
+    sessionId: PASessionId;
+    membershipRevision: number;
+    clientScopeId: PAClientScopeId;
+}>;
+export type PAConversationSelection = Readonly<{
+    sessionId: PASessionId | null;
+    provisionalId: string | null;
+}>;
+export type PADirectoryState = Readonly<{
+    authorityId: PAAuthorityId | null;
+    generation: number;
+    entities: Readonly<Record<string, PAConversationMetadata>>;
+    optimisticEntries: Readonly<Record<string, PADirectoryOptimisticEntry>>;
+    durableActivityBySessionId: Readonly<Record<string, boolean>>;
+    activityBySessionId: Readonly<Record<string, boolean>>;
+    activityRevisionBySessionId: Readonly<Record<string, number>>;
+    activityRevision: number;
+    queries: Readonly<Record<string, PADirectoryQueryState>>;
+    mutations: Readonly<Record<string, Readonly<Partial<Record<"title" | "pinned", PADirectoryMutation>>>>>;
+    metadataRevision: number;
+    membershipRevision: number;
+    clients: Readonly<Record<string, PAConversationScopeId>>;
+    selections: Readonly<Record<string, PAConversationSelection>>;
+    memberships: Readonly<Record<string, PAMembership>>;
+    views: Readonly<Record<string, PAClientScopeId>>;
+    requestSequence: number;
+    requests: Readonly<Record<string, PADirectoryRequest>>;
+}>;
+export type PADirectoryQueryRequest = PADirectoryAuthority & Readonly<{
+    requestId: PARequestId;
+    query: PADirectoryQuery;
+    cursor: string | null;
+}>;
+export type PADirectoryMutationRequest = PADirectoryAuthority & Readonly<{
+    requestId: PARequestId;
+    sessionId: PASessionId;
+    patch: PADirectoryPatch;
+}>;
+export type PADirectoryRequest = Readonly<{
+    kind: "directory.query";
+    input: PADirectoryQueryRequest;
+}> | Readonly<{
+    kind: "directory.mutate";
+    input: PADirectoryMutationRequest;
+}>;
+export type PADirectoryEffects = {
+    "directory.query": {
+        input: PADirectoryQueryRequest;
+        output: PAConversationDirectoryPage & Readonly<{
+            updatedAt: number;
+        }>;
+    };
+    "directory.mutate": {
+        input: PADirectoryMutationRequest;
+        output: PAConversationMetadata;
+    };
+};
+export type PADirectoryPorts = PAEffectHandlers<PADirectoryEffects>;
+export type PADirectoryCommand = PADirectoryAuthority & (Readonly<{
+    type: "directory.authority_replace";
+    expectedGeneration: number;
+}> | Readonly<{
+    type: "directory.query";
+    query: PADirectoryQuery;
+    requestId: PARequestId;
+    mode: "replace" | "append";
+    cursor?: string | null;
+}> | Readonly<{
+    type: "directory.invalidate";
+}> | Readonly<{
+    type: "directory.optimistic_upsert";
+    entry: PADirectoryOptimisticEntry;
+}> | Readonly<{
+    type: "directory.optimistic_accept";
+    clientMessageId: string;
+    sessionId: PASessionId;
+}> | Readonly<{
+    type: "directory.optimistic_remove";
+    clientMessageId: string;
+}> | Readonly<{
+    type: "directory.activity_set";
+    sessionId: PASessionId;
+    active: boolean;
+}> | Readonly<{
+    type: "directory.mutate";
+    sessionId: PASessionId;
+    requestId: PARequestId;
+    patch: PADirectoryPatch;
+}> | Readonly<{
+    type: "directory.bind";
+    clientScopeId: PAClientScopeId;
+    conversationScopeId: PAConversationScopeId;
+    sessionId: PASessionId;
+    reason: "user" | "tool";
+    replacement: PAMainReplacement | null;
+}> | Readonly<{
+    type: "directory.provisional";
+    clientScopeId: PAClientScopeId;
+    conversationScopeId: PAConversationScopeId;
+    provisionalId: string;
+    replacement: PAMainReplacement | null;
+}> | Readonly<{
+    type: "directory.accepted";
+    conversationScopeId: PAConversationScopeId;
+    provisionalId: string;
+    sessionId: PASessionId;
+}> | Readonly<{
+    type: "directory.detach";
+    clientScopeId: PAClientScopeId;
+    replacement: PAMainReplacement | null;
+}> | Readonly<{
+    type: "directory.view_attach";
+    viewId: PAViewId;
+    clientScopeId: PAClientScopeId;
+}> | Readonly<{
+    type: "directory.view_detach";
+    viewId: PAViewId;
+}>);
+export type PADirectoryEvent = PADirectoryAuthority & Readonly<{
+    type: "directory.metadata_received";
+    metadata: PAConversationMetadata;
+}>;
+export type PADirectoryIntent = Readonly<{
+    observe: boolean;
+    titleClientScopeId: PAClientScopeId | null;
+    title: string | null;
+    groupClientScopeIds: readonly PAClientScopeId[];
+}>;
+export type PADirectoryProjection = Omit<PADirectoryState, "views" | "durableActivityBySessionId" | "activityRevisionBySessionId" | "activityRevision"> & Readonly<{
+    intents: Readonly<Record<string, PADirectoryIntent>>;
+    views: Readonly<Record<string, PAConversationSelection | null>>;
+}>;