@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/session-facade-factory.js

@@ -0,0 +1,460 @@
+/**
+ * SessionFacade factory.
+ *
+ * Builds a fully wired, pure event-sourced session: EventStore (SQLite) +
+ * projection SessionManager + EventSourcedRuntime, wrapped in a SessionFacade.
+ *
+ * This is the primary session creation API. Modes and extensions subscribe
+ * directly to EventStore TypedEvents through the facade.
+ */
+import { join } from "node:path";
+import { streamSimple } from "@earendil-works/pi-ai/compat";
+import { getAgentDir, getDocsPath } from "../config.js";
+import { AuthStorage } from "./auth-storage.js";
+import { estimateContextTokens } from "./compaction/index.js";
+import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { EventStoreExtensionSessionManager, ExtensionRunner, } from "./extensions/index.js";
+import { SqliteEventStore } from "./event-store/sqlite-store.js";
+import { deriveWorkspaceId, ensureWorkspaceMeta, getEventDatabasePath, getSessionIndexPath } from "./event-store/workspace.js";
+import { createToolRegistry } from "./intent/tool-adapter.js";
+import { ModelRegistry } from "./model-registry.js";
+import { findInitialModel } from "./model-resolver.js";
+import { SessionManager as ProjectionSessionManager } from "./projection/session-manager.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { buildLlmClientFromStreamFn, toModelConfig } from "./runtime/ai-client.js";
+import { DefaultRetryPolicy } from "./runtime/policies.js";
+import { EventSourcedRuntime } from "./runtime/runtime.js";
+import { SessionFacade } from "./session-facade.js";
+import { SettingsManager } from "./settings-manager.js";
+import { createSyntheticSourceInfo } from "./source-info.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { allToolNames, createToolDefinition, DEFAULT_LLM_TOOLS } from "./tools/index.js";
+import { createSessionSplitToolDefinition } from "./tools/session-split.js";
+import { wrapToolDefinitions } from "./tools/tool-definition-wrapper.js";
+function isBuiltInToolName(name) {
+    return allToolNames.has(name);
+}
+function toRuntimeToolDefinition(definition) {
+    return {
+        name: definition.name,
+        description: definition.description ?? "",
+        input_schema: definition.parameters,
+    };
+}
+function splitUserContent(content) {
+    if (typeof content === "string") {
+        return { text: content };
+    }
+    const textParts = [];
+    const images = [];
+    for (const part of content) {
+        if (part.type === "text" && typeof part.text === "string") {
+            textParts.push(part.text);
+        }
+        else if (part.type === "image") {
+            images.push(part);
+        }
+    }
+    return {
+        text: textParts.join("\n"),
+        images: images.length > 0 ? images : undefined,
+    };
+}
+function estimateContextUsage(model, messages) {
+    if (!model)
+        return undefined;
+    const contextWindow = model.contextWindow ?? 0;
+    if (contextWindow <= 0)
+        return undefined;
+    const estimate = estimateContextTokens(messages);
+    return {
+        tokens: estimate.tokens,
+        contextWindow,
+        percent: (estimate.tokens / contextWindow) * 100,
+    };
+}
+function cloneContextEventForFork(event) {
+    return {
+        actor_id: event.actor_id,
+        type: event.type,
+        payload: event.payload,
+        timestamp: event.timestamp,
+        schema_version: event.schema_version,
+    };
+}
+function prepareForkedSession(options) {
+    const { store, sessionManager, agentDir, source } = options;
+    if (source.workspaceId === store.workspace_id) {
+        sessionManager.forkFromSession(source.sessionId);
+        return;
+    }
+    const sourceAgentDir = source.agentDir ?? agentDir;
+    const sourceStore = new SqliteEventStore(source.workspaceId, getEventDatabasePath(source.workspaceId, sourceAgentDir), "session_fork_source");
+    const sourceSessionManager = new ProjectionSessionManager(sourceStore, getSessionIndexPath(source.workspaceId, sourceAgentDir));
+    try {
+        const sourceProjection = sourceSessionManager.getSessionProjection(source.sessionId);
+        if (!sourceProjection) {
+            throw new Error(`Session not found: ${source.sessionId}`);
+        }
+        const sourceDescriptor = sourceProjection.getDescriptor();
+        const forkAtEventId = sourceDescriptor.event_range.end_event_id === "HEAD"
+            ? sourceStore.head ?? sourceDescriptor.event_range.start_event_id
+            : sourceDescriptor.event_range.end_event_id;
+        const forked = sessionManager.createSession("fork", sourceDescriptor.name, {
+            parentSessionId: source.sessionId,
+        });
+        store.append({
+            actor_id: "runtime",
+            type: "SESSION_FORKED",
+            payload: {
+                new_session_id: forked.session_id,
+                parent_session_id: source.sessionId,
+                fork_at_event_id: forkAtEventId,
+            },
+            thread_id: forked.thread_id,
+        });
+        store.appendBatch(sourceProjection.buildContext().events.map(cloneContextEventForFork));
+    }
+    finally {
+        sourceSessionManager.dispose();
+        sourceStore.close();
+    }
+}
+/**
+ * Create a pure event-sourced SessionFacade.
+ */
+export async function createSessionFacade(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const agentDir = options.agentDir ?? getAgentDir();
+    const authPath = options.agentDir ? join(agentDir, "auth.json") : undefined;
+    const modelsPath = options.agentDir ? join(agentDir, "models.json") : undefined;
+    const authStorage = options.authStorage ?? AuthStorage.create(authPath);
+    const modelRegistry = options.modelRegistry ?? ModelRegistry.create(authStorage, modelsPath);
+    const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
+    let resourceLoader = options.resourceLoader;
+    if (!resourceLoader) {
+        resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager });
+        await resourceLoader.reload();
+    }
+    // ── Resolve model + thinking level ─────────────────────────────────────
+    let model = options.model;
+    let modelFallbackMessage;
+    if (!model) {
+        const resolved = await findInitialModel({
+            scopedModels: [],
+            isContinuing: false,
+            defaultProvider: settingsManager.getDefaultProvider(),
+            defaultModelId: settingsManager.getDefaultModel(),
+            defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
+            modelRegistry,
+        });
+        model = resolved.model;
+        if (!model) {
+            modelFallbackMessage = `No models available. Use /login or set an API key environment variable. See ${join(getDocsPath(), "providers.md")}. Then use /model to select a model.`;
+        }
+    }
+    let thinkingLevel = options.thinkingLevel ?? settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+    if (!model || !model.reasoning) {
+        thinkingLevel = "off";
+    }
+    // ── EventStore + projection SessionManager ─────────────────────────────
+    const workspaceId = options.workspaceId ?? deriveWorkspaceId(cwd);
+    if (options.storagePath !== ":memory:" && options.sessionIndexPath !== ":memory:") {
+        ensureWorkspaceMeta(workspaceId, cwd, options.agentDir);
+    }
+    const store = new SqliteEventStore(workspaceId, options.storagePath ?? getEventDatabasePath(workspaceId, options.agentDir));
+    const sessionManager = new ProjectionSessionManager(store, options.sessionIndexPath ?? getSessionIndexPath(workspaceId, options.agentDir));
+    if (options.forkFrom) {
+        prepareForkedSession({ store, sessionManager, agentDir, source: options.forkFrom });
+    }
+    else if (options.sessionId) {
+        sessionManager.switchTo(options.sessionId);
+    }
+    // ── Extensions + tools ─────────────────────────────────────────────────
+    const projection = sessionManager.getActiveSession();
+    const extensionSessionManager = new EventStoreExtensionSessionManager({
+        store,
+        projection,
+        cwd,
+        sessionManager,
+    });
+    const extensionsResult = resourceLoader.getExtensions();
+    const extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, cwd, extensionSessionManager, modelRegistry);
+    const requestedToolNames = options.tools ?? [...DEFAULT_LLM_TOOLS];
+    const allowedToolNames = options.tools ? new Set(options.tools) : undefined;
+    const shellCommandPrefix = settingsManager.getShellCommandPrefix();
+    const shellPath = settingsManager.getShellPath();
+    const autoResizeImages = settingsManager.getImageAutoResize();
+    const toolOptions = {
+        read: { autoResizeImages },
+        cli: { commandPrefix: shellCommandPrefix, shellPath, read: { autoResizeImages } },
+    };
+    let runtime;
+    let activeToolDefinitions = [];
+    let availableToolDefinitions = [];
+    let availableToolSources = new Map();
+    let systemPrompt = "";
+    const includeTool = (name) => !allowedToolNames || allowedToolNames.has(name);
+    const buildAvailableTools = () => {
+        const definitions = new Map();
+        const sources = new Map();
+        for (const name of requestedToolNames) {
+            if (!isBuiltInToolName(name) || !includeTool(name))
+                continue;
+            const definition = createToolDefinition(name, cwd, toolOptions);
+            definitions.set(definition.name, definition);
+            sources.set(definition.name, createSyntheticSourceInfo(`<builtin:${definition.name}>`, { source: "builtin" }));
+        }
+        for (const tool of extensionRunner.getAllRegisteredTools()) {
+            if (!includeTool(tool.definition.name))
+                continue;
+            definitions.set(tool.definition.name, tool.definition);
+            sources.set(tool.definition.name, tool.sourceInfo);
+        }
+        for (const definition of options.customTools ?? []) {
+            if (!includeTool(definition.name))
+                continue;
+            definitions.set(definition.name, definition);
+            sources.set(definition.name, createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }));
+        }
+        // Always include the session_split tool
+        const sessionSplitDef = createSessionSplitToolDefinition();
+        definitions.set(sessionSplitDef.name, sessionSplitDef);
+        sources.set(sessionSplitDef.name, createSyntheticSourceInfo(`<builtin:${sessionSplitDef.name}>`, { source: "builtin" }));
+        availableToolDefinitions = Array.from(definitions.values());
+        availableToolSources = sources;
+    };
+    const buildPromptForTools = (definitions) => {
+        const appendSystemPrompt = resourceLoader.getAppendSystemPrompt();
+        const toolSnippets = {};
+        const promptGuidelines = [];
+        for (const definition of definitions) {
+            const snippet = definition.promptSnippet?.trim();
+            if (snippet) {
+                toolSnippets[definition.name] = snippet;
+            }
+            for (const guideline of definition.promptGuidelines ?? []) {
+                const normalized = guideline.trim();
+                if (normalized) {
+                    promptGuidelines.push(normalized);
+                }
+            }
+        }
+        return buildSystemPrompt({
+            cwd,
+            skills: resourceLoader.getSkills().skills,
+            contextFiles: resourceLoader.getAgentsFiles().agentsFiles,
+            customPrompt: resourceLoader.getSystemPrompt(),
+            appendSystemPrompt: appendSystemPrompt.length > 0 ? appendSystemPrompt.join("\n\n") : undefined,
+            selectedTools: definitions.map((definition) => definition.name),
+            toolSnippets,
+            promptGuidelines,
+        });
+    };
+    const applyActiveTools = (toolNames) => {
+        buildAvailableTools();
+        const activeNames = toolNames ? new Set(toolNames) : undefined;
+        activeToolDefinitions = activeNames
+            ? availableToolDefinitions.filter((definition) => activeNames.has(definition.name))
+            : [...availableToolDefinitions];
+        systemPrompt = buildPromptForTools(activeToolDefinitions);
+        if (runtime) {
+            runtime.setTools(activeToolDefinitions.map(toRuntimeToolDefinition));
+            runtime.setSystemPrompt(systemPrompt);
+        }
+    };
+    const getToolInfos = () => availableToolDefinitions.map((definition) => ({
+        name: definition.name,
+        description: definition.description,
+        parameters: definition.parameters,
+        sourceInfo: availableToolSources.get(definition.name) ??
+            createSyntheticSourceInfo(`<tool:${definition.name}>`, { source: "unknown" }),
+    }));
+    const currentSessionId = () => sessionManager.getActiveSessionId() ?? projection.getDescriptor().session_id;
+    const currentThreadId = () => sessionManager.getActiveThreadId() ?? projection.getDescriptor().thread_id;
+    const appendSessionEntry = (entry) => {
+        store.append({
+            actor_id: "runtime",
+            type: "SESSION_ENTRY_APPENDED",
+            payload: {
+                session_id: currentSessionId(),
+                entry: {
+                    id: `entry_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    parentId: store.head ?? null,
+                    timestamp: new Date().toISOString(),
+                    ...entry,
+                },
+                leaf_id: store.head ?? null,
+            },
+            thread_id: currentThreadId(),
+        });
+    };
+    applyActiveTools();
+    extensionRunner.bindCore({
+        sendMessage: (message, options) => {
+            store.append({
+                actor_id: "runtime",
+                type: "CUSTOM_MESSAGE",
+                payload: {
+                    extension_id: "sdk",
+                    kind: message.customType,
+                    data: message.details ?? message.content,
+                    display: message.display,
+                },
+                thread_id: currentThreadId(),
+            });
+            if (!runtime || (!options?.triggerTurn && !options?.deliverAs))
+                return;
+            const text = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+            if (options?.deliverAs === "steer") {
+                runtime.steer(text);
+            }
+            else if (options?.deliverAs === "followUp") {
+                runtime.followUp(text);
+            }
+            else if (options?.triggerTurn) {
+                void runtime.prompt(text).catch((err) => {
+                    extensionRunner.emitError({
+                        extensionPath: "<runtime>",
+                        event: "send_message",
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+        },
+        sendUserMessage: (content, options) => {
+            if (!runtime)
+                return;
+            const { text, images } = splitUserContent(content);
+            if (runtime.isRunning) {
+                if (options?.deliverAs === "steer") {
+                    runtime.steer(text, images);
+                }
+                else {
+                    runtime.followUp(text, images);
+                }
+                return;
+            }
+            void runtime.prompt(text, images).catch((err) => {
+                extensionRunner.emitError({
+                    extensionPath: "<runtime>",
+                    event: "send_user_message",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        },
+        appendEntry: (customType, data) => appendSessionEntry({ type: "custom", customType, data }),
+        setSessionName: (name) => {
+            sessionManager.renameSession(currentSessionId(), name);
+            appendSessionEntry({ type: "session_info", name });
+        },
+        getSessionName: () => extensionSessionManager.getSessionName(),
+        setLabel: (entryId, label) => appendSessionEntry({ type: "label", targetId: entryId, label }),
+        getActiveTools: () => activeToolDefinitions.map((definition) => definition.name),
+        getAllTools: getToolInfos,
+        setActiveTools: (toolNames) => applyActiveTools(toolNames),
+        refreshTools: () => applyActiveTools(activeToolDefinitions.map((definition) => definition.name)),
+        getCommands: () => extensionRunner.getRegisteredCommands().map((command) => ({
+            name: command.invocationName,
+            description: command.description,
+            source: "extension",
+            sourceInfo: command.sourceInfo,
+        })),
+        setModel: async (nextModel) => {
+            if (!modelRegistry.hasConfiguredAuth(nextModel))
+                return false;
+            model = nextModel;
+            runtime?.setModel(nextModel.provider, nextModel.id);
+            return true;
+        },
+        getThinkingLevel: () => thinkingLevel,
+        setThinkingLevel: (level) => {
+            thinkingLevel = level;
+            runtime?.setThinkingLevel(level);
+        },
+    }, {
+        getModel: () => model,
+        isIdle: () => !runtime?.isRunning,
+        getSignal: () => runtime?.signal,
+        abort: () => runtime?.abort(),
+        hasPendingMessages: () => false,
+        shutdown: () => { },
+        getContextUsage: () => estimateContextUsage(model, runtime?.getProjection().buildContext().messages ?? []),
+        compact: (options) => {
+            runtime?.compact({ reason: "manual" });
+            void options;
+        },
+        getSystemPrompt: () => runtime?.getSystemPrompt() ?? systemPrompt,
+    }, {
+        registerProvider: (name, config) => modelRegistry.registerProvider(name, config),
+        unregisterProvider: (name) => modelRegistry.unregisterProvider(name),
+    });
+    const tools = wrapToolDefinitions(availableToolDefinitions, () => extensionRunner.createContext());
+    // ── LLM client (AI stream function -> reactor LLMClient) ───────────────
+    const llmClient = model
+        ? buildLlmClientFromStreamFn(model, async (m, context, opts) => {
+            const auth = await modelRegistry.getApiKeyAndHeaders(m);
+            if (!auth.ok) {
+                throw new Error(auth.error);
+            }
+            return streamSimple(m, context, {
+                ...opts,
+                apiKey: auth.apiKey,
+                headers: auth.headers ?? opts?.headers,
+            });
+        }, {
+            thinkingBudgets: settingsManager.getThinkingBudgets(),
+            transport: settingsManager.getTransport(),
+            onPayload: async (payload) => {
+                if (!extensionRunner.hasHandlers("before_provider_request")) {
+                    return payload;
+                }
+                return extensionRunner.emitBeforeProviderRequest(payload);
+            },
+            onResponse: async (response) => {
+                if (!extensionRunner.hasHandlers("after_provider_response")) {
+                    return;
+                }
+                await extensionRunner.emit({
+                    type: "after_provider_response",
+                    status: response.status,
+                    headers: response.headers,
+                });
+            },
+        })
+        : undefined;
+    // ── Runtime ────────────────────────────────────────────────────────────
+    runtime = new EventSourcedRuntime({
+        cwd,
+        agentDir,
+        store,
+        sessionManager,
+        threadId: currentThreadId(),
+        toolRegistry: createToolRegistry(tools),
+        llmClient: llmClient,
+        systemPrompt,
+        model: toModelConfig(model ?? { provider: "none", id: "none" }, thinkingLevel),
+        tools: activeToolDefinitions.map(toRuntimeToolDefinition),
+        // The default facade currently has no approval UI handler, so keep coding tools usable.
+        // Direct runtime/classifier consumers get the stricter defaults unless they opt out.
+        classifierConfig: {
+            require_approval_writes: false,
+            require_approval_edits: false,
+            require_approval_unknown: false,
+        },
+        retryAssistantErrorCompletions: true,
+        retryPolicy: new DefaultRetryPolicy({ capDelayMs: settingsManager.getRetrySettings().maxDelayMs }),
+        contextBudget: options.contextBudget ?? model?.contextWindow ?? 128000,
+    });
+    const extensionEventUnsubscribe = extensionRunner.bindEventStore(store);
+    await extensionRunner.emit(options.sessionStartEvent ?? { type: "session_start", reason: "startup" });
+    const facade = new SessionFacade({
+        runtime,
+        settingsManager,
+        modelRegistry,
+        extensionRunner,
+        resourceLoader,
+        disposers: [extensionEventUnsubscribe],
+    });
+    return { facade, runtime, model, thinkingLevel, extensionsResult, modelFallbackMessage };
+}

package/dist/core/session-facade.d.ts

@@ -0,0 +1,57 @@
+/**
+ * SessionFacade
+ *
+ * Lightweight event-sourced session entry point for modes and extensions.
+ * It owns no transcript state; conversation data is read from EventStore
+ * projections through EventSourcedRuntime.
+ */
+import type { Model } from "@earendil-works/pi-ai/compat";
+import type { EventBase, ImageContent } from "./event-store/types.js";
+import type { SubscribeOptions } from "./event-store/store.js";
+import type { ExtensionRunner } from "./extensions/runner.js";
+import type { ModelRegistry } from "./model-registry.js";
+import type { ResourceLoader } from "./resource-loader.js";
+import type { SessionProjection } from "./projection/session-projection.js";
+import type { SettingsManager } from "./settings-manager.js";
+import type { ModelConfig, ToolDefinition } from "./runtime/llm-types.js";
+import type { RuntimeCompactOptions } from "./runtime/runtime.js";
+import { EventSourcedRuntime } from "./runtime/runtime.js";
+export interface SessionFacadeConfig {
+    runtime: EventSourcedRuntime;
+    settingsManager: SettingsManager;
+    extensionRunner?: ExtensionRunner;
+    modelRegistry?: ModelRegistry;
+    resourceLoader?: ResourceLoader;
+    disposers?: Array<() => void>;
+}
+export type SessionFacadeEventListener = (event: EventBase) => void;
+export declare class SessionFacade {
+    readonly runtime: EventSourcedRuntime;
+    readonly settingsManager: SettingsManager;
+    readonly extensionRunner: ExtensionRunner | undefined;
+    readonly modelRegistry: ModelRegistry | undefined;
+    readonly resourceLoader: ResourceLoader | undefined;
+    private disposers;
+    private disposed;
+    constructor(config: SessionFacadeConfig);
+    subscribe(listener: SessionFacadeEventListener, options?: SubscribeOptions): () => void;
+    prompt(text: string, images?: ImageContent[]): Promise<void>;
+    steer(text: string, images?: ImageContent[]): void;
+    followUp(text: string, images?: ImageContent[]): void;
+    abort(): void;
+    compact(options?: RuntimeCompactOptions): void;
+    waitForIdle(): Promise<void>;
+    get isRunning(): boolean;
+    get signal(): AbortSignal | undefined;
+    getProjection(): SessionProjection;
+    get model(): ModelConfig;
+    set model(model: ModelConfig);
+    setModel(model: ModelConfig | Model<any>, thinkingLevel?: string): void;
+    get thinkingLevel(): string | undefined;
+    set thinkingLevel(level: string | undefined);
+    get tools(): ToolDefinition[];
+    set tools(tools: ToolDefinition[]);
+    get systemPrompt(): string;
+    set systemPrompt(prompt: string);
+    dispose(): void;
+}

package/dist/core/session-facade.js

@@ -0,0 +1,91 @@
+/**
+ * SessionFacade
+ *
+ * Lightweight event-sourced session entry point for modes and extensions.
+ * It owns no transcript state; conversation data is read from EventStore
+ * projections through EventSourcedRuntime.
+ */
+export class SessionFacade {
+    constructor(config) {
+        this.disposed = false;
+        this.runtime = config.runtime;
+        this.settingsManager = config.settingsManager;
+        this.extensionRunner = config.extensionRunner;
+        this.modelRegistry = config.modelRegistry;
+        this.resourceLoader = config.resourceLoader;
+        this.disposers = config.disposers ?? [];
+    }
+    subscribe(listener, options) {
+        return this.runtime.subscribe(listener, options);
+    }
+    prompt(text, images) {
+        return this.runtime.prompt(text, images);
+    }
+    steer(text, images) {
+        this.runtime.steer(text, images);
+    }
+    followUp(text, images) {
+        this.runtime.followUp(text, images);
+    }
+    abort() {
+        this.runtime.abort();
+    }
+    compact(options) {
+        this.runtime.compact(options);
+    }
+    waitForIdle() {
+        return this.runtime.waitForIdle();
+    }
+    get isRunning() {
+        return this.runtime.isRunning;
+    }
+    get signal() {
+        return this.runtime.signal;
+    }
+    getProjection() {
+        return this.runtime.getProjection();
+    }
+    get model() {
+        return this.runtime.getModel();
+    }
+    set model(model) {
+        this.setModel(model);
+    }
+    setModel(model, thinkingLevel) {
+        const modelId = "model_id" in model ? model.model_id : model.id;
+        this.runtime.setModel(model.provider, modelId);
+        const nextThinkingLevel = thinkingLevel ?? ("thinking_level" in model ? model.thinking_level : undefined);
+        if (nextThinkingLevel !== undefined) {
+            this.runtime.setThinkingLevel(nextThinkingLevel);
+        }
+    }
+    get thinkingLevel() {
+        return this.runtime.getThinkingLevel();
+    }
+    set thinkingLevel(level) {
+        if (level !== undefined) {
+            this.runtime.setThinkingLevel(level);
+        }
+    }
+    get tools() {
+        return this.runtime.getTools();
+    }
+    set tools(tools) {
+        this.runtime.setTools(tools);
+    }
+    get systemPrompt() {
+        return this.runtime.getSystemPrompt();
+    }
+    set systemPrompt(prompt) {
+        this.runtime.setSystemPrompt(prompt);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const dispose of this.disposers.splice(0)) {
+            dispose();
+        }
+        this.runtime.dispose();
+    }
+}

package/dist/core/session-listing.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Session Listing
+ *
+ * Lists sessions from the new session index (sessions.json) and EventStore.
+ * Replaces old SessionManager.list/listAll static methods with a clean,
+ * event-sourced implementation.
+ */
+export interface SessionListInfo {
+    path: string;
+    id: string;
+    cwd: string;
+    name?: string;
+    parentSessionPath?: string;
+    created: Date;
+    modified: Date;
+    messageCount: number;
+    firstMessage: string;
+    allMessagesText: string;
+}
+export type SessionListProgress = (loaded: number, total: number) => void;
+/**
+ * List all sessions for a workspace (current cwd).
+ * Reads from sessions.json + EventStore for each session.
+ */
+export declare function listWorkspaceSessions(cwd: string, agentDir?: string, onProgress?: SessionListProgress): Promise<SessionListInfo[]>;
+/**
+ * List all sessions across all workspaces.
+ * Scans agentDir/workspaces/* for sessions.json files.
+ */
+export declare function listAllSessions(agentDir?: string, onProgress?: SessionListProgress): Promise<SessionListInfo[]>;