niahere 0.2.62 → 0.2.63

package/src/core/consolidator.ts

@@ -1,27 +1,13 @@
 /**
- * Memory consolidator — stage 1 of a two-stage memory architecture.
+ * Memory consolidator — stage 1 of the two-stage memory pipeline.
  *
- * After a chat session goes idle, this module reflects on the transcript
- * and writes CANDIDATE memories to ~/.niahere/self/staging.md. It never
- * writes directly to memory.md or rules.md — the nightly memory-promoter
- * job handles promotion once candidates are reinforced (count >= 2) and
- * pass durability review.
+ * After a chat session goes idle, reflects on the transcript and appends
+ * CANDIDATE memories to ~/.niahere/self/staging.md. The nightly
+ * memory-promoter job handles promotion from staging to memory.md/rules.md.
+ * The write-path restriction is enforced by the consolidator prompt, not
+ * by tool sandboxing.
  *
- * Architecture:
- *   chat idle → consolidator → staging.md (candidate log, TTL 14d)
- *                                    ↓  nightly promoter (3am)
- *                                    ↓  - count >= 2 required
- *                                    ↓  - durability review
- *                              memory.md / rules.md
- *
- * Jobs do NOT flow through this path — job-local learnings live in each
- * job's state.md (see runner.ts:buildWorkingMemory). Routing job output
- * into global persona memory caused layer violations (transient incidents
- * promoted to durable facts).
- *
- * The consolidator uses the same agent loop as cron jobs — full Nia system
- * prompt, full tool access. The write-path restriction is enforced by the
- * prompt (the agent is told to only edit staging.md), not by tool sandboxing.
+ * See AGENTS.md > "Two-stage memory" for the full architecture.
  */
 
 import { Message } from "../db/models";
@@ -138,12 +124,16 @@ Report a one-line summary of what you did: "staged N new / reinforced M /
 skipped (trivial session)". No preamble.`;
 }
 
