niahere 0.2.38 → 0.2.41

package/package.json

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

package/src/commands/service.ts

@@ -48,6 +48,8 @@ function buildPlist(): string {
     <key>SuccessfulExit</key>
     <false/>
   </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
   <key>StandardOutPath</key>
   <string>${paths.daemonLog}</string>
   <key>StandardErrorPath</key>
@@ -86,10 +88,10 @@ async function uninstallLaunchd(): Promise<void> {
   const path = plistPath();
   if (!existsSync(path)) return;
 
+  // Unload to stop the process and disable KeepAlive respawn.
+  // Keep the plist file so RunAtLoad starts the daemon on next login.
   const unload = Bun.spawn(["launchctl", "unload", path], { stdout: "pipe", stderr: "pipe" });
   await unload.exited;
-
-  try { unlinkSync(path); } catch { /* already gone */ }
 }
 
 function isLaunchdInstalled(): boolean {

package/src/core/alive.ts

@@ -4,11 +4,72 @@ import { getSql, closeDb } from "../db/connection";
 import { getFailures, type Check } from "./health";
 
 const HEARTBEAT_INTERVAL = 60_000; // 60s
+const PG_DATA_DIRS = [
+  "/opt/homebrew/var/postgresql@18",
+  "/opt/homebrew/var/postgresql@17",
+  "/opt/homebrew/var/postgres",
+];
 
 let timer: ReturnType<typeof setInterval> | null = null;
 let lastFailures: string[] = [];
 let recoveryAttempted = false;
 
+/** Deterministic Postgres recovery: remove stale PID file + restart service. */
+async function recoverPostgres(): Promise<boolean> {
+  const ready = Bun.spawnSync(["pg_isready"]);
+  if (ready.exitCode === 0) return true; // already up
+
+  log.info("alive: postgres not ready, attempting deterministic recovery");
+
+  // Find and remove stale postmaster.pid
+  const { existsSync, unlinkSync, readFileSync } = await import("fs");
+  for (const dir of PG_DATA_DIRS) {
+    const pidFile = `${dir}/postmaster.pid`;
+    if (!existsSync(pidFile)) continue;
+
+    // Read the PID from line 1 and check if it's actually a postgres process
+    try {
+      const pid = parseInt(readFileSync(pidFile, "utf8").split("\n")[0], 10);
+      if (!isNaN(pid)) {
+        const check = Bun.spawnSync(["ps", "-p", String(pid), "-o", "comm="]);
+        const comm = new TextDecoder().decode(check.stdout).trim();
+        if (check.exitCode !== 0 || !comm.includes("postgres")) {
+          log.info({ pidFile, stalePid: pid, actualProcess: comm || "dead" }, "alive: removing stale postmaster.pid");
+          unlinkSync(pidFile);
+        }
+      }
+    } catch (err) {
+      log.warn({ err, pidFile }, "alive: could not inspect postmaster.pid");
+    }
+  }
+
+  // Restart the service
+  if (process.platform === "darwin") {
+    // Try common brew postgresql service names
+    for (const svc of ["postgresql@18", "postgresql@17", "postgresql"]) {
+      const result = Bun.spawnSync(["brew", "services", "start", svc]);
+      if (result.exitCode === 0) {
+        log.info({ service: svc }, "alive: brew service start issued");
+        break;
+      }
+    }
+  } else {
+    Bun.spawnSync(["systemctl", "start", "postgresql"]);
+  }
+
+  // Wait briefly for postgres to come up
+  await new Promise((r) => setTimeout(r, 3000));
+
+  const check = Bun.spawnSync(["pg_isready"]);
+  if (check.exitCode === 0) {
+    log.info("alive: postgres recovered via deterministic fix");
+    return true;
+  }
+
+  log.warn("alive: deterministic postgres recovery failed");
+  return false;
+}
+
 async function attemptDbReconnect(): Promise<boolean> {
   try {
     await closeDb();
@@ -138,10 +199,28 @@ async function heartbeat(): Promise<void> {
     }
   }
 
-  // Run recovery agent once per outage
+  // Deterministic postgres recovery before LLM agent
+  if (failureNames.includes("database") && !recoveryAttempted) {
+    const pgFixed = await recoverPostgres();
+    if (pgFixed) {
+      const reconnected = await attemptDbReconnect();
+      if (reconnected) {
+        const remaining = await getFailures();
+        if (remaining.length === 0) {
+          log.info("alive: postgres recovered (deterministic fix, no LLM needed)");
+          await notifyUser("Postgres was down (stale PID). Fixed automatically — no LLM agent needed.");
+          lastFailures = [];
+          recoveryAttempted = false;
+          return;
+        }
+      }
+    }
+  }
+
+  // Run LLM recovery agent once per outage (fallback for non-trivial issues)
   if (!recoveryAttempted) {
     recoveryAttempted = true;
-    log.info({ failures: failureNames }, "alive: running recovery agent");
+    log.info({ failures: failureNames }, "alive: running LLM recovery agent");
 
     const { recovered, report } = await runRecoveryAgent(failures);
 

package/src/core/daemon.ts

@@ -121,7 +121,7 @@ function waitForExit(timeoutMs: number): void {
 /** Return PIDs of running daemon processes (excluding ourselves). */
 export function findDaemonPids(): number[] {
   try {
-    const result = Bun.spawnSync(["pgrep", "-f", "niahere/src/cli.* run$"]);
+    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")
@@ -150,16 +150,19 @@ export async function runDaemon(): Promise<void> {
   delete process.env.CLAUDE_CODE_ENTRYPOINT;
   delete process.env.CLAUDE_AGENT_SDK_VERSION;
 
-  // Startup guard: if another daemon is alive, exit immediately
+  // Startup guard: if another nia daemon is alive, exit immediately.
+  // Use pgrep (via findDaemonPids) instead of kill(pid,0) to verify the
+  // PID is actually a nia process — not a recycled OS PID from something else.
   const existingPid = readPid();
   if (existingPid !== null && existingPid !== process.pid) {
-    try {
-      process.kill(existingPid, 0); // Check if alive
+    const aliveDaemons = findDaemonPids();
+    if (aliveDaemons.includes(existingPid)) {
       log.debug({ existingPid, myPid: process.pid }, "another daemon is already running, exiting");
       process.exit(0);
-    } catch {
-      // Dead PID in pidfile — safe to take over
     }
+    // PID in file is stale (dead or recycled by OS) — safe to take over
+    log.warn({ stalePid: existingPid }, "taking over from stale pid");
+    removePid();
   }
 
   // Crash handlers — ensure PID cleanup and logging on unhandled errors.

package/src/core/runner.ts

@@ -247,13 +247,15 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     appendAudit(auditEntry);
 
-    state[job.name] = {
+    // Re-read state to avoid clobbering concurrent job updates
+    const freshState = { ...readState() };
+    freshState[job.name] = {
       lastRun: timestamp,
       status: result.status,
       duration_ms: result.duration_ms,
       error: result.error,
     };
-    writeState(state);
+    writeState(freshState);
 
     return result;
   } catch (err) {
@@ -278,13 +280,15 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       error: errorMsg,
     });
 
-    state[job.name] = {
+    // Re-read state to avoid clobbering concurrent job updates
+    const freshState = { ...readState() };
+    freshState[job.name] = {
       lastRun: timestamp,
       status: "error",
       duration_ms,
       error: errorMsg,
     };
-    writeState(state);
+    writeState(freshState);
 
     return result;
   }

package/src/db/models/message.ts

@@ -1,5 +1,5 @@
 import { getSql } from "../connection";
-import type { SaveMessageParams, RoomStats, RecentMessage } from "../../types";
+import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "../../types";
 
 export async function save(params: SaveMessageParams): Promise<void> {
   const sql = getSql();
@@ -29,6 +29,45 @@ export async function getRecent(limit = 20, room?: string): Promise<RecentMessag
   }));
 }
 
+export async function search(query: string, limit = 20, room?: string): Promise<SearchResult[]> {
+  const sql = getSql();
+  const pattern = `%${query}%`;
+  const rows = room
+    ? await sql`
+        SELECT session_id, room, sender, content, created_at
+        FROM messages WHERE content ILIKE ${pattern} AND room = ${room}
+        ORDER BY created_at DESC LIMIT ${limit}
+      `
+    : await sql`
+        SELECT session_id, room, sender, content, created_at
+        FROM messages WHERE content ILIKE ${pattern}
+        ORDER BY created_at DESC LIMIT ${limit}
+      `;
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    room: r.room,
+    sender: r.sender,
+    content: r.content,
+    createdAt: String(r.created_at),
+  }));
+}
+
+export async function getBySession(sessionId: string): Promise<SessionMessage[]> {
+  const sql = getSql();
+  const rows = await sql`
+    SELECT room, sender, content, is_from_agent, created_at
+    FROM messages WHERE session_id = ${sessionId}
+    ORDER BY created_at ASC
+  `;
+  return rows.map((r) => ({
+    room: r.room,
+    sender: r.sender,
+    content: r.content,
+    isFromAgent: r.is_from_agent,
+    createdAt: String(r.created_at),
+  }));
+}
+
 export async function getRoomStats(): Promise<RoomStats[]> {
   const sql = getSql();
   const rows = await sql`

package/src/db/models/session.ts

@@ -49,6 +49,35 @@ export async function getRecent(room: string, limit = 10): Promise<SessionSummar
   }));
 }
 
+export async function listRecent(limit = 10, room?: string): Promise<SessionSummary[]> {
+  if (room) return getRecent(room, limit);
+  const sql = getSql();
+  const rows = await sql`
+    SELECT
+      s.id,
+      s.room,
+      s.created_at,
+      s.updated_at,
+      (
+        SELECT content FROM messages m
+        WHERE m.session_id = s.id AND m.sender = 'user'
+        ORDER BY m.created_at ASC LIMIT 1
+      ) AS preview,
+      (SELECT COUNT(*)::int FROM messages m WHERE m.session_id = s.id) AS message_count
+    FROM sessions s
+    ORDER BY s.updated_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.map((r) => ({
+    id: r.id,
+    room: r.room,
+    createdAt: String(r.created_at),
+    updatedAt: String(r.updated_at),
+    preview: r.preview ? String(r.preview) : null,
+    messageCount: r.message_count,
+  }));
+}
+
 export async function create(id: string, room: string): Promise<void> {
   const sql = getSql();
   await sql`INSERT INTO sessions (id, room) VALUES (${id}, ${room})`;

package/src/mcp/server.ts

@@ -99,6 +99,39 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: await handlers.listMessages(args.limit, args.room) }],
         }),
       ),
