niahere 0.2.60 → 0.2.61

package/src/core/daemon.ts

@@ -12,6 +12,7 @@ import { startScheduler, stopScheduler, recomputeAllNextRuns } from "./scheduler
 import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
 import { setMcpFactory } from "../mcp";
+import { processPending, cleanupOldRequests } from "./finalizer";
 
 export function writePid(pid: number): void {
   const { pid: pidPath } = getPaths();
@@ -107,7 +108,9 @@ function waitForExit(timeoutMs: number): void {
   // Still alive — escalate to SIGKILL
   const remaining = findDaemonPids();
   for (const pid of remaining) {
-    try { process.kill(pid, "SIGKILL"); } catch {}
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
   }
 
   // Brief wait for SIGKILL to take effect
@@ -124,7 +127,8 @@ export function findDaemonPids(): number[] {
     const result = Bun.spawnSync(["pgrep", "-f", "src/cli\\.ts run$"]);
     const stdout = new TextDecoder().decode(result.stdout).trim();
     if (!stdout) return [];
-    return stdout.split("\n")
+    return stdout
+      .split("\n")
       .map((l) => parseInt(l, 10))
       .filter((pid) => !isNaN(pid) && pid !== process.pid);
   } catch {
@@ -138,7 +142,9 @@ function killAllDaemons(knownPid?: number | null): number {
   if (knownPid && knownPid !== process.pid) toKill.add(knownPid);
 
   for (const pid of toKill) {
-    try { process.kill(pid, "SIGTERM"); } catch {}
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
   }
   return toKill.size;
 }
@@ -189,10 +195,20 @@ export async function runDaemon(): Promise<void> {
     const { version } = await import("../../package.json");
     const update = await checkForUpdate(version);
     if (update) {
-      log.warn({ current: update.current, latest: update.latest }, "update available — run `npm i -g niahere` to update");
+      log.warn(
+        { current: update.current, latest: update.latest },
+        "update available — run `npm i -g niahere` to update",
+      );
     }
   } catch {}
 
+  // Ensure watches dir exists — used for file-backed watch behaviors and
+  // per-watch working memory. Safe to call on every startup.
+  try {
+    mkdirSync(getPaths().watchesDir, { recursive: true });
+  } catch (err) {
+    log.warn({ err }, "failed to ensure watches dir");
+  }
 
   // Startup recovery
   try {
@@ -260,6 +276,35 @@ export async function runDaemon(): Promise<void> {
     log.warn({ err }, "could not subscribe to nia_jobs, falling back to SIGHUP only");
   }
 
+  // Listen for session finalization requests from CLI processes
+  try {
+    const sql = getSql();
+    await sql.listen("nia_finalize", async () => {
+      log.info("finalization request received via NOTIFY, processing pending");
+      await processPending().catch((err) => {
+        log.warn({ err }, "failed to process pending finalizations on notify");
+      });
+    });
+    log.info("listening for finalization requests on nia_finalize channel");
+  } catch (err) {
+    log.warn({ err }, "could not subscribe to nia_finalize");
+  }
+
+  // Drain any finalization requests that arrived while daemon was down
+  processPending().catch((err) => {
+    log.warn({ err }, "startup: failed to drain pending finalizations");
+  });
+
+  // Clean up old finalization requests every 24h
+  setInterval(
+    () => {
+      cleanupOldRequests().catch((err) => {
+        log.warn({ err }, "failed to cleanup old finalization requests");
+      });
+    },
+    24 * 60 * 60 * 1000,
+  );
+
   // SIGHUP: reload config, reconcile channels, recompute jobs
   process.on("SIGHUP", async () => {
     log.info("received SIGHUP, reloading config");

package/src/core/finalizer.ts

@@ -0,0 +1,125 @@
+/**
+ * Unified session finalizer — durable queue for post-session work.
+ *
+ * All callers use finalizeSession() instead of calling consolidator/summarizer
+ * directly. The function writes a row to finalization_requests and fires
+ * pg_notify('nia_finalize') to wake the daemon. That's it — all processing
+ * happens in the daemon via processPending().
+ */
+
+import { getSql } from "../db/connection";
+import { consolidateSession } from "./consolidator";
+import { summarizeSession } from "./summarizer";
+import { log } from "../utils/log";
+
+/** Enqueue a session for finalization. Always returns immediately. */
+export async function finalizeSession(sessionId: string, room: string): Promise<void> {
+  const sql = getSql();
+
+  // Get current message count for idempotency
+  const countRows = await sql`
+    SELECT COUNT(*)::int AS count FROM messages WHERE session_id = ${sessionId}
+  `;
+  const messageCount = countRows[0]?.count ?? 0;
+  if (messageCount < 2) return;
+
+  // Cancel any pending request for this session (session resumed or new close)
+  await sql`
+    DELETE FROM finalization_requests
+    WHERE session_id = ${sessionId} AND status = 'pending'
+  `;
+
+  // Skip if already done/processing for this exact message count
+  const existing = await sql`
+    SELECT id FROM finalization_requests
+    WHERE session_id = ${sessionId}
+      AND message_count = ${messageCount}
+      AND status IN ('done', 'processing')
+    LIMIT 1
+  `;
+  if (existing.length > 0) return;
+
+  // Insert new request
+  await sql`
+    INSERT INTO finalization_requests (session_id, room, message_count, status)
+    VALUES (${sessionId}, ${room}, ${messageCount}, 'pending')
+  `;
+
+  // Wake the daemon
+  await sql.notify("nia_finalize", sessionId).catch((err) => {
+    log.warn({ err, sessionId }, "finalizer: pg_notify failed (daemon may not be running)");
+  });
+}
+
+/** Cancel pending finalization for a session (e.g. session resumed). */
+export async function cancelPending(sessionId: string): Promise<void> {
+  const sql = getSql();
+  await sql`
+    DELETE FROM finalization_requests
+    WHERE session_id = ${sessionId} AND status = 'pending'
+  `;
+}
+
+/** Process a single finalization request. */
+async function processOne(sessionId: string, room: string, messageCount: number): Promise<void> {
+  const sql = getSql();
+
+  // Claim the request (pending -> processing)
+  const claimed = await sql`
+    UPDATE finalization_requests
+    SET status = 'processing', updated_at = NOW()
+    WHERE session_id = ${sessionId}
+      AND message_count = ${messageCount}
+      AND status = 'pending'
+    RETURNING id
+  `;
+  if (claimed.length === 0) return; // Already claimed or cancelled
+
+  const requestId = claimed[0].id;
+
+  try {
+    await Promise.allSettled([consolidateSession(sessionId, room), summarizeSession(sessionId, room)]);
+
+    await sql`
+      UPDATE finalization_requests
+      SET status = 'done', updated_at = NOW()
+      WHERE id = ${requestId}
+    `;
+
+    log.info({ sessionId, room, messageCount }, "finalizer: completed");
+  } catch (err) {
+    await sql`
+      UPDATE finalization_requests
+      SET status = 'failed', updated_at = NOW()
+      WHERE id = ${requestId}
+    `.catch(() => {});
+
+    log.error({ err, sessionId, room }, "finalizer: processing failed");
+  }
+}
+
+/** Drain all pending finalization requests. Called by daemon on startup and on NOTIFY. */
+export async function processPending(): Promise<void> {
+  const sql = getSql();
+
+  const pending = await sql`
+    SELECT session_id, room, message_count
+    FROM finalization_requests
+    WHERE status = 'pending'
+    ORDER BY created_at ASC
+  `;
+
+  for (const row of pending) {
+    await processOne(row.session_id, row.room, row.message_count);
+  }
+}
+
+/** Clean up old completed/failed requests (> 7 days). Called periodically by daemon. */
+export async function cleanupOldRequests(): Promise<void> {
+  const sql = getSql();
+  await sql`
+    DELETE FROM finalization_requests
+    WHERE status IN ('done', 'failed')
+      AND updated_at < NOW() - INTERVAL '7 days'
+  `;
+}

package/src/db/migrations/014_finalization_requests.ts

@@ -0,0 +1,21 @@
+import type postgres from "postgres";
+
+export const name = "014_finalization_requests";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`
+    CREATE TABLE IF NOT EXISTS finalization_requests (
+      id            SERIAL PRIMARY KEY,
+      session_id    TEXT NOT NULL,
+      room          TEXT NOT NULL,
+      message_count INT NOT NULL,
+      status        TEXT NOT NULL DEFAULT 'pending',
+      created_at    TIMESTAMPTZ DEFAULT NOW(),
+      updated_at    TIMESTAMPTZ DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_finalization_session
+    ON finalization_requests (session_id, status)
+  `;
+}

package/src/mcp/server.ts

@@ -7,54 +7,33 @@ export function createNiaMcpServer() {
     name: "nia",
     version: "0.1.0",
     tools: [
-      tool(
-        "list_jobs",
-        "List all scheduled jobs with status and next run time",
-        {},
-        async () => ({
-          content: [{ type: "text" as const, text: await handlers.listJobs() }],
-        }),
-      ),
+      tool("list_jobs", "List all scheduled jobs with status and next run time", {}, async () => ({
+        content: [{ type: "text" as const, text: await handlers.listJobs() }],
+      })),
       tool(
         "add_job",
         "Create a new scheduled job. Supports cron expressions (0 9 * * *), interval durations (5m, 2h, 1d), or one-time ISO timestamps.",
         {
           name: z.string().describe("Unique job name"),
-          schedule: z
-            .string()
-            .describe("Cron expression, duration string, or ISO timestamp"),
+          schedule: z.string().describe("Cron expression, duration string, or ISO timestamp"),
           prompt: z.string().describe("What the job should do"),
-          schedule_type: z
-            .enum(["cron", "interval", "once"])
-            .default("cron")
-            .describe("Schedule type"),
-          always: z
-            .boolean()
-            .default(false)
-            .describe("If true, runs 24/7 ignoring active hours"),
+          schedule_type: z.enum(["cron", "interval", "once"]).default("cron").describe("Schedule type"),
+          always: z.boolean().default(false).describe("If true, runs 24/7 ignoring active hours"),
           agent: z
             .string()
             .optional()
-            .describe(
-              "Agent name to use for this job (loads agent's AGENT.md as system prompt)",
-            ),
+            .describe("Agent name to use for this job (loads agent's AGENT.md as system prompt)"),
           stateless: z
             .boolean()
             .default(false)
-            .describe(
-              "If true, disables working memory (no state.md injection or workspace)",
-            ),
+            .describe("If true, disables working memory (no state.md injection or workspace)"),
           model: z
             .string()
             .optional()
-            .describe(
-              "Model override for this job (e.g. haiku, sonnet, opus). Overrides agent and global model.",
-            ),
+            .describe("Model override for this job (e.g. haiku, sonnet, opus). Overrides agent and global model."),
         },
         async (args) => ({
-          content: [
-            { type: "text" as const, text: await handlers.addJob(args) },
-          ],
+          content: [{ type: "text" as const, text: await handlers.addJob(args) }],
         }),
       ),
       tool(
@@ -65,39 +44,22 @@ export function createNiaMcpServer() {
           schedule: z
             .string()
             .optional()
-            .describe(
-              "New schedule (cron expression, interval duration, or ISO timestamp)",
-            ),
+            .describe("New schedule (cron expression, interval duration, or ISO timestamp)"),
           prompt: z.string().optional().describe("New prompt"),
-          always: z
-            .boolean()
-            .optional()
-            .describe("If true, runs 24/7 ignoring active hours"),
-          agent: z
-            .string()
-            .nullable()
-            .optional()
-            .describe("Agent name (set null to remove agent)"),
-          model: z
-            .string()
-            .nullable()
-            .optional()
-            .describe("Model override (set null to remove and use default)"),
+          always: z.boolean().optional().describe("If true, runs 24/7 ignoring active hours"),
+          agent: z.string().nullable().optional().describe("Agent name (set null to remove agent)"),
+          model: z.string().nullable().optional().describe("Model override (set null to remove and use default)"),
           stateless: z
             .boolean()
             .optional()
-            .describe(
-              "If true, disables working memory (no state.md injection or workspace)",
-            ),
+            .describe("If true, disables working memory (no state.md injection or workspace)"),
           schedule_type: z
             .enum(["cron", "interval", "once"])
             .optional()
             .describe("Schedule type (must match the schedule format)"),
         },
         async (args) => ({
-          content: [
-            { type: "text" as const, text: await handlers.updateJob(args) },
-          ],
+          content: [{ type: "text" as const, text: await handlers.updateJob(args) }],
         }),
       ),
       tool(
@@ -157,26 +119,17 @@ export function createNiaMcpServer() {
         "Send a message to the user via configured channel (telegram, slack). Uses default_channel from config if not specified. Can also send a file/image by providing media_path.",
         {
           text: z.string().describe("Message text to send"),
-          channel: z
-            .string()
-            .optional()
-            .describe("Channel name (telegram, slack). Omit to use default."),
+          channel: z.string().optional().describe("Channel name (telegram, slack). Omit to use default."),
           media_path: z
             .string()
             .optional()
-            .describe(
-              "Absolute path to a file to send as an attachment (image, document)",
-            ),
+            .describe("Absolute path to a file to send as an attachment (image, document)"),
         },
         async (args) => ({
           content: [
             {
               type: "text" as const,
-              text: await handlers.sendMessage(
-                args.text,
-                args.channel,
-                args.media_path,
-              ),
+              text: await handlers.sendMessage(args.text, args.channel, args.media_path),
             },
           ],
         }),
@@ -185,10 +138,7 @@ export function createNiaMcpServer() {
         "list_messages",
         "Read recent chat history",
         {
-          limit: z
-            .number()
-            .default(20)
-            .describe("Number of messages to return"),
+          limit: z.number().default(20).describe("Number of messages to return"),
           room: z.string().optional().describe("Filter by room name"),
         },
         async (args) => ({
@@ -205,10 +155,7 @@ export function createNiaMcpServer() {
         "Browse past conversation sessions with previews. Returns session IDs you can pass to read_session.",
         {
           room: z.string().optional().describe("Filter by room name"),
-          limit: z
-            .number()
-            .default(10)
-            .describe("Number of sessions to return"),
+          limit: z.number().default(10).describe("Number of sessions to return"),
         },
         async (args) => ({
           content: [
@@ -231,11 +178,7 @@ export function createNiaMcpServer() {
           content: [
             {
               type: "text" as const,
-              text: await handlers.searchMessages(
-                args.query,
-                args.limit,
-                args.room,
-              ),
+              text: await handlers.searchMessages(args.query, args.limit, args.room),
             },
           ],
         }),
@@ -257,7 +200,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "add_watch_channel",
-        "Add or update a Slack watch channel. Watch channels receive ALL messages (not just @mentions) and act based on the behavior prompt. Takes effect on next message (hot-reloads).",
+        "Add or update a Slack watch channel. Watch channels receive ALL messages (not just @mentions). Behavior is optional — if omitted, loads watches/<channel_name>/behavior.md at runtime. If a single word, it names a different watch dir. If prose (with spaces), treated as inline behavior. Takes effect on next message (hot-reloads).",
         {
           name: z
             .string()
@@ -266,8 +209,9 @@ export function createNiaMcpServer() {
             ),
           behavior: z
             .string()
+            .optional()
             .describe(
-              "What to monitor and how to respond, e.g. 'Monitor thread notifications. Flag failures to #tech.'",
+              "Optional. Omit to load watches/<channel_name>/behavior.md. A single word names a different watch dir. Prose (with spaces) is inline behavior.",
             ),
         },
         async (args) => ({
@@ -285,9 +229,7 @@ export function createNiaMcpServer() {
         {
           name: z
             .string()
-            .describe(
-              "Slack channel key to stop watching (e.g. 'C1234567890#ask-kay-thread-notifications')",
-            ),
+            .describe("Slack channel key to stop watching (e.g. 'C1234567890#ask-kay-thread-notifications')"),
         },
         async (args) => ({
           content: [
@@ -332,16 +274,10 @@ export function createNiaMcpServer() {
         "add_rule",
         "Add a behavioral rule. Rules are loaded into every session and take effect without restart. Use for 'from now on' / 'always' / 'never' type instructions.",
         {
-          rule: z
-            .string()
-            .describe(
-              "The rule to add (e.g. 'stamp updates: 1-2 lines max, no preamble')",
-            ),
+          rule: z.string().describe("The rule to add (e.g. 'stamp updates: 1-2 lines max, no preamble')"),
         },
         async (args) => ({
-          content: [
-            { type: "text" as const, text: handlers.addRule(args.rule) },
-          ],
+          content: [{ type: "text" as const, text: handlers.addRule(args.rule) }],
         }),
       ),
       tool(
@@ -356,17 +292,10 @@ export function createNiaMcpServer() {
         "add_memory",
         "Save a concise factual memory for future reference. Proactively save personal facts (travel, schedule), work context (decisions, deadlines), and corrections — don't wait to be asked. RULES: Max 300 chars. One insight per entry. NO raw logs, NO transcripts, NO status dumps.",
         {
-          entry: z
-            .string()
-            .max(300)
-            .describe(
-              "A single concise insight (max 300 chars, no raw logs or transcripts)",
-            ),
+          entry: z.string().max(300).describe("A single concise insight (max 300 chars, no raw logs or transcripts)"),
         },
         async (args) => ({
-          content: [
-            { type: "text" as const, text: handlers.addMemory(args.entry) },
-          ],
+          content: [{ type: "text" as const, text: handlers.addMemory(args.entry) }],
         }),
       ),
       tool(