audrey 1.0.1 → 1.0.3

package/dist/mcp-server/index.js

@@ -2,150 +2,24 @@
 import { z } from 'zod';
 import { homedir, platform, tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { Audrey, MemoryController } from '../src/index.js';
 import { readStoredDimensions } from '../src/db.js';
-import { importSnapshotSchema } from '../src/import.js';
 import { isAudreyProfileEnabled } from '../src/profile.js';
 import { VERSION, SERVER_NAME, MCP_ENTRYPOINT, buildAudreyConfig, buildInstallArgs, formatMcpHostConfig, resolveDataDir, resolveEmbeddingProvider, resolveLLMProvider, } from './config.js';
-const VALID_SOURCES = [
-    'direct-observation',
-    'told-by-user',
-    'tool-result',
-    'inference',
-    'model-generated',
-];
-const VALID_TYPES = ['episodic', 'semantic', 'procedural'];
-export const MAX_MEMORY_CONTENT_LENGTH = 50_000;
-export const ADMIN_TOOLS_ENV = 'AUDREY_ENABLE_ADMIN_TOOLS';
+import { initializeEmbeddingProvider, requireAdminTools, validateForgetSelection, validateMemoryContent, } from './tool-validation.js';
+import { memoryEncodeToolSchema, memoryForgetToolSchema, memoryGuardAfterToolSchema, memoryGuardBeforeToolSchema, memoryImportToolSchema, memoryPreflightToolSchema, memoryRecallToolSchema, memoryReflexesToolSchema, memoryValidateToolSchema, } from './tool-schemas.js';
+// Re-export the tool-validation and tool-schema public surface so existing
+// importers of `mcp-server/index.js` (tests, embedders) keep resolving.
+export { ADMIN_TOOLS_ENV, MAX_MEMORY_CONTENT_LENGTH, initializeEmbeddingProvider, isAdminToolsEnabled, requireAdminTools, validateForgetSelection, validateMemoryContent, } from './tool-validation.js';
+export * from './tool-schemas.js';
 const subcommand = (process.argv[2] || '').trim() || undefined;
-function isNonEmptyText(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
-export function validateMemoryContent(content) {
-    if (!isNonEmptyText(content)) {
-        throw new Error('content must be a non-empty string');
-    }
-    if (content.length > MAX_MEMORY_CONTENT_LENGTH) {
-        throw new Error(`content exceeds maximum length of ${MAX_MEMORY_CONTENT_LENGTH} characters`);
-    }
-}
-export function validateForgetSelection(id, query) {
-    if ((id && query) || (!id && !query)) {
-        throw new Error('Provide exactly one of id or query');
-    }
-}
-export function isAdminToolsEnabled(env = process.env) {
-    const value = env[ADMIN_TOOLS_ENV]?.toLowerCase();
-    return value === '1' || value === 'true' || value === 'yes';
-}
-export function requireAdminTools(env = process.env) {
-    if (!isAdminToolsEnabled(env)) {
-        throw new Error(`Admin memory tools are disabled. Set ${ADMIN_TOOLS_ENV}=1 to enable export, import, and forget operations.`);
-    }
-}
-export async function initializeEmbeddingProvider(provider) {
-    if (provider && typeof provider.ready === 'function') {
-        await provider.ready();
-    }
-}
 function isEmbeddingWarmupDisabled(env = process.env) {
     const value = env['AUDREY_DISABLE_WARMUP'];
     return value === '1' || value?.toLowerCase() === 'true' || value?.toLowerCase() === 'yes';
 }
-export const memoryEncodeToolSchema = {
-    content: z.string()
-        .max(MAX_MEMORY_CONTENT_LENGTH)
-        .refine(isNonEmptyText, 'Content must not be empty')
-        .describe('The memory content to encode'),
-    source: z.enum(VALID_SOURCES).describe('Source type of the memory'),
-    tags: z.array(z.string()).optional().describe('Optional tags for categorization'),
-    salience: z.number().min(0).max(1).optional().describe('Importance weight 0-1'),
-    context: z.record(z.string(), z.string()).optional().describe('Situational context as key-value pairs (e.g., {task: "debugging", domain: "payments"})'),
-    affect: z.object({
-        valence: z.number().min(-1).max(1).describe('Emotional valence: -1 (very negative) to 1 (very positive)'),
-        arousal: z.number().min(0).max(1).optional().describe('Emotional arousal: 0 (calm) to 1 (highly activated)'),
-        label: z.string().optional().describe('Human-readable emotion label (e.g., "curiosity", "frustration", "relief")'),
-    }).optional().describe('Emotional affect - how this memory feels'),
-    private: z.boolean().optional().describe('If true, memory is only visible to the AI and excluded from public recall results'),
-    wait_for_consolidation: z.boolean().optional().describe('If true, wait for post-encode validation/interference/resonance work before returning. Defaults to false.'),
-};
-export const memoryRecallToolSchema = {
-    query: z.string().describe('Search query to match against memories'),
-    limit: z.number().min(1).max(50).optional().describe('Max results (default 10)'),
-    types: z.array(z.enum(VALID_TYPES)).optional().describe('Memory types to search'),
-    min_confidence: z.number().min(0).max(1).optional().describe('Minimum confidence threshold'),
-    tags: z.array(z.string()).optional().describe('Only return episodic memories with these tags'),
-    sources: z.array(z.enum(VALID_SOURCES)).optional().describe('Only return episodic memories from these sources'),
-    after: z.string().optional().describe('Only return memories created after this ISO date'),
-    before: z.string().optional().describe('Only return memories created before this ISO date'),
-    context: z.record(z.string(), z.string()).optional().describe('Retrieval context - memories encoded in matching context get boosted'),
-    mood: z.object({
-        valence: z.number().min(-1).max(1).describe('Current emotional valence: -1 (negative) to 1 (positive)'),
-        arousal: z.number().min(0).max(1).optional().describe('Current arousal: 0 (calm) to 1 (activated)'),
-    }).optional().describe('Current mood - boosts recall of memories encoded in similar emotional state'),
-    retrieval: z.enum(['hybrid', 'vector']).optional().describe('Retrieval strategy. hybrid is the default (vector + FTS/BM25 fusion); vector bypasses FTS for lower latency but loses lexical exact-match signal.'),
-    scope: z.enum(['agent', 'shared']).optional().describe('agent restricts recall to this MCP server agent identity. shared searches the whole store. Defaults to shared for backward compatibility.'),
-};
-export const memoryImportToolSchema = {
-    snapshot: importSnapshotSchema.describe('A validated snapshot from memory_export'),
-};
-export const memoryForgetToolSchema = {
-    id: z.string().optional().describe('ID of the memory to forget'),
-    query: z.string().optional().describe('Semantic query to find and forget the closest matching memory'),
-    min_similarity: z.number().min(0).max(1).optional().describe('Minimum similarity for query-based forget (default 0.9)'),
-    purge: z.boolean().optional().describe('Hard-delete the memory permanently (default false, soft-delete)'),
-};
-export const memoryValidateToolSchema = {
-    id: z.string().describe('ID of the memory to validate'),
-    outcome: z.enum(['used', 'helpful', 'wrong']).describe('How the memory played out: "used" (referenced without obvious value), "helpful" (drove a correct action — reinforces salience and retrieval), "wrong" (memory was misleading — bumps challenge_count and decreases salience).'),
-};
-export const memoryPreflightToolSchema = {
-    action: z.string()
-        .refine(isNonEmptyText, 'Action must not be empty')
-        .describe('Natural-language description of the action the agent is about to take.'),
-    tool: z.string().optional().describe('Tool or command family about to be used, e.g. Bash, npm test, Edit, deploy.'),
-    session_id: z.string().optional().describe('Session identifier for grouping the optional preflight event.'),
-    cwd: z.string().optional().describe('Working directory for the action.'),
-    files: z.array(z.string()).optional().describe('File paths to fingerprint if record_event is true.'),
-    strict: z.boolean().optional().describe('If true, high-severity memory warnings produce decision=block instead of caution.'),
-    limit: z.number().int().min(1).max(50).optional().describe('Max recall results to consider before preflight categorization.'),
-    budget_chars: z.number().int().min(200).max(32000).optional().describe('Capsule budget in characters.'),
-    mode: z.enum(['balanced', 'conservative', 'aggressive']).optional().describe('Underlying capsule mode. Defaults to conservative.'),
-    failure_window_hours: z.number().int().min(1).max(8760).optional().describe('How far back to check failed tool events. Defaults to 168 hours.'),
-    include_status: z.boolean().optional().describe('Include memory health in the response and warning calculation. Defaults to true.'),
-    record_event: z.boolean().optional().describe('Record a redacted PreToolUse event for this preflight. Defaults to false.'),
-    include_capsule: z.boolean().optional().describe('If false, omit the embedded Memory Capsule from the response.'),
-    scope: z.enum(['agent', 'shared']).optional().describe('agent restricts memory recall to this server agent identity. shared searches the whole store. Defaults to agent.'),
-};
-const { record_event: _preflightRecordEvent, ...memoryGuardBeforeFields } = memoryPreflightToolSchema;
-export const memoryGuardBeforeToolSchema = {
-    ...memoryGuardBeforeFields,
-    session_id: z.string().optional().describe('Session identifier for grouping the required guard receipt event.'),
-    files: z.array(z.string()).optional().describe('File paths to fingerprint in the required guard receipt.'),
-};
-export const memoryGuardAfterToolSchema = {
-    receipt_id: z.string()
-        .refine(isNonEmptyText, 'Receipt id must not be empty')
-        .describe('Receipt id returned by memory_guard_before.'),
-    tool: z.string().optional().describe('Tool or command family that completed, e.g. Bash, npm test, Edit, deploy.'),
-    session_id: z.string().optional().describe('Session identifier for grouping related guard events.'),
-    input: z.unknown().optional().describe('Tool input. Hashed and never stored raw; redacted metadata is only stored when retain_details is true.'),
-    output: z.unknown().optional().describe('Tool output. Same redaction and storage policy as input.'),
-    outcome: z.enum(['succeeded', 'failed', 'blocked', 'skipped', 'unknown']).optional().describe('Outcome classification'),
-    error_summary: z.string().optional().describe('Short error description if the action failed. Redacted and truncated to 2 KB.'),
-    cwd: z.string().optional().describe('Working directory at the time of the action.'),
-    files: z.array(z.string()).optional().describe('File paths to fingerprint (size + mtime + content hash).'),
-    metadata: z.record(z.string(), z.unknown()).optional().describe('Arbitrary structured metadata (redacted before storage).'),
-    retain_details: z.boolean().optional().describe('If true, redacted input and output payloads are stored alongside hashes. Defaults to false.'),
-    evidence_feedback: z.record(z.string(), z.enum(['used', 'helpful', 'wrong'])).optional().describe('Map of evidence ids from the guard receipt to memory validation outcomes.'),
-};
-export const memoryReflexesToolSchema = {
-    ...memoryPreflightToolSchema,
-    include_preflight: z.boolean().optional().describe('If true, include the full underlying preflight report.'),
-};
 // ---------------------------------------------------------------------------
 // CLI subcommands
 // ---------------------------------------------------------------------------
@@ -160,7 +34,9 @@ async function serveHttp() {
     if (apiKey) {
         console.error('[audrey-http] API key authentication enabled');
     }
-    else if (server.hostname === '127.0.0.1' || server.hostname === '::1' || server.hostname === 'localhost') {
+    else if (server.hostname === '127.0.0.1' ||
+        server.hostname === '::1' ||
+        server.hostname === 'localhost') {
         console.error('[audrey-http] no API key set (loopback only — set AUDREY_API_KEY to enable network access)');
     }
 }
@@ -178,7 +54,9 @@ async function reembed() {
     try {
         await initializeEmbeddingProvider(audrey.embeddingProvider);
         const { reembedAll } = await import('../src/migrate.js');
-        const counts = await reembedAll(audrey.db, audrey.embeddingProvider, { dropAndRecreate: dimensionsChanged });
+        const counts = await reembedAll(audrey.db, audrey.embeddingProvider, {
+            dropAndRecreate: dimensionsChanged,
+        });
         console.log(`Done. Re-embedded: ${counts.episodes} episodes, ${counts.semantics} semantics, ${counts.procedures} procedures`);
     }
     finally {
@@ -208,13 +86,13 @@ async function dream() {
         console.log(`[audrey] Embedding: ${embeddingLabel}`);
         const result = await audrey.dream();
         const health = audrey.memoryStatus();
-        console.log(`[audrey] Consolidation: evaluated ${result.consolidation.episodesEvaluated} episodes, `
-            + `found ${result.consolidation.clustersFound} clusters, extracted ${result.consolidation.principlesExtracted} principles `
-            + `(${result.consolidation.semanticsCreated ?? 0} semantic, ${result.consolidation.proceduresCreated ?? 0} procedural)`);
-        console.log(`[audrey] Decay: evaluated ${result.decay.totalEvaluated} memories, `
-            + `${result.decay.transitionedToDormant} transitioned to dormant`);
-        console.log(`[audrey] Final: ${result.stats.episodic} episodic, ${result.stats.semantic} semantic, ${result.stats.procedural} procedural `
-            + `| ${health.healthy ? 'healthy' : 'unhealthy'}`);
+        console.log(`[audrey] Consolidation: evaluated ${result.consolidation.episodesEvaluated} episodes, ` +
+            `found ${result.consolidation.clustersFound} clusters, extracted ${result.consolidation.principlesExtracted} principles ` +
+            `(${result.consolidation.semanticsCreated ?? 0} semantic, ${result.consolidation.proceduresCreated ?? 0} procedural)`);
+        console.log(`[audrey] Decay: evaluated ${result.decay.totalEvaluated} memories, ` +
+            `${result.decay.transitionedToDormant} transitioned to dormant`);
+        console.log(`[audrey] Final: ${result.stats.episodic} episodic, ${result.stats.semantic} semantic, ${result.stats.procedural} procedural ` +
+            `| ${health.healthy ? 'healthy' : 'unhealthy'}`);
         console.log('[audrey] Dream complete.');
     }
     finally {
@@ -257,9 +135,9 @@ async function greeting() {
     }
     const storedDimensions = readStoredDimensions(dataDir);
     const resolvedEmbedding = resolveEmbeddingProvider(process.env, process.env['AUDREY_EMBEDDING_PROVIDER']);
-    const canUseResolvedEmbedding = Boolean(contextArg)
-        && storedDimensions !== null
-        && storedDimensions === resolvedEmbedding.dimensions;
+    const canUseResolvedEmbedding = Boolean(contextArg) &&
+        storedDimensions !== null &&
+        storedDimensions === resolvedEmbedding.dimensions;
     const dimensions = storedDimensions || resolvedEmbedding.dimensions || 8;
     const audrey = new Audrey({
         dataDir,
@@ -272,28 +150,30 @@ async function greeting() {
         if (canUseResolvedEmbedding) {
             await initializeEmbeddingProvider(audrey.embeddingProvider);
         }
-        const result = await audrey.greeting({ context: canUseResolvedEmbedding ? contextArg : undefined });
+        const result = await audrey.greeting({
+            context: canUseResolvedEmbedding ? contextArg : undefined,
+        });
         const health = audrey.memoryStatus();
         const lines = [];
         lines.push(`[Audrey v${VERSION}] Memory briefing`);
         lines.push('');
         if (contextArg && !canUseResolvedEmbedding) {
-            lines.push(`Context recall skipped: stored index is ${storedDimensions ?? 'unknown'}d `
-                + `but current embedding config resolves to ${resolvedEmbedding.dimensions}d.`);
+            lines.push(`Context recall skipped: stored index is ${storedDimensions ?? 'unknown'}d ` +
+                `but current embedding config resolves to ${resolvedEmbedding.dimensions}d.`);
             lines.push('');
         }
         // Mood
         if (result.mood && result.mood.samples > 0) {
             const v = result.mood.valence;
             const moodWord = v > 0.3 ? 'positive' : v < -0.3 ? 'negative' : 'neutral';
-            lines.push(`Mood: ${moodWord} (valence=${v.toFixed(2)}, `
-                + `arousal=${result.mood.arousal.toFixed(2)}, `
-                + `from ${result.mood.samples} recent memories)`);
+            lines.push(`Mood: ${moodWord} (valence=${v.toFixed(2)}, ` +
+                `arousal=${result.mood.arousal.toFixed(2)}, ` +
+                `from ${result.mood.samples} recent memories)`);
         }
         // Health
         const stats = audrey.introspect();
-        lines.push(`Memory: ${stats.episodic} episodic, ${stats.semantic} semantic, `
-            + `${stats.procedural} procedural | ${health.healthy ? 'healthy' : 'needs attention'}`);
+        lines.push(`Memory: ${stats.episodic} episodic, ${stats.semantic} semantic, ` +
+            `${stats.procedural} procedural | ${health.healthy ? 'healthy' : 'needs attention'}`);
         lines.push('');
         // Principles (semantic memories)
         if (result.principles?.length > 0) {
@@ -398,12 +278,12 @@ async function reflect() {
         // Always run dream cycle after reflect
         console.log('[audrey] Starting dream cycle...');
         const result = await audrey.dream();
-        console.log(`[audrey] Consolidation: ${result.consolidation.episodesEvaluated} episodes evaluated, `
-            + `${result.consolidation.clustersFound} clusters, ${result.consolidation.principlesExtracted} principles`);
-        console.log(`[audrey] Decay: ${result.decay.totalEvaluated} evaluated, `
-            + `${result.decay.transitionedToDormant} dormant`);
-        console.log(`[audrey] Status: ${result.stats.episodic} episodic, ${result.stats.semantic} semantic, `
-            + `${result.stats.procedural} procedural`);
+        console.log(`[audrey] Consolidation: ${result.consolidation.episodesEvaluated} episodes evaluated, ` +
+            `${result.consolidation.clustersFound} clusters, ${result.consolidation.principlesExtracted} principles`);
+        console.log(`[audrey] Decay: ${result.decay.totalEvaluated} evaluated, ` +
+            `${result.decay.transitionedToDormant} dormant`);
+        console.log(`[audrey] Status: ${result.stats.episodic} episodic, ${result.stats.semantic} semantic, ` +
+            `${result.stats.procedural} procedural`);
         console.log('[audrey] Dream complete.');
     }
     finally {
@@ -449,11 +329,7 @@ export function formatInstallGuide(host, env = process.env, dryRun = false) {
         formatMcpHostConfig(normalizedHost, env),
         '',
         ...(normalizedHost === 'claude-code'
-            ? [
-                'Generated Claude Code hook config:',
-                formatClaudeCodeHookConfig(),
-                '',
-            ]
+            ? ['Generated Claude Code hook config:', formatClaudeCodeHookConfig(), '']
             : []),
         'Next steps:',
     ];
@@ -643,8 +519,12 @@ function printHookConfig() {
             dryRun: options.dryRun,
         });
         const action = result.dryRun
-            ? result.changed ? 'would update' : 'would leave unchanged'
-            : result.changed ? 'updated' : 'already up to date';
+            ? result.changed
+                ? 'would update'
+                : 'would leave unchanged'
+            : result.changed
+                ? 'updated'
+                : 'already up to date';
         console.log(`[audrey] Claude Code hook settings ${action}: ${result.settingsPath}`);
         if (result.backupPath)
             console.log(`[audrey] backup written: ${result.backupPath}`);
@@ -826,7 +706,9 @@ export function applyClaudeCodeHookConfig(options) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(`Cannot merge Audrey hooks into invalid JSON at ${settingsPath}: ${message}`);
+            throw new Error(`Cannot merge Audrey hooks into invalid JSON at ${settingsPath}: ${message}`, {
+                cause: err,
+            });
         }
     }
     const settings = mergeClaudeCodeHookSettings(existing);
@@ -875,11 +757,7 @@ function demoScenario(argv = process.argv) {
     return cliValue('--scenario', argv);
 }
 function formatControllerGuardResult(result) {
-    const label = result.decision === 'block'
-        ? 'BLOCKED'
-        : result.decision === 'warn'
-            ? 'WARN'
-            : 'ALLOW';
+    const label = result.decision === 'block' ? 'BLOCKED' : result.decision === 'warn' ? 'WARN' : 'ALLOW';
     const lines = [];
     lines.push(`Audrey Guard: ${label}`);
     lines.push('');
@@ -992,8 +870,8 @@ export async function runDemoCommand({ out = console.log, keep = process.argv.in
             tags: ['procedure', 'memory-capsule', 'agent-loop'],
         }));
         ids.push(await audrey.encode({
-            content: 'If a host cannot auto-install Audrey, run npx audrey mcp-config codex '
-                + 'or npx audrey mcp-config generic and paste the generated config.',
+            content: 'If a host cannot auto-install Audrey, run npx audrey mcp-config codex ' +
+                'or npx audrey mcp-config generic and paste the generated config.',
             source: 'direct-observation',
             tags: ['procedure', 'mcp', 'first-contact'],
         }));
@@ -1011,8 +889,8 @@ export async function runDemoCommand({ out = console.log, keep = process.argv.in
             event: 'PostToolUse',
             tool: 'npm test',
             outcome: 'failed',
-            errorSummary: 'Vitest can fail with spawn EPERM on locked-down Windows hosts; '
-                + 'use build, typecheck, benchmarks, and direct dist smokes as the fallback evidence path.',
+            errorSummary: 'Vitest can fail with spawn EPERM on locked-down Windows hosts; ' +
+                'use build, typecheck, benchmarks, and direct dist smokes as the fallback evidence path.',
             cwd: process.cwd(),
             metadata: { demo: true, source: 'audrey demo' },
         });
@@ -1118,12 +996,15 @@ export function buildStatusReport({ dataDir = resolveDataDir(process.env), claud
         });
         report.stats = audrey.introspect();
         report.health = audrey.memoryStatus();
-        report.lastConsolidation = audrey.db.prepare(`
+        report.lastConsolidation =
+            audrey.db
+                .prepare(`
       SELECT completed_at FROM consolidation_runs
       WHERE status = 'completed'
       ORDER BY completed_at DESC
       LIMIT 1
-    `).get()?.completed_at ?? 'never';
+    `)
+                .get()?.completed_at ?? 'never';
         audrey.close();
     }
     catch (err) {
@@ -1145,11 +1026,11 @@ export function formatStatusReport(report) {
     lines.push(`Data directory: ${report.dataDir}`);
     lines.push(`Stored dimensions: ${report.storedDimensions ?? 'unknown'}`);
     lines.push(`Memories: ${report.stats.episodic} episodic, ${report.stats.semantic} semantic, ${report.stats.procedural} procedural`);
-    lines.push(`Index sync: ${report.health.vec_episodes}/${report.health.searchable_episodes} episodic, `
-        + `${report.health.vec_semantics}/${report.health.searchable_semantics} semantic, `
-        + `${report.health.vec_procedures}/${report.health.searchable_procedures} procedural`);
-    lines.push(`Health: ${report.health.healthy ? 'healthy' : 'unhealthy'}`
-        + `${report.health.reembed_recommended ? ' (re-embed recommended)' : ''}`);
+    lines.push(`Index sync: ${report.health.vec_episodes}/${report.health.searchable_episodes} episodic, ` +
+        `${report.health.vec_semantics}/${report.health.searchable_semantics} semantic, ` +
+        `${report.health.vec_procedures}/${report.health.searchable_procedures} procedural`);
+    lines.push(`Health: ${report.health.healthy ? 'healthy' : 'unhealthy'}` +
+        `${report.health.reembed_recommended ? ' (re-embed recommended)' : ''}`);
     lines.push(`Dormant: ${report.stats.dormant}`);
     lines.push(`Causal links: ${report.stats.causalLinks}`);
     lines.push(`Contradictions: ${report.stats.contradictions.open} open, ${report.stats.contradictions.resolved} resolved`);
@@ -1165,8 +1046,11 @@ export function runStatusCommand({ argv = process.argv, dataDir = resolveDataDir
     else {
         out(formatStatusReport(report));
     }
-    const exitCode = report.error
-        || (cliHasFlag('--fail-on-unhealthy', argv) && report.exists && report.health && !report.health.healthy)
+    const exitCode = report.error ||
+        (cliHasFlag('--fail-on-unhealthy', argv) &&
+            report.exists &&
+            report.health &&
+            !report.health.healthy)
         ? 1
         : 0;
     return { report, exitCode };
@@ -1319,23 +1203,30 @@ function toolResult(data, diagnostics) {
     return result;
 }
 function toolError(err) {
-    return { isError: true, content: [{ type: 'text', text: `Error: ${err.message || String(err)}` }] };
+    return {
+        isError: true,
+        content: [{ type: 'text', text: `Error: ${err.message || String(err)}` }],
+    };
 }
 function jsonResource(uri, data) {
     return {
-        contents: [{
+        contents: [
+            {
                 uri: uri.toString(),
                 mimeType: 'application/json',
                 text: JSON.stringify(data, null, 2),
-            }],
+            },
+        ],
     };
 }
 function promptText(text) {
     return {
-        messages: [{
+        messages: [
+            {
                 role: 'user',
                 content: { type: 'text', text },
-            }],
+            },
+        ],
     };
 }
 export function registerShutdownHandlers(processRef, audrey, logger = console.error) {
@@ -1350,8 +1241,8 @@ export function registerShutdownHandlers(processRef, audrey, logger = console.er
                 if (typeof audrey.drainPostEncodeQueue === 'function') {
                     const drain = await audrey.drainPostEncodeQueue(5000);
                     if (!drain.drained && drain.pendingIds.length > 0) {
-                        logger(`[audrey-mcp] post-encode queue did not drain within 5000ms; `
-                            + `pending ids: ${drain.pendingIds.join(', ')}`);
+                        logger(`[audrey-mcp] post-encode queue did not drain within 5000ms; ` +
+                            `pending ids: ${drain.pendingIds.join(', ')}`);
                     }
                 }
                 audrey.close();
@@ -1365,9 +1256,15 @@ export function registerShutdownHandlers(processRef, audrey, logger = console.er
             processRef.exit(exitCode);
         }
     };
-    processRef.once('SIGINT', () => { void shutdown('[audrey-mcp] received SIGINT, shutting down'); });
-    processRef.once('SIGTERM', () => { void shutdown('[audrey-mcp] received SIGTERM, shutting down'); });
-    processRef.once('SIGHUP', () => { void shutdown('[audrey-mcp] received SIGHUP, shutting down'); });
+    processRef.once('SIGINT', () => {
+        void shutdown('[audrey-mcp] received SIGINT, shutting down');
+    });
+    processRef.once('SIGTERM', () => {
+        void shutdown('[audrey-mcp] received SIGTERM, shutting down');
+    });
+    processRef.once('SIGHUP', () => {
+        void shutdown('[audrey-mcp] received SIGHUP, shutting down');
+    });
     processRef.once('uncaughtException', (err) => {
         logger('[audrey-mcp] uncaught exception:', err);
         void shutdown(undefined, 1);
@@ -1381,13 +1278,20 @@ export function registerShutdownHandlers(processRef, audrey, logger = console.er
     });
     return (message, exitCode = 0) => shutdown(message, exitCode);
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function registerDreamTool(server, audrey) {
     server.tool('memory_dream', {
         min_cluster_size: z.number().optional().describe('Minimum episodes per cluster (default 3)'),
-        similarity_threshold: z.number().optional().describe('Similarity threshold for clustering (default 0.85)'),
-        dormant_threshold: z.number().min(0).max(1).optional().describe('Confidence below which memories go dormant (default 0.1)'),
-    }, async ({ min_cluster_size, similarity_threshold, dormant_threshold }) => {
+        similarity_threshold: z
+            .number()
+            .optional()
+            .describe('Similarity threshold for clustering (default 0.85)'),
+        dormant_threshold: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe('Confidence below which memories go dormant (default 0.1)'),
+    }, async ({ min_cluster_size, similarity_threshold, dormant_threshold, }) => {
         try {
             const result = await audrey.dream({
                 minClusterSize: min_cluster_size,
@@ -1401,7 +1305,6 @@ export function registerDreamTool(server, audrey) {
         }
     });
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function registerHostResources(server, audrey) {
     server.registerResource('audrey-status', 'audrey://status', {
         title: 'Audrey Status',
@@ -1448,7 +1351,6 @@ export function registerHostResources(server, audrey) {
         });
     });
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function registerHostPrompts(server) {
     server.registerPrompt('audrey-session-briefing', {
         title: 'Audrey Session Briefing',
@@ -1476,13 +1378,18 @@ export function registerHostPrompts(server) {
         title: 'Audrey Memory Reflection',
         description: 'Reflect at the end of a meaningful session and encode durable lessons.',
         argsSchema: {
-            summary: z.string().optional().describe('Optional compact summary of the session to reflect on.'),
+            summary: z
+                .string()
+                .optional()
+                .describe('Optional compact summary of the session to reflect on.'),
         },
     }, ({ summary }) => promptText([
         'Call memory_reflect with the important user and assistant turns from this session.',
         'Encode only durable preferences, decisions, fixes, failures, and project facts that should affect future work.',
         summary ? `Session summary hint: ${summary}` : undefined,
-    ].filter(Boolean).join('\n')));
+    ]
+        .filter(Boolean)
+        .join('\n')));
 }
 async function main() {
     const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
@@ -1626,7 +1533,10 @@ async function main() {
                     purge: purge ?? false,
                 });
                 if (!result) {
-                    return toolResult({ forgotten: false, reason: 'No memory found above similarity threshold' });
+                    return toolResult({
+                        forgotten: false,
+                        reason: 'No memory found above similarity threshold',
+                    });
                 }
             }
             return toolResult({ forgotten: true, ...result });
@@ -1647,7 +1557,12 @@ async function main() {
         }
     });
     server.tool('memory_decay', {
-        dormant_threshold: z.number().min(0).max(1).optional().describe('Confidence below which memories go dormant (default 0.1)'),
+        dormant_threshold: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe('Confidence below which memories go dormant (default 0.1)'),
     }, async ({ dormant_threshold }) => {
         try {
             return toolResult(audrey.decay({ dormantThreshold: dormant_threshold }));
@@ -1665,10 +1580,12 @@ async function main() {
         }
     });
     server.tool('memory_reflect', {
-        turns: z.array(z.object({
+        turns: z
+            .array(z.object({
             role: z.string().describe('Message role: user or assistant'),
             content: z.string().describe('Message content'),
-        })).describe('Conversation turns to reflect on. Call at end of meaningful conversations to form lasting memories.'),
+        }))
+            .describe('Conversation turns to reflect on. Call at end of meaningful conversations to form lasting memories.'),
     }, async ({ turns }) => {
         try {
             return toolResult(await audrey.reflect(turns));
@@ -1679,8 +1596,14 @@ async function main() {
     });
     registerDreamTool(server, audrey);
     server.tool('memory_greeting', {
-        context: z.string().optional().describe('Optional hint about this session. When provided, Audrey also returns semantically relevant memories.'),
-        scope: z.enum(['agent', 'shared']).optional().describe('agent keeps greeting scoped to this server agent identity. shared includes the whole store. Defaults to agent.'),
+        context: z
+            .string()
+            .optional()
+            .describe('Optional hint about this session. When provided, Audrey also returns semantically relevant memories.'),
+        scope: z
+            .enum(['agent', 'shared'])
+            .optional()
+            .describe('agent keeps greeting scoped to this server agent identity. shared includes the whole store. Defaults to agent.'),
     }, async ({ context, scope }) => {
         try {
             return toolResult(await audrey.greeting({ context, scope: scope ?? 'agent' }));
@@ -1690,17 +1613,40 @@ async function main() {
         }
     });
     server.tool('memory_observe_tool', {
-        event: z.string().describe('Hook event name (PreToolUse, PostToolUse, PostToolUseFailure, PreCompact, PostCompact, etc.)'),
+        event: z
+            .string()
+            .describe('Hook event name (PreToolUse, PostToolUse, PostToolUseFailure, PreCompact, PostCompact, etc.)'),
         tool: z.string().describe('Tool name being observed (Bash, Edit, Write, etc.)'),
         session_id: z.string().optional().describe('Session identifier for grouping related events'),
-        input: z.unknown().optional().describe('Tool input. Hashed and never stored raw; redacted metadata is only stored when retain_details is true.'),
-        output: z.unknown().optional().describe('Tool output. Same redaction and storage policy as input.'),
-        outcome: z.enum(['succeeded', 'failed', 'blocked', 'skipped', 'unknown']).optional().describe('Outcome classification'),
-        error_summary: z.string().optional().describe('Short error description if the tool failed. Redacted and truncated to 2 KB.'),
+        input: z
+            .unknown()
+            .optional()
+            .describe('Tool input. Hashed and never stored raw; redacted metadata is only stored when retain_details is true.'),
+        output: z
+            .unknown()
+            .optional()
+            .describe('Tool output. Same redaction and storage policy as input.'),
+        outcome: z
+            .enum(['succeeded', 'failed', 'blocked', 'skipped', 'unknown'])
+            .optional()
+            .describe('Outcome classification'),
+        error_summary: z
+            .string()
+            .optional()
+            .describe('Short error description if the tool failed. Redacted and truncated to 2 KB.'),
         cwd: z.string().optional().describe('Working directory at the time of the tool call'),
-        files: z.array(z.string()).optional().describe('File paths to fingerprint (size + mtime + content hash)'),
-        metadata: z.record(z.string(), z.unknown()).optional().describe('Arbitrary structured metadata (redacted before storage)'),
-        retain_details: z.boolean().optional().describe('If true, redacted input and output payloads are stored alongside hashes. Defaults to false.'),
+        files: z
+            .array(z.string())
+            .optional()
+            .describe('File paths to fingerprint (size + mtime + content hash)'),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Arbitrary structured metadata (redacted before storage)'),
+        retain_details: z
+            .boolean()
+            .optional()
+            .describe('If true, redacted input and output payloads are stored alongside hashes. Defaults to false.'),
     }, async ({ event, tool, session_id, input, output, outcome, error_summary, cwd, files, metadata, retain_details, }) => {
         try {
             const result = audrey.observeTool({
@@ -1732,7 +1678,13 @@ async function main() {
     });
     server.tool('memory_recent_failures', {
         since: z.string().optional().describe('ISO timestamp lower bound (defaults to 7 days ago)'),
-        limit: z.number().int().min(1).max(200).optional().describe('Max rows to return (defaults to 20)'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe('Max rows to return (defaults to 20)'),
     }, async ({ since, limit }) => {
         try {
             return toolResult(audrey.recentFailures({ since, limit }));
@@ -1743,13 +1695,43 @@ async function main() {
     });
     server.tool('memory_capsule', {
         query: z.string().describe('Natural-language query for the turn. Drives what gets surfaced.'),
-        limit: z.number().int().min(1).max(50).optional().describe('Max recall results to consider before categorization.'),
-        budget_chars: z.number().int().min(200).max(32000).optional().describe('Token budget in characters (defaults to AUDREY_CONTEXT_BUDGET_CHARS or 4000).'),
-        mode: z.enum(['balanced', 'conservative', 'aggressive']).optional().describe('Capsule mode: conservative = fewer, higher-confidence entries; aggressive = broader sweep.'),
-        recent_change_window_hours: z.number().int().min(1).max(720).optional().describe('How far back "recent_changes" looks (default 24h).'),
-        include_risks: z.boolean().optional().describe('Include recent tool failures as risks (default true).'),
-        include_contradictions: z.boolean().optional().describe('Include open contradictions (default true).'),
-        scope: z.enum(['agent', 'shared']).optional().describe('agent restricts memory recall to this MCP server agent identity. shared searches the whole store. Defaults to agent.'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(50)
+            .optional()
+            .describe('Max recall results to consider before categorization.'),
+        budget_chars: z
+            .number()
+            .int()
+            .min(200)
+            .max(32000)
+            .optional()
+            .describe('Token budget in characters (defaults to AUDREY_CONTEXT_BUDGET_CHARS or 4000).'),
+        mode: z
+            .enum(['balanced', 'conservative', 'aggressive'])
+            .optional()
+            .describe('Capsule mode: conservative = fewer, higher-confidence entries; aggressive = broader sweep.'),
+        recent_change_window_hours: z
+            .number()
+            .int()
+            .min(1)
+            .max(720)
+            .optional()
+            .describe('How far back "recent_changes" looks (default 24h).'),
+        include_risks: z
+            .boolean()
+            .optional()
+            .describe('Include recent tool failures as risks (default true).'),
+        include_contradictions: z
+            .boolean()
+            .optional()
+            .describe('Include open contradictions (default true).'),
+        scope: z
+            .enum(['agent', 'shared'])
+            .optional()
+            .describe('agent restricts memory recall to this MCP server agent identity. shared searches the whole store. Defaults to agent.'),
     }, async ({ query, limit, budget_chars, mode, recent_change_window_hours, include_risks, include_contradictions, scope, }) => {
         try {
             const capsule = await audrey.capsule(query, {
@@ -1860,14 +1842,42 @@ async function main() {
         }
     });
     server.tool('memory_promote', {
-        target: z.enum(['claude-rules']).optional().describe('Promotion target. Only claude-rules is implemented in PR 4 v1.'),
-        min_confidence: z.number().min(0).max(1).optional().describe('Minimum memory confidence for promotion (default 0.7 for procedural, 0.8 for semantic).'),
-        min_evidence: z.number().int().min(1).optional().describe('Minimum supporting episode count (default 2).'),
-        limit: z.number().int().min(1).max(50).optional().describe('Max candidates to return/apply (default 20).'),
-        dry_run: z.boolean().optional().describe('If true (default), return candidates without writing. Pair with yes=true to actually write.'),
-        yes: z.boolean().optional().describe('Confirm write. Without this or dry_run=false the command stays in dry-run mode.'),
-        project_dir: z.string().optional().describe('Absolute path to the project root where .claude/rules/ should be created. Defaults to process.cwd().'),
-    }, async ({ target, min_confidence, min_evidence, limit, dry_run, yes, project_dir, }) => {
+        target: z
+            .enum(['claude-rules'])
+            .optional()
+            .describe('Promotion target. Only claude-rules is implemented in PR 4 v1.'),
+        min_confidence: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe('Minimum memory confidence for promotion (default 0.7 for procedural, 0.8 for semantic).'),
+        min_evidence: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('Minimum supporting episode count (default 2).'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(50)
+            .optional()
+            .describe('Max candidates to return/apply (default 20).'),
+        dry_run: z
+            .boolean()
+            .optional()
+            .describe('If true (default), return candidates without writing. Pair with yes=true to actually write.'),
+        yes: z
+            .boolean()
+            .optional()
+            .describe('Confirm write. Without this or dry_run=false the command stays in dry-run mode.'),
+        project_dir: z
+            .string()
+            .optional()
+            .describe('Absolute path to the project root where .claude/rules/ should be created. Defaults to process.cwd().'),
+    }, async ({ target, min_confidence, min_evidence, limit, dry_run, yes, project_dir }) => {
         try {
             const result = await audrey.promote({
                 target,
@@ -1890,7 +1900,8 @@ async function main() {
         console.error('[audrey-mcp] connected via stdio');
     }
     if (!isEmbeddingWarmupDisabled(process.env)) {
-        void audrey.startEmbeddingWarmup()
+        void audrey
+            .startEmbeddingWarmup()
             .then(() => {
             if (process.env.AUDREY_DEBUG === '1') {
                 const status = audrey.memoryStatus();
@@ -1925,7 +1936,10 @@ function parseObserveToolArgs(argv) {
         else if (token === '--files') {
             const list = next();
             if (list)
-                out.files = list.split(',').map(s => s.trim()).filter(Boolean);
+                out.files = list
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(Boolean);
         }
         else if (token === '--input-json')
             out.inputJson = next();
@@ -1980,13 +1994,11 @@ async function observeToolCli() {
     };
     const inputPayload = args.inputJson !== undefined
         ? parseMaybeJson(args.inputJson)
-        : stdinPayload?.tool_input ?? stdinPayload?.input;
+        : (stdinPayload?.tool_input ?? stdinPayload?.input);
     const outputPayload = args.outputJson !== undefined
         ? parseMaybeJson(args.outputJson)
-        : stdinPayload?.tool_response ?? stdinPayload?.tool_output ?? stdinPayload?.output;
-    const metadataPayload = args.metadataJson !== undefined
-        ? parseMaybeJson(args.metadataJson)
-        : stdinPayload?.metadata;
+        : (stdinPayload?.tool_response ?? stdinPayload?.tool_output ?? stdinPayload?.output);
+    const metadataPayload = args.metadataJson !== undefined ? parseMaybeJson(args.metadataJson) : stdinPayload?.metadata;
     const sessionId = args.sessionId ?? stdinPayload?.session_id;
     const cwd = args.cwd ?? stdinPayload?.cwd;
     // Detect failure from Claude Code hook payload shape: tool_response often
@@ -2124,7 +2136,7 @@ function guardDisplayDecision(result) {
     return 'allow';
 }
 function summarizeToolInput(payload, tool) {
-    const input = (payload.tool_input && typeof payload.tool_input === 'object')
+    const input = payload.tool_input && typeof payload.tool_input === 'object'
         ? payload.tool_input
         : {};
     const command = typeof input.command === 'string' ? input.command : undefined;
@@ -2139,9 +2151,7 @@ function summarizeToolInput(payload, tool) {
         return { action: `${tool}: ${description}`, files };
     const compactInput = JSON.stringify(input);
     return {
-        action: compactInput && compactInput !== '{}'
-            ? `${tool} ${compactInput}`
-            : `Use ${tool}`,
+        action: compactInput && compactInput !== '{}' ? `${tool} ${compactInput}` : `Use ${tool}`,
         files,
     };
 }
@@ -2160,7 +2170,9 @@ function formatHookReason(result) {
         result.summary,
         recommendations.length > 0 ? `Recommended: ${recommendations.join(' ')}` : '',
         result.evidence_ids.length > 0 ? `Evidence: ${result.evidence_ids.slice(0, 5).join(', ')}` : '',
-    ].filter(Boolean).join('\n');
+    ]
+        .filter(Boolean)
+        .join('\n');
 }
 function formatPreToolUseHookOutput(result, failOnWarn) {
     const decision = guardDisplayDecision(result);
@@ -2253,7 +2265,11 @@ async function guardCli() {
             tool: hookTool ?? args.tool,
             sessionId: args.sessionId ?? hookSessionId,
             cwd: args.cwd ?? hookCwd ?? process.cwd(),
-            files: args.files.length > 0 ? args.files : hookSummary?.files?.length ? hookSummary.files : undefined,
+            files: args.files.length > 0
+                ? args.files
+                : hookSummary?.files?.length
+                    ? hookSummary.files
+                    : undefined,
             strict: args.strict || args.failOnWarn || args.hook,
             recordEvent: true,
             includeCapsule: args.includeCapsule || args.explain,
@@ -2268,7 +2284,9 @@ async function guardCli() {
             console.log(formatGuardDecision(result, { explain: args.explain }));
         }
         const display = guardDisplayDecision(result);
-        if (!args.hook && (display === 'block' || (args.failOnWarn && display === 'warn')) && !args.override) {
+        if (!args.hook &&
+            (display === 'block' || (args.failOnWarn && display === 'warn')) &&
+            !args.override) {
             process.exitCode = 2;
         }
     }
@@ -2314,9 +2332,9 @@ async function readOptionalJsonFromStdin(command) {
     }
 }
 function inferGuardAfterOutcome(stdinPayload) {
-    const response = stdinPayload?.tool_response
-        ?? stdinPayload?.tool_output
-        ?? stdinPayload?.output;
+    const response = stdinPayload?.tool_response ??
+        stdinPayload?.tool_output ??
+        stdinPayload?.output;
     const success = response?.success;
     if (typeof success === 'boolean')
         return success ? 'succeeded' : 'failed';
@@ -2433,8 +2451,8 @@ async function promoteCli() {
             const snippet = c.content.length > 120 ? c.content.slice(0, 117) + '...' : c.content;
             console.log(`    memory: ${snippet}`);
             console.log(`    why:    ${c.reason}`);
-            console.log(`    confidence=${(c.confidence * 100).toFixed(1)}%  `
-                + `evidence=${c.evidence_count}  prevented_failures=${c.failure_prevented}`);
+            console.log(`    confidence=${(c.confidence * 100).toFixed(1)}%  ` +
+                `evidence=${c.evidence_count}  prevented_failures=${c.failure_prevented}`);
         }
         if (result.dry_run) {
             console.log('');
@@ -2454,11 +2472,26 @@ function canonicalEntryPath(path) {
         return resolved.toLowerCase();
     }
 }
-const isDirectRun = Boolean(process.argv[1])
-    && canonicalEntryPath(process.argv[1]) === canonicalEntryPath(fileURLToPath(import.meta.url));
+const isDirectRun = Boolean(process.argv[1]) &&
+    canonicalEntryPath(process.argv[1]) === canonicalEntryPath(fileURLToPath(import.meta.url));
 const KNOWN_SUBCOMMANDS = [
-    'install', 'uninstall', 'mcp-config', 'hook-config', 'demo', 'reembed', 'dream',
-    'greeting', 'reflect', 'serve', 'status', 'doctor', 'observe-tool', 'guard', 'guard-after', 'promote', 'impact',
+    'install',
+    'uninstall',
+    'mcp-config',
+    'hook-config',
+    'demo',
+    'reembed',
+    'dream',
+    'greeting',
+    'reflect',
+    'serve',
+    'status',
+    'doctor',
+    'observe-tool',
+    'guard',
+    'guard-after',
+    'promote',
+    'impact',
 ];
 function printHelp() {
     process.stdout.write(`audrey ${VERSION} — local-first memory runtime for AI agents