actoviq-agent-sdk 0.4.11 → 0.4.13

package/dist/src/memory/hadamardMemory.js

@@ -1,59 +1,13 @@
 import { createHash } from 'node:crypto';
 import path from 'node:path';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import { getDefaultHadamardSettingsPath, persistHadamardSettingsStore, resolveHadamardSettingsStore, } from '../config/hadamardSettingsStore.js';
 import { resolveHadamardHome } from '../config/hadamardHome.js';
 import { assertSafeStorageSegment, joinUnderStorageRoot, safeStorageFileName, } from '../storage/pathSafety.js';
 import { formatMemoryManifest, memoryAge, memoryAgeDays, memoryFreshnessNote, memoryFreshnessText, memoryHeader, readMemoriesForSurfacing, scanMemoryFiles, selectRelevantMemories, } from './hadamardRelevantMemories.js';
-const DEFAULT_SESSION_MEMORY_TEMPLATE = `
-# Session Title
-_A short and distinctive 5-10 word descriptive title for the session. Super info dense, no filler_
-
-# Current State
-_What is actively being worked on right now? Pending tasks not yet completed. Immediate next steps._
-
-# Task specification
-_What did the user ask to build? Any design decisions or other explanatory context_
-
-# Files and Functions
-_What are the important files? In short, what do they contain and why are they relevant?_
-
-# Workflow
-_What bash commands are usually run and in what order? How to interpret their output if not obvious?_
-
-# Errors & Corrections
-_Errors encountered and how they were fixed. What did the user correct? What approaches failed and should not be tried again?_
-
-# Codebase and System Documentation
-_What are the important system components? How do they work/fit together?_
-
-# Learnings
-_What has worked well? What has not? What to avoid? Do not duplicate items from other sections_
-
-# Key results
-_If the user asked a specific output such as an answer to a question, a table, or other document, repeat the exact result here_
-
-# Worklog
-_Step by step, what was attempted, done? Very terse summary for each step_
-`.trim();
-const MAX_SECTION_LENGTH = 2_000;
-const MAX_TOTAL_SESSION_MEMORY_TOKENS = 12_000;
 const ENTRYPOINT_NAME = 'MEMORY.md';
 const MAX_ENTRYPOINT_LINES = 200;
 const MAX_ENTRYPOINT_BYTES = 25_000;
-const DEFAULT_SESSION_MEMORY_CONFIG = {
-    minimumMessageTokensToInit: 10_000,
-    minimumTokensBetweenUpdate: 5_000,
-    toolCallsBetweenUpdates: 3,
-};
-const DEFAULT_SESSION_MEMORY_COMPACT_CONFIG = {
-    minTokens: 10_000,
-    minTextBlockMessages: 5,
-    maxTokens: 40_000,
-};
-function roughTokenCountEstimation(content) {
-    return Math.ceil(content.length / 4);
-}
 function sanitizeSegment(value) {
     return value.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
 }
@@ -136,52 +90,28 @@ function buildPaths(raw, configPath, homeDir, projectPath, sessionId) {
         teamMemoryDir: path.join(autoMemoryDir, 'team'),
         teamMemoryEntrypoint: path.join(autoMemoryDir, 'team', ENTRYPOINT_NAME),
         sessionId: safeSessionId,
-        sessionMemoryDir: safeSessionId
-            ? joinUnderStorageRoot(projectStateDir, safeSessionId, 'session-memory')
-            : undefined,
-        sessionMemoryPath: safeSessionId
-            ? joinUnderStorageRoot(projectStateDir, safeSessionId, 'session-memory', 'summary.md')
-            : undefined,
     };
 }
 function buildCombinedMemoryPrompt(paths, extraGuidelines, skipIndex = false) {
-    const howToSave = skipIndex
-        ? [
-            '## How to save memories',
-            '',
-            'Write each memory to its own file in the chosen directory using the frontmatter format described below.',
-            '',
-            '- Keep the name, description, and type fields in memory files up-to-date with the content',
-            '- Organize memory semantically by topic, not chronologically',
-            '- Update or remove memories that turn out to be wrong or outdated',
-            '- Do not write duplicate memories. Update an existing memory before creating a new one when possible.',
-        ]
-        : [
-            '## How to save memories',
-            '',
-            'Saving a memory is a two-step process:',
-            '',
-            `1. Write the memory to its own file in either \`${paths.autoMemoryDir}\` or \`${paths.teamMemoryDir}\`.`,
-            `2. Add a pointer to that file in the directory entrypoint \`${ENTRYPOINT_NAME}\`. Each entry should be one short line: \`- [Title](file.md) — one-line hook\`. Never write the memory body directly into \`${ENTRYPOINT_NAME}\`.`,
-            '',
-            `Both \`${ENTRYPOINT_NAME}\` indexes are loaded into future context, so keep them concise and actively maintained.`,
-            '- Keep the name, description, and type fields in memory files up-to-date with the content',
-            '- Organize memory semantically by topic, not chronologically',
-            '- Update or remove memories that turn out to be wrong or outdated',
-            '- Do not write duplicate memories. Update an existing memory before creating a new one when possible.',
-        ];
+    const howToSave = [
+        '## How memory is updated',
+        '',
+        '- Treat durable memory as read-only during the main chat.',
+        '- Never use ordinary Write or Edit calls to silently modify durable memory.',
+        '- To suggest a durable fact, use ProposeMemory. The runtime writes it only after the user applies the proposal.',
+        '- Automatic Dream consolidation rewrites MEMORY.md and memory_summary.md.',
+        ...(skipIndex ? [] : [
+            `- Detailed durable memory lives in \`${paths.autoMemoryEntrypoint}\`.`,
+            `- Only \`memory_summary.md\` is auto-injected into this prompt; Read MEMORY.md when you need detail.`,
+        ]),
+    ];
     return [
         '# Memory',
         '',
-        `You have a persistent, file-based memory system with two directories: a private directory at \`${paths.autoMemoryDir}\` and a shared team directory at \`${paths.teamMemoryDir}\`.`,
+        `You have a persistent file-based durable memory under \`${paths.autoMemoryDir}\`.`,
         '',
         'Use memory for information that will be useful in future conversations, not for transient task state that only matters within the current turn.',
         '',
-        '## Memory scope',
-        '',
-        `- private: memories that are private to the current user and stored under \`${paths.autoMemoryDir}\``,
-        `- team: memories that are shared with collaborators in the current project and stored under \`${paths.teamMemoryDir}\``,
-        '',
         '## What to save',
         '',
         '- collaboration preferences that remain useful over time',
@@ -201,6 +131,7 @@ function buildCombinedMemoryPrompt(paths, extraGuidelines, skipIndex = false) {
         '',
         '- when the user explicitly asks you to remember, recall, or check memory',
         '- when prior collaboration context seems directly relevant',
+        `- Read \`${paths.autoMemoryEntrypoint}\` for full detail; the summary below is only a map`,
         '- if the user asks you to ignore memory, behave as if MEMORY.md were empty',
         '',
         '## Memory and other forms of persistence',
@@ -248,82 +179,6 @@ function truncateEntrypointContent(raw) {
         wasByteTruncated,
     };
 }
-function substituteVariables(template, variables) {
-    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => Object.prototype.hasOwnProperty.call(variables, key) ? variables[key] : match);
-}
-function analyzeSectionSizes(content) {
-    const sections = {};
-    const lines = content.split('\n');
-    let currentSection = '';
-    let currentContent = [];
-    for (const line of lines) {
-        if (line.startsWith('# ')) {
-            if (currentSection && currentContent.length > 0) {
-                sections[currentSection] = roughTokenCountEstimation(currentContent.join('\n').trim());
-            }
-            currentSection = line;
-            currentContent = [];
-            continue;
-        }
-        currentContent.push(line);
-    }
-    if (currentSection && currentContent.length > 0) {
-        sections[currentSection] = roughTokenCountEstimation(currentContent.join('\n').trim());
-    }
-    return sections;
-}
-function generateSectionReminders(sectionSizes, totalTokens) {
-    const overBudget = totalTokens > MAX_TOTAL_SESSION_MEMORY_TOKENS;
-    const oversizedSections = Object.entries(sectionSizes)
-        .filter(([, tokens]) => tokens > MAX_SECTION_LENGTH)
-        .sort(([, left], [, right]) => right - left)
-        .map(([section, tokens]) => `- "${section}" is ~${tokens} tokens (limit: ${MAX_SECTION_LENGTH})`);
-    if (oversizedSections.length === 0 && !overBudget) {
-        return '';
-    }
-    const parts = [];
-    if (overBudget) {
-        parts.push(`\n\nCRITICAL: The session memory file is currently ~${totalTokens} tokens, which exceeds the maximum of ${MAX_TOTAL_SESSION_MEMORY_TOKENS} tokens. Condense the file while keeping Current State and Errors & Corrections accurate.`);
-    }
-    if (oversizedSections.length > 0) {
-        parts.push(`\n\nOversized sections to condense:\n${oversizedSections.join('\n')}`);
-    }
-    return parts.join('');
-}
-function buildCompactContinuationSummary(summary, transcriptPath, recentMessagesPreserved = true) {
-    let baseSummary = `This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.
-
-${summary}`;
-    if (transcriptPath) {
-        baseSummary += `\n\nIf you need specific details from before compaction, read the full transcript at: ${transcriptPath}`;
-    }
-    if (recentMessagesPreserved) {
-        baseSummary += '\n\nRecent messages are preserved verbatim.';
-    }
-    return `${baseSummary}
-
-Continue the conversation from where it left off without asking the user to repeat prior context. Resume directly and keep moving on the most recent task.`;
-}
-function flushSessionSection(sectionHeader, sectionLines, maxCharsPerSection) {
-    if (!sectionHeader) {
-        return { lines: sectionLines, wasTruncated: false };
-    }
-    const sectionContent = sectionLines.join('\n');
-    if (sectionContent.length <= maxCharsPerSection) {
-        return { lines: [sectionHeader, ...sectionLines], wasTruncated: false };
-    }
-    let charCount = 0;
-    const keptLines = [sectionHeader];
-    for (const line of sectionLines) {
-        if (charCount + line.length + 1 > maxCharsPerSection) {
-            break;
-        }
-        keptLines.push(line);
-        charCount += line.length + 1;
-    }
-    keptLines.push('\n[... section truncated for length ...]');
-    return { lines: keptLines, wasTruncated: true };
-}
 async function readTextIfExists(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -336,6 +191,35 @@ async function readTextIfExists(filePath) {
         throw error;
     }
 }
+async function listMarkdownFiles(root) {
+    const files = [];
+    const visit = async (directory) => {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const target = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'team')
+                    continue;
+                await visit(target);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push(target);
+            }
+        }
+    };
+    await visit(root);
+    return files;
+}
 export class HadamardMemoryApi {
     defaults;
     constructor(defaults = {}) {
@@ -385,24 +269,14 @@ export class HadamardMemoryApi {
         const lines = [
             buildCombinedMemoryPrompt(paths, options.extraGuidelines, options.skipIndex),
         ];
-        const entrypoints = [
-            {
-                title: paths.autoMemoryEntrypoint,
-                content: await readTextIfExists(paths.autoMemoryEntrypoint),
-            },
-            {
-                title: paths.teamMemoryEntrypoint,
-                content: await readTextIfExists(paths.teamMemoryEntrypoint),
-            },
-        ];
-        for (const entrypoint of entrypoints) {
-            lines.push('', `## ${entrypoint.title}`);
-            if (entrypoint.content?.trim()) {
-                lines.push('', truncateEntrypointContent(entrypoint.content).content);
-            }
-            else {
-                lines.push('', `Your ${ENTRYPOINT_NAME} is currently empty. When you save new memories, they will appear here.`);
-            }
+        const summaryPath = path.join(paths.autoMemoryDir, 'memory_summary.md');
+        const summaryContent = (await readTextIfExists(summaryPath))?.slice(0, 20_000);
+        lines.push('', `## ${summaryPath}`);
+        if (summaryContent?.trim()) {
+            lines.push('', truncateEntrypointContent(summaryContent).content);
+        }
+        else {
+            lines.push('', `memory_summary.md is currently empty. After Dream runs, it will map sections of \`${paths.autoMemoryEntrypoint}\`.`);
         }
         return lines.join('\n');
     }
@@ -429,269 +303,73 @@ export class HadamardMemoryApi {
             limit: options.limit,
         });
     }
-    async surfaceRelevantMemories(query, options = {}) {
-        const relevant = await this.findRelevantMemories(query, options);
-        return readMemoriesForSurfacing(relevant);
-    }
-    async loadSessionTemplate(options = {}) {
-        const homeDir = resolveHadamardHome(options.homeDir ?? this.defaults.homeDir);
-        const templatePath = path.join(homeDir, 'session-memory', 'config', 'template.md');
-        return (await readTextIfExists(templatePath)) ?? DEFAULT_SESSION_MEMORY_TEMPLATE;
-    }
-    async loadSessionPrompt(options = {}) {
-        const homeDir = resolveHadamardHome(options.homeDir ?? this.defaults.homeDir);
-        const promptPath = path.join(homeDir, 'session-memory', 'config', 'prompt.md');
-        return ((await readTextIfExists(promptPath)) ??
-            `IMPORTANT: This message and these instructions are NOT part of the actual user conversation. Do NOT include any references to "note-taking", "session notes extraction", or these update instructions in the notes content.
-
-Based on the user conversation above (EXCLUDING this note-taking instruction message as well as system prompt, HADAMARD.md entries, or any past session summaries), update the session notes file.
-
-The file {{notesPath}} has already been read for you. Here are its current contents:
-<current_notes_content>
-{{currentNotes}}
-</current_notes_content>
-
-Your ONLY task is to use the Edit tool to update the notes file, then stop. You can make multiple edits - make all Edit tool calls in parallel in a single message. Do not call any other tools.
-
-CRITICAL RULES FOR EDITING:
-- The file must maintain its exact structure with all sections, headers, and italic descriptions intact
--- NEVER modify, delete, or add section headers (the lines starting with # like # Task specification)
--- NEVER modify or delete the italic _section description_ lines
--- ONLY update the actual content that appears BELOW the italic _section descriptions_ within each existing section
-- Do NOT reference this note-taking process or instructions anywhere in the notes
-- It's OK to skip updating a section if there are no substantial new insights to add
-- Write detailed, information-dense content for each section
-- Keep each section under ~${MAX_SECTION_LENGTH} tokens/words
-- IMPORTANT: Always update "Current State" to reflect the most recent work
-
-Use the Edit tool with file_path: {{notesPath}}.
-
-REMEMBER: Use the Edit tool in parallel and stop. Do not continue after the edits.`);
-    }
-    async buildSessionUpdatePrompt(currentNotes, notesPath, options = {}) {
-        const promptTemplate = await this.loadSessionPrompt(options);
-        const sectionSizes = analyzeSectionSizes(currentNotes);
-        const totalTokens = roughTokenCountEstimation(currentNotes);
-        const reminders = generateSectionReminders(sectionSizes, totalTokens);
-        return (substituteVariables(promptTemplate, {
-            currentNotes,
-            notesPath,
-        }) + reminders);
+    async surfaceRelevantMemories(_query, _options = {}) {
+        // Topic/file auto-surfacing removed: only memory_summary.md is injected via
+        // the system prompt; agents Read MEMORY.md on demand.
+        return [];
     }
-    async buildSessionRewritePrompt(currentNotes, notesPath, options = {}) {
-        return `${await this.buildSessionUpdatePrompt(currentNotes, notesPath, options)}
-
-You are running in direct-output mode, not tool-edit mode.
-
-Return the FULL updated notes file as markdown only.
-- Do not wrap the response in code fences
-- Do not explain what you changed
-- Preserve every existing section header and italic guide line exactly
-- Only update the section bodies beneath those guides
-- If a section has no meaningful updates, keep its existing content unchanged`;
-    }
-    async ensureSessionMemory(options = {}) {
+    async listMemoryContent(options = {}) {
         const paths = await this.paths(options);
-        if (!paths.sessionMemoryPath || !paths.sessionMemoryDir) {
-            throw new Error('A sessionId is required to create or update session memory.');
-        }
-        await mkdir(paths.sessionMemoryDir, { recursive: true });
-        const existing = await readTextIfExists(paths.sessionMemoryPath);
-        if (existing != null) {
-            return {
-                path: paths.sessionMemoryPath,
-                content: existing,
-                created: false,
-            };
-        }
-        const template = await this.loadSessionTemplate(options);
-        await writeFile(paths.sessionMemoryPath, `${template.trim()}\n`, 'utf8');
-        return {
-            path: paths.sessionMemoryPath,
-            content: template,
-            created: true,
-        };
-    }
-    async writeSessionMemory(content, options = {}) {
-        const ensured = await this.ensureSessionMemory(options);
-        await writeFile(ensured.path, `${content.trim()}\n`, 'utf8');
-        return {
-            path: ensured.path,
-            content: content.trim(),
-        };
-    }
-    async isSessionMemoryEmpty(content, options = {}) {
-        const template = await this.loadSessionTemplate(options);
-        return content.trim() === template.trim();
-    }
-    truncateSessionMemoryForCompact(content) {
-        const lines = content.split('\n');
-        const maxCharsPerSection = MAX_SECTION_LENGTH * 4;
-        const outputLines = [];
-        let currentSectionHeader = '';
-        let currentSectionLines = [];
-        let wasTruncated = false;
-        for (const line of lines) {
-            if (line.startsWith('# ')) {
-                const result = flushSessionSection(currentSectionHeader, currentSectionLines, maxCharsPerSection);
-                outputLines.push(...result.lines);
-                wasTruncated = wasTruncated || result.wasTruncated;
-                currentSectionHeader = line;
-                currentSectionLines = [];
+        const entries = [];
+        const durableFiles = await listMarkdownFiles(paths.autoMemoryDir);
+        for (const filePath of durableFiles) {
+            const relative = path.relative(paths.autoMemoryDir, filePath).replaceAll(path.sep, '/');
+            if (relative === 'team' || relative.startsWith('team/'))
                 continue;
-            }
-            currentSectionLines.push(line);
+            const raw = relative === 'raw_memories.md' || relative.startsWith('rollout_summaries/');
+            const stats = await stat(filePath);
+            entries.push({
+                id: `${raw ? 'raw' : 'durable'}:${relative}`,
+                kind: raw ? 'raw' : 'durable',
+                path: filePath,
+                size: stats.size,
+                modifiedAt: stats.mtime.toISOString(),
+            });
         }
-        const result = flushSessionSection(currentSectionHeader, currentSectionLines, maxCharsPerSection);
-        outputLines.push(...result.lines);
-        wasTruncated = wasTruncated || result.wasTruncated;
-        return {
-            truncatedContent: outputLines.join('\n'),
-            wasTruncated,
-        };
-    }
-    async readSessionMemory(options = {}) {
-        const paths = await this.paths(options);
-        const summaryPath = paths.sessionMemoryPath;
-        if (!summaryPath) {
-            return { exists: false };
-        }
-        const content = await readTextIfExists(summaryPath);
-        if (content == null) {
-            return {
-                exists: false,
-                path: summaryPath,
-            };
+        return entries
+            .filter(entry => options.kind == null || entry.kind === options.kind)
+            .sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt));
+    }
+    async readMemoryContent(idOrPath, options = {}) {
+        const entries = await this.listMemoryContent(options);
+        const resolved = path.resolve(idOrPath);
+        const entry = entries.find(candidate => candidate.id === idOrPath || path.resolve(candidate.path) === resolved);
+        if (!entry)
+            throw new Error(`Memory content not found in the current project: ${idOrPath}`);
+        return { entry, content: await readFile(entry.path, 'utf8') };
+    }
+    async searchMemoryContent(query, options = {}) {
+        const normalized = query.trim().toLowerCase();
+        if (!normalized)
+            return [];
+        const results = [];
+        for (const entry of await this.listMemoryContent(options)) {
+            const lines = (await readFile(entry.path, 'utf8')).split(/\r?\n/u);
+            const matches = lines.filter(line => line.toLowerCase().includes(normalized)).slice(0, 20);
+            if (matches.length > 0)
+                results.push({ entry, matches });
         }
-        const truncated = this.truncateSessionMemoryForCompact(content);
-        return {
-            exists: true,
-            path: summaryPath,
-            content,
-            isEmpty: await this.isSessionMemoryEmpty(content, options),
-            tokenEstimate: roughTokenCountEstimation(content),
-            truncatedContent: truncated.truncatedContent,
-            wasTruncated: truncated.wasTruncated,
-        };
-    }
-    getSessionMemoryConfig() {
-        return {
-            ...DEFAULT_SESSION_MEMORY_CONFIG,
-        };
-    }
-    getSessionMemoryCompactConfig() {
-        return {
-            ...DEFAULT_SESSION_MEMORY_COMPACT_CONFIG,
-        };
-    }
-    evaluateSessionMemoryProgress(options) {
-        const config = this.getSessionMemoryConfig();
-        const currentTokenCount = options.currentTokenCount;
-        const tokensAtLastExtraction = options.tokensAtLastExtraction ?? 0;
-        const tokensSinceLastExtraction = typeof currentTokenCount === 'number'
-            ? Math.max(currentTokenCount - tokensAtLastExtraction, 0)
-            : undefined;
-        const meetsInitializationThreshold = typeof currentTokenCount === 'number'
-            ? currentTokenCount >= config.minimumMessageTokensToInit
-            : undefined;
-        const meetsUpdateThreshold = typeof tokensSinceLastExtraction === 'number'
-            ? tokensSinceLastExtraction >= config.minimumTokensBetweenUpdate
-            : undefined;
-        const meetsToolCallThreshold = typeof options.toolCallsSinceLastUpdate === 'number'
-            ? options.toolCallsSinceLastUpdate >= config.toolCallsBetweenUpdates
-            : undefined;
-        const hasToolCallsInLastTurn = options.hasToolCallsInLastTurn;
-        const initialized = options.initialized === true || meetsInitializationThreshold === true;
-        const shouldExtract = initialized &&
-            meetsUpdateThreshold === true &&
-            (meetsToolCallThreshold === true || hasToolCallsInLastTurn === false);
-        return {
-            currentTokenCount,
-            tokensAtLastExtraction,
-            tokensSinceLastExtraction,
-            messageCountSinceLastExtraction: options.messageCountSinceLastExtraction,
-            toolCallsSinceLastUpdate: options.toolCallsSinceLastUpdate,
-            initialized,
-            meetsInitializationThreshold,
-            meetsUpdateThreshold,
-            meetsToolCallThreshold,
-            hasToolCallsInLastTurn,
-            shouldExtract,
-        };
-    }
-    async buildSessionMemoryCompactSummary(options = {}) {
-        const state = await this.readSessionMemory({
-            sessionId: options.sessionId ?? this.defaults.sessionId,
-            projectPath: options.projectPath ?? this.defaults.projectPath,
-        });
-        if (!state.exists || !state.content || state.isEmpty) {
-            return undefined;
-        }
-        const paths = await this.paths({
-            sessionId: options.sessionId ?? this.defaults.sessionId,
-            projectPath: options.projectPath ?? this.defaults.projectPath,
-        });
-        let summaryContent = state.truncatedContent ?? state.content;
-        if (state.wasTruncated && options.includeFullMemoryPathHint !== false && paths.sessionMemoryPath) {
-            summaryContent += `\n\nSome session memory sections were truncated for length. The full session memory can be viewed at: ${paths.sessionMemoryPath}`;
-        }
-        return buildCompactContinuationSummary(summaryContent, options.transcriptPath, options.recentMessagesPreserved ?? true);
+        return results;
     }
     async compactState(options = {}) {
-        const baseState = await this.state({
-            ...options,
-            includeSessionMemory: options.includeSessionMemory ?? true,
-        });
-        const sessionMemoryConfig = this.getSessionMemoryConfig();
-        const sessionMemoryCompactConfig = this.getSessionMemoryCompactConfig();
+        const baseState = await this.state(options);
         const sessionId = options.sessionId ?? this.defaults.sessionId;
         const transcriptPath = sessionId != null
             ? joinUnderStorageRoot(baseState.paths.projectStateDir, safeStorageFileName('sessionId', sessionId, 'jsonl'))
             : undefined;
-        const progress = options.currentTokenCount != null ||
-            options.tokensAtLastExtraction != null ||
-            options.initialized != null ||
-            options.toolCallsSinceLastUpdate != null
-            ? this.evaluateSessionMemoryProgress({
-                currentTokenCount: options.currentTokenCount,
-                tokensAtLastExtraction: options.tokensAtLastExtraction,
-                initialized: options.initialized,
-                toolCallsSinceLastUpdate: options.toolCallsSinceLastUpdate,
-            })
-            : undefined;
-        const boundaries = undefined;
-        const latestBoundary = undefined;
-        const compactCount = 0;
-        const microcompactCount = 0;
-        const lastSummarizedMessageUuid = undefined;
-        const latestPreservedSegment = undefined;
-        const latestBoundarySummary = undefined;
         return {
             ...baseState,
-            sessionMemoryConfig,
-            sessionMemoryCompactConfig,
-            progress,
             runtimeState: options.runtimeState,
             transcriptPath,
-            boundaries,
-            latestBoundary,
-            compactCount,
-            microcompactCount,
-            hasCompacted: compactCount + microcompactCount > 0,
+            boundaries: undefined,
+            latestBoundary: undefined,
+            compactCount: 0,
+            microcompactCount: 0,
+            hasCompacted: false,
             pendingPostCompaction: options.runtimeState?.pendingPostCompaction,
-            lastSummarizedMessageUuid,
-            latestPreservedSegment,
-            latestBoundarySummary,
-            canUseSessionMemoryCompaction: baseState.enabled.autoCompact &&
-                baseState.sessionMemory?.exists === true &&
-                baseState.sessionMemory?.isEmpty === false,
-            summaryMessage: options.includeSummaryMessage
-                ? await this.buildSessionMemoryCompactSummary({
-                    sessionId,
-                    projectPath: baseState.paths.projectPath,
-                    transcriptPath,
-                })
-                : undefined,
+            lastSummarizedMessageUuid: undefined,
+            latestPreservedSegment: undefined,
+            latestBoundarySummary: undefined,
         };
     }
     async state(options = {}) {
@@ -702,9 +380,15 @@ Return the FULL updated notes file as markdown only.
         const settings = parseSettings(store.raw);
         const paths = buildPaths(store.raw, store.configPath, store.homeDir, options.projectPath ?? this.defaults.projectPath ?? process.cwd(), options.sessionId ?? this.defaults.sessionId);
         const enabled = {
-            autoCompact: settings.autoCompactEnabled !== false,
-            autoMemory: settings.autoMemoryEnabled !== false,
-            autoDream: settings.autoDreamEnabled === true,
+            autoCompact: options.enabledOverrides?.autoCompact
+                ?? this.defaults.enabledOverrides?.autoCompact
+                ?? settings.autoCompactEnabled !== false,
+            autoMemory: options.enabledOverrides?.autoMemory
+                ?? this.defaults.enabledOverrides?.autoMemory
+                ?? settings.autoMemoryEnabled !== false,
+            autoDream: options.enabledOverrides?.autoDream
+                ?? this.defaults.enabledOverrides?.autoDream
+                ?? settings.autoDreamEnabled === true,
         };
         return {
             settings,
@@ -713,24 +397,12 @@ Return the FULL updated notes file as markdown only.
             combinedPrompt: options.includeCombinedPrompt
                 ? buildCombinedMemoryPrompt(paths, options.extraGuidelines, options.skipIndex)
                 : undefined,
-            sessionMemory: options.includeSessionMemory
-                ? await this.readSessionMemory(options)
-                : undefined,
-            sessionTemplate: options.includeSessionTemplate
-                ? await this.loadSessionTemplate(options)
-                : undefined,
-            sessionPrompt: options.includeSessionPrompt
-                ? await this.loadSessionPrompt(options)
-                : undefined,
         };
     }
 }
 export function createHadamardMemoryApi(options = {}) {
     return new HadamardMemoryApi(options);
 }
-export function getHadamardDefaultSessionMemoryTemplate() {
-    return DEFAULT_SESSION_MEMORY_TEMPLATE;
-}
 export function getHadamardCompactBoundarySummary(metadata) {
     if (!metadata) {
         return undefined;
@@ -760,16 +432,6 @@ export function getHadamardCompactBoundarySummary(metadata) {
     ].filter(Boolean);
     return parts.length > 0 ? parts.join(', ') : undefined;
 }
-export function getHadamardDefaultSessionMemoryConfig() {
-    return {
-        ...DEFAULT_SESSION_MEMORY_CONFIG,
-    };
-}
-export function getHadamardDefaultSessionMemoryCompactConfig() {
-    return {
-        ...DEFAULT_SESSION_MEMORY_COMPACT_CONFIG,
-    };
-}
 export { formatMemoryManifest as formatHadamardMemoryManifest, memoryAge as getHadamardMemoryAge, memoryAgeDays as getHadamardMemoryAgeDays, memoryFreshnessNote as getHadamardMemoryFreshnessNote, memoryFreshnessText as getHadamardMemoryFreshnessText, memoryHeader as getHadamardMemoryHeader, readMemoriesForSurfacing as readHadamardMemoriesForSurfacing, scanMemoryFiles as scanHadamardMemoryFiles, selectRelevantMemories as selectHadamardRelevantMemories, };
 export function getHadamardDefaultSettingsPath(options = {}) {
     return getDefaultHadamardSettingsPath(options.homeDir);