niahere 0.2.45 → 0.2.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.45",
+  "version": "0.2.47",
   "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

@@ -5,12 +5,13 @@ import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
-import { buildSystemPrompt } from "./identity";
+import { buildSystemPrompt, getSessionContext } from "./identity";
 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 { summarizeSession } from "../core/summarizer";
 import { log } from "../utils/log";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
@@ -112,7 +113,14 @@ function sessionFileExists(sessionId: string, cwd: string): boolean {
 
 export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine> {
   const { room, channel, resume, mcpServers } = opts;
-  const systemPrompt = buildSystemPrompt("chat", channel);
+  let systemPrompt = buildSystemPrompt("chat", channel);
+
+  // Inject recent session summaries for continuity
+  const sessionContext = await getSessionContext(room);
+  if (sessionContext) {
+    systemPrompt += "\n\n" + sessionContext;
+  }
+
   const cwd = homedir();
 
   let sessionId: string | null = null;
@@ -151,11 +159,14 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         log.warn({ room }, "idle timer fired while request pending, skipping teardown");
         return;
       }
-      // Memory consolidation — "hippocampal replay" before sleep
+      // Memory consolidation + session summary before "sleep"
       if (sessionId && messageCount > 0) {
         consolidateSession(sessionId, room).catch((err) => {
           log.error({ err, room }, "consolidation failed during idle teardown");
         });
+        summarizeSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "session summary failed during idle teardown");
+        });
       }
       teardown();
     }, IDLE_TIMEOUT);
@@ -415,11 +426,14 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     },
 
     close() {
-      // Memory consolidation on explicit close (skip if mid-turn — transcript is incomplete)
+      // Memory consolidation + session summary on explicit close
       if (sessionId && messageCount > 0 && !pending) {
         consolidateSession(sessionId, room).catch((err) => {
           log.error({ err, room }, "consolidation failed during close");
         });
+        summarizeSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "session summary failed during close");
+        });
       }
       teardown();
       ActiveEngine.unregister(room).catch(() => {});

package/src/chat/identity.ts