+      tool(
+        "list_sessions",
+        "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"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.listSessions(args.limit, args.room) }],
+        }),
+      ),
+      tool(
+        "search_messages",
+        "Search across all past messages by keyword. Returns matching messages with session IDs for deeper reading.",
+        {
+          query: z.string().describe("Text to search for in message content"),
+          room: z.string().optional().describe("Filter by room name"),
+          limit: z.number().default(20).describe("Max results to return"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.searchMessages(args.query, args.limit, args.room) }],
+        }),
+      ),
+      tool(
+        "read_session",
+        "Load the full transcript of a specific conversation session. Use list_sessions or search_messages to find session IDs.",
+        {
+          session_id: z.string().describe("Session ID to read"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.readSession(args.session_id) }],
+        }),
+      ),
       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).",

package/src/mcp/tools.ts

@@ -244,6 +244,24 @@ export async function listMessages(limit = 20, room?: string): Promise<string> {
   return JSON.stringify(messages, null, 2);
 }
 
+export async function listSessions(limit = 10, room?: string): Promise<string> {
+  const sessions = await Session.listRecent(limit, room);
+  if (sessions.length === 0) return "No sessions found.";
+  return JSON.stringify(sessions, null, 2);
+}
+
+export async function searchMessages(query: string, limit = 20, room?: string): Promise<string> {
+  const results = await Message.search(query, limit, room);
+  if (results.length === 0) return "No matching messages found.";
+  return JSON.stringify(results, null, 2);
+}
+
+export async function readSession(sessionId: string): Promise<string> {
+  const messages = await Message.getBySession(sessionId);
+  if (messages.length === 0) return "Session not found or has no messages.";
+  return JSON.stringify(messages, null, 2);
+}
+
 export function addRule(rule: string): string {
   const { selfDir } = getPaths();
   const rulesPath = join(selfDir, "rules.md");

package/src/prompts/environment.md

@@ -31,6 +31,9 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 - **run_job** — trigger a job to run immediately
 - **send_message** — send a message to the user (via telegram, slack, or default channel). Supports `media_path` to send images/files.
 - **list_messages** — read recent chat history
+- **list_sessions** — browse past conversation sessions with previews and message counts. Returns session IDs.
+- **search_messages** — keyword search across all past messages. Find when something was discussed.
+- **read_session** — load the full transcript of a specific session by ID.
 - **add_watch_channel** — add a Slack channel for proactive monitoring. Specify channel key (`channel_id#name`) and behavior prompt. Hot-reloads.
 - **remove_watch_channel** — stop watching a Slack channel. Hot-reloads.
 - **enable_watch_channel** / **disable_watch_channel** — toggle a watch channel on/off without removing it. Hot-reloads.
@@ -73,6 +76,16 @@ Config reference:
 - `channels.slack.watch` — per-channel proactive monitoring. Keys are `channel_id#channel_name` format.
 {{slackWatch}}
 
+## Conversation History
+
+You have access to all prior conversations stored in the database:
+
+- **list_sessions** — browse past sessions (with previews and message counts). Use to find a conversation.
+- **search_messages** — search across all past messages by keyword. Returns session IDs for deeper reading.
+- **read_session** — load the full transcript of a session by ID.
+
+Use these when the user asks "did we talk about...", "what did I say about...", or when you need context from a prior conversation. Combine with `read_memory` for a complete picture.
+
 ## Persona & Memory
 
 Your persona files live in {{selfDir}}/:

package/src/types/index.ts

@@ -7,5 +7,5 @@ export type { Channel, ChannelFactory } from "./channel";
 export type { ChatState } from "./chat-state";
 export type { Config, ChannelsConfig, TelegramConfig, SlackConfig } from "./config";
 export type { Paths } from "./paths";
-export type { SaveMessageParams, RoomStats, RecentMessage } from "./message";
+export type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "./message";
 export type { AgentInfo } from "./agent";

package/src/types/message.ts

@@ -19,3 +19,19 @@ export interface RecentMessage {
   content: string;
   createdAt: string;
 }
+
+export interface SearchResult {
+  sessionId: string;
+  room: string;
+  sender: string;
+  content: string;
+  createdAt: string;
+}
+
+export interface SessionMessage {
+  room: string;
+  sender: string;
+  content: string;
+  isFromAgent: boolean;
+  createdAt: string;
+}