niahere 0.2.44 → 0.2.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.44",
+  "version": "0.2.45",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/chat/engine.ts

@@ -10,6 +10,7 @@ import { getAgentDefinitions } from "../core/agents";
 import { Session, Message, ActiveEngine } from "../db/models";
 import type { Attachment, SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "../types";
 import { truncate, formatToolUse } from "../utils/format-activity";
+import { consolidateSession } from "../core/consolidator";
 import { log } from "../utils/log";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
@@ -133,6 +134,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
   let longRunningTimer: ReturnType<typeof setTimeout> | null = null;
   let longRunningWarned = false;
   let alive = false;
+  let messageCount = 0;
 
   function clearIdleTimer() {
     if (idleTimer) {
@@ -143,12 +145,18 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
   function resetIdleTimer() {
     clearIdleTimer();
-    idleTimer = setTimeout(() => {
+    idleTimer = setTimeout(async () => {
       if (pending) {
         // Don't tear down while a request is in flight
         log.warn({ room }, "idle timer fired while request pending, skipping teardown");
         return;
       }
+      // Memory consolidation — "hippocampal replay" before sleep
+      if (sessionId && messageCount > 0) {
+        consolidateSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "consolidation failed during idle teardown");
+        });
+      }
       teardown();
     }, IDLE_TIMEOUT);
   }
@@ -239,6 +247,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                 content: pending.userMessage,
                 isFromAgent: false,
               });
+              messageCount++;
             }
           }
 
@@ -406,6 +415,12 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     },
 
     close() {
+      // Memory consolidation on explicit close (skip if mid-turn — transcript is incomplete)
+      if (sessionId && messageCount > 0 && !pending) {
+        consolidateSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "consolidation failed during close");
+        });
+      }
       teardown();
       ActiveEngine.unregister(room).catch(() => {});
     },

package/src/core/consolidator.ts

