opencode-claude-memory 1.6.0 → 1.6.2

package/README.md

@@ -230,7 +230,9 @@ Supported memory types:
 # Run tests
 bun test
 
-# No build needed — raw TS consumed by OpenCode
+# Build published artifacts
+bun run build
+
 # Release: push to main triggers semantic-release → npm publish
 ```
 

package/bin/opencode-memory

@@ -956,6 +956,80 @@ rollback_consolidation_lock() {
   set_file_mtime_secs "$path" "$prior_mtime"
 }
 
+cleanup_forked_sessions() {
+  local before_json="$1"
+
+  if ! command -v python3 >/dev/null 2>&1; then
+    return 0
+  fi
+
+  local after_json
+  after_json=$(get_session_list_json 10 2>/dev/null || true)
+
+  if [ -z "$before_json" ] || [ -z "$after_json" ]; then
+    return 0
+  fi
+
+  local fork_ids
+  fork_ids=$(python3 - "$before_json" "$after_json" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" <<'PY'
+import json
+import os
+import sys
+
+def parse(raw):
+    try:
+        data = json.loads(raw)
+        return data if isinstance(data, list) else []
+    except Exception:
+        return []
+
+before_raw, after_raw, workdir, project_dir = sys.argv[1:5]
+before = parse(before_raw)
+after = parse(after_raw)
+
+before_ids = {item.get("id") for item in before if item.get("id")}
+workdir = os.path.realpath(workdir)
+project_dir = os.path.realpath(project_dir)
+
+for item in after:
+    sid = item.get("id", "")
+    if not sid or sid in before_ids:
+        continue
+    directory = item.get("directory", "")
+    if not directory:
+        continue
+    d = os.path.realpath(directory)
+    if d in (workdir, project_dir):
+        print(sid)
+PY
+  ) || return 0
+
+  while IFS= read -r fork_id; do
+    [ -n "$fork_id" ] || continue
+    if "$REAL_OPENCODE" session delete "$fork_id" >/dev/null 2>&1; then
+      log "Cleaned up forked session $fork_id"
+    fi
+  done <<< "$fork_ids"
+}
+
+session_has_conversation() {
+  local session_id="$1"
+  local transcript_file
+  transcript_file="$(get_transcripts_dir)/${session_id}.jsonl"
+
+  if [ -f "$transcript_file" ]; then
+    local line_count
+    line_count=$(wc -l < "$transcript_file")
+    # Empty sessions have at most 1 line (the initial user entry with no content).
+    # Real sessions have 3+ lines (user + tool_use + tool_result at minimum).
+    [ "$line_count" -gt 1 ]
+    return $?
+  fi
+
+  # Transcript not found — assume content exists to avoid skipping a valid session.
+  return 0
+}
+
 run_extraction_if_needed() {
   local session_id="$1"
   local memory_written_during_session="$2"
@@ -985,6 +1059,9 @@ run_extraction_if_needed() {
   fi
   cmd+=("$EXTRACT_PROMPT")
 
+  local pre_fork_json
+  pre_fork_json=$(get_session_list_json 5 2>/dev/null || true)
+
   if "${cmd[@]}" >> "$EXTRACT_LOG_FILE" 2>&1; then
     log "Memory extraction completed successfully"
   else
@@ -992,6 +1069,7 @@ run_extraction_if_needed() {
     log "Memory extraction failed (exit code $code). Check $EXTRACT_LOG_FILE for details"
   fi
 
+  cleanup_forked_sessions "$pre_fork_json"
   release_simple_lock "$EXTRACT_LOCK_FILE"
 }
 
@@ -1043,6 +1121,9 @@ run_autodream_if_needed() {
   fi
   cmd+=("$AUTODREAM_PROMPT")
 
+  local pre_fork_json
+  pre_fork_json=$(get_session_list_json 5 2>/dev/null || true)
+
   if "${cmd[@]}" >> "$AUTODREAM_LOG_FILE" 2>&1; then
     log "Auto-dream consolidation completed successfully"
     # Keep lock mtime at "now" to represent last consolidated timestamp.
@@ -1050,8 +1131,9 @@ run_autodream_if_needed() {
     local code=$?
     log "Auto-dream consolidation failed (exit code $code). Rolling back gate timestamp"
     rollback_consolidation_lock "$CONSOLIDATION_PRIOR_MTIME"
-    return 0
   fi
+
+  cleanup_forked_sessions "$pre_fork_json"
 }
 
 run_post_session_tasks() {
@@ -1093,6 +1175,13 @@ if [ -z "$session_id" ]; then
   exit $opencode_exit
 fi
 
+# Step 3.5: Skip if session had no real conversation (e.g. user opened TUI and exited)
+if ! session_has_conversation "$session_id"; then
+  log "Session $session_id has no conversation, skipping post-session memory maintenance"
+  cleanup_timestamp
+  exit $opencode_exit
+fi
+
 # Step 4: Check whether main session already wrote memory files
 memory_written_during_session=0
 if has_new_memories; then

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const MemoryPlugin: Plugin;

package/dist/index.js

@@ -0,0 +1,239 @@
+import { tool } from "@opencode-ai/plugin";
+import { buildMemorySystemPrompt } from "./prompt.js";
+import { recallRelevantMemories, formatRecalledMemories } from "./recall.js";
+import { saveMemory, deleteMemory, listMemories, searchMemories, readMemory, MEMORY_TYPES, } from "./memory.js";
+import { getMemoryDir } from "./paths.js";
+const turnContextBySession = new Map();
+function shouldIgnoreMemoryContext(query) {
+    if (process.env.OPENCODE_MEMORY_IGNORE === "1")
+        return true;
+    if (!query)
+        return false;
+    const normalized = query.toLowerCase();
+    return (/(ignore|don't use|do not use|without|skip)\s+(the\s+)?memory/.test(normalized) ||
+        /memory\s+(should be|must be)?\s*ignored/.test(normalized));
+}
+function extractUserQuery(message) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    if ("content" in message) {
+        const content = message.content;
+        if (typeof content === "string")
+            return content;
+        if (content !== undefined)
+            return JSON.stringify(content);
+    }
+    if ("parts" in message) {
+        const parts = message.parts;
+        if (Array.isArray(parts)) {
+            const text = parts
+                .map((part) => {
+                if (!part || typeof part !== "object")
+                    return "";
+                return typeof part.text === "string"
+                    ? part.text
+                    : "";
+            })
+                .filter(Boolean)
+                .join("\n")
+                .trim();
+            if (text)
+                return text;
+        }
+    }
+    return undefined;
+}
+function getLastUserQuery(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message?.info?.role !== "user")
+            continue;
+        const query = extractUserQuery(message);
+        const sessionID = typeof message.info?.sessionID === "string" ? message.info.sessionID : undefined;
+        return { query, sessionID };
+    }
+    return {};
+}
+function isAutoMemoryPart(part) {
+    if (!part || typeof part !== "object")
+        return false;
+    return typeof part.text === "string" &&
+        part.text.includes("# Auto Memory");
+}
+// Parses "### <name> (<type>)" headers from the ## Recalled Memories section
+// of system prompts. After compaction old system messages disappear, so
+// the returned set naturally shrinks — no manual reset needed.
+function extractSurfacedMemoryKeys(systemText) {
+    const keys = new Set();
+    const recalledSection = systemText.indexOf("## Recalled Memories");
+    if (recalledSection === -1)
+        return keys;
+    const headerPattern = /^### (.+?) \((\w+)\)/gm;
+    const section = systemText.slice(recalledSection);
+    for (let match = headerPattern.exec(section); match !== null; match = headerPattern.exec(section)) {
+        keys.add(`${match[1]}|${match[2]}`);
+    }
+    return keys;
+}
+// Only completed tools — matches Claude Code's collectRecentSuccessfulTools().
+function extractRecentTools(messages) {
+    const tools = [];
+    const seen = new Set();
+    for (const message of messages) {
+        if (!message.parts || !Array.isArray(message.parts))
+            continue;
+        for (const part of message.parts) {
+            if (!part || typeof part !== "object")
+                continue;
+            const p = part;
+            if (p.type !== "tool" || !p.tool)
+                continue;
+            if (p.state?.status !== "completed")
+                continue;
+            if (seen.has(p.tool))
+                continue;
+            seen.add(p.tool);
+            tools.push(p.tool);
+        }
+    }
+    return tools;
+}
+export const MemoryPlugin = async ({ worktree }) => {
+    getMemoryDir(worktree);
+    return {
+        "experimental.chat.messages.transform": async (_input, output) => {
+            const { query, sessionID } = getLastUserQuery(output.messages);
+            if (sessionID) {
+                const alreadySurfaced = new Set();
+                for (const message of output.messages) {
+                    const role = String(message.info.role);
+                    if (role !== "system")
+                        continue;
+                    for (const part of message.parts) {
+                        if (!part || typeof part !== "object")
+                            continue;
+                        const text = part.text;
+                        if (typeof text === "string") {
+                            for (const key of extractSurfacedMemoryKeys(text)) {
+                                alreadySurfaced.add(key);
+                            }
+                        }
+                    }
+                }
+                const recentTools = extractRecentTools(output.messages);
+                turnContextBySession.set(sessionID, { query, alreadySurfaced, recentTools });
+            }
+            if (shouldIgnoreMemoryContext(query)) {
+                output.messages = output.messages
+                    .map((message) => {
+                    const role = String(message.info.role);
+                    if (role !== "system")
+                        return message;
+                    const parts = message.parts.filter((part) => !isAutoMemoryPart(part));
+                    return { ...message, parts };
+                })
+                    .filter((message) => message.parts.length > 0);
+            }
+        },
+        "experimental.chat.system.transform": async (_input, output) => {
+            let sessionID;
+            if (_input && typeof _input === "object") {
+                sessionID = (typeof _input.sessionID === "string"
+                    ? _input.sessionID
+                    : undefined);
+            }
+            const ctx = sessionID ? turnContextBySession.get(sessionID) : undefined;
+            const query = ctx?.query;
+            const alreadySurfaced = ctx?.alreadySurfaced ?? new Set();
+            const recentTools = ctx?.recentTools ?? [];
+            const ignoreMemoryContext = process.env.OPENCODE_MEMORY_IGNORE === "1" || shouldIgnoreMemoryContext(query);
+            const recalled = ignoreMemoryContext ? [] : recallRelevantMemories(worktree, query, alreadySurfaced, recentTools);
+            const recalledSection = formatRecalledMemories(recalled);
+            const memoryPrompt = buildMemorySystemPrompt(worktree, recalledSection, {
+                includeIndex: !ignoreMemoryContext,
+            });
+            output.system.push(memoryPrompt);
+        },
+        tool: {
+            memory_save: tool({
+                description: "Save or update a memory for future conversations. " +
+                    "Each memory is stored as a markdown file with frontmatter. " +
+                    "Use this when the user explicitly asks you to remember something, " +
+                    "or when you observe important information worth preserving across sessions " +
+                    "(user preferences, feedback, project context, external references). " +
+                    "Check existing memories first with memory_list or memory_search to avoid duplicates.",
+                args: {
+                    file_name: tool.schema
+                        .string()
+                        .describe('File name for the memory (without .md extension). Use snake_case, e.g. "user_role", "feedback_testing_style", "project_auth_rewrite"'),
+                    name: tool.schema.string().describe("Human-readable name for this memory"),
+                    description: tool.schema
+                        .string()
+                        .describe("One-line description — used to decide relevance in future conversations, so be specific"),
+                    type: tool.schema
+                        .enum(MEMORY_TYPES)
+                        .describe("Memory type: user (about the person), feedback (guidance on approach), project (ongoing work context), reference (pointers to external systems)"),
+                    content: tool.schema
+                        .string()
+                        .describe("Memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines"),
+                },
+                async execute(args) {
+                    const filePath = saveMemory(worktree, args.file_name, args.name, args.description, args.type, args.content);
+                    return `Memory saved to ${filePath}`;
+                },
+            }),
+            memory_delete: tool({
+                description: "Delete a memory that is outdated, wrong, or no longer relevant. Also removes it from the index.",
+                args: {
+                    file_name: tool.schema.string().describe("File name of the memory to delete (with or without .md extension)"),
+                },
+                async execute(args) {
+                    const deleted = deleteMemory(worktree, args.file_name);
+                    return deleted ? `Memory "${args.file_name}" deleted.` : `Memory "${args.file_name}" not found.`;
+                },
+            }),
+            memory_list: tool({
+                description: "List all saved memories with their names, types, and descriptions. " +
+                    "Use this to check what memories exist before saving a new one (to avoid duplicates) " +
+                    "or when you need to recall what's been stored.",
+                args: {},
+                async execute() {
+                    const entries = listMemories(worktree);
+                    if (entries.length === 0) {
+                        return "No memories saved yet.";
+                    }
+                    const lines = entries.map((e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}`);
+                    return `${entries.length} memories found:\n${lines.join("\n")}`;
+                },
+            }),
+            memory_search: tool({
+                description: "Search memories by keyword. Searches across names, descriptions, and content. " +
+                    "Use this to find relevant memories before answering questions or when the user references past conversations.",
+                args: {
+                    query: tool.schema.string().describe("Search query — searches across name, description, and content"),
+                },
+                async execute(args) {
+                    const results = searchMemories(worktree, args.query);
+                    if (results.length === 0) {
+                        return `No memories matching "${args.query}".`;
+                    }
+                    const lines = results.map((e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}\n  Content: ${e.content.slice(0, 200)}${e.content.length > 200 ? "..." : ""}`);
+                    return `${results.length} matches for "${args.query}":\n${lines.join("\n")}`;
+                },
+            }),
+            memory_read: tool({
+                description: "Read the full content of a specific memory file.",
+                args: {
+                    file_name: tool.schema.string().describe("File name of the memory to read (with or without .md extension)"),
+                },
+                async execute(args) {
+                    const entry = readMemory(worktree, args.file_name);
+                    if (!entry) {
+                        return `Memory "${args.file_name}" not found.`;
+                    }
+                    return `# ${entry.name}\n**Type:** ${entry.type}\n**Description:** ${entry.description}\n\n${entry.content}`;
+                },
+            }),
+        },
+    };
+};

package/dist/memory.d.ts

@@ -0,0 +1,25 @@
+export declare const MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
+export type MemoryType = (typeof MEMORY_TYPES)[number];
+export type MemoryEntry = {
+    filePath: string;
+    fileName: string;
+    name: string;
+    description: string;
+    type: MemoryType;
+    content: string;
+    rawContent: string;
+};
+export declare function listMemories(worktree: string): MemoryEntry[];
+export declare function readMemory(worktree: string, fileName: string): MemoryEntry | null;
+export declare function saveMemory(worktree: string, fileName: string, name: string, description: string, type: MemoryType, content: string): string;
+export declare function deleteMemory(worktree: string, fileName: string): boolean;
+export declare function searchMemories(worktree: string, query: string): MemoryEntry[];
+export declare function readIndex(worktree: string): string;
+export type EntrypointTruncation = {
+    content: string;
+    lineCount: number;
+    byteCount: number;
+    wasLineTruncated: boolean;
+    wasByteTruncated: boolean;
+};
+export declare function truncateEntrypoint(raw: string): EntrypointTruncation;

package/dist/memory.js

@@ -0,0 +1,200 @@
+import { readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs";
+import { join, basename } from "path";
+import { getMemoryDir, getMemoryEntrypoint, ENTRYPOINT_NAME, validateMemoryFileName, MAX_MEMORY_FILES, MAX_MEMORY_FILE_BYTES, MAX_ENTRYPOINT_LINES, MAX_ENTRYPOINT_BYTES, FRONTMATTER_MAX_LINES, } from "./paths.js";
+export const MEMORY_TYPES = ["user", "feedback", "project", "reference"];
+function parseFrontmatter(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("---")) {
+        return { frontmatter: {}, content: trimmed };
+    }
+    const lines = trimmed.split("\n");
+    let closingLineIdx = -1;
+    for (let i = 1; i < Math.min(lines.length, FRONTMATTER_MAX_LINES); i++) {
+        if (lines[i].trimEnd() === "---") {
+            closingLineIdx = i;
+            break;
+        }
+    }
+    if (closingLineIdx === -1) {
+        return { frontmatter: {}, content: trimmed };
+    }
+    const endIndex = lines.slice(0, closingLineIdx).join("\n").length + 1;
+    const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+    const content = trimmed.slice(endIndex + 3).trim();
+    const frontmatter = {};
+    for (const line of frontmatterBlock.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        if (key && value) {
+            frontmatter[key] = value;
+        }
+    }
+    return { frontmatter, content };
+}
+function buildFrontmatter(name, description, type) {
+    return `---\nname: ${name}\ndescription: ${description}\ntype: ${type}\n---`;
+}
+function parseMemoryType(raw) {
+    if (!raw)
+        return undefined;
+    return MEMORY_TYPES.find((t) => t === raw);
+}
+export function listMemories(worktree) {
+    const memDir = getMemoryDir(worktree);
+    const entries = [];
+    let files;
+    try {
+        files = readdirSync(memDir, { encoding: "utf-8" })
+            .filter((f) => f.endsWith(".md") && f !== ENTRYPOINT_NAME)
+            .sort()
+            .slice(0, MAX_MEMORY_FILES);
+    }
+    catch {
+        return entries;
+    }
+    for (const fileName of files) {
+        const filePath = join(memDir, fileName);
+        try {
+            const rawContent = readFileSync(filePath, "utf-8");
+            const { frontmatter, content } = parseFrontmatter(rawContent);
+            entries.push({
+                filePath,
+                fileName,
+                name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
+                description: frontmatter.description ?? "",
+                type: parseMemoryType(frontmatter.type) ?? "user",
+                content,
+                rawContent,
+            });
+        }
+        catch {
+        }
+    }
+    return entries;
+}
+export function readMemory(worktree, fileName) {
+    const safeName = validateMemoryFileName(fileName);
+    const memDir = getMemoryDir(worktree);
+    const filePath = join(memDir, safeName);
+    try {
+        const rawContent = readFileSync(filePath, "utf-8");
+        const { frontmatter, content } = parseFrontmatter(rawContent);
+        return {
+            filePath,
+            fileName: basename(filePath),
+            name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
+            description: frontmatter.description ?? "",
+            type: parseMemoryType(frontmatter.type) ?? "user",
+            content,
+            rawContent,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveMemory(worktree, fileName, name, description, type, content) {
+    const safeName = validateMemoryFileName(fileName);
+    const memDir = getMemoryDir(worktree);
+    const filePath = join(memDir, safeName);
+    const fileContent = `${buildFrontmatter(name, description, type)}\n\n${content.trim()}\n`;
+    if (Buffer.byteLength(fileContent, "utf-8") > MAX_MEMORY_FILE_BYTES) {
+        throw new Error(`Memory file content exceeds the ${MAX_MEMORY_FILE_BYTES}-byte limit`);
+    }
+    writeFileSync(filePath, fileContent, "utf-8");
+    updateIndex(worktree, safeName, name, description);
+    return filePath;
+}
+export function deleteMemory(worktree, fileName) {
+    const safeName = validateMemoryFileName(fileName);
+    const memDir = getMemoryDir(worktree);
+    const filePath = join(memDir, safeName);
+    try {
+        unlinkSync(filePath);
+        removeFromIndex(worktree, safeName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function searchMemories(worktree, query) {
+    const all = listMemories(worktree);
+    const lowerQuery = query.toLowerCase();
+    return all.filter((entry) => entry.name.toLowerCase().includes(lowerQuery) ||
+        entry.description.toLowerCase().includes(lowerQuery) ||
+        entry.content.toLowerCase().includes(lowerQuery));
+}
+export function readIndex(worktree) {
+    const entrypoint = getMemoryEntrypoint(worktree);
+    try {
+        return readFileSync(entrypoint, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function updateIndex(worktree, fileName, name, description) {
+    const entrypoint = getMemoryEntrypoint(worktree);
+    const existing = readIndex(worktree);
+    const lines = existing.split("\n").filter((l) => l.trim());
+    const pointer = `- [${name}](${fileName}) — ${description}`;
+    const existingIdx = lines.findIndex((l) => l.includes(`(${fileName})`));
+    if (existingIdx >= 0) {
+        lines[existingIdx] = pointer;
+    }
+    else {
+        lines.push(pointer);
+    }
+    writeFileSync(entrypoint, lines.join("\n") + "\n", "utf-8");
+}
+function removeFromIndex(worktree, fileName) {
+    const entrypoint = getMemoryEntrypoint(worktree);
+    const existing = readIndex(worktree);
+    const lines = existing
+        .split("\n")
+        .filter((l) => l.trim() && !l.includes(`(${fileName})`));
+    writeFileSync(entrypoint, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    return `${(bytes / 1024).toFixed(1)}KB`;
+}
+// Port of Claude Code's truncateEntrypointContent() from memdir.ts.
+// Uses .length (char count, same as Claude Code) for byte measurement.
+export function truncateEntrypoint(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { content: "", lineCount: 0, byteCount: 0, wasLineTruncated: false, wasByteTruncated: false };
+    const contentLines = trimmed.split("\n");
+    const lineCount = contentLines.length;
+    const byteCount = trimmed.length;
+    const wasLineTruncated = lineCount > MAX_ENTRYPOINT_LINES;
+    const wasByteTruncated = byteCount > MAX_ENTRYPOINT_BYTES;
+    if (!wasLineTruncated && !wasByteTruncated) {
+        return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated };
+    }
+    let truncated = wasLineTruncated
+        ? contentLines.slice(0, MAX_ENTRYPOINT_LINES).join("\n")
+        : trimmed;
+    if (truncated.length > MAX_ENTRYPOINT_BYTES) {
+        const cutAt = truncated.lastIndexOf("\n", MAX_ENTRYPOINT_BYTES);
+        truncated = truncated.slice(0, cutAt > 0 ? cutAt : MAX_ENTRYPOINT_BYTES);
+    }
+    const reason = wasByteTruncated && !wasLineTruncated
+        ? `${formatFileSize(byteCount)} (limit: ${formatFileSize(MAX_ENTRYPOINT_BYTES)}) — index entries are too long`
+        : wasLineTruncated && !wasByteTruncated
+            ? `${lineCount} lines (limit: ${MAX_ENTRYPOINT_LINES})`
+            : `${lineCount} lines and ${formatFileSize(byteCount)}`;
+    return {
+        content: truncated + `\n\n> WARNING: ${ENTRYPOINT_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
+        lineCount,
+        byteCount,
+        wasLineTruncated,
+        wasByteTruncated,
+    };
+}

package/dist/memoryScan.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryType } from "./memory.js";
+export type MemoryHeader = {
+    filename: string;
+    filePath: string;
+    mtimeMs: number;
+    name: string | null;
+    description: string | null;
+    type: MemoryType | undefined;
+};
+/**
+ * Recursive scan of memory directory. Reads only frontmatter (first N lines),
+ * returns headers sorted by mtime desc, capped at MAX_MEMORY_FILES.
+ * Port of Claude Code's scanMemoryFiles().
+ */
+export declare function scanMemoryFiles(memoryDir: string): MemoryHeader[];
+export declare function formatMemoryManifest(memories: MemoryHeader[]): string;
+export declare function getMemoryManifest(worktree: string): {
+    headers: MemoryHeader[];
+    manifest: string;
+};