lsd-pi 1.0.0 → 1.1.1

package/dist/resources/extensions/memory/auto-extract.js

@@ -0,0 +1,154 @@
+/**
+ * Auto-extract — fire-and-forget background memory extraction.
+ *
+ * Runs after a session ends: reads the conversation transcript,
+ * spawns a headless agent to identify durable facts worth remembering,
+ * and writes memory files to the project's memory directory.
+ */
+import { spawn } from 'node:child_process';
+import { mkdirSync, writeFileSync, unlinkSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { getMemoryDir } from './memory-paths.js';
+import { scanMemoryFiles, formatMemoryManifest } from './memory-scan.js';
+/**
+ * Build a plain-text transcript from session entries, keeping only
+ * human-readable message content (no tool_use / tool_result blocks).
+ *
+ * Returns an empty string if the transcript has fewer than 3 messages.
+ */
+export function buildTranscriptSummary(entries) {
+    const lines = [];
+    for (const entry of entries) {
+        if (entry.type !== 'message')
+            continue;
+        const role = entry.message?.role;
+        if (role !== 'user' && role !== 'assistant')
+            continue;
+        const raw = entry.message.content;
+        let text = '';
+        if (typeof raw === 'string') {
+            text = raw;
+        }
+        else if (Array.isArray(raw)) {
+            // Multi-part messages — extract text blocks only, skip tool_use / tool_result
+            text = raw
+                .filter((part) => part.type === 'text' && typeof part.text === 'string')
+                .map((part) => part.text)
+                .join('\n');
+        }
+        if (!text.trim())
+            continue;
+        // Truncate individual messages to keep the transcript manageable
+        const truncated = text.length > 2000 ? text.slice(0, 2000) + '…' : text;
+        const label = role === 'user' ? 'User' : 'Assistant';
+        lines.push(`${label}: ${truncated}`);
+    }
+    if (lines.length < 3)
+        return '';
+    return lines.join('\n\n');
+}
+/**
+ * Build the system prompt that instructs the headless extraction agent
+ * on what to save (and what to skip).
+ */
+export function buildExtractionPrompt(memoryDir, transcript) {
+    const existing = scanMemoryFiles(memoryDir);
+    const manifest = existing.length > 0 ? formatMemoryManifest(existing) : 'None yet';
+    return `You are a memory extraction agent for a coding assistant. Read the conversation transcript and save any durable facts worth remembering.
+
+Memory directory: ${memoryDir}
+This directory already exists — write files directly.
+
+Rules:
+- Save ONLY: user preferences/role, feedback/corrections, project context (deadlines, decisions), external references
+- Do NOT save: code patterns, architecture, file paths, git history, debugging steps, ephemeral task details
+- Check existing memories below — update existing files rather than creating duplicates
+- Use frontmatter: ---\\nname: ...\\ndescription: ...\\ntype: user|feedback|project|reference\\n---
+- After writing topic files, update MEMORY.md with one-line index entries
+- Be VERY selective — only save things useful in FUTURE conversations
+- If nothing is worth saving, do nothing
+
+Existing memories:
+${manifest}
+
+Conversation transcript:
+${transcript}`;
+}
+/**
+ * Resolve the path to the LSD/GSD CLI entry point.
+ * Returns null if no valid CLI binary can be found.
+ */
+export function resolveCliPath() {
+    // Primary: the entry point used to launch the current process
+    const argv1 = process.argv[1];
+    if (argv1 && existsSync(argv1))
+        return argv1;
+    // Fallback: walk up from argv1 to find a bin/ sibling
+    if (argv1) {
+        const binDir = join(dirname(argv1), '..', 'bin');
+        for (const name of ['lsd', 'gsd']) {
+            const candidate = join(binDir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Main entry point — called from the session_shutdown hook.
+ *
+ * Reads the conversation transcript, builds an extraction prompt,
+ * and spawns a detached headless agent to process it.
+ * Fire-and-forget: the parent can exit without killing the child.
+ */
+export function extractMemories(ctx, cwd) {
+    // Guard: prevent recursive extraction
+    if (process.env.LSD_MEMORY_EXTRACT === '1')
+        return;
+    // Guard: user opt-out
+    if (process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY)
+        return;
+    const entries = ctx.sessionManager.getEntries();
+    // Guard: need enough user messages to be worth extracting
+    const userMessageCount = entries.filter((e) => e.type === 'message' && e.message?.role === 'user').length;
+    if (userMessageCount < 3)
+        return;
+    const transcript = buildTranscriptSummary(entries);
+    if (!transcript)
+        return;
+    const memoryDir = getMemoryDir(cwd);
+    mkdirSync(memoryDir, { recursive: true });
+    const prompt = buildExtractionPrompt(memoryDir, transcript);
+    // Write prompt to a temp file so the spawned agent can read it
+    const tmpPromptPath = join(tmpdir(), `lsd-memory-extract-${randomUUID()}.md`);
+    writeFileSync(tmpPromptPath, prompt, 'utf-8');
+    const cliPath = resolveCliPath();
+    if (!cliPath)
+        return;
+    const proc = spawn(process.execPath, [
+        cliPath,
+        'headless',
+        '--bare',
+        '--context',
+        tmpPromptPath,
+        '--context-text',
+        'Extract memories from the transcript above. Write any worth-saving memories to the memory directory, then update MEMORY.md.',
+    ], {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env, LSD_MEMORY_EXTRACT: '1' },
+    });
+    proc.unref();
+    // Clean up the temp file after the child has had time to read it
+    setTimeout(() => {
+        try {
+            unlinkSync(tmpPromptPath);
+        }
+        catch {
+            // Already cleaned up or inaccessible — safe to ignore
+        }
+    }, 120_000).unref();
+}

package/dist/resources/extensions/memory/extension-manifest.json

@@ -0,0 +1,11 @@
+{
+  "id": "memory",
+  "name": "Persistent Memory",
+  "version": "1.0.0",
+  "description": "Persistent file-based memory across sessions",
+  "tier": "bundled",
+  "provides": {
+    "hooks": ["session_start", "before_agent_start", "session_shutdown"],
+    "commands": ["memories", "remember", "forget"]
+  }
+}

package/dist/resources/extensions/memory/index.js

@@ -0,0 +1,223 @@
+/**
+ * Memory Extension — persistent, file-based memory for LSD agents.
+ *
+ * Bootstraps a per-project memory directory, injects the memory system prompt
+ * into every agent turn, and registers /memories, /remember, /forget commands.
+ *
+ * Memory files live under ~/.lsd/memory/<sanitized-project-path>/ and are
+ * indexed by a MEMORY.md entrypoint that is always loaded into context.
+ */
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { getMemoryDir, getMemoryEntrypoint, ensureMemoryDir } from './memory-paths.js';
+import { MEMORY_FRONTMATTER_EXAMPLE, TYPES_SECTION, WHAT_NOT_TO_SAVE_SECTION, WHEN_TO_ACCESS_SECTION, TRUSTING_RECALL_SECTION, } from './memory-types.js';
+import { scanMemoryFiles } from './memory-scan.js';
+import { memoryAge } from './memory-age.js';
+import { extractMemories } from './auto-extract.js';
+// ── Constants ────────────────────────────────────────────────────────
+/** Name of the entrypoint file that indexes all memories. */
+const ENTRYPOINT_NAME = 'MEMORY.md';
+/** Maximum number of lines loaded from MEMORY.md into context. */
+const MAX_ENTRYPOINT_LINES = 200;
+/** Maximum byte size loaded from MEMORY.md into context. */
+const MAX_ENTRYPOINT_BYTES = 25_000;
+// ── Helpers ──────────────────────────────────────────────────────────
+/**
+ * Truncate the raw MEMORY.md content to stay within context-window limits.
+ *
+ * Applies two caps in order:
+ *   1. Line count (MAX_ENTRYPOINT_LINES)
+ *   2. Byte size  (MAX_ENTRYPOINT_BYTES)
+ *
+ * If either cap triggers, a warning footer is appended so the agent knows
+ * the index was trimmed.
+ */
+function truncateEntrypointContent(raw) {
+    let wasTruncated = false;
+    let content = raw.trim();
+    const lines = content.split('\n');
+    // Cap 1: line count
+    if (lines.length > MAX_ENTRYPOINT_LINES) {
+        content = lines.slice(0, MAX_ENTRYPOINT_LINES).join('\n');
+        wasTruncated = true;
+    }
+    // Cap 2: byte size
+    if (Buffer.byteLength(content, 'utf-8') > MAX_ENTRYPOINT_BYTES) {
+        // Walk backwards to find the last newline within budget
+        let cutoff = content.length;
+        while (Buffer.byteLength(content.slice(0, cutoff), 'utf-8') > MAX_ENTRYPOINT_BYTES) {
+            const idx = content.lastIndexOf('\n', cutoff - 1);
+            cutoff = idx > 0 ? idx : 0;
+        }
+        content = content.slice(0, cutoff);
+        wasTruncated = true;
+    }
+    if (wasTruncated) {
+        content +=
+            '\n\n> WARNING: MEMORY.md is too large. Only part was loaded. Keep index entries concise.';
+    }
+    return { content, wasTruncated };
+}
+/**
+ * Build the full memory system prompt that is injected via before_agent_start.
+ *
+ * @param memoryDir  Absolute path to the project's memory directory.
+ * @param entrypointContent  The (possibly truncated) contents of MEMORY.md.
+ */
+function buildMemoryPrompt(memoryDir, entrypointContent) {
+    const sections = [];
+    // ── Header ──
+    sections.push(`# Memory
+
+You have a persistent, file-based memory system at \`${memoryDir}\`.
+This directory already exists — write to it directly with the file write tool (do not run mkdir or check existence).
+
+Build up this memory over time so future conversations have a complete picture of who the user is, how they'd like to collaborate, what to avoid or repeat, and the context behind their work.
+
+If the user explicitly asks you to remember something, save it immediately. If they ask you to forget, find and remove it.`);
+    // ── Types ──
+    sections.push(TYPES_SECTION.join('\n'));
+    // ── What not to save ──
+    sections.push(WHAT_NOT_TO_SAVE_SECTION.join('\n'));
+    // ── How to save ──
+    sections.push(`## How to save memories
+
+Saving a memory is a two-step process:
+
+**Step 1** — write the memory to its own file (e.g., \`user_role.md\`, \`feedback_testing.md\`) using this frontmatter format:
+
+${MEMORY_FRONTMATTER_EXAMPLE.join('\n')}
+
+**Step 2** — add a pointer to that file in \`MEMORY.md\`. Each entry should be one line, under ~150 characters: \`- [Title](file.md) — one-line hook\`. Never write memory content directly into \`MEMORY.md\`.
+
+- \`MEMORY.md\` is always loaded into your context — lines after ${MAX_ENTRYPOINT_LINES} will be truncated
+- Keep name, description, and type fields up-to-date
+- Organize semantically, not chronologically
+- Update or remove stale memories
+- Check for existing memories before writing duplicates`);
+    // ── When to access ──
+    sections.push(WHEN_TO_ACCESS_SECTION.join('\n'));
+    // ── Trusting recall ──
+    sections.push(TRUSTING_RECALL_SECTION.join('\n'));
+    // ── Entrypoint content ──
+    const body = entrypointContent.trim() ||
+        'Your MEMORY.md is currently empty. When you save new memories, they will appear here.';
+    sections.push(`## MEMORY.md\n\n${body}`);
+    return sections.join('\n\n');
+}
+// ── Extension entry point ────────────────────────────────────────────
+/**
+ * Memory extension for LSD.
+ *
+ * Lifecycle:
+ *   session_start     → bootstrap memory directory & MEMORY.md
+ *   before_agent_start → inject memory system prompt
+ *   session_shutdown   → fire-and-forget auto-extract of new memories
+ *
+ * Commands:
+ *   /memories  — list all saved memories
+ *   /remember  — save a memory immediately
+ *   /forget    — remove a memory by topic
+ */
+export default function memoryExtension(pi) {
+    let memoryCwd = '';
+    let memoryDir = '';
+    // ── session_start: bootstrap memory directory ──────────────────────
+    pi.on('session_start', async (_event, ctx) => {
+        memoryCwd = ctx.cwd;
+        memoryDir = getMemoryDir(memoryCwd);
+        ensureMemoryDir(memoryCwd);
+        // Create MEMORY.md if it doesn't exist
+        const entrypoint = getMemoryEntrypoint(memoryCwd);
+        if (!existsSync(entrypoint)) {
+            writeFileSync(entrypoint, '', 'utf-8');
+        }
+    });
+    // ── before_agent_start: inject memory prompt into system prompt ───
+    pi.on('before_agent_start', async (event) => {
+        if (!memoryCwd)
+            return;
+        const entrypoint = getMemoryEntrypoint(memoryCwd);
+        let entrypointContent = '';
+        try {
+            entrypointContent = readFileSync(entrypoint, 'utf-8');
+        }
+        catch {
+            // File may have been deleted between session_start and now
+        }
+        if (entrypointContent.trim()) {
+            const { content } = truncateEntrypointContent(entrypointContent);
+            entrypointContent = content;
+        }
+        const prompt = buildMemoryPrompt(memoryDir, entrypointContent);
+        return {
+            systemPrompt: event.systemPrompt + '\n\n' + prompt,
+        };
+    });
+    // ── session_shutdown: trigger auto-extract ────────────────────────
+    pi.on('session_shutdown', async (_event, ctx) => {
+        if (!memoryCwd)
+            return;
+        // Don't extract if this IS the extraction agent
+        if (process.env.LSD_MEMORY_EXTRACT === '1')
+            return;
+        try {
+            extractMemories(ctx, memoryCwd);
+        }
+        catch {
+            // Fire-and-forget — never block shutdown
+        }
+    });
+    // ── Slash commands ────────────────────────────────────────────────
+    /**
+     * /memories — list all saved memories with type, age, and description.
+     */
+    pi.registerCommand('memories', {
+        description: 'List all saved memories',
+        handler: async (_args, ctx) => {
+            if (!memoryCwd) {
+                ctx.ui?.notify('No memory directory initialized', 'warning');
+                return;
+            }
+            const memories = scanMemoryFiles(memoryDir);
+            if (memories.length === 0) {
+                pi.sendUserMessage("No memories saved yet. I'll start building memory as we work together.");
+                return;
+            }
+            const lines = memories.map((m) => {
+                const age = memoryAge(m.mtimeMs);
+                const type = m.type ? `[${m.type}]` : '';
+                const desc = m.description ? ` — ${m.description}` : '';
+                return `- ${type} **${m.filename}** (${age})${desc}`;
+            });
+            pi.sendUserMessage(`Here are your saved memories:\n\n${lines.join('\n')}`);
+        },
+    });
+    /**
+     * /remember <text> — ask the agent to save a memory immediately.
+     */
+    pi.registerCommand('remember', {
+        description: 'Save a memory immediately',
+        handler: async (args) => {
+            if (!memoryCwd)
+                return;
+            const text = args.trim();
+            if (!text)
+                return;
+            pi.sendUserMessage(`Please save this to memory: ${text}`);
+        },
+    });
+    /**
+     * /forget <topic> — ask the agent to find and remove a memory.
+     */
+    pi.registerCommand('forget', {
+        description: 'Forget/remove a memory',
+        handler: async (args) => {
+            if (!memoryCwd)
+                return;
+            const topic = args.trim();
+            if (!topic)
+                return;
+            pi.sendUserMessage(`Please find and remove any memories about: ${topic}`);
+        },
+    });
+}

package/dist/resources/extensions/memory/memory-age.js

@@ -0,0 +1,43 @@
+/**
+ * Freshness tracking utilities for memories.
+ *
+ * Memories are point-in-time observations. These helpers turn an mtime
+ * into a human-readable age string and an optional staleness warning
+ * that the agent can surface when recalling old memories.
+ */
+/**
+ * Return the age of a memory in whole days (floored), clamped to ≥ 0.
+ *
+ * @param mtimeMs - The file's `mtime` in epoch milliseconds.
+ */
+export function memoryAgeDays(mtimeMs) {
+    return Math.max(0, Math.floor((Date.now() - mtimeMs) / 86_400_000));
+}
+/**
+ * Return a short human-readable age label.
+ *
+ * @param mtimeMs - The file's `mtime` in epoch milliseconds.
+ * @returns `"today"`, `"yesterday"`, or `"N days ago"`.
+ */
+export function memoryAge(mtimeMs) {
+    const d = memoryAgeDays(mtimeMs);
+    if (d === 0)
+        return 'today';
+    if (d === 1)
+        return 'yesterday';
+    return `${d} days ago`;
+}
+/**
+ * Return a freshness caveat string for memories older than one day.
+ *
+ * When the memory is fresh (≤ 1 day old) an empty string is returned so
+ * callers can simply concatenate without branching.
+ *
+ * @param mtimeMs - The file's `mtime` in epoch milliseconds.
+ */
+export function memoryFreshnessNote(mtimeMs) {
+    const d = memoryAgeDays(mtimeMs);
+    if (d <= 1)
+        return '';
+    return `This memory is ${d} days old. Memories are point-in-time observations — claims about code or file:line citations may be outdated. Verify against current code before asserting as fact.`;
+}

package/dist/resources/extensions/memory/memory-paths.js

@@ -0,0 +1,49 @@
+import { mkdirSync } from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+/**
+ * Sanitize a project's absolute cwd into a safe directory name.
+ * Returns `<basename>-<8char-sha256-hex>` where non-alphanumeric
+ * characters in the basename are replaced with underscores.
+ *
+ * @example sanitizeProjectPath('/Users/me/projects/my-app') → 'my_app-a1b2c3d4'
+ */
+export function sanitizeProjectPath(cwd) {
+    const base = path.basename(cwd).replace(/[^a-zA-Z0-9]/g, '_');
+    const hash = createHash('sha256').update(cwd).digest('hex').slice(0, 8);
+    return `${base}-${hash}`;
+}
+/**
+ * Return the global LSD base directory (~/.lsd).
+ */
+export function getMemoryBaseDir() {
+    return path.join(homedir(), '.lsd');
+}
+/**
+ * Return the NFC-normalized memory directory for a given project cwd,
+ * with a trailing path separator appended.
+ */
+export function getMemoryDir(cwd) {
+    const dir = path.join(getMemoryBaseDir(), 'projects', sanitizeProjectPath(cwd), 'memory');
+    return (dir + path.sep).normalize('NFC');
+}
+/**
+ * Return the path to the project's MEMORY.md entrypoint file.
+ */
+export function getMemoryEntrypoint(cwd) {
+    return path.join(getMemoryDir(cwd), 'MEMORY.md');
+}
+/**
+ * Ensure the memory directory exists on disk.
+ * Uses sync I/O because prompt building is synchronous.
+ */
+export function ensureMemoryDir(cwd) {
+    mkdirSync(getMemoryDir(cwd), { recursive: true });
+}
+/**
+ * Check whether an absolute path resides inside the project's memory directory.
+ */
+export function isMemoryPath(absolutePath, cwd) {
+    return path.normalize(absolutePath).startsWith(getMemoryDir(cwd));
+}

package/dist/resources/extensions/memory/memory-recall.js

@@ -0,0 +1,150 @@
+/**
+ * Memory recall — finds relevant memories for a given user query
+ * by asking a fast LLM to select from available memory headers.
+ *
+ * Supports both Anthropic and OpenAI APIs via direct `fetch()` calls.
+ * Gracefully falls back to empty results when no API key is available
+ * or when the LLM call fails for any reason.
+ */
+import { scanMemoryFiles, formatMemoryManifest } from './memory-scan.js';
+const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to a coding agent as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
+
+Return a JSON object with a single key "selected_memories" containing an array of filenames (up to 5) that will clearly be useful. Only include memories you are certain will be helpful. If none are relevant, return an empty array.
+
+Example response: {"selected_memories": ["user_role.md", "feedback_testing.md"]}`;
+/** Timeout for LLM API calls (ms) */
+const API_TIMEOUT_MS = 15_000;
+/**
+ * Find memories relevant to a user query by asking an LLM to select
+ * from the available memory headers.
+ *
+ * @param query - The user's query or message
+ * @param memoryDir - Absolute path to the memory directory
+ * @param alreadySurfaced - Set of file paths that have already been surfaced (to avoid duplicates)
+ * @returns Array of relevant memories with path and modification time
+ */
+export async function findRelevantMemories(query, memoryDir, alreadySurfaced) {
+    const allMemories = scanMemoryFiles(memoryDir);
+    // Filter out already-surfaced paths
+    const memories = alreadySurfaced?.size
+        ? allMemories.filter((m) => !alreadySurfaced.has(m.filePath))
+        : allMemories;
+    if (memories.length === 0)
+        return [];
+    const selectedFilenames = await selectRelevantMemories(query, memories);
+    if (selectedFilenames.length === 0)
+        return [];
+    // Build a lookup from filename → header for O(1) mapping
+    const byFilename = new Map();
+    for (const m of memories)
+        byFilename.set(m.filename, m);
+    const results = [];
+    for (const filename of selectedFilenames) {
+        const header = byFilename.get(filename);
+        if (header) {
+            results.push({ path: header.filePath, mtimeMs: header.mtimeMs });
+        }
+    }
+    return results;
+}
+/**
+ * Ask an LLM to select the most relevant memory filenames for a query.
+ * Tries Anthropic first (if ANTHROPIC_API_KEY is set), then OpenAI.
+ * Returns an empty array on any failure.
+ */
+async function selectRelevantMemories(query, memories) {
+    const manifest = formatMemoryManifest(memories);
+    const validFilenames = new Set(memories.map((m) => m.filename));
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    if (!apiKey)
+        return [];
+    const userMessage = `User query:\n${query}\n\nAvailable memories:\n${manifest}`;
+    try {
+        const isAnthropic = !!process.env.ANTHROPIC_API_KEY;
+        const selected = isAnthropic
+            ? await callAnthropic(apiKey, userMessage)
+            : await callOpenAI(apiKey, userMessage);
+        // Only return filenames that actually exist in the scanned memories
+        return selected.filter((f) => validFilenames.has(f));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Call the Anthropic Messages API to select relevant memories.
+ */
+async function callAnthropic(apiKey, userMessage) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+    try {
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 256,
+                system: SELECT_MEMORIES_SYSTEM_PROMPT,
+                messages: [{ role: 'user', content: userMessage }],
+            }),
+        });
+        if (!res.ok)
+            return [];
+        const body = (await res.json());
+        const text = body.content?.find((b) => b.type === 'text')?.text ?? '';
+        return parseSelectedMemories(text);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Call the OpenAI Chat Completions API to select relevant memories.
+ */
+async function callOpenAI(apiKey, userMessage) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+    try {
+        const res = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: 'gpt-4o-mini',
+                max_tokens: 256,
+                messages: [
+                    { role: 'system', content: SELECT_MEMORIES_SYSTEM_PROMPT },
+                    { role: 'user', content: userMessage },
+                ],
+            }),
+        });
+        if (!res.ok)
+            return [];
+        const body = (await res.json());
+        const text = body.choices?.[0]?.message?.content ?? '';
+        return parseSelectedMemories(text);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Parse the LLM response text to extract the `selected_memories` array.
+ * Handles both clean JSON and JSON wrapped in markdown code fences.
+ */
+function parseSelectedMemories(text) {
+    // Strip markdown code fences if present
+    const cleaned = text.replace(/^```(?:json)?\s*\n?/m, '').replace(/\n?```\s*$/m, '');
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed.selected_memories))
+        return [];
+    return parsed.selected_memories.filter((item) => typeof item === 'string');
+}