@miriad-systems/nuum 0.1.9 → 0.1.10

package/dist/index.js

@@ -17400,7 +17400,8 @@ __export(exports_schema, {
   temporalMessages: () => temporalMessages,
   sessionConfig: () => sessionConfig,
   presentState: () => presentState,
-  ltmEntries: () => ltmEntries
+  ltmEntries: () => ltmEntries,
+  backgroundReports: () => backgroundReports
 });
 
 // node_modules/drizzle-orm/entity.js
@@ -18694,6 +18695,15 @@ var workers = sqliteTable("workers", {
   completedAt: text("completed_at"),
   error: text("error")
 });
+var backgroundReports = sqliteTable("background_reports", {
+  id: text("id").primaryKey(),
+  createdAt: text("created_at").notNull(),
+  subsystem: text("subsystem").notNull(),
+  report: text("report").notNull(),
+  surfacedAt: text("surfaced_at")
+}, (table) => [
+  index("idx_background_reports_unsurfaced").on(table.surfacedAt)
+]);
 
 // src/storage/db.ts
 var isBun = typeof globalThis.Bun !== "undefined";
@@ -23457,7 +23467,9 @@ var Identifier;
     task: "tsk",
     entry: "ent",
     worker: "wrk",
-    session: "ses"
+    report: "rpt",
+    session: "ses",
+    toolcall: "tcl"
   };
   function schema(prefix) {
     return exports_external.string().startsWith(prefixes[prefix]);
@@ -23561,6 +23573,45 @@ function createSessionStorage(db) {
   };
 }
 
+// src/storage/background.ts
+function createBackgroundStorage(db) {
+  return {
+    async fileReport(input) {
+      const id = Identifier.ascending("report");
+      const now = new Date().toISOString();
+      await db.insert(backgroundReports).values({
+        id,
+        createdAt: now,
+        subsystem: input.subsystem,
+        report: JSON.stringify(input.report)
+      });
+      return id;
+    },
+    async getUnsurfaced() {
+      const rows = await db.select().from(backgroundReports).where(isNull(backgroundReports.surfacedAt)).orderBy(backgroundReports.createdAt);
+      return rows.map((row) => ({
+        id: row.id,
+        createdAt: row.createdAt,
+        subsystem: row.subsystem,
+        report: JSON.parse(row.report),
+        surfacedAt: row.surfacedAt
+      }));
+    },
+    async markSurfaced(id) {
+      const now = new Date().toISOString();
+      await db.update(backgroundReports).set({ surfacedAt: now }).where(eq(backgroundReports.id, id));
+    },
+    async markManySurfaced(ids) {
+      if (ids.length === 0)
+        return;
+      const now = new Date().toISOString();
+      for (const id of ids) {
+        await db.update(backgroundReports).set({ surfacedAt: now }).where(eq(backgroundReports.id, id));
+      }
+    }
+  };
+}
+
 // src/storage/index.ts
 function createStorage(dbPath, options) {
   const { mkdirSync } = __require("fs");
@@ -23579,6 +23630,7 @@ function createStorageFromDb(db) {
     ltm: createLTMStorage(db),
     workers: createWorkerStorage(db),
     session: createSessionStorage(db),
+    background: createBackgroundStorage(db),
     _db: db
   };
 }
@@ -34945,16 +34997,17 @@ function buildCreateDistillationTool(ctx, results) {
 }
 function buildFinishDistillationTool(results) {
   return tool({
-    description: "Signal that working memory optimization is complete. Call when you've distilled enough or no more optimization is beneficial.",
+    description: "Signal that working memory optimization is complete. Write a contextual summary for your future self explaining what you compressed and what you retained.",
     parameters: exports_external.object({
-      reason: exports_external.string().describe("Brief explanation (e.g., 'reached target', 'recent content needs detail for ongoing work')")
+      summary: exports_external.string().describe("A note to your future self: what did you compress and what key information did you retain? Example: 'Combined the three debugging sessions into one distillation - retained the key insight about the race condition and the fix in src/agent/loop.ts.'")
     }),
-    execute: async ({ reason }, { toolCallId }) => {
-      log6.info("distillation finished", { reason });
+    execute: async ({ summary }, { toolCallId }) => {
+      log6.info("distillation finished", { summary });
       const result = {
-        output: `Distillation complete: ${reason}`,
+        output: `Distillation complete`,
         done: true,
-        distillationCreated: false
+        distillationCreated: false,
+        summary
       };
       results.set(toolCallId, result);
       return result.output;
@@ -35044,6 +35097,19 @@ For each distillation, call **create_distillation** with:
 
 Call **finish_distillation** when you've optimized enough or no more distillation is beneficial.
 
+### Writing Your Summary
+
+When you call \`finish_distillation\`, write a brief note to your future self explaining what you compressed and what you retained. This is a dialog between your subconscious (the compactor) and your conscious self (the main agent).
+
+**Good summaries** explain the WHAT and WHY:
+- "Combined the three debugging sessions into one distillation - retained the key insight about the race condition and the fix in src/agent/loop.ts."
+- "Distilled the API refactoring work, keeping all the endpoint paths and the decision to use REST over GraphQL."
+- "Compressed the deployment troubleshooting - kept the final working config and the gotcha about environment variables."
+
+**Avoid mechanical summaries**:
+- \u2717 "Reached target"
+- \u2717 "Created 3 distillations"
+
 **Remember:** You're optimizing your own working memory. Keep what helps you act with precision.
 `;
 }
@@ -35128,6 +35194,9 @@ async function runCompaction(storage, config) {
           if (toolResult?.distillationCreated) {
             result.distillationsCreated++;
           }
+          if (toolResult?.summary) {
+            result.summary = toolResult.summary;
+          }
         }
       });
     } catch (error) {
@@ -44340,7 +44409,7 @@ var LTMTools = {
 };
 // src/ltm/consolidation.ts
 var log9 = Log.create({ service: "consolidation-agent" });
-var MAX_CONSOLIDATION_TURNS = 10;
+var MAX_CONSOLIDATION_TURNS = 20;
 var AGENT_TYPE = "ltm-consolidate";
 function isConversationNoteworthy(messages) {
   if (messages.length < 5) {
@@ -44414,7 +44483,13 @@ function buildConsolidationTools(storage) {
       if (entryCreated) {
         activity.ltmCurator.ltmOperation("create", args.slug, args.title);
       }
-      const result = { output: toolResult.output, done: false, entryCreated };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryCreated,
+        slug: args.slug,
+        title: args.title
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44428,7 +44503,12 @@ function buildConsolidationTools(storage) {
       if (entryUpdated) {
         activity.ltmCurator.ltmOperation("update", args.slug);
       }
-      const result = { output: toolResult.output, done: false, entryUpdated };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44442,7 +44522,12 @@ function buildConsolidationTools(storage) {
       if (entryUpdated) {
         activity.ltmCurator.ltmOperation("update", args.slug, "surgical edit");
       }
-      const result = { output: toolResult.output, done: false, entryUpdated };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44456,7 +44541,12 @@ function buildConsolidationTools(storage) {
       if (entryUpdated) {
         activity.ltmCurator.ltmOperation("reparent", args.slug, `\u2192 ${args.newParentSlug ?? "root"}`);
       }
-      const result = { output: toolResult.output, done: false, entryUpdated };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44470,7 +44560,12 @@ function buildConsolidationTools(storage) {
       if (entryUpdated) {
         activity.ltmCurator.ltmOperation("rename", args.slug, `\u2192 ${args.newSlug}`);
       }
-      const result = { output: toolResult.output, done: false, entryUpdated };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44484,7 +44579,12 @@ function buildConsolidationTools(storage) {
       if (entryArchived) {
         activity.ltmCurator.ltmOperation("archive", args.slug);
       }
-      const result = { output: toolResult.output, done: false, entryArchived };
+      const result = {
+        output: toolResult.output,
+        done: false,
+        entryArchived,
+        slug: args.slug
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -44565,9 +44665,9 @@ function buildConsolidationTools(storage) {
     }
   });
   tools.finish_consolidation = tool({
-    description: "Call this when you have finished curating the knowledge base. Always call this to complete the task.",
+    description: "Call this when you have finished curating the knowledge base. Write a contextual summary for your future self.",
     parameters: exports_external.object({
-      summary: exports_external.string().describe("Brief summary of what you did: entries created/updated, research performed, organization changes, etc.")
+      summary: exports_external.string().describe("A note to your future self: what did you capture and why does it matter? Reference entries with [[slug]] syntax. Example: 'Captured the bloom filter insights in [[bloom-filter-overview]]. Archived X system workarounds since it's decommissioned.'")
     }),
     execute: async ({ summary }, { toolCallId }) => {
       const result = { output: "Curation complete", done: true, summary };
@@ -44742,7 +44842,20 @@ Review these entries periodically. Are they accurate? Complete? Do they reflect
 1. **First**: Capture any insights from the recent conversation (this is the priority)
 2. **Then**: Look at your knowledge base - is it serving you well? Improve it.
 3. **Check**: Are /identity and /behavior current? Update them if you've learned something new.
-4. **Finally**: Call \`finish_consolidation\` with a summary of what you did
+4. **Finally**: Call \`finish_consolidation\` with a contextual summary
+
+### Writing Your Summary
+
+When you call \`finish_consolidation\`, write a brief note to your future self explaining what you captured and why it matters. This is a dialog between your subconscious (the curator) and your conscious self (the main agent).
+
+**Good summaries** explain the WHAT and WHY:
+- "Captured the insights on probabilistic filtering in [[bloom-filter-overview]]. Also archived the X system workarounds since it's been decommissioned."
+- "Updated [[user-preferences]] with the new testing philosophy - run tests before committing. Created [[cast-integration]] to document the engine abstraction pattern."
+- "Reorganized the codebase knowledge - moved protocol docs under [[miriad-code/protocol]] and cross-linked with [[memory-system]]."
+
+**Avoid mechanical summaries**:
+- \u2717 "Created 2 entries, updated 1 entry"
+- \u2717 "Finished curation"
 
 Be proactive! This is YOUR knowledge base. Make it useful.
 `;
@@ -44755,6 +44868,7 @@ async function runConsolidation(storage, messages) {
     entriesUpdated: 0,
     entriesArchived: 0,
     summary: "",
+    details: [],
     usage: { inputTokens: 0, outputTokens: 0 }
   };
   if (!isConversationNoteworthy(messages)) {
@@ -44792,12 +44906,21 @@ ${reviewTurnContent}` }
       const toolResult = getLastResult(toolCallId);
       if (toolResult?.entryCreated) {
         result.entriesCreated++;
+        if (toolResult.slug) {
+          result.details.push(`Created [[${toolResult.slug}]]${toolResult.title ? ` - ${toolResult.title}` : ""}`);
+        }
       }
       if (toolResult?.entryUpdated) {
         result.entriesUpdated++;
+        if (toolResult.slug) {
+          result.details.push(`Updated [[${toolResult.slug}]]`);
+        }
       }
       if (toolResult?.entryArchived) {
         result.entriesArchived++;
+        if (toolResult.slug) {
+          result.details.push(`Archived [[${toolResult.slug}]]`);
+        }
       }
       if (toolResult?.summary) {
         result.summary = toolResult.summary;
@@ -44874,6 +44997,16 @@ async function runLTMConsolidation(storage) {
       const changes = result.entriesCreated + result.entriesUpdated + result.entriesArchived;
       if (changes > 0) {
         activity.ltmCurator.complete(`${result.entriesCreated} created, ${result.entriesUpdated} updated, ${result.entriesArchived} archived`);
+        await storage.background.fileReport({
+          subsystem: "ltm_curator",
+          report: {
+            entriesCreated: result.entriesCreated,
+            entriesUpdated: result.entriesUpdated,
+            entriesArchived: result.entriesArchived,
+            details: result.details || [],
+            summary: result.summary
+          }
+        });
       } else {
         activity.ltmCurator.complete("No changes needed");
       }
@@ -44899,6 +45032,17 @@ async function runDistillation(storage, threshold, target, force) {
       force
     });
     activity.distillation.tokens(result.tokensBefore, result.tokensAfter, `${result.distillationsCreated} distillations`);
+    if (result.distillationsCreated > 0) {
+      await storage.background.fileReport({
+        subsystem: "distillation",
+        report: {
+          tokensBefore: result.tokensBefore,
+          tokensAfter: result.tokensAfter,
+          distillationsCreated: result.distillationsCreated,
+          summary: result.summary
+        }
+      });
+    }
     return result;
   } catch (error2) {
     activity.distillation.error(error2 instanceof Error ? error2.message : String(error2));
@@ -44908,7 +45052,81 @@ async function runDistillation(storage, threshold, target, force) {
 
 // src/agent/index.ts
 var log10 = Log.create({ service: "agent" });
-var MAX_TURNS = 50;
+var MAX_TURNS = 200;
+async function surfaceBackgroundReports(storage) {
+  const reports = await storage.background.getUnsurfaced();
+  if (reports.length === 0)
+    return;
+  log10.info("surfacing background reports", { count: reports.length });
+  for (const report of reports) {
+    const toolCallId = Identifier.ascending("toolcall");
+    await storage.temporal.appendMessage({
+      id: Identifier.ascending("message"),
+      type: "tool_call",
+      content: JSON.stringify({
+        name: "background_activity",
+        args: { subsystem: report.subsystem },
+        toolCallId
+      }),
+      tokenEstimate: 20,
+      createdAt: report.createdAt
+    });
+    const reportContent = formatBackgroundReport(report.subsystem, report.report);
+    await storage.temporal.appendMessage({
+      id: Identifier.ascending("message"),
+      type: "tool_result",
+      content: JSON.stringify({
+        toolCallId,
+        result: reportContent
+      }),
+      tokenEstimate: estimateTokens2(reportContent),
+      createdAt: report.createdAt
+    });
+    await storage.background.markSurfaced(report.id);
+  }
+}
+function formatBackgroundReport(subsystem, report) {
+  switch (subsystem) {
+    case "ltm_curator": {
+      const r = report;
+      if (r.summary) {
+        return `[Knowledge Curator] ${r.summary}`;
+      }
+      const lines = ["[Knowledge Curator] I organized my knowledge:"];
+      if (r.entriesCreated)
+        lines.push(`- Created ${r.entriesCreated} new entries`);
+      if (r.entriesUpdated)
+        lines.push(`- Updated ${r.entriesUpdated} existing entries`);
+      if (r.entriesArchived)
+        lines.push(`- Archived ${r.entriesArchived} outdated entries`);
+      if (r.details && r.details.length > 0) {
+        lines.push("");
+        lines.push(...r.details.map((d) => `- ${d}`));
+      }
+      return lines.join(`
+`);
+    }
+    case "distillation": {
+      const r = report;
+      if (r.summary) {
+        const tokenInfo = r.tokensBefore && r.tokensAfter ? ` (${r.tokensBefore.toLocaleString()} \u2192 ${r.tokensAfter.toLocaleString()} tokens)` : "";
+        return `[Memory Compaction]${tokenInfo} ${r.summary}`;
+      }
+      const lines = ["[Memory Compaction] I compressed my working memory:"];
+      if (r.tokensBefore && r.tokensAfter) {
+        const saved = r.tokensBefore - r.tokensAfter;
+        lines.push(`- Reduced from ${r.tokensBefore.toLocaleString()} to ${r.tokensAfter.toLocaleString()} tokens (saved ${saved.toLocaleString()})`);
+      }
+      if (r.distillationsCreated) {
+        lines.push(`- Created ${r.distillationsCreated} distillation${r.distillationsCreated > 1 ? "s" : ""}`);
+      }
+      return lines.join(`
+`);
+    }
+    default:
+      return `[${subsystem}] ${JSON.stringify(report, null, 2)}`;
+  }
+}
 function summarizeToolResult(toolName, result) {
   const lines = result.split(`
 `).length;
@@ -45139,6 +45357,7 @@ async function runAgent(prompt, options) {
   const { storage, onEvent, abortSignal, onBeforeTurn } = options;
   const sessionId = Identifier.ascending("session");
   await initializeMcp();
+  await surfaceBackgroundReports(storage);
   const config2 = Config.get();
   const softLimit = config2.tokenBudgets.compactionThreshold;
   const hardLimit = config2.tokenBudgets.compactionHardLimit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miriad-systems/nuum",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "AI coding agent with continuous memory - infinite context across sessions",
   "type": "module",
   "bin": {

package/src/storage/migrations/0003_background_reports.sql

@@ -0,0 +1,15 @@
+-- Background reports table
+-- Allows background workers (LTM curator, distillation, etc.) to file reports
+-- that get surfaced to the main agent at the start of the next turn.
+
+CREATE TABLE IF NOT EXISTS background_reports (
+  id TEXT PRIMARY KEY,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  subsystem TEXT NOT NULL,  -- e.g., 'ltm_curator', 'distillation'
+  report TEXT NOT NULL,     -- JSON report content
+  surfaced_at TEXT          -- NULL until shown to main agent
+);
+
+-- Index for efficient lookup of unsurfaced reports
+CREATE INDEX IF NOT EXISTS idx_background_reports_unsurfaced 
+  ON background_reports(surfaced_at) WHERE surfaced_at IS NULL;