-/** Run the consolidation agent loop. */
 async function runConsolidation(transcript: string, source: string): Promise<void> {
-  await runTask({
+  const output = await runTask({
     name: "consolidator",
     prompt: buildConsolidationPrompt(transcript, source),
   });
+  // runTask returns {error} on failure instead of throwing; escalate so
+  // consolidateSession doesn't mark the session processed on a failed run.
+  if (output.error) {
+    throw new Error(`consolidator task failed: ${output.error}`);
+  }
 }
 
 /**
@@ -178,12 +168,8 @@ export async function consolidateSession(sessionId: string, room: string): Promi
     }
   } catch (err) {
     log.error({ err, sessionId, room }, "consolidator: chat extraction failed");
+    throw err;
   } finally {
     inFlight.delete(sessionId);
   }
 }
-
-// Job runs no longer flow through the global memory consolidator. Each job
-// maintains its own working memory in state.md (see buildWorkingMemory() in
-// runner.ts). This separation prevents transient job-local incidents from
-// being promoted to durable persona memory.

package/src/core/daemon.ts

@@ -1,9 +1,10 @@
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve as pathResolve } from "path";
 import { fileURLToPath } from "url";
 import { getPaths } from "../utils/paths";
 import { getConfig, resetConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { isRunning, readPid, removePid, writePid } from "../utils/pid";
 import { ActiveEngine, Job } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { closeDb, getSql } from "../db/connection";
@@ -15,45 +16,7 @@ import { createNiaMcpServer } from "../mcp/server";
 import { setMcpFactory } from "../mcp";
 import { processPending, cleanupOldRequests } from "./finalizer";
 
-export function writePid(pid: number): void {
-  const { pid: pidPath } = getPaths();
-  mkdirSync(dirname(pidPath), { recursive: true });
-  writeFileSync(pidPath, String(pid));
-}
-
-export function readPid(): number | null {
-  const { pid: pidPath } = getPaths();
-  if (!existsSync(pidPath)) return null;
-
-  try {
-    return parseInt(readFileSync(pidPath, "utf8").trim(), 10);
-  } catch {
-    return null;
-  }
-}
-
-export function removePid(): void {
-  const { pid: pidPath } = getPaths();
-  try {
-    unlinkSync(pidPath);
-  } catch {
-    // Already gone
-  }
-}
-
-export function isRunning(): boolean {
-  const pid = readPid();
-  if (pid === null) return false;
-
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    log.warn({ stalePid: pid }, "removing stale pid file (process not running)");
-    removePid();
-    return false;
-  }
-}
+export { isRunning, readPid, removePid, writePid };
 
 export function startDaemon(): number {
   const { daemonLog } = getPaths();
@@ -125,7 +88,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", "src/cli\\.ts run$"]);
+    const result = Bun.spawnSync(["pgrep", "-f", "src/cli/index\\.ts run$"]);
     const stdout = new TextDecoder().decode(result.stdout).trim();
     if (!stdout) return [];
     return stdout

package/src/core/finalizer.ts

@@ -78,15 +78,32 @@ async function processOne(sessionId: string, room: string, messageCount: number)
   const requestId = claimed[0].id;
 
   try {
-    await Promise.allSettled([consolidateSession(sessionId, room), summarizeSession(sessionId, room)]);
+    const [consolidateResult, summarizeResult] = await Promise.allSettled([
+      consolidateSession(sessionId, room),
+      summarizeSession(sessionId, room),
+    ]);
+
+    const errors: string[] = [];
+    if (consolidateResult.status === "rejected") {
+      errors.push(`consolidate: ${formatRejection(consolidateResult.reason)}`);
+    }
+    if (summarizeResult.status === "rejected") {
+      errors.push(`summarize: ${formatRejection(summarizeResult.reason)}`);
+    }
+
+    const finalStatus = errors.length === 0 ? "done" : "failed";
 
     await sql`
       UPDATE finalization_requests
-      SET status = 'done', updated_at = NOW()
+      SET status = ${finalStatus}, updated_at = NOW()
       WHERE id = ${requestId}
     `;
 
-    log.info({ sessionId, room, messageCount }, "finalizer: completed");
+    if (errors.length === 0) {
+      log.info({ sessionId, room, messageCount }, "finalizer: completed");
+    } else {
+      log.error({ sessionId, room, messageCount, errors }, "finalizer: completed with task failures");
+    }
   } catch (err) {
     await sql`
       UPDATE finalization_requests
@@ -98,6 +115,17 @@ async function processOne(sessionId: string, room: string, messageCount: number)
   }
 }
 
+/** Normalize a Promise rejection reason into a loggable string. */
+function formatRejection(reason: unknown): string {
+  if (reason instanceof Error) return reason.message;
+  if (typeof reason === "string") return reason;
+  try {
+    return JSON.stringify(reason);
+  } catch {
+    return String(reason);
+  }
+}
+
 /** Drain all pending finalization requests. Called by daemon on startup and on NOTIFY. */
 export async function processPending(): Promise<void> {
   const sql = getSql();

package/src/core/health.ts

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "fs";
 import { join } from "path";
 import { getConfig, readRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
-import { isRunning, readPid } from "./daemon";
+import { isRunning, readPid } from "../utils/pid";
 import { errMsg } from "../utils/errors";
 import { localTime } from "../utils/time";
 import { withRetry } from "../utils/retry";
@@ -123,11 +123,7 @@ export async function runHealthChecks(): Promise<Check[]> {
           }),
         );
         const data = (await resp.json()) as { ok: boolean; error?: string };
-        results.push(
-          data.ok
-            ? "slack: connected"
-            : `slack: ${data.error || "auth failed"}`,
-        );
+        results.push(data.ok ? "slack: connected" : `slack: ${data.error || "auth failed"}`);
         if (!data.ok)
           checks.push({
             name: "slack",
@@ -159,10 +155,7 @@ export async function runHealthChecks(): Promise<Check[]> {
   // API keys
   const geminiKey = config.gemini_api_key;
   const rawConfig = readRawConfig();
-  const openaiKey =
-    typeof rawConfig.openai_api_key === "string"
-      ? rawConfig.openai_api_key
-      : null;
+  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
   const apiKeys: string[] = [];
   if (geminiKey) apiKeys.push("gemini");
   if (openaiKey) apiKeys.push("openai");
@@ -174,16 +167,11 @@ export async function runHealthChecks(): Promise<Check[]> {
 
   // Persona files
   const personaFiles = ["identity.md", "owner.md", "soul.md"];
-  const missing = personaFiles.filter(
-    (f) => !existsSync(join(paths.selfDir, f)),
-  );
+  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
   checks.push({
     name: "persona",
     status: missing.length === 0 ? "ok" : "warn",
-    detail:
-      missing.length === 0
-        ? "all files present"
-        : "missing: " + missing.join(", "),
+    detail: missing.length === 0 ? "all files present" : "missing: " + missing.join(", "),
   });
 
   // Daemon log

package/src/core/runner.ts

@@ -372,12 +372,6 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     writeState(freshState);
 
-    // Job-local learnings live in state.md (injected into the next run's
-    // prompt), not in global self/memory.md. The global memory consolidator
-    // only processes chat sessions — routing job output through it created
-    // layer violations (transient incidents promoted to durable memory).
-    // See src/core/consolidator.ts and AGENTS.md memory architecture notes.
-
     return result;
   } catch (err) {
     const duration_ms = Math.round(performance.now() - startMs);

package/src/core/scheduler.ts

@@ -1,50 +1,10 @@
-import { CronExpressionParser } from "cron-parser";
-import { parseDuration } from "../utils/duration";
-import type { ScheduleType } from "../types";
 import { Job } from "../db/models";
 import { runJob } from "./runner";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { computeInitialNextRun, computeNextRun } from "../utils/schedule";
 
-export function computeNextRun(
-  scheduleType: ScheduleType,
-  schedule: string,
-  timezone: string,
-  lastRunAt?: Date,
-): Date | null {
-  switch (scheduleType) {
-    case "cron": {
-      const expr = CronExpressionParser.parse(schedule, { tz: timezone });
-      return expr.next().toDate();
-    }
-    case "interval": {
-      const ms = parseDuration(schedule);
-      const base = lastRunAt || new Date();
-      return new Date(base.getTime() + ms);
-    }
-    case "once":
-      return null;
-  }
-}
-
-export function computeInitialNextRun(
-  scheduleType: ScheduleType,
-  schedule: string,
-  timezone: string,
-): Date {
-  switch (scheduleType) {
-    case "cron": {
-      const expr = CronExpressionParser.parse(schedule, { tz: timezone });
-      return expr.next().toDate();
-    }
-    case "interval": {
-      const ms = parseDuration(schedule);
-      return new Date(Date.now() + ms);
-    }
-    case "once":
-      return new Date(schedule);
-  }
-}
+export { computeInitialNextRun, computeNextRun };
 
 function isWithinActiveHours(): boolean {
   const config = getConfig();
@@ -96,13 +56,16 @@ async function tick(): Promise<void> {
     log.info({ job: job.name, type: job.scheduleType }, "scheduler: running job");
     runningJobs.add(job.name);
 
-    runJob(job).then((result) => {
-      log.info({ job: job.name, status: result.status, duration: result.duration_ms }, "scheduler: job completed");
-    }).catch((err) => {
-      log.error({ err, job: job.name }, "scheduler: job failed");
-    }).finally(() => {
-      runningJobs.delete(job.name);
-    });
+    runJob(job)
+      .then((result) => {
+        log.info({ job: job.name, status: result.status, duration: result.duration_ms }, "scheduler: job completed");
+      })
+      .catch((err) => {
+        log.error({ err, job: job.name }, "scheduler: job failed");
+      })
+      .finally(() => {
+        runningJobs.delete(job.name);
+      });
 
     let nextRun: Date | null = null;
     try {

package/src/core/skills.ts

@@ -40,14 +40,10 @@ export function scanSkills(): SkillInfo[] {
       try {
         meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
       } catch (err) {
-        log.warn(
-          { err, skill: entry.name, path: skillFile },
-          "failed to parse skill metadata, skipping",
-        );
+        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
         continue;
       }
-      const name =
-        (typeof meta.name === "string" ? meta.name : "") || entry.name;
+      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
 
       const key = name.toLowerCase();
       if (seen.has(key)) continue;
@@ -55,8 +51,7 @@ export function scanSkills(): SkillInfo[] {
 
       skills.push({
         name,
-        description:
-          typeof meta.description === "string" ? meta.description : "",
+        description: typeof meta.description === "string" ? meta.description : "",
         source,
       });
     }
@@ -72,8 +67,6 @@ export function getSkillNames(): string[] {
 export function getSkillsSummary(): string {
   const skills = scanSkills();
   if (skills.length === 0) return "";
-  const lines = skills.map((s) =>
-    s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`,
-  );
+  const lines = skills.map((s) => (s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`));
   return `Available skills:\n${lines.join("\n")}`;
 }

package/src/core/summarizer.ts

@@ -26,19 +26,14 @@ 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");
+  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> {
+export async function summarizeSession(sessionId: string, room: string): Promise<void> {
   if (room.includes("placeholder")) return;
   if (inFlight.has(sessionId)) return;
 
@@ -51,10 +46,7 @@ export async function summarizeSession(
 
     inFlight.add(sessionId);
 
-    log.info(
-      { sessionId, room, messageCount: messages.length },
-      "summarizer: generating session summary",
-    );
+    log.info({ sessionId, room, messageCount: messages.length }, "summarizer: generating session summary");
 
     const transcript = formatTranscript(messages);
 
@@ -76,8 +68,7 @@ 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;
+      throw new Error(`summarizer task failed: ${output.error}`);
     }
 
     const summary = output.agentText.trim();
@@ -88,18 +79,13 @@ Keep it concise — a handoff note, not a report. Output ONLY the summary text.`
         const firstKey = processedCounts.keys().next().value;
         if (firstKey) processedCounts.delete(firstKey);
       }
-      log.info(
-        { sessionId, room, summaryChars: summary.length },
-        "summarizer: saved",
-      );
+      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",
-      );
+      log.warn({ sessionId, room, length: summary.length }, "summarizer: output too short or too long, skipped");
     }
   } catch (err) {
     log.error({ err, sessionId, room }, "summarizer: failed");
+    throw err;
   } finally {
     inFlight.delete(sessionId);
   }

package/src/db/connection.ts

@@ -23,14 +23,3 @@ export async function closeDb(): Promise<void> {
     _sql = null;
   }
 }
-
-/** Run migrations, execute fn, then close DB. */
-export async function withDb<T>(fn: () => Promise<T>): Promise<T> {
-  const { runMigrations } = await import("./migrate");
-  await runMigrations();
-  try {
-    return await fn();
-  } finally {
-    await closeDb();
-  }
-}

package/src/db/models/job.ts

@@ -1,6 +1,8 @@
 import { getSql } from "../connection";
 import { CronExpressionParser } from "cron-parser";
 import { parseDuration } from "../../utils/duration";
+import { computeInitialNextRun } from "../../utils/schedule";
+import { getConfig } from "../../utils/config";
 import type { ScheduleType } from "../../types";
 
 /** Validate that a schedule string matches its declared type. Throws on mismatch. */
@@ -10,26 +12,20 @@ function validateSchedule(schedule: string, scheduleType: ScheduleType): void {
       try {
         CronExpressionParser.parse(schedule);
       } catch (err) {
-        throw new Error(
-          `Invalid cron expression "${schedule}": ${err instanceof Error ? err.message : err}`,
-        );
+        throw new Error(`Invalid cron expression "${schedule}": ${err instanceof Error ? err.message : err}`);
       }
       break;
     case "interval":
       try {
         parseDuration(schedule);
       } catch (err) {
-        throw new Error(
-          `Invalid interval "${schedule}": ${err instanceof Error ? err.message : err}`,
-        );
+        throw new Error(`Invalid interval "${schedule}": ${err instanceof Error ? err.message : err}`);
       }
       break;
     case "once": {
       const d = new Date(schedule);
       if (isNaN(d.getTime())) {
-        throw new Error(
-          `Invalid timestamp "${schedule}": expected ISO 8601 date`,
-        );
+        throw new Error(`Invalid timestamp "${schedule}": expected ISO 8601 date`);
       }
       break;
     }
@@ -89,9 +85,7 @@ export async function create(
   validateSchedule(schedule, scheduleType);
   const existing = await get(name);
   if (existing) {
-    throw new Error(
-      `Job "${name}" already exists. Use \`nia job remove ${name}\` first, or choose a different name.`,
-    );
+    throw new Error(`Job "${name}" already exists. Use \`nia job remove ${name}\` first, or choose a different name.`);
   }
   const sql = getSql();
   await sql`
@@ -141,15 +135,25 @@ export async function update(
   const model = fields.model !== undefined ? fields.model : existing.model;
   const stateless = fields.stateless ?? existing.stateless;
 
-  if (fields.schedule || fields.scheduleType) {
+  const scheduleChanged = fields.schedule !== undefined || fields.scheduleType !== undefined;
+  if (scheduleChanged) {
     validateSchedule(schedule, scheduleType);
   }
 
-  await sql`
-    UPDATE jobs
-    SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
-    WHERE name = ${name}
-  `;
+  if (scheduleChanged) {
+    const nextRun = computeInitialNextRun(scheduleType, schedule, getConfig().timezone);
+    await sql`
+      UPDATE jobs
+      SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, model = ${model}, stateless = ${stateless}, next_run_at = ${nextRun}, updated_at = NOW()
+      WHERE name = ${name}
+    `;
+  } else {
+    await sql`
+      UPDATE jobs
+      SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
+      WHERE name = ${name}
+    `;
+  }
   await notifyChange();
   return true;
 }
@@ -179,10 +183,7 @@ export async function listDue(): Promise<Job[]> {
   return rows.map(toJob);
 }
 
-export async function markRun(
-  name: string,
-  nextRunAt: Date | null,
-): Promise<void> {
+export async function markRun(name: string, nextRunAt: Date | null): Promise<void> {
   const sql = getSql();
   if (nextRunAt) {
     await sql`UPDATE jobs SET last_run_at = NOW(), next_run_at = ${nextRunAt}, updated_at = NOW() WHERE name = ${name}`;

package/src/db/with-db.ts

@@ -0,0 +1,11 @@
+import { closeDb } from "./connection";
+import { runMigrations } from "./migrate";
+
+export async function withDb<T>(fn: () => Promise<T>): Promise<T> {
+  await runMigrations();
+  try {
+    return await fn();
+  } finally {
+    await closeDb();
+  }
+}

package/src/mcp/server.ts

@@ -290,7 +290,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "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.",
+        "Save a concise factual memory for future reference. Call this when the user explicitly asks you to remember something, or when a correction needs an immediate durable record. For observations you notice on your own during a session, let the post-session consolidator handle it via staging.md — don't preemptively save here. 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)"),
         },