@@ -0,0 +1,138 @@
+/**
+ * Memory consolidator — "hippocampal replay" for Nia.
+ *
+ * After a chat session goes idle or a job completes, this module reviews
+ * what happened and saves memories worth keeping.
+ *
+ * This decouples memory formation from task execution: during a conversation,
+ * the agent focuses on the task. Afterward, a background pass extracts what's
+ * worth remembering — just like the brain consolidates memories during sleep.
+ *
+ * The consolidator uses the same agent loop as cron jobs — full Nia system
+ * prompt, full tool access, same runner. It's just a specialized job.
+ *
+ * Research basis:
+ * - LangChain: "background" memory formation avoids latency + competing optimization pressures
+ * - Mem0: LLM-driven extraction with ADD/UPDATE/NOOP decisions against existing memories
+ * - Cognitive science: hippocampal replay consolidates experiences after the fact, not during
+ */
+
+import { Message } from "../db/models";
+import { buildSystemPrompt } from "../chat/identity";
+import { runJobWithClaude } from "./runner";
+import { log } from "../utils/log";
+import { homedir } from "os";
+import type { SessionMessage } from "../types";
+
+/** Track sessions already consolidated to prevent double runs. */
+const consolidated = new Set<string>();
+
+/** Max messages to include in transcript (most recent). Keeps prompt size bounded. */
+const MAX_TRANSCRIPT_MESSAGES = 50;
+
+/** Rooms to skip (placeholder sessions). */
+function shouldSkip(room: string): boolean {
+  return room.includes("placeholder");
+}
+
+/** Format conversation transcript for the extraction prompt. Cap to recent messages. */
+function formatTranscript(messages: SessionMessage[]): string {
+  const recent = messages.slice(-MAX_TRANSCRIPT_MESSAGES);
+  const skipped = messages.length - recent.length;
+  const prefix = skipped > 0 ? `[...${skipped} earlier messages omitted]\n\n` : "";
+
+  return prefix + recent
+    .map((m) => `[${m.sender}] (${m.createdAt}): ${m.content.slice(0, 2000)}`)
+    .join("\n\n");
+}
+
+/** Build the extraction prompt from a conversation transcript. */
+function buildConsolidationPrompt(transcript: string, source: string): string {
+  return `Job: memory-consolidation (triggered by ${source})
+
+You just finished a session. It has gone idle.
+Your task: review the transcript below and save anything worth keeping for future sessions.
+
+## Transcript
+${transcript}
+
+## Instructions
+1. First, read your existing memories (read_memory tool) and rules (read rules.md) to avoid duplicates
+2. Review the transcript for things worth persisting. Use the RIGHT tool for each:
+
+   **Use add_memory for FACTS** (nouns — things that are true):
+   - People: names, roles, orgs, relationships
+   - Decisions: what was decided or agreed on
+   - Technical facts: system details, API quirks, config gotchas
+   - Patterns: recurring issues, user behaviors, workflow tendencies
+   - Events: travel, deadlines, incidents, milestones with dates
+
+   **Use add_rule for INSTRUCTIONS** (verbs — how to behave):
+   - User corrected your tone, format, or approach
+   - User said "from now on" / "always" / "never" / "stop doing X"
+   - User expressed a preference about how you communicate or work
+
+3. Skip anything already in existing memories or rules (no duplicates)
+4. Skip small talk, greetings, conversational filler
+5. Skip transient state ("currently working on X")
+6. Quality over quantity — saving nothing is fine if the conversation was trivial
+7. If existing memories are outdated based on new info, note what should be updated
+
+Do NOT message the user about this. Save silently and report a brief summary of what you saved.`;
+}
+
+/** Run the consolidation agent loop. */
+async function runConsolidation(transcript: string, source: string): Promise<void> {
+  const systemPrompt = buildSystemPrompt("job");
+  const jobPrompt = buildConsolidationPrompt(transcript, source);
+  const output = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
+
+  if (output.error) {
+    log.error({ source, error: output.error }, "consolidator: extraction failed");
+  } else {
+    log.info({ source, resultChars: output.agentText.length }, "consolidator: done");
+  }
+}
+
+/**
+ * Consolidate a chat session's conversation into memories.
+ * Called when a chat engine goes idle or is explicitly closed.
+ */
+export async function consolidateSession(sessionId: string, room: string): Promise<void> {
+  if (shouldSkip(room)) return;
+  if (consolidated.has(sessionId)) return;
+  consolidated.add(sessionId);
+
+  try {
+    const messages = await Message.getBySession(sessionId);
+    if (messages.length < 2) return;
+
+    log.info({ sessionId, room, messageCount: messages.length }, "consolidator: extracting memories from chat");
+
+    const transcript = formatTranscript(messages);
+    await runConsolidation(transcript, `chat session idle — ${room}`);
+  } catch (err) {
+    log.error({ err, sessionId, room }, "consolidator: chat extraction failed");
+  }
+}
+
+/**
+ * Consolidate a job run's output into memories.
+ * Called after a job completes in the runner.
+ */
+export async function consolidateJobRun(jobName: string, jobPrompt: string, result: string): Promise<void> {
+  // Skip if the job itself is the consolidator (prevent infinite loop)
+  if (jobName === "memory-consolidation") return;
+
+  const transcript = `[job-prompt]: ${jobPrompt}\n\n[job-result]: ${result}`;
+
+  // Skip trivial results
+  if (result.length < 50) return;
+
+  try {
+    log.info({ jobName, resultChars: result.length }, "consolidator: extracting memories from job");
+    await runConsolidation(transcript, `job run — ${jobName}`);
+  } catch (err) {
+    log.error({ err, jobName }, "consolidator: job extraction failed");
+  }
+}

package/src/core/runner.ts

@@ -257,6 +257,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     writeState(freshState);
 
+    // Memory consolidation — review what the job learned (fire-and-forget)
+    if (ok && result.result) {
+      import("./consolidator").then(({ consolidateJobRun }) => {
+        consolidateJobRun(job.name, jobPrompt, result.result).catch(() => {});
+      }).catch(() => {});
+    }
+
     return result;
   } catch (err) {
     const duration_ms = Math.round(performance.now() - startMs);