@@ -4,6 +4,7 @@ import { getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
 import { getSkillsSummary } from "../core/skills";
 import { getAgentsSummary } from "../core/agents";
+import { Session } from "../db/models";
 import type { Mode } from "../types";
 
 // Re-export for backwards compat
@@ -43,3 +44,23 @@ export function buildSystemPrompt(mode: Mode = "chat", channel: string = "termin
 
   return parts.join("\n\n");
 }
+
+/**
+ * Load recent session summaries for a room and format as a context block.
+ * Returns empty string if no summaries are available.
+ */
+export async function getSessionContext(room: string): Promise<string> {
+  try {
+    const summaries = await Session.getRecentSummaries(room, 3);
+    if (summaries.length === 0) return "";
+
+    const lines = summaries
+      .reverse() // oldest first
+      .map((s) => `- (${s.updatedAt}): ${s.summary}`)
+      .join("\n");
+
+    return `## Recent Session Context\nBrief summaries of your last few sessions in this room — use for continuity:\n${lines}`;
+  } catch {
+    return "";
+  }
+}

package/src/core/consolidator.ts

@@ -18,10 +18,8 @@
  */
 
 import { Message } from "../db/models";
-import { buildSystemPrompt } from "../chat/identity";
-import { runJobWithClaude } from "./runner";
+import { runTask } from "./runner";
 import { log } from "../utils/log";
-import { homedir } from "os";
 import type { SessionMessage } from "../types";
 
 /** Track sessions already consolidated to prevent double runs. */
@@ -83,15 +81,10 @@ Do NOT message the user about this. Save silently and report a brief summary of
 
 /** 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");
-  }
+  await runTask({
+    name: "consolidator",
+    prompt: buildConsolidationPrompt(transcript, source),
+  });
 }
 
 /**

package/src/core/runner.ts

@@ -9,6 +9,9 @@ import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
 import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
+import { getMcpServers } from "../mcp";
+import { ActiveEngine } from "../db/models";
+import { log } from "../utils/log";
 
 export type ActivityCallback = (line: string) => void;
 
@@ -87,14 +90,21 @@ export async function runJobWithClaude(
     };
   }
 
+  const options: Record<string, unknown> = {
+    systemPrompt,
+    cwd,
+    permissionMode: "bypassPermissions",
+    sessionId,
+  };
+
+  const mcpServers = getMcpServers();
+  if (mcpServers) {
+    options.mcpServers = mcpServers;
+  }
+
   const handle = query({
     prompt: singleMessage() as any,
-    options: {
-      systemPrompt,
-      cwd,
-      permissionMode: "bypassPermissions",
-      sessionId,
-    } as any,
+    options: options as any,
   });
 
   let agentText = "";
@@ -178,6 +188,40 @@ export async function runJobWithClaude(
   return { agentText, sessionId: actualSessionId };
 }
 
+// ---------------------------------------------------------------------------
+// Background task runner — tracked one-shot agent with full Nia personality
+// ---------------------------------------------------------------------------
+
+export interface TaskOptions {
+  /** Task name — used for ActiveEngine tracking as _system/{name}. */
+  name: string;
+  /** The prompt/instruction for the task. */
+  prompt: string;
+  /** System prompt override. Defaults to buildSystemPrompt("job"). */
+  systemPrompt?: string;
+}
+
+/**
+ * Run a background agent task with ActiveEngine tracking and MCP tools.
+ * Use for consolidator, summarizer, and any future background work.
+ */
+export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
+  const room = `_system/${opts.name}`;
+  await ActiveEngine.register(room, "system").catch(() => {});
+  try {
+    const systemPrompt = opts.systemPrompt || buildSystemPrompt("job");
+    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir());
+    if (output.error) {
+      log.error({ task: opts.name, error: output.error }, "task failed");
+    } else {
+      log.info({ task: opts.name, resultChars: output.agentText.length }, "task completed");
+    }
+    return output;
+  } finally {
+    await ActiveEngine.unregister(room).catch(() => {});
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

package/src/core/summarizer.ts

@@ -0,0 +1,81 @@
+/**
+ * Session summarizer — generates a brief handoff note when a session ends.
+ *
+ * Separate from memory consolidation. The consolidator extracts durable facts
+ * (memories/rules). The summarizer produces a short, ephemeral context bridge
+ * so the next session knows what just happened.
+ *
+ * Summaries are stored directly in the sessions table (summary column) via SQL.
+ * The last few summaries are injected into buildSystemPrompt() so new sessions
+ * have continuity without needing full transcript access.
+ */
+
+import { Message, Session } from "../db/models";
+import { runTask } from "./runner";
+import { log } from "../utils/log";
+import type { SessionMessage } from "../types";
+
+/** Track sessions already summarized to prevent double runs. */
+const summarized = new Set<string>();
+
+/** Max messages to include (most recent). */
+const MAX_MESSAGES = 30;
+
+/** Format transcript for the summarization prompt. */
+function formatTranscript(messages: SessionMessage[]): string {
+  const recent = messages.slice(-MAX_MESSAGES);
+  return recent
+    .map((m) => `[${m.sender}]: ${m.content.slice(0, 1000)}`)
+    .join("\n");
+}
+
+/**
+ * Summarize a session and store the result in the sessions table.
+ * Called when a chat engine goes idle — produces a context bridge for the next session.
+ */
+export async function summarizeSession(sessionId: string, room: string): Promise<void> {
+  if (room.includes("placeholder")) return;
+  if (summarized.has(sessionId)) return;
+  summarized.add(sessionId);
+
+  try {
+    const messages = await Message.getBySession(sessionId);
+    if (messages.length < 2) return;
+
+    log.info({ sessionId, room, messageCount: messages.length }, "summarizer: generating session summary");
+
+    const transcript = formatTranscript(messages);
+
+    const prompt = `Job: session-summary (triggered by session idle in ${room})
+
+Generate a brief session summary. This will be shown to your future self at the start of the next session for continuity.
+
+## Conversation
+${transcript}
+
+## Instructions
+Write a 2-4 sentence summary covering:
+- What was discussed or worked on
+- Any decisions made or outcomes reached
+- Anything pending or unresolved
+
+Keep it concise — a handoff note, not a report. Output ONLY the summary text.`;
+
+    const output = await runTask({ name: "summarizer", prompt });
+
+    if (output.error) {
+      log.error({ sessionId, room, error: output.error }, "summarizer: failed");
+      return;
+    }
+
+    const summary = output.agentText.trim();
+    if (summary && summary.length > 10 && summary.length < 2000) {
+      await Session.setSummary(sessionId, summary);
+      log.info({ sessionId, room, summaryChars: summary.length }, "summarizer: saved");
+    } else {
+      log.warn({ sessionId, room, length: summary.length }, "summarizer: output too short or too long, skipped");
+    }
+  } catch (err) {
+    log.error({ err, sessionId, room }, "summarizer: failed");
+  }
+}

package/src/db/migrations/009_session_summary.ts

@@ -0,0 +1,7 @@
+import type postgres from "postgres";
+
+export const name = "009_session_summary";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`ALTER TABLE sessions ADD COLUMN IF NOT EXISTS summary TEXT`;
+}

package/src/db/models/session.ts

@@ -88,6 +88,31 @@ export async function touch(id: string): Promise<void> {
   await sql`UPDATE sessions SET updated_at = NOW() WHERE id = ${id}`;
 }
 
+export async function setSummary(id: string, summary: string): Promise<void> {
+  const sql = getSql();
+  await sql`UPDATE sessions SET summary = ${summary} WHERE id = ${id}`;
+}
+
+export async function getRecentSummaries(room: string, limit = 3): Promise<Array<{ summary: string; updatedAt: string }>> {
+  const sql = getSql();
+  // Match summaries from sessions in the same channel (e.g. slack-dm-U...-*)
+  // by extracting the room prefix (everything before the last -N index)
+  const prefix = room.replace(/-\d+$/, "");
+  const rows = await sql`
+    SELECT summary, updated_at
+    FROM sessions
+    WHERE room LIKE ${prefix + "-%"}
+      AND summary IS NOT NULL
+      AND id != ${""}
+    ORDER BY updated_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.map((r) => ({
+    summary: String(r.summary),
+    updatedAt: String(r.updated_at),
+  }));
+}
+
 export async function getLatestRoomIndex(prefix: string): Promise<number> {
   const sql = getSql();
   const rows = await sql`