@makaio/contracts 1.0.0-dev-1779051654000

package/dist/session/schemas/events.d.ts

@@ -0,0 +1,525 @@
+import { z } from 'zod';
+/**
+ * Session client-account linkage changed event payload.
+ */
+export declare const SessionClientAccountChangedSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    clientId: z.ZodString;
+    previousClientAccountId: z.ZodNullable<z.ZodString>;
+    clientAccountId: z.ZodString;
+    source: z.ZodString;
+    observedAt: z.ZodNumber;
+    lastClientIdentityObservation: z.ZodObject<{
+        clientId: z.ZodString;
+        source: z.ZodString;
+        kind: z.ZodString;
+        observedAt: z.ZodNumber;
+        payload: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SessionClientAccountChanged = z.infer<typeof SessionClientAccountChangedSchema>;
+/**
+ * Session event schemas.
+ *
+ * Handles session lifecycle events and context window state queries.
+ */
+export declare const EventSchemas: {
+    /**
+     * Agent added to session event.
+     *
+     * Subject: `session.agent.added`
+     * Type: Event (fire-and-forget)
+     * Emitted when: An agent is attached to a session
+     * @example
+     * ```typescript
+     * bus.on(SessionSubjects.agent.added, (ctx) => {
+     *   console.debug(`Agent ${ctx.payload.agentId} joined session ${ctx.payload.sessionId}`);
+     * });
+     * ```
+     */
+    'agent.added': z.ZodObject<{
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodString;
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        role: z.ZodOptional<z.ZodEnum<{
+            lead: "lead";
+            member: "member";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /**
+     * Agent removed from session event.
+     *
+     * Subject: `session.agent.removed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: An agent is detached/removed from a session
+     * @example
+     * ```typescript
+     * bus.on(SessionSubjects.agent.removed, (ctx) => {
+     *   console.debug(`Agent ${ctx.payload.agentId} left session ${ctx.payload.sessionId}`);
+     * });
+     * ```
+     */
+    'agent.removed': z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Session closed event.
+     *
+     * Subject: `session.closed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A session is closed (via close request)
+     * @example
+     * ```typescript
+     * bus.on(SessionSubjects.closed, (ctx) => {
+     *   console.debug(`Session ${ctx.payload.sessionId} closed`);
+     *   if (ctx.payload.reason) {
+     *     console.debug(`Reason: ${ctx.payload.reason}`);
+     *   }
+     * });
+     * ```
+     */
+    closed: z.ZodObject<{
+        sessionId: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /**
+     * Session resumed event.
+     *
+     * Subject: `session.resumed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A closed session is resumed to active state
+     */
+    resumed: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Session archived event.
+     *
+     * Subject: `session.archived`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A closed session is archived
+     */
+    archived: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Session purged event.
+     *
+     * Subject: `session.purged`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A session is permanently deleted (via purge request)
+     * @example
+     * ```typescript
+     * bus.on(SessionSubjects.purged, (ctx) => {
+     *   console.debug(`Session ${ctx.payload.sessionId} purged`);
+     * });
+     * ```
+     */
+    purged: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Session compressed event.
+     *
+     * Subject: `session.compressed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A session's context is compressed (via compress request)
+     *
+     * Used to notify components (like ContextWindowTracker) that context state
+     * should be cleared since compression resets the context window.
+     * @example
+     * ```typescript
+     * bus.on(SessionSubjects.compressed, (ctx) => {
+     *   console.debug(`Session ${ctx.payload.sessionId} compressed`);
+     *   // Clear cached context state
+     * });
+     * ```
+     */
+    compressed: z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Session client-account linkage changed event.
+     *
+     * Subject: `session.clientAccount.changed`
+     * Type: Event (fire-and-forget)
+     * Emitted when: A session resolves to a different canonical client account
+     */
+    'clientAccount.changed': z.ZodObject<{
+        sessionId: z.ZodString;
+        clientId: z.ZodString;
+        previousClientAccountId: z.ZodNullable<z.ZodString>;
+        clientAccountId: z.ZodString;
+        source: z.ZodString;
+        observedAt: z.ZodNumber;
+        lastClientIdentityObservation: z.ZodObject<{
+            clientId: z.ZodString;
+            source: z.ZodString;
+            kind: z.ZodString;
+            observedAt: z.ZodNumber;
+            payload: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    /**
+     * Request UI to open history editing flow after a connector swap decision.
+     *
+     * Subject: `session.connectorSwap.editRequested`
+     * Type: Event (fire-and-forget)
+     */
+    'connectorSwap.editRequested': z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        previousCwd: z.ZodOptional<z.ZodString>;
+        newCwd: z.ZodOptional<z.ZodString>;
+        previousModel: z.ZodOptional<z.ZodString>;
+        newModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /**
+     * Get context window state for a session.
+     *
+     * Subject: `session.getContextWindowState`
+     * Type: Request (RPC)
+     *
+     * Returns the current context window usage for a session, aggregated
+     * across all agents (using "worst agent" strategy).
+     * @example
+     * ```typescript
+     * const { state } = await bus.request(SessionSubjects.getContextWindowState, {
+     *   sessionId: 'session-123',
+     * });
+     * if (state.level === 'critical') {
+     *   // Suggest compression
+     * }
+     * ```
+     */
+    getContextWindowState: {
+        request: z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            state: z.ZodNullable<z.ZodObject<{
+                currentTokens: z.ZodNumber;
+                maxTokens: z.ZodNumber;
+                percentage: z.ZodNumber;
+                level: z.ZodEnum<{
+                    critical: "critical";
+                    ok: "ok";
+                    warn: "warn";
+                }>;
+                lastUpdatedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Catch-all session event for observability and persistence.
+     *
+     * Subject: `session.event`
+     * Type: Event (fire-and-forget)
+     * Use for: Single subscription to all session events, event storage
+     */
+    event: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"agent.added">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            adapterSessionId: z.ZodString;
+            agentId: z.ZodString;
+            adapterId: z.ZodString;
+            adapterName: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                lead: "lead";
+                member: "member";
+            }>>;
+            model: z.ZodOptional<z.ZodString>;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"user_message.sent">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            turnId: z.ZodString;
+            turnNumber: z.ZodNumber;
+            messageId: z.ZodString;
+            content: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                role: z.ZodOptional<z.ZodEnum<{
+                    assistant: "assistant";
+                    system: "system";
+                    user: "user";
+                }>>;
+                blocks: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    content: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"document">;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"attachment">;
+                    fileName: z.ZodString;
+                    filePath: z.ZodString;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                    displayName: z.ZodOptional<z.ZodString>;
+                    attachmentType: z.ZodEnum<{
+                        directory: "directory";
+                        file: "file";
+                    }>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"reasoning">;
+                    content: z.ZodString;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_call">;
+                    toolCallId: z.ZodString;
+                    name: z.ZodString;
+                    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_output">;
+                    toolCallId: z.ZodString;
+                    output: z.ZodString;
+                    isError: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    content: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"document">;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"attachment">;
+                    fileName: z.ZodString;
+                    filePath: z.ZodString;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"base64">;
+                        data: z.ZodString;
+                        mimeType: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"url">;
+                        url: z.ZodString;
+                        mimeType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>], "type">;
+                    displayName: z.ZodOptional<z.ZodString>;
+                    attachmentType: z.ZodEnum<{
+                        directory: "directory";
+                        file: "file";
+                    }>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"reasoning">;
+                    content: z.ZodString;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_call">;
+                    toolCallId: z.ZodString;
+                    name: z.ZodString;
+                    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_output">;
+                    toolCallId: z.ZodString;
+                    output: z.ZodString;
+                    isError: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>]>;
+            }, z.core.$strip>]>;
+            agentIds: z.ZodArray<z.ZodString>;
+            source: z.ZodOptional<z.ZodEnum<{
+                extension: "extension";
+                system: "system";
+                user: "user";
+            }>>;
+            origin: z.ZodOptional<z.ZodEnum<{
+                compact: "compact";
+                text: "text";
+                voice: "voice";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"user_message.acknowledged">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            turnId: z.ZodString;
+            turnNumber: z.ZodNumber;
+            messageId: z.ZodString;
+            agentId: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"user_message.completed">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            turnId: z.ZodString;
+            turnNumber: z.ZodNumber;
+            messageId: z.ZodString;
+            agentId: z.ZodString;
+            outcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                error: "error";
+                merged: "merged";
+                rejected: "rejected";
+                superseded: "superseded";
+            }>;
+            supersededBy: z.ZodOptional<z.ZodString>;
+            mergedInto: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"turn.started">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            turnId: z.ZodString;
+            turnNumber: z.ZodNumber;
+            messageId: z.ZodString;
+            agentIds: z.ZodArray<z.ZodString>;
+            initiator: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    extension: "extension";
+                    system: "system";
+                    user: "user";
+                }>;
+                sourceId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"turn.completed">;
+        payload: z.ZodObject<{
+            sessionId: z.ZodString;
+            turnId: z.ZodString;
+            turnNumber: z.ZodNumber;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            initiator: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    extension: "extension";
+                    system: "system";
+                    user: "user";
+                }>;
+                sourceId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"message">;
+        payload: z.ZodObject<{
+            messageId: z.ZodString;
+            turnId: z.ZodNullable<z.ZodString>;
+            role: z.ZodEnum<{
+                assistant: "assistant";
+                user: "user";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"branch.created">;
+        payload: z.ZodObject<{
+            childSessionId: z.ZodString;
+            parentSessionId: z.ZodString;
+            kind: z.ZodEnum<{
+                aside: "aside";
+                branch: "branch";
+                compress: "compress";
+                coordinator: "coordinator";
+                fork: "fork";
+                rewrite: "rewrite";
+                subagent: "subagent";
+            }>;
+            forkPointMessageId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"branch.merged">;
+        payload: z.ZodObject<{
+            childSessionId: z.ZodString;
+            parentSessionId: z.ZodString;
+            resultJson: z.ZodOptional<z.ZodString>;
+            resultMessageId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodLiteral<"squash">;
+        payload: z.ZodObject<{
+            summaryJson: z.ZodString;
+            tokensBefore: z.ZodOptional<z.ZodNumber>;
+            tokensAfter: z.ZodOptional<z.ZodNumber>;
+            compressedMessageIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">, z.ZodObject<{
+        sessionId: z.ZodString;
+        eventId: z.ZodString;
+        timestamp: z.ZodNumber;
+        type: z.ZodString;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>]>;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/session/schemas/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/session/schemas/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;iBAQ5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;IAoBH;;;;;;;;;;;;OAYG;;;;;IAQH;;;;;;;;;;;;;;;OAeG;;;;;IAQH;;;;;;OAMG;;;;IAMH;;;;;;OAMG;;;;IAMH;;;;;;;;;;;;OAYG;;;;IAMH;;;;;;;;;;;;;;;;OAgBG;;;;;IAQH;;;;;;OAMG;;;;;;;;;;;;;;;;IAGH;;;;;OAKG;;;;;;;;;IAgBH;;;;;;;;;;;;;;;;;OAiBG;;;;;;;;;;;;;;;;;;;IAqBH;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEmB,CAAC"}

package/dist/session/schemas/extension-context.d.ts

@@ -0,0 +1,79 @@
+import type { Message } from '../../shared/index.js';
+/**
+ * Options for forking a session.
+ */
+export interface ForkOptions {
+    /** Why this fork was created (for audit) */
+    reason: string;
+    /** Which agent should handle the child session */
+    targetAgentId?: string;
+    /** Initial message for child session */
+    initialMessage?: Message;
+    /** Whether to copy parent's context to child (default: true) */
+    inheritContext?: boolean;
+}
+/**
+ * Context window state for threshold checking.
+ */
+export interface ContextWindowState {
+    currentTokens: number;
+    maxTokens: number;
+    percentage: number;
+    level: 'ok' | 'warn' | 'critical';
+}
+/**
+ * Session-specific context provided to extensions during lifecycle events.
+ * All actions route through SessionOrchestrator.
+ *
+ * Note: This is separate from PluginContext (extensions/core) which is for initialize().
+ */
+export interface SessionExtensionContext {
+    /** Current session ID */
+    readonly sessionId: string;
+    /** Current turn ID (if in a turn) */
+    readonly turnId?: string;
+    /** Parent session ID (if this is a forked session) */
+    readonly parentSessionId?: string;
+    /** Extension's own ID (for audit trail) */
+    readonly extensionId: string;
+    /**
+     * Send a message to an agent.
+     * Routes through SessionOrchestrator, not directly to agent.
+     */
+    sendToAgent(agentId: string, message: Message): Promise<void>;
+    /**
+     * Contribute context for the next turn.
+     * Added to SessionContext.context via declaration-merge pattern.
+     */
+    contributeContext(key: string, value: unknown): void;
+    /**
+     * Fork the current session into a child session.
+     * @returns Child session ID
+     */
+    fork(options: ForkOptions): Promise<string>;
+    /**
+     * Merge a child session back into this session.
+     */
+    merge(childSessionId: string, summary?: string): Promise<void>;
+    /**
+     * Abandon a child session without merging.
+     */
+    abandon(childSessionId: string): Promise<void>;
+    /**
+     * Request compression of the current session.
+     */
+    requestCompression(reason: string): Promise<void>;
+    /**
+     * Get current context window state.
+     */
+    getContextWindowState(): Promise<ContextWindowState>;
+    /**
+     * Get child sessions of current session.
+     */
+    getChildSessions(): Promise<string[]>;
+}
+/**
+ * Factory function type for creating SessionExtensionContext instances.
+ */
+export type SessionExtensionContextFactory = (sessionId: string, extensionId: string, turnId?: string) => SessionExtensionContext;
+//# sourceMappingURL=extension-context.d.ts.map

package/dist/session/schemas/extension-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-context.d.ts","sourceRoot":"","sources":["../../../src/session/schemas/extension-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IAGtC,yBAAyB;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB,sDAAsD;IACtD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAElC,2CAA2C;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAI7B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAI9D;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAIrD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5C;;OAEG;IACH,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/D;;OAEG;IACH,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAI/C;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAIlD;;OAEG;IACH,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAErD;;OAEG;IACH,gBAAgB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,CAC3C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,MAAM,KACZ,uBAAuB,CAAC"}

package/dist/session/schemas/fork-child-info.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+/**
+ * Information about a child session for fork display.
+ * Used by getChildren enriched response.
+ */
+export declare const ForkChildInfoSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    forkPointMessageId: z.ZodNullable<z.ZodString>;
+    branchKind: z.ZodNullable<z.ZodEnum<{
+        aside: "aside";
+        branch: "branch";
+        compress: "compress";
+        coordinator: "coordinator";
+        fork: "fork";
+        rewrite: "rewrite";
+        subagent: "subagent";
+    }>>;
+    messageCount: z.ZodNumber;
+    hasChildren: z.ZodBoolean;
+    spawningToolCallId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ForkChildInfo = z.infer<typeof ForkChildInfoSchema>;
+//# sourceMappingURL=fork-child-info.d.ts.map

package/dist/session/schemas/fork-child-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-child-info.d.ts","sourceRoot":"","sources":["../../../src/session/schemas/fork-child-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAe9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}