@miriad-systems/nuum 0.1.12 → 0.1.13

package/dist/index.js

@@ -34411,6 +34411,7 @@ var activity = {
   ltmCurator: new ActivityLog("ltm-curator"),
   distillation: new ActivityLog("distillation"),
   reflection: new ActivityLog("reflection"),
+  research: new ActivityLog("research"),
   server: new ActivityLog("server"),
   mcp: new ActivityLog("mcp")
 };
@@ -35315,7 +35316,54 @@ async function buildAgentContext(storage) {
   };
 }
 
-// src/tool/reflection-search.ts
+// src/sub-agent/index.ts
+var log8 = Log.create({ service: "sub-agent" });
+async function runSubAgent(storage, config) {
+  const {
+    name: name17,
+    taskPrompt,
+    tools,
+    finishToolName,
+    extractResult,
+    tier = "workhorse",
+    maxTurns = 20,
+    maxTokens = 4096,
+    temperature = 0,
+    onToolResult
+  } = config;
+  log8.info(`starting sub-agent: ${name17}`, { maxTurns, tier });
+  const ctx = await buildAgentContext(storage);
+  const model = Provider.getModelForTier(tier);
+  const initialMessages = [
+    ...ctx.historyTurns,
+    { role: "user", content: `[SYSTEM TASK]
+
+${taskPrompt}` }
+  ];
+  const loopResult = await runAgentLoop({
+    model,
+    systemPrompt: ctx.systemPrompt,
+    initialMessages,
+    tools,
+    maxTokens,
+    temperature,
+    maxTurns,
+    isDone: stopOnTool(finishToolName),
+    onToolResult
+  });
+  log8.info(`sub-agent complete: ${name17}`, {
+    turnsUsed: loopResult.turnsUsed,
+    stopReason: loopResult.stopReason
+  });
+  return {
+    result: extractResult(),
+    turnsUsed: loopResult.turnsUsed,
+    usage: loopResult.usage,
+    stopReason: loopResult.stopReason
+  };
+}
+
+// src/reflection/tools.ts
 function buildSearchMessagesTool(ctx) {
   const { storage } = ctx;
   return tool({
@@ -35373,19 +35421,6 @@ ${marker17}${m.content}`;
     }
   });
 }
-function buildFinishReflectionTool(setAnswer) {
-  return tool({
-    description: "Complete the reflection and return your answer to the main agent.",
-    parameters: exports_external.object({
-      answer: exports_external.string().describe("Your answer or research findings. Be specific and include relevant details, quotes, or references.")
-    }),
-    execute: async ({ answer }) => {
-      activity.reflection.toolResult("finish_reflection", `${answer.length} chars`);
-      setAnswer(answer);
-      return "Reflection complete.";
-    }
-  });
-}
 function createLTMContext(storage, toolCallId) {
   const baseCtx = Tool.createContext({
     sessionID: "reflection",
@@ -35410,7 +35445,7 @@ function wrapLTMTool(ltmTool, toolName, storage, summarizeResult) {
     }
   });
 }
-function buildReflectionSearchTools(ctx) {
+function buildReflectionTools(ctx) {
   let answer = null;
   const tools = {
     search_messages: buildSearchMessagesTool(ctx),
@@ -35419,8 +35454,16 @@ function buildReflectionSearchTools(ctx) {
     ltm_read: wrapLTMTool(LTMReadTool, "ltm_read", ctx.storage, (output) => output.slice(0, 50)),
     ltm_glob: wrapLTMTool(LTMGlobTool, "ltm_glob", ctx.storage, (output) => `${output.split(`
 `).length} entries`),
-    finish_reflection: buildFinishReflectionTool((ans) => {
-      answer = ans;
+    finish_reflection: tool({
+      description: "Complete the reflection and return your answer to the main agent.",
+      parameters: exports_external.object({
+        answer: exports_external.string().describe("Your answer or research findings. Be specific and include relevant details, quotes, or references.")
+      }),
+      execute: async ({ answer: ans }) => {
+        activity.reflection.toolResult("finish_reflection", `${ans.length} chars`);
+        answer = ans;
+        return "Reflection complete.";
+      }
     })
   };
   return {
@@ -35430,8 +35473,6 @@ function buildReflectionSearchTools(ctx) {
 }
 
 // src/reflection/index.ts
-var log8 = Log.create({ service: "reflection-agent" });
-var MAX_REFLECTION_TURNS = 20;
 function buildReflectionPrompt(question) {
   return `## Reflection Mode
 
@@ -35459,39 +35500,24 @@ I'll search my memory now. Once I have enough information, I MUST call finish_re
 }
 async function runReflection(storage, question) {
   activity.reflection.start("Memory research", { question: question.slice(0, 50) });
-  const ctx = await buildAgentContext(storage);
-  const model = Provider.getModelForTier("workhorse");
-  const { tools, getAnswer } = buildReflectionSearchTools({ storage });
-  const taskPrompt = buildReflectionPrompt(question);
-  const initialMessages = [
-    ...ctx.historyTurns,
-    { role: "user", content: `[SYSTEM TASK]
-
-${taskPrompt}` }
-  ];
-  const loopResult = await runAgentLoop({
-    model,
-    systemPrompt: ctx.systemPrompt,
-    initialMessages,
+  const { tools, getAnswer } = buildReflectionTools({ storage });
+  const result = await runSubAgent(storage, {
+    name: "reflection",
+    taskPrompt: buildReflectionPrompt(question),
     tools,
-    maxTokens: 4096,
-    temperature: 0,
-    maxTurns: MAX_REFLECTION_TURNS,
-    isDone: stopOnTool("finish_reflection")
-  });
-  const answer = getAnswer();
-  if (!answer) {
-    log8.warn("reflection agent did not call finish_reflection", {
-      turnsUsed: loopResult.turnsUsed
-    });
-  }
-  const result = {
-    answer: answer ?? loopResult.finalText ?? "Unable to find relevant information.",
-    turnsUsed: loopResult.turnsUsed,
-    usage: loopResult.usage
+    finishToolName: "finish_reflection",
+    extractResult: getAnswer,
+    tier: "workhorse",
+    maxTurns: 20,
+    maxTokens: 4096
+  });
+  const answer = result.result ?? "Unable to find relevant information.";
+  activity.reflection.complete(`${result.turnsUsed} turns, ${answer.length} chars`);
+  return {
+    answer,
+    turnsUsed: result.turnsUsed,
+    usage: result.usage
   };
-  activity.reflection.complete(`${result.turnsUsed} turns, ${result.answer.length} chars`);
-  return result;
 }
 
 // src/tool/reflect.ts
@@ -35556,6 +35582,427 @@ var ReflectTool = Tool.define("reflect", {
     }
   }
 });
+// src/research/tools.ts
+var AGENT_TYPE = "research";
+function buildResearchTools(storage) {
+  const results = new Map;
+  const createLTMContext2 = (toolCallId) => {
+    const ctx = Tool.createContext({
+      sessionID: "research",
+      messageID: "research",
+      callID: toolCallId
+    });
+    ctx.extra = {
+      ltm: storage.ltm,
+      agentType: AGENT_TYPE
+    };
+    return ctx;
+  };
+  const createBaseContext = (toolCallId) => {
+    return Tool.createContext({
+      sessionID: "research",
+      messageID: "research",
+      callID: toolCallId
+    });
+  };
+  const tools = {};
+  tools.ltm_glob = tool({
+    description: LTMGlobTool.definition.description,
+    parameters: LTMGlobTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMGlobTool.definition.execute(args, createLTMContext2(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_search = tool({
+    description: LTMSearchTool.definition.description,
+    parameters: LTMSearchTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMSearchTool.definition.execute(args, createLTMContext2(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_read = tool({
+    description: LTMReadTool.definition.description,
+    parameters: LTMReadTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMReadTool.definition.execute(args, createLTMContext2(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_create = tool({
+    description: LTMCreateTool.definition.description,
+    parameters: LTMCreateTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMCreateTool.definition.execute(args, createLTMContext2(toolCallId));
+      const entryCreated = toolResult.output.startsWith("Created entry:");
+      results.set(toolCallId, {
+        output: toolResult.output,
+        done: false,
+        entryCreated,
+        slug: args.slug,
+        title: args.title
+      });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_update = tool({
+    description: LTMUpdateTool.definition.description,
+    parameters: LTMUpdateTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMUpdateTool.definition.execute(args, createLTMContext2(toolCallId));
+      const entryUpdated = toolResult.output.startsWith("Updated entry:");
+      results.set(toolCallId, {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_edit = tool({
+    description: LTMEditTool.definition.description,
+    parameters: LTMEditTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMEditTool.definition.execute(args, createLTMContext2(toolCallId));
+      const entryUpdated = toolResult.output.startsWith("Edited entry:");
+      results.set(toolCallId, {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_reparent = tool({
+    description: LTMReparentTool.definition.description,
+    parameters: LTMReparentTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMReparentTool.definition.execute(args, createLTMContext2(toolCallId));
+      const entryUpdated = toolResult.output.startsWith("Moved entry:");
+      results.set(toolCallId, {
+        output: toolResult.output,
+        done: false,
+        entryUpdated,
+        slug: args.slug
+      });
+      return toolResult.output;
+    }
+  });
+  tools.ltm_archive = tool({
+    description: LTMArchiveTool.definition.description,
+    parameters: LTMArchiveTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await LTMArchiveTool.definition.execute(args, createLTMContext2(toolCallId));
+      const entryArchived = toolResult.output.startsWith("Archived entry:");
+      results.set(toolCallId, {
+        output: toolResult.output,
+        done: false,
+        entryArchived,
+        slug: args.slug
+      });
+      return toolResult.output;
+    }
+  });
+  tools.search_messages = tool({
+    description: "Search conversation history using full-text search. Returns message snippets with matches highlighted.",
+    parameters: exports_external.object({
+      query: exports_external.string().describe("Search query - keywords to find in messages"),
+      limit: exports_external.number().optional().describe("Maximum results to return (default: 20)")
+    }),
+    execute: async ({ query, limit }, { toolCallId }) => {
+      const searchResults = await storage.temporal.searchFTS(query, limit ?? 20);
+      if (searchResults.length === 0) {
+        const output2 = `No messages found matching "${query}"`;
+        results.set(toolCallId, { output: output2, done: false });
+        return output2;
+      }
+      const formatted = searchResults.map((r) => `[${r.id}] (${r.type}) ${r.snippet}`).join(`
+
+`);
+      const output = `Found ${searchResults.length} messages:
+
+${formatted}`;
+      results.set(toolCallId, { output, done: false });
+      return output;
+    }
+  });
+  tools.get_message = tool({
+    description: "Get a specific message by ID, optionally with surrounding context messages.",
+    parameters: exports_external.object({
+      id: exports_external.string().describe("Message ID (e.g., msg_01ABC...)"),
+      contextBefore: exports_external.number().optional().describe("Number of messages to include before (default: 0)"),
+      contextAfter: exports_external.number().optional().describe("Number of messages to include after (default: 0)")
+    }),
+    execute: async ({ id, contextBefore, contextAfter }, { toolCallId }) => {
+      const messages = await storage.temporal.getMessageWithContext({
+        id,
+        contextBefore: contextBefore ?? 0,
+        contextAfter: contextAfter ?? 0
+      });
+      if (messages.length === 0) {
+        const output = `Message not found: ${id}`;
+        results.set(toolCallId, { output, done: false });
+        return output;
+      }
+      const formatted = messages.map((m) => {
+        const marker17 = m.id === id ? ">>> " : "    ";
+        return `${marker17}[${m.id}] (${m.type})
+${marker17}${m.content}`;
+      }).join(`
+
+`);
+      results.set(toolCallId, { output: formatted, done: false });
+      return formatted;
+    }
+  });
+  tools.web_search = tool({
+    description: WebSearchTool.definition.description,
+    parameters: WebSearchTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await WebSearchTool.definition.execute(args, createBaseContext(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.web_fetch = tool({
+    description: WebFetchTool.definition.description,
+    parameters: WebFetchTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await WebFetchTool.definition.execute(args, createBaseContext(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.glob = tool({
+    description: GlobTool.definition.description,
+    parameters: GlobTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await GlobTool.definition.execute(args, createBaseContext(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.read = tool({
+    description: ReadTool.definition.description,
+    parameters: ReadTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await ReadTool.definition.execute(args, createBaseContext(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.grep = tool({
+    description: GrepTool.definition.description,
+    parameters: GrepTool.definition.parameters,
+    execute: async (args, { toolCallId }) => {
+      const toolResult = await GrepTool.definition.execute(args, createBaseContext(toolCallId));
+      results.set(toolCallId, { output: toolResult.output, done: false });
+      return toolResult.output;
+    }
+  });
+  tools.finish_research = tool({
+    description: "Complete the research and return your findings to the main agent.",
+    parameters: exports_external.object({
+      report: exports_external.string().describe("Your research report. Include: 1) Summary of what you learned, 2) LTM entries created/updated with [[slug]] references, 3) Key sources consulted.")
+    }),
+    execute: async ({ report }, { toolCallId }) => {
+      results.set(toolCallId, { output: "Research complete.", done: true, report });
+      return "Research complete.";
+    }
+  });
+  return {
+    tools,
+    getLastResult: (toolCallId) => results.get(toolCallId)
+  };
+}
+
+// src/research/index.ts
+var MAX_RESEARCH_TURNS = 50;
+function buildResearchPrompt(topic) {
+  return `## Research Mode
+
+I am now in **research mode**. My task is to investigate a topic and build knowledge in my LTM.
+
+**Topic to research:**
+${topic}
+
+---
+
+### My Approach
+
+1. **Check existing knowledge** - What do I already know? (ltm_search, ltm_glob, ltm_read)
+2. **Search conversation history** - Have we discussed this before? (search_messages, get_message)
+3. **Research external sources** - What can I learn from the web? (web_search, web_fetch)
+4. **Read relevant code** - If it's about our codebase, look at the source (glob, read, grep)
+5. **Synthesize into LTM** - Create or update entries with what I learned (ltm_create, ltm_update)
+6. **Return a report** - Summarize findings and what was added (finish_research)
+
+### Guidelines
+
+- **Don't duplicate** - Search before creating. Update existing entries if relevant.
+- **Cross-link** - Use [[slug]] syntax to connect related entries.
+- **Cite sources** - Note where information came from (URLs, file paths, conversation IDs).
+- **Be thorough** - This is directed research, not a quick lookup. Take time to understand deeply.
+- **Focus on actionable knowledge** - What will help me work more effectively?
+
+### Tools Available
+
+**LTM (full access):**
+- \`ltm_glob(pattern)\` - Browse tree structure
+- \`ltm_search(query)\` - Find entries by keyword
+- \`ltm_read(slug)\` - Read full entry
+- \`ltm_create(slug, parentSlug, title, body)\` - Create new entry
+- \`ltm_update(slug, body, version)\` - Replace entry content
+- \`ltm_edit(slug, old, new, version)\` - Surgical edit
+- \`ltm_reparent(slug, newParentSlug, version)\` - Move entry
+- \`ltm_archive(slug, version)\` - Remove outdated entry
+
+**History:**
+- \`search_messages(query)\` - Full-text search in conversation history
+- \`get_message(id, contextBefore, contextAfter)\` - Get specific message with context
+
+**Web:**
+- \`web_search(query)\` - Search the web
+- \`web_fetch(url, question)\` - Read a webpage and extract info
+
+**Files:**
+- \`glob(pattern)\` - Find files matching pattern
+- \`read(filePath)\` - Read file contents
+- \`grep(pattern)\` - Search file contents
+
+**Control:**
+- \`finish_research(report)\` - Complete research and return findings
+
+---
+
+When done, call \`finish_research\` with a report that includes:
+1. Summary of what I learned
+2. What LTM entries I created or updated (with [[slug]] references)
+3. Key sources consulted
+
+Be thorough! This is research, not a quick answer.
+`;
+}
+async function runResearch(storage, topic) {
+  activity.research?.start?.("Research", { topic: topic.slice(0, 50) });
+  const result = {
+    report: "",
+    entriesCreated: [],
+    entriesUpdated: [],
+    turnsUsed: 0,
+    usage: { inputTokens: 0, outputTokens: 0 }
+  };
+  const { tools, getLastResult } = buildResearchTools(storage);
+  const subAgentResult = await runSubAgent(storage, {
+    name: "research",
+    taskPrompt: buildResearchPrompt(topic),
+    tools,
+    finishToolName: "finish_research",
+    extractResult: () => {
+      return result.report || null;
+    },
+    tier: "workhorse",
+    maxTurns: MAX_RESEARCH_TURNS,
+    maxTokens: 8192,
+    onToolResult: (toolCallId) => {
+      const toolResult = getLastResult(toolCallId);
+      if (!toolResult)
+        return;
+      if (toolResult.entryCreated && toolResult.slug) {
+        result.entriesCreated.push(toolResult.slug);
+      }
+      if (toolResult.entryUpdated && toolResult.slug) {
+        result.entriesUpdated.push(toolResult.slug);
+      }
+      if (toolResult.report) {
+        result.report = toolResult.report;
+      }
+    }
+  });
+  result.turnsUsed = subAgentResult.turnsUsed;
+  result.usage = subAgentResult.usage;
+  if (!result.report) {
+    result.report = "Research ended without explicit report.";
+  }
+  activity.research?.complete?.(`${result.turnsUsed} turns, ${result.entriesCreated.length} created, ${result.entriesUpdated.length} updated`);
+  return result;
+}
+
+// src/tool/research.ts
+var DESCRIPTION4 = `Investigate a topic and build knowledge in your long-term memory.
+
+This spawns a research sub-agent that can:
+- Search and update your long-term knowledge base
+- Search the web and fetch documentation
+- Search your conversation history
+- Read files in the codebase
+
+Use this when you need to:
+- Deeply understand something before implementing
+- Document a service, API, or system
+- Build a profile of a company or technology
+- Research best practices or prior art
+
+The sub-agent will research thoroughly and return a report of what it learned and what LTM entries it created or updated.`;
+var parameters4 = exports_external.object({
+  topic: exports_external.string().describe("The topic to research. Be specific about what you want to learn. Examples: 'How does Stripe's payment intent API work?', 'Document the authentication flow in our codebase', 'Research best practices for rate limiting'")
+});
+var ResearchTool = Tool.define("research", {
+  description: DESCRIPTION4,
+  parameters: parameters4,
+  async execute({ topic }, ctx) {
+    const storage = ctx.extra?.storage;
+    if (!storage) {
+      return {
+        output: "Error: Storage not available for research",
+        title: "Research failed",
+        metadata: {
+          topic,
+          turnsUsed: 0,
+          entriesCreated: [],
+          entriesUpdated: [],
+          inputTokens: 0,
+          outputTokens: 0
+        }
+      };
+    }
+    try {
+      const result = await runResearch(storage, topic);
+      return {
+        output: result.report,
+        title: `Researched: ${topic.slice(0, 40)}${topic.length > 40 ? "..." : ""}`,
+        metadata: {
+          topic,
+          turnsUsed: result.turnsUsed,
+          entriesCreated: result.entriesCreated,
+          entriesUpdated: result.entriesUpdated,
+          inputTokens: result.usage.inputTokens,
+          outputTokens: result.usage.outputTokens
+        }
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        output: `Research failed: ${errorMsg}`,
+        title: "Research error",
+        metadata: {
+          topic,
+          turnsUsed: 0,
+          entriesCreated: [],
+          entriesUpdated: [],
+          inputTokens: 0,
+          outputTokens: 0
+        }
+      };
+    }
+  }
+});
 // node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
   status: "aborted"
@@ -43913,7 +44360,7 @@ var Mcp;
 })(Mcp ||= {});
 
 // src/tool/mcp-status.ts
-var parameters4 = exports_external.object({});
+var parameters5 = exports_external.object({});
 var McpStatusTool = Tool.define("mcp_status", {
   description: `Inspect MCP (Model Context Protocol) server status.
 
@@ -43926,7 +44373,7 @@ Use this when:
 - A tool you expect isn't available
 - You want to see what MCP capabilities are configured
 - Debugging MCP connection issues`,
-  parameters: parameters4,
+  parameters: parameters5,
   async execute(_args, _ctx) {
     const status = Mcp.getStatus();
     const toolNames = Mcp.getToolNames();
@@ -44442,26 +44889,8 @@ var LTMTools = {
   ...LTMReadOnlyTools,
   ...LTMWriteTools
 };
-// src/ltm/consolidation.ts
-var log9 = Log.create({ service: "consolidation-agent" });
-var MAX_CONSOLIDATION_TURNS = 20;
-var AGENT_TYPE = "ltm-consolidate";
-function isConversationNoteworthy(messages) {
-  if (messages.length < 5) {
-    return false;
-  }
-  let hasToolUsage = false;
-  let hasSubstantialContent = false;
-  for (const msg of messages) {
-    if (msg.type === "tool_call" || msg.type === "tool_result") {
-      hasToolUsage = true;
-    }
-    if (msg.content.length > 200) {
-      hasSubstantialContent = true;
-    }
-  }
-  return hasToolUsage || hasSubstantialContent;
-}
+// src/ltm/tools.ts
+var AGENT_TYPE2 = "ltm-consolidate";
 function buildConsolidationTools(storage) {
   const results = new Map;
   const createLTMContext2 = (toolCallId) => {
@@ -44472,10 +44901,17 @@ function buildConsolidationTools(storage) {
     });
     ctx.extra = {
       ltm: storage.ltm,
-      agentType: AGENT_TYPE
+      agentType: AGENT_TYPE2
     };
     return ctx;
   };
+  const createBaseContext = (toolCallId) => {
+    return Tool.createContext({
+      sessionID: "consolidation",
+      messageID: "consolidation",
+      callID: toolCallId
+    });
+  };
   const tools = {};
   tools.ltm_read = tool({
     description: LTMReadTool.definition.description,
@@ -44628,12 +45064,7 @@ function buildConsolidationTools(storage) {
     description: ReadTool.definition.description,
     parameters: ReadTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
-      const ctx = Tool.createContext({
-        sessionID: "consolidation",
-        messageID: "consolidation",
-        callID: toolCallId
-      });
-      const toolResult = await ReadTool.definition.execute(args, ctx);
+      const toolResult = await ReadTool.definition.execute(args, createBaseContext(toolCallId));
       const result = { output: toolResult.output, done: false };
       results.set(toolCallId, result);
       return result.output;
@@ -44643,12 +45074,7 @@ function buildConsolidationTools(storage) {
     description: GlobTool.definition.description,
     parameters: GlobTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
-      const ctx = Tool.createContext({
-        sessionID: "consolidation",
-        messageID: "consolidation",
-        callID: toolCallId
-      });
-      const toolResult = await GlobTool.definition.execute(args, ctx);
+      const toolResult = await GlobTool.definition.execute(args, createBaseContext(toolCallId));
       const result = { output: toolResult.output, done: false };
       results.set(toolCallId, result);
       return result.output;
@@ -44658,12 +45084,7 @@ function buildConsolidationTools(storage) {
     description: GrepTool.definition.description,
     parameters: GrepTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
-      const ctx = Tool.createContext({
-        sessionID: "consolidation",
-        messageID: "consolidation",
-        callID: toolCallId
-      });
-      const toolResult = await GrepTool.definition.execute(args, ctx);
+      const toolResult = await GrepTool.definition.execute(args, createBaseContext(toolCallId));
       const result = { output: toolResult.output, done: false };
       results.set(toolCallId, result);
       return result.output;
@@ -44673,12 +45094,7 @@ function buildConsolidationTools(storage) {
     description: WebSearchTool.definition.description,
     parameters: WebSearchTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
-      const ctx = Tool.createContext({
-        sessionID: "consolidation",
-        messageID: "consolidation",
-        callID: toolCallId
-      });
-      const toolResult = await WebSearchTool.definition.execute(args, ctx);
+      const toolResult = await WebSearchTool.definition.execute(args, createBaseContext(toolCallId));
       const result = { output: toolResult.output, done: false };
       results.set(toolCallId, result);
       return result.output;
@@ -44688,12 +45104,7 @@ function buildConsolidationTools(storage) {
     description: WebFetchTool.definition.description,
     parameters: WebFetchTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
-      const ctx = Tool.createContext({
-        sessionID: "consolidation",
-        messageID: "consolidation",
-        callID: toolCallId
-      });
-      const toolResult = await WebFetchTool.definition.execute(args, ctx);
+      const toolResult = await WebFetchTool.definition.execute(args, createBaseContext(toolCallId));
       const result = { output: toolResult.output, done: false };
       results.set(toolCallId, result);
       return result.output;
@@ -44715,7 +45126,27 @@ function buildConsolidationTools(storage) {
     getLastResult: (toolCallId) => results.get(toolCallId)
   };
 }
-async function buildLTMReviewTurn(storage, recentlyUpdatedEntries) {
+
+// src/ltm/consolidation.ts
+var log9 = Log.create({ service: "consolidation-agent" });
+var MAX_CONSOLIDATION_TURNS = 20;
+function isConversationNoteworthy(messages) {
+  if (messages.length < 5) {
+    return false;
+  }
+  let hasToolUsage = false;
+  let hasSubstantialContent = false;
+  for (const msg of messages) {
+    if (msg.type === "tool_call" || msg.type === "tool_result") {
+      hasToolUsage = true;
+    }
+    if (msg.content.length > 200) {
+      hasSubstantialContent = true;
+    }
+  }
+  return hasToolUsage || hasSubstantialContent;
+}
+async function buildLTMReviewPrompt(storage, recentlyUpdatedEntries) {
   const allEntries = await storage.ltm.glob("/**");
   const treeView = renderCompactTree(allEntries, 3);
   let content = `## Knowledge Base Curation Task
@@ -44772,46 +45203,6 @@ ${recentlyUpdatedEntries.map((e) => `- **${e.slug}**: ${e.title}`).join(`
 - \u2713 "Tool pattern: parameters must be defined BEFORE Tool.define() call due to initialization order"
 - \u2717 "The config module handles configuration" (too obvious, adds no value)
 
-**When to document code structure:**
-- Complex modules with non-obvious responsibilities
-- Files that interact in subtle ways
-- Patterns that took effort to understand
-- Entry points and key abstractions
-
----
-
-### Curation Tasks (do these!)
-
-**Organize the tree:**
-- Group related entries under parent paths
-- Create small "index" entries that just organize children (this is fine!)
-- A flat list of 20 entries is hard to navigate - a tree is better
-
-Example structure:
-  /miriad-code           <- index entry: "My codebase - architecture and patterns"
-    /protocol            <- NDJSON protocol details
-    /memory-system       <- temporal, LTM, distillation
-  /user                  <- index entry: "Working with Simen"
-    /preferences         <- simplicity over compat, incremental refactoring
-  /integrations          <- index entry: "External systems"
-    /mcp                 <- MCP protocol, config resolution
-
-**Cross-link for findability:**
-- Use [[slug]] syntax to connect related entries
-- Ask: "If I search for X, will I find this?"
-- Index entries can list their children with [[links]]
-
-**Maintain quality:**
-- Combine entries that overlap significantly
-- Split entries that cover too many topics
-- Archive entries that are outdated or wrong
-- Update entries with new information
-
-**Enrich with research:**
-- Use web_search/web_fetch to fact-check or fill gaps
-- Look up documentation for libraries/APIs you reference
-- Verify assumptions about external systems
-
 ---
 
 ### Tools Available
@@ -44827,10 +45218,6 @@ Example structure:
 - \`ltm_rename(slug, newSlug, version)\` - Change entry slug
 - \`ltm_archive(slug, version)\` - Remove outdated entry
 
-To create a tree:
-1. Create parent first: \`ltm_create("miriad-code", null, "My Codebase", "Index of codebase knowledge...")\`
-2. Create children with parentSlug: \`ltm_create("protocol", "miriad-code", "Protocol", "...")\`
-
 **Codebase Research:**
 - \`read(filePath)\` - Read a file to verify/enrich knowledge
 - \`glob(pattern)\` - Find files matching pattern
@@ -44840,12 +45227,6 @@ To create a tree:
 - \`web_search(query)\` - Search the web for information
 - \`web_fetch(url, question)\` - Read a webpage and extract info
 
-Use codebase tools to:
-- Verify file paths in entries still exist
-- Check if documented patterns are still accurate
-- Explore related files to build richer documentation
-- Confirm technical details before recording them
-
 ---
 
 ### Special Entries: /identity and /behavior
@@ -44860,16 +45241,12 @@ This frames everything you do. It's how you understand yourself in relationship
 - Other agents or entities you interact with
 - Your own nature and capabilities
 
-This is actionable because it helps you form lasting relationships and maintain continuity. Update it as your understanding deepens.
-
 **/behavior** - How you operate
 - User preferences you've learned
 - Working patterns that work well
 - Guidelines for code quality, testing, commits
 - Communication style preferences
 
-Review these entries periodically. Are they accurate? Complete? Do they reflect what you've learned?
-
 ---
 
 ### Your Task
@@ -44881,12 +45258,11 @@ Review these entries periodically. Are they accurate? Complete? Do they reflect
 
 ### 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).
+When you call \`finish_consolidation\`, write a brief note to your future self explaining what you captured and why it matters.
 
 **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]]."
+- "Updated [[user-preferences]] with the new testing philosophy - run tests before committing."
 
 **Avoid mechanical summaries**:
 - \u2717 "Created 2 entries, updated 1 entry"
@@ -44915,55 +45291,50 @@ async function runConsolidation(storage, messages) {
   }
   result.ran = true;
   log9.info("starting consolidation", { messageCount: messages.length });
-  const ctx = await buildAgentContext(storage);
   const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
   const allEntries = await storage.ltm.glob("/**");
   const recentlyUpdated = allEntries.filter((e) => e.updatedAt > oneHourAgo && e.slug !== "identity" && e.slug !== "behavior");
-  const reviewTurnContent = await buildLTMReviewTurn(storage, recentlyUpdated);
-  const model = Provider.getModelForTier("workhorse");
+  const taskPrompt = await buildLTMReviewPrompt(storage, recentlyUpdated);
   const { tools, getLastResult } = buildConsolidationTools(storage);
-  const initialMessages = [
-    ...ctx.historyTurns,
-    { role: "user", content: `[SYSTEM TASK]
-
-${reviewTurnContent}` }
-  ];
-  const loopResult = await runAgentLoop({
-    model,
-    systemPrompt: ctx.systemPrompt,
-    initialMessages,
+  const subAgentResult = await runSubAgent(storage, {
+    name: "ltm-curator",
+    taskPrompt,
     tools,
-    maxTokens: 2048,
-    temperature: 0,
+    finishToolName: "finish_consolidation",
+    extractResult: () => {
+      return result.summary;
+    },
+    tier: "workhorse",
     maxTurns: MAX_CONSOLIDATION_TURNS,
-    isDone: stopOnTool("finish_consolidation"),
+    maxTokens: 2048,
     onToolResult: (toolCallId) => {
       const toolResult = getLastResult(toolCallId);
-      if (toolResult?.entryCreated) {
+      if (!toolResult)
+        return;
+      if (toolResult.entryCreated) {
         result.entriesCreated++;
         if (toolResult.slug) {
           result.details.push(`Created [[${toolResult.slug}]]${toolResult.title ? ` - ${toolResult.title}` : ""}`);
         }
       }
-      if (toolResult?.entryUpdated) {
+      if (toolResult.entryUpdated) {
         result.entriesUpdated++;
         if (toolResult.slug) {
           result.details.push(`Updated [[${toolResult.slug}]]`);
         }
       }
-      if (toolResult?.entryArchived) {
+      if (toolResult.entryArchived) {
         result.entriesArchived++;
         if (toolResult.slug) {
           result.details.push(`Archived [[${toolResult.slug}]]`);
         }
       }
-      if (toolResult?.summary) {
+      if (toolResult.summary) {
         result.summary = toolResult.summary;
       }
     }
   });
-  result.usage.inputTokens += loopResult.usage.inputTokens;
-  result.usage.outputTokens += loopResult.usage.outputTokens;
+  result.usage = subAgentResult.usage;
   if (!result.summary) {
     result.summary = "Consolidation ended without explicit finish";
   }
@@ -45252,6 +45623,16 @@ function createToolContextFactory(storage, sessionId, messageId, abortSignal) {
         storage
       };
       return ctx;
+    },
+    createResearchContext(callId) {
+      const ctx = Tool.createContext({
+        ...baseContext,
+        callID: callId
+      });
+      ctx.extra = {
+        storage
+      };
+      return ctx;
     }
   };
 }
@@ -45369,6 +45750,11 @@ function buildTools(storage, sessionId, messageId, abortSignal) {
     parameters: ReflectTool.definition.parameters,
     execute: async (args, { toolCallId }) => safeExecute("reflect", () => ReflectTool.definition.execute(args, factory.createReflectContext(toolCallId)))
   });
+  tools.research = tool({
+    description: ResearchTool.definition.description,
+    parameters: ResearchTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("research", () => ResearchTool.definition.execute(args, factory.createResearchContext(toolCallId)))
+  });
   return tools;
 }
 async function initializeMcp() {
@@ -46805,8 +47191,8 @@ async function runRepl(options) {
 }
 
 // src/version.ts
-var VERSION = "0.1.12";
-var GIT_HASH = "712107d";
+var VERSION = "0.1.13";
+var GIT_HASH = "1d9eea4";
 var VERSION_STRING = `miriad-code v${VERSION} (${GIT_HASH})`;
 
 // src/cli/index.ts

package/package.json

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