@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/services/extract-memories.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Extract Memories service — extract durable memories from session transcripts.
+ *
+ * Runs at the end of a query loop to identify important information
+ * worth persisting across sessions.
+ */
+export interface ExtractedMemory {
+    type: "user" | "feedback" | "project" | "reference";
+    name: string;
+    description: string;
+    content: string;
+}
+/**
+ * Build the prompt for extracting memories from a conversation.
+ */
+export declare function buildExtractionPrompt(transcript: Array<{
+    role: string;
+    content: string;
+}>, existingMemories: Array<{
+    name: string;
+    type: string;
+    description: string;
+}>): string;
+/** Max memories to accept from a single extraction pass. Code-side cap that
+ *  enforces the same limit the prompt asks for — the model occasionally
+ *  ignores prompt rules, but this guarantees the cap. */
+export declare const MAX_MEMORIES_PER_EXTRACTION = 2;
+/**
+ * Parse extracted memories from LLM response.
+ */
+export declare function parseExtractionResponse(response: string): ExtractedMemory[];

package/dist/services/extract-memories.js

@@ -0,0 +1,71 @@
+/**
+ * Extract Memories service — extract durable memories from session transcripts.
+ *
+ * Runs at the end of a query loop to identify important information
+ * worth persisting across sessions.
+ */
+/**
+ * Build the prompt for extracting memories from a conversation.
+ */
+export function buildExtractionPrompt(transcript, existingMemories) {
+    const conversationText = transcript
+        .map((m) => `[${m.role}]: ${m.content.slice(0, 3000)}`)
+        .join("\n\n");
+    const existingList = existingMemories.length > 0
+        ? existingMemories.map((m) => `  - [${m.type}] ${m.name}: ${m.description}`).join("\n")
+        : "  (none)";
+    return `Analyze the following conversation and extract any information worth remembering for future sessions.
+
+## Existing Memories
+${existingList}
+
+## Conversation
+${conversationText.slice(0, 30000)}
+
+## Instructions
+Identify NEW information that should be saved as persistent memories. Categories:
+- **user**: Information about the user's role, preferences, or expertise
+- **feedback**: Guidance about how to approach work (corrections or confirmations)
+- **project**: Non-obvious facts about ongoing work, goals, or decisions
+- **reference**: Pointers to external resources or systems
+
+Rules:
+- Extract AT MOST 2 memories per session. Prefer 0 to a marginal one — most sessions are noise.
+- Only extract information that would be useful in FUTURE conversations
+- Do not duplicate existing memories (re-read the "Existing Memories" list above carefully)
+- Do not extract code patterns, file structures, or git history (derivable from code)
+- Do not extract ephemeral task details, progress snapshots, or in-flight work state — those belong in the conversation, not memory
+- Do not extract one-off research products (news reports, AI industry summaries, slide deck content, daily progress dumps) — they're done and not "durable, reusable information"
+- Each memory should have a clear, specific description
+
+Respond with a JSON array of objects with fields: type, name, description, content
+If nothing worth remembering, respond with an empty array: []`;
+}
+/** Max memories to accept from a single extraction pass. Code-side cap that
+ *  enforces the same limit the prompt asks for — the model occasionally
+ *  ignores prompt rules, but this guarantees the cap. */
+export const MAX_MEMORIES_PER_EXTRACTION = 2;
+/**
+ * Parse extracted memories from LLM response.
+ */
+export function parseExtractionResponse(response) {
+    try {
+        // Find JSON array in response
+        const jsonMatch = response.match(/\[[\s\S]*\]/);
+        if (!jsonMatch)
+            return [];
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(parsed))
+            return [];
+        const valid = parsed.filter((m) => typeof m === "object" &&
+            m !== null &&
+            typeof m.type === "string" &&
+            typeof m.name === "string" &&
+            typeof m.content === "string" &&
+            ["user", "feedback", "project", "reference"].includes(m.type));
+        return valid.slice(0, MAX_MEMORIES_PER_EXTRACTION);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Services index — re-exports all service modules.
+ */
+export { analytics, trackEvent } from "./analytics.js";
+export { authorize, refreshToken, type OAuthConfig, type OAuthTokens } from "./oauth.js";
+export { notify, notifyComplete, notifyError } from "./notifier.js";
+export { diagnostics } from "./diagnostics.js";
+export { buildExtractionPrompt, parseExtractionResponse, type ExtractedMemory, } from "./extract-memories.js";
+export { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt, } from "./auto-dream.js";
+export { saveSessionMemory, loadSessionMemory, listSessionMemories, searchSessionMemories, buildSessionMemoryPrompt, } from "./session-memory.js";
+export { MemoryOrchestrator, type MemoryOrchestratorOptions, type MemoryOrchestratorResult, } from "./memory-orchestrator.js";

package/dist/services/index.js

@@ -0,0 +1,17 @@
+/**
+ * Services index — re-exports all service modules.
+ */
+export { analytics, trackEvent } from "./analytics.js";
+// NOTE: ./compact.ts was a stand-alone stub that duplicated the real
+// microcompact/autocompact logic now living in src/context/. It was never
+// wired into Engine and shipped with incompatible semantics (a single
+// `microCompact` that truncated long *messages* by char count, unrelated
+// to the tool_result-based microcompact in ContextManager). Removed to end
+// the "which microcompact?" ambiguity — the source of truth is ContextManager.
+export { authorize, refreshToken } from "./oauth.js";
+export { notify, notifyComplete, notifyError } from "./notifier.js";
+export { diagnostics } from "./diagnostics.js";
+export { buildExtractionPrompt, parseExtractionResponse, } from "./extract-memories.js";
+export { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt, } from "./auto-dream.js";
+export { saveSessionMemory, loadSessionMemory, listSessionMemories, searchSessionMemories, buildSessionMemoryPrompt, } from "./session-memory.js";
+export { MemoryOrchestrator, } from "./memory-orchestrator.js";

package/dist/services/memory-orchestrator.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MemoryOrchestrator — ties extract-memories, session-memory, and auto-dream
+ * into a single end-of-session pipeline.
+ *
+ * Called by Engine.run() after the turn loop completes. Runs memory extraction
+ * and session summarisation via lightweight LLM calls, then conditionally
+ * triggers auto-dream consolidation. None of this blocks the Engine result.
+ *
+ * Dream uses a tool-call loop (not free-text JSON output) so the LLM can
+ * incrementally inspect and modify the dream-scope workspace via the same
+ * MemoryList/Read/Save/Delete tools the user-facing assistant has access to.
+ * The caller supplies `runDream`, which owns the LLM client and tool registry
+ * — orchestrator just decides WHEN to trigger.
+ */
+import { MemoryManager } from "../session/memory.js";
+export interface MemoryOrchestratorOptions {
+    /** Lightweight LLM call — must be a non-streaming summarisation call. */
+    callLLM: (systemPrompt: string, userMsg: string) => Promise<string>;
+    /**
+     * Auto-dream consolidation driver. Called when the dream cadence is due
+     * (every N sessions, no more than once per 24h). Returns true if the dream
+     * actually executed (so the orchestrator can record the timestamp); false
+     * if the caller decided to skip (e.g. no memories to consolidate, headless
+     * mode without LLM client, etc.).
+     *
+     * Implementation lives in Engine because it needs the LLM client and the
+     * memory tool implementations — both of which are orchestrator-agnostic.
+     */
+    runDream?: (input: {
+        systemPrompt: string;
+        userPrompt: string;
+        projectDir?: string;
+    }) => Promise<boolean>;
+    /** Project root; when set, memories are scoped per-project. */
+    projectDir?: string;
+    /** Optional pre-constructed MemoryManager (avoids re-creating for every call). */
+    memoryManager?: MemoryManager;
+}
+export interface MemoryOrchestratorResult {
+    /** Number of new memory entries extracted and saved. */
+    extracted: number;
+    /** Whether the auto-dream consolidation was triggered. */
+    dreamTriggered: boolean;
+}
+export declare class MemoryOrchestrator {
+    private readonly options;
+    constructor(options: MemoryOrchestratorOptions);
+    /**
+     * Run the full end-of-session memory pipeline.
+     *
+     *  1. Extract durable memories from the transcript (extract-memories)
+     *  2. Summarise the session (session-memory)
+     *  3. Record a completed session for auto-dream tracking
+     *  4. Conditionally trigger auto-dream consolidation
+     */
+    run(transcript: Array<{
+        role: string;
+        content: string;
+    }>, sessionId: string): Promise<MemoryOrchestratorResult>;
+}

package/dist/services/memory-orchestrator.js

@@ -0,0 +1,133 @@
+/**
+ * MemoryOrchestrator — ties extract-memories, session-memory, and auto-dream
+ * into a single end-of-session pipeline.
+ *
+ * Called by Engine.run() after the turn loop completes. Runs memory extraction
+ * and session summarisation via lightweight LLM calls, then conditionally
+ * triggers auto-dream consolidation. None of this blocks the Engine result.
+ *
+ * Dream uses a tool-call loop (not free-text JSON output) so the LLM can
+ * incrementally inspect and modify the dream-scope workspace via the same
+ * MemoryList/Read/Save/Delete tools the user-facing assistant has access to.
+ * The caller supplies `runDream`, which owns the LLM client and tool registry
+ * — orchestrator just decides WHEN to trigger.
+ */
+import { MemoryManager } from "../session/memory.js";
+import { buildExtractionPrompt, parseExtractionResponse } from "./extract-memories.js";
+import { saveSessionMemory, buildSessionMemoryPrompt } from "./session-memory.js";
+import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt } from "./auto-dream.js";
+import { logger } from "../logging/logger.js";
+export class MemoryOrchestrator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Run the full end-of-session memory pipeline.
+     *
+     *  1. Extract durable memories from the transcript (extract-memories)
+     *  2. Summarise the session (session-memory)
+     *  3. Record a completed session for auto-dream tracking
+     *  4. Conditionally trigger auto-dream consolidation
+     */
+    async run(transcript, sessionId) {
+        const mm = this.options.memoryManager ?? new MemoryManager({ projectDir: this.options.projectDir });
+        const startTime = Date.now();
+        // --------------- 1. Extract durable memories ---------------
+        let extracted = 0;
+        try {
+            const existing = mm.loadAll();
+            const extractionPrompt = buildExtractionPrompt(transcript, existing);
+            const response = await this.options.callLLM("You are a memory extraction assistant. Extract only durable, reusable information worth carrying into future sessions.", extractionPrompt);
+            const entries = parseExtractionResponse(response);
+            for (const entry of entries) {
+                mm.save({
+                    type: entry.type,
+                    name: entry.name,
+                    description: entry.description,
+                    content: entry.content,
+                });
+            }
+            extracted = entries.length;
+            logger.info("memory.extraction_done", {
+                sessionId,
+                extracted,
+                elapsedMs: Date.now() - startTime,
+            });
+        }
+        catch (err) {
+            logger.warn("memory.extraction_failed", {
+                sessionId,
+                error: err.message,
+            });
+        }
+        // --------------- 2. Session summary ---------------
+        try {
+            // Only summarise sessions with enough content to be meaningful.
+            const messageCount = transcript.filter((m) => m.role !== "system").length;
+            if (messageCount >= 3) {
+                const smPrompt = buildSessionMemoryPrompt(transcript);
+                const smResponse = await this.options.callLLM("You are a session summariser. Output only valid JSON.", smPrompt);
+                const jsonMatch = smResponse.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    saveSessionMemory({
+                        sessionId,
+                        summary: String(parsed.summary ?? "").slice(0, 1000),
+                        keyTopics: Array.isArray(parsed.keyTopics) ? parsed.keyTopics.slice(0, 20) : [],
+                        decisions: Array.isArray(parsed.decisions) ? parsed.decisions.slice(0, 20) : [],
+                        createdAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.warn("memory.session_memory_failed", {
+                sessionId,
+                error: err.message,
+            });
+        }
+        // --------------- 3. Record session for auto-dream tracking ---------------
+        recordSession();
+        // --------------- 4. Auto-dream consolidation ---------------
+        // Drives a tool-call loop in the caller (Engine.runDream) so the LLM can
+        // list/read/save/delete dream-scope memories via the same Memory* tools
+        // the user-facing assistant uses. Skipped when:
+        //   - the cadence isn't due yet (shouldAutoDream returns false)
+        //   - the caller didn't wire a runDream driver (e.g. headless tests)
+        //   - the workspace is empty (nothing to consolidate)
+        let dreamTriggered = false;
+        try {
+            if (shouldAutoDream() && this.options.runDream) {
+                // Dream sees BOTH scopes — user/ is read-only context so it can spot
+                // duplicates spanning scopes, dream/ is the workspace it edits.
+                const userMems = mm.loadScope("user");
+                const dreamMems = mm.loadScope("dream");
+                if (userMems.length + dreamMems.length > 0) {
+                    const ran = await this.options.runDream({
+                        systemPrompt: buildDreamSystemPrompt(),
+                        userPrompt: buildDreamUserPrompt(userMems, dreamMems),
+                        projectDir: this.options.projectDir,
+                    });
+                    if (ran) {
+                        recordDreamComplete();
+                        dreamTriggered = true;
+                        logger.info("memory.auto_dream_done", {
+                            sessionId,
+                            userMemoryCount: userMems.length,
+                            dreamMemoryCount: dreamMems.length,
+                            elapsedMs: Date.now() - startTime,
+                        });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.warn("memory.auto_dream_failed", {
+                sessionId,
+                error: err.message,
+            });
+        }
+        return { extracted, dreamTriggered };
+    }
+}

package/dist/services/notifier.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Notifier service — desktop/system notifications.
+ *
+ * Sends notifications when tasks complete, agents finish, or errors occur.
+ * Falls back gracefully when no notification system is available.
+ */
+export interface NotificationOptions {
+    title: string;
+    message: string;
+    sound?: boolean;
+    /** Urgency level: low, normal, critical */
+    urgency?: "low" | "normal" | "critical";
+}
+/**
+ * Send a desktop notification.
+ */
+export declare function notify(options: NotificationOptions): void;
+/**
+ * Send a notification that a task/agent has completed.
+ */
+export declare function notifyComplete(taskName: string, duration?: number): void;
+/**
+ * Send an error notification.
+ */
+export declare function notifyError(context: string, error: string): void;

package/dist/services/notifier.js

@@ -0,0 +1,69 @@
+/**
+ * Notifier service — desktop/system notifications.
+ *
+ * Sends notifications when tasks complete, agents finish, or errors occur.
+ * Falls back gracefully when no notification system is available.
+ */
+import { execSync } from "node:child_process";
+/**
+ * Send a desktop notification.
+ */
+export function notify(options) {
+    const { title, message, sound = false, urgency = "normal" } = options;
+    try {
+        if (process.platform === "darwin") {
+            // macOS: osascript
+            const soundFlag = sound ? 'sound name "default"' : "";
+            execSync(`osascript -e 'display notification "${escape(message)}" with title "${escape(title)}" ${soundFlag}'`, { timeout: 5000 });
+        }
+        else if (process.platform === "linux") {
+            // Linux: notify-send
+            const urgencyFlag = urgency === "critical" ? "-u critical" : urgency === "low" ? "-u low" : "-u normal";
+            execSync(`notify-send ${urgencyFlag} "${escape(title)}" "${escape(message)}"`, {
+                timeout: 5000,
+            });
+        }
+        else if (process.platform === "win32") {
+            // Windows: PowerShell toast
+            const ps = `
+        [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+        $xml = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+        $text = $xml.GetElementsByTagName('text')
+        $text[0].AppendChild($xml.CreateTextNode('${escape(title)}')) | Out-Null
+        $text[1].AppendChild($xml.CreateTextNode('${escape(message)}')) | Out-Null
+        $toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
+        [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('CodeShell').Show($toast)
+      `.trim();
+            execSync(`powershell.exe -NoProfile -Command "${ps.replace(/\n/g, "; ")}"`, {
+                timeout: 5000,
+            });
+        }
+    }
+    catch {
+        // Silently fail — notifications are best-effort
+    }
+}
+/**
+ * Send a notification that a task/agent has completed.
+ */
+export function notifyComplete(taskName, duration) {
+    const durationStr = duration ? ` (${(duration / 1000).toFixed(1)}s)` : "";
+    notify({
+        title: "Code Shell",
+        message: `✓ ${taskName} completed${durationStr}`,
+        sound: true,
+    });
+}
+/**
+ * Send an error notification.
+ */
+export function notifyError(context, error) {
+    notify({
+        title: "Code Shell Error",
+        message: `✗ ${context}: ${error.slice(0, 100)}`,
+        urgency: "critical",
+    });
+}
+function escape(str) {
+    return str.replace(/['"\\]/g, "\\$&").replace(/\n/g, " ");
+}

package/dist/services/oauth.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OAuth service — OAuth 2.0 authorization code flow with PKCE.
+ *
+ * Supports browser-based login flow for API authentication.
+ */
+export interface OAuthConfig {
+    clientId: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    redirectUri?: string;
+    scopes?: string[];
+}
+export interface OAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    tokenType: string;
+}
+/**
+ * Run the OAuth authorization code flow.
+ * Opens a browser for user login and waits for the callback.
+ */
+export declare function authorize(config: OAuthConfig): Promise<OAuthTokens>;
+/**
+ * Refresh an access token using a refresh token.
+ */
+export declare function refreshToken(config: OAuthConfig, refreshTokenValue: string): Promise<OAuthTokens>;

package/dist/services/oauth.js

@@ -0,0 +1,153 @@
+/**
+ * OAuth service — OAuth 2.0 authorization code flow with PKCE.
+ *
+ * Supports browser-based login flow for API authentication.
+ */
+import { createServer } from "node:http";
+import { randomBytes, createHash } from "node:crypto";
+import { exec } from "node:child_process";
+/**
+ * Generate PKCE code verifier and challenge.
+ */
+function generatePKCE() {
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    return { verifier, challenge };
+}
+/**
+ * Open a URL in the system browser.
+ */
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? `open "${url}"`
+        : process.platform === "win32"
+            ? `start "${url}"`
+            : `xdg-open "${url}"`;
+    exec(cmd, () => { });
+}
+/**
+ * Run the OAuth authorization code flow.
+ * Opens a browser for user login and waits for the callback.
+ */
+export async function authorize(config) {
+    const { verifier, challenge } = generatePKCE();
+    const state = randomBytes(16).toString("hex");
+    const port = 18910 + Math.floor(Math.random() * 100);
+    const redirectUri = config.redirectUri ?? `http://localhost:${port}/callback`;
+    // Build authorization URL
+    const params = new URLSearchParams({
+        response_type: "code",
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        state,
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+    });
+    if (config.scopes?.length) {
+        params.set("scope", config.scopes.join(" "));
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error("OAuth authorization timed out (120s)"));
+        }, 120_000);
+        const server = createServer(async (req, res) => {
+            if (!req.url?.startsWith("/callback")) {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            const error = url.searchParams.get("error");
+            clearTimeout(timeout);
+            if (error) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<html><body><h1>Authorization failed</h1><p>You can close this window.</p></body></html>");
+                server.close();
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+            if (!code || returnedState !== state) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end("<html><body><h1>Invalid callback</h1></body></html>");
+                server.close();
+                reject(new Error("Invalid OAuth callback: missing code or state mismatch"));
+                return;
+            }
+            // Exchange code for tokens
+            try {
+                const tokenParams = new URLSearchParams({
+                    grant_type: "authorization_code",
+                    code,
+                    redirect_uri: redirectUri,
+                    client_id: config.clientId,
+                    code_verifier: verifier,
+                });
+                const tokenRes = await fetch(config.tokenEndpoint, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                    body: tokenParams.toString(),
+                });
+                if (!tokenRes.ok) {
+                    throw new Error(`Token exchange failed: ${tokenRes.status} ${await tokenRes.text()}`);
+                }
+                const data = (await tokenRes.json());
+                const tokens = {
+                    accessToken: data.access_token,
+                    refreshToken: data.refresh_token,
+                    expiresAt: data.expires_in
+                        ? Date.now() + data.expires_in * 1000
+                        : undefined,
+                    tokenType: data.token_type ?? "Bearer",
+                };
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<html><body><h1>Authorization successful!</h1><p>You can close this window.</p></body></html>");
+                server.close();
+                resolve(tokens);
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "text/html" });
+                res.end("<html><body><h1>Token exchange failed</h1></body></html>");
+                server.close();
+                reject(err);
+            }
+        });
+        server.listen(port, () => {
+            openBrowser(authUrl);
+        });
+        server.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`OAuth server error: ${err.message}`));
+        });
+    });
+}
+/**
+ * Refresh an access token using a refresh token.
+ */
+export async function refreshToken(config, refreshTokenValue) {
+    const params = new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: config.clientId,
+        refresh_token: refreshTokenValue,
+    });
+    const res = await fetch(config.tokenEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString(),
+    });
+    if (!res.ok) {
+        throw new Error(`Token refresh failed: ${res.status}`);
+    }
+    const data = (await res.json());
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token ?? refreshTokenValue,
+        expiresAt: data.expires_in
+            ? Date.now() + data.expires_in * 1000
+            : undefined,
+        tokenType: data.token_type ?? "Bearer",
+    };
+}

package/dist/services/session-memory.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Session Memory service — automatic session memory maintenance.
+ *
+ * Extracts and maintains conversation context as persistent memory
+ * entries that survive across sessions.
+ */
+export interface SessionMemoryEntry {
+    sessionId: string;
+    summary: string;
+    keyTopics: string[];
+    decisions: string[];
+    createdAt: string;
+    tokenCount?: number;
+}
+/**
+ * Save a session memory entry.
+ */
+export declare function saveSessionMemory(entry: SessionMemoryEntry): void;
+/**
+ * Load a session memory by session ID.
+ */
+export declare function loadSessionMemory(sessionId: string): SessionMemoryEntry | null;
+/**
+ * List all session memories, most recent first.
+ */
+export declare function listSessionMemories(limit?: number): SessionMemoryEntry[];
+/**
+ * Search session memories by keyword.
+ */
+export declare function searchSessionMemories(query: string): SessionMemoryEntry[];
+/**
+ * Build a prompt for extracting session memory from a conversation.
+ */
+export declare function buildSessionMemoryPrompt(messages: Array<{
+    role: string;
+    content: string;
+}>): string;