audrey 1.1.1 → 1.1.2

package/dist/mcp-server/index.js

@@ -72,6 +72,41 @@ async function reembed() {
         await audrey.closeAsync();
     }
 }
+// The dream/reflect CLIs run under a utility agent name, but memories belong to
+// real agents (claude-code, codex, ...). Consolidate per owning agent so the
+// sweep actually touches stored episodes instead of the utility agent's empty set.
+async function dreamAcrossAgents(audrey) {
+    const rows = audrey.db
+        .prepare(`SELECT DISTINCT agent FROM episodes
+       WHERE consolidated = 0 AND superseded_by IS NULL AND embedding IS NOT NULL`)
+        .all();
+    const agents = rows
+        .map(row => row.agent)
+        .filter(agent => typeof agent === 'string' && agent.trim().length > 0);
+    if (agents.length === 0)
+        agents.push(audrey.agent);
+    const totals = {
+        episodesEvaluated: 0,
+        clustersFound: 0,
+        principlesExtracted: 0,
+        semanticsCreated: 0,
+        proceduresCreated: 0,
+        decayEvaluated: 0,
+        decayDormant: 0,
+        agents,
+    };
+    for (const agent of agents) {
+        const result = await audrey.dream({ agent });
+        totals.episodesEvaluated += result.consolidation.episodesEvaluated;
+        totals.clustersFound += result.consolidation.clustersFound;
+        totals.principlesExtracted += result.consolidation.principlesExtracted;
+        totals.semanticsCreated += result.consolidation.semanticsCreated ?? 0;
+        totals.proceduresCreated += result.consolidation.proceduresCreated ?? 0;
+        totals.decayEvaluated += result.decay.totalEvaluated;
+        totals.decayDormant += result.decay.transitionedToDormant;
+    }
+    return totals;
+}
 async function dream() {
     const dataDir = resolveDataDir(process.env);
     const explicit = process.env['AUDREY_EMBEDDING_PROVIDER'];
@@ -93,14 +128,16 @@ async function dream() {
             : `${embedding.provider} (${embedding.dimensions}d)`;
         console.log('[audrey] Starting dream cycle...');
         console.log(`[audrey] Embedding: ${embeddingLabel}`);
-        const result = await audrey.dream();
+        const totals = await dreamAcrossAgents(audrey);
+        const stats = audrey.introspect();
         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 ` +
+        console.log(`[audrey] Agents: ${totals.agents.join(', ')}`);
+        console.log(`[audrey] Consolidation: evaluated ${totals.episodesEvaluated} episodes, ` +
+            `found ${totals.clustersFound} clusters, extracted ${totals.principlesExtracted} principles ` +
+            `(${totals.semanticsCreated} semantic, ${totals.proceduresCreated} procedural)`);
+        console.log(`[audrey] Decay: evaluated ${totals.decayEvaluated} memories, ` +
+            `${totals.decayDormant} transitioned to dormant`);
+        console.log(`[audrey] Final: ${stats.episodic} episodic, ${stats.semantic} semantic, ${stats.procedural} procedural ` +
             `| ${health.healthy ? 'healthy' : 'unhealthy'}`);
         console.log('[audrey] Dream complete.');
     }
@@ -248,7 +285,7 @@ async function reflect() {
     const embedding = resolveEmbeddingProvider(process.env, explicit);
     const config = {
         dataDir,
-        agent: 'reflect',
+        agent: process.env['AUDREY_AGENT'] ?? 'reflect',
         embedding,
     };
     const llm = resolveLLMProvider(process.env, process.env['AUDREY_LLM_PROVIDER']);
@@ -286,13 +323,13 @@ 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`);
+        const totals = await dreamAcrossAgents(audrey);
+        const stats = audrey.introspect();
+        console.log(`[audrey] Consolidation: ${totals.episodesEvaluated} episodes evaluated, ` +
+            `${totals.clustersFound} clusters, ${totals.principlesExtracted} principles`);
+        console.log(`[audrey] Decay: ${totals.decayEvaluated} evaluated, ` + `${totals.decayDormant} dormant`);
+        console.log(`[audrey] Status: ${stats.episodic} episodic, ${stats.semantic} semantic, ` +
+            `${stats.procedural} procedural`);
         console.log('[audrey] Dream complete.');
     }
     finally {
@@ -1773,9 +1810,17 @@ async function main() {
             .max(200)
             .optional()
             .describe('Max rows to return (defaults to 20)'),
-    }, async ({ since, limit }) => {
+        cwd: z
+            .string()
+            .optional()
+            .describe('Scope failures to the project containing this directory'),
+        include_resolved: z
+            .boolean()
+            .optional()
+            .describe('Include failure streaks already resolved by a later success (default false)'),
+    }, async ({ since, limit, cwd, include_resolved }) => {
         try {
-            return toolResult(audrey.recentFailures({ since, limit }));
+            return toolResult(audrey.recentFailures({ since, limit, cwd, includeResolved: include_resolved }));
         }
         catch (err) {
             return toolError(err);
@@ -1820,7 +1865,11 @@ async function main() {
             .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, }) => {
+        cwd: z
+            .string()
+            .optional()
+            .describe('Scope tool-failure risks to the project containing this directory.'),
+    }, async ({ query, limit, budget_chars, mode, recent_change_window_hours, include_risks, include_contradictions, scope, cwd, }) => {
         try {
             const capsule = await audrey.capsule(query, {
                 limit,
@@ -1829,6 +1878,7 @@ async function main() {
                 recentChangeWindowHours: recent_change_window_hours,
                 includeRisks: include_risks,
                 includeContradictions: include_contradictions,
+                cwd,
                 recall: { scope: scope ?? 'agent' },
             });
             return toolResult(capsule);