niahere 0.2.62 → 0.2.64

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/migrations/015_jobs_employee.ts

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

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;
     }
@@ -44,6 +40,7 @@ export interface Job {
   always: boolean;
   scheduleType: ScheduleType;
   agent: string | null;
+  employee: string | null;
   model: string | null;
   stateless: boolean;
   nextRunAt: string | null;
@@ -61,6 +58,7 @@ function toJob(r: Record<string, any>): Job {
     always: r.always ?? false,
     scheduleType: r.schedule_type || "cron",
     agent: r.agent || null,
+    employee: r.employee || null,
     model: r.model || null,
     stateless: r.stateless ?? false,
     nextRunAt: r.next_run_at ? String(r.next_run_at) : null,
@@ -85,18 +83,17 @@ export async function create(
   agent?: string,
   stateless = false,
   model?: string,
+  employee?: string,
 ): Promise<void> {
   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`
-    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent, stateless, model)
-    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null}, ${stateless}, ${model ?? null})
+    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent, stateless, model, employee)
+    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null}, ${stateless}, ${model ?? null}, ${employee ?? null})
   `;
   await notifyChange();
 }
@@ -104,14 +101,14 @@ export async function create(
 export async function list(): Promise<Job[]> {
   const sql = getSql();
   const rows =
-    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs ORDER BY name`;
+    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs ORDER BY name`;
   return rows.map(toJob);
 }
 
 export async function get(name: string): Promise<Job | null> {
   const sql = getSql();
   const rows =
-    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
+    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
   return rows.length > 0 ? toJob(rows[0]) : null;
 }
 
@@ -123,6 +120,7 @@ export async function update(
     enabled: boolean;
     always: boolean;
     agent: string | null;
+    employee: string | null;
     model: string | null;
     stateless: boolean;
     scheduleType: ScheduleType;
@@ -138,18 +136,29 @@ export async function update(
   const enabled = fields.enabled ?? existing.enabled;
   const always = fields.always ?? existing.always;
   const agent = fields.agent !== undefined ? fields.agent : existing.agent;
+  const employee = fields.employee !== undefined ? fields.employee : existing.employee;
   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}, employee = ${employee}, 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}, employee = ${employee}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
+      WHERE name = ${name}
+    `;
+  }
   await notifyChange();
   return true;
 }
@@ -164,14 +173,14 @@ export async function remove(name: string): Promise<boolean> {
 export async function listEnabled(): Promise<Job[]> {
   const sql = getSql();
   const rows =
-    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
+    await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
   return rows.map(toJob);
 }
 
 export async function listDue(): Promise<Job[]> {
   const sql = getSql();
   const rows = await sql`
-    SELECT name, schedule, prompt, enabled, always, schedule_type, agent, model, stateless, next_run_at, last_run_at, created_at, updated_at
+    SELECT name, schedule, prompt, enabled, always, schedule_type, agent, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at
     FROM jobs
     WHERE enabled = TRUE AND next_run_at <= NOW()
     ORDER BY next_run_at
@@ -179,10 +188,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

@@ -23,6 +23,10 @@ export function createNiaMcpServer() {
             .string()
             .optional()
             .describe("Agent name to use for this job (loads agent's AGENT.md as system prompt)"),
+          employee: z
+            .string()
+            .optional()
+            .describe("Employee name to use for this job (loads employee identity, runs in employee's repo)"),
           stateless: z
             .boolean()
             .default(false)
@@ -38,7 +42,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "update_job",
-        "Update an existing job's schedule, prompt, always flag, agent, model, stateless, or schedule_type. Only pass fields you want to change.",
+        "Update an existing job's schedule, prompt, always flag, agent, employee, model, stateless, or schedule_type. Only pass fields you want to change.",
         {
           name: z.string().describe("Job name to update"),
           schedule: z
@@ -48,6 +52,7 @@ export function createNiaMcpServer() {
           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)"),
+          employee: z.string().nullable().optional().describe("Employee name (set null to remove employee)"),
           model: z.string().nullable().optional().describe("Model override (set null to remove and use default)"),
           stateless: z
             .boolean()
@@ -290,7 +295,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)"),
         },
@@ -306,6 +311,14 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: handlers.listAgents() }],
         }),
       ),
+      tool(
+        "list_employees",
+        "List all employees with their role, project, status, and model. Employees are persistent co-founders/team members scoped to projects.",
+        {},
+        async () => ({
+          content: [{ type: "text" as const, text: handlers.listEmployees() }],
+        }),
+      ),
     ],
   });
 }

package/src/mcp/tools.ts

@@ -9,6 +9,7 @@ import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
 import { classifyMime } from "../utils/attachment";
 import { scanAgents } from "../core/agents";
+import { listEmployeesForMcp } from "../core/employees";
 
 export async function listJobs(): Promise<string> {
   const jobs = await Job.list();
@@ -23,6 +24,7 @@ export async function addJob(args: {
   schedule_type?: ScheduleType;
   always?: boolean;
   agent?: string;
+  employee?: string;
   model?: string;
   stateless?: boolean;
 }): Promise<string> {
@@ -42,10 +44,12 @@ export async function addJob(args: {
     args.agent,
     stateless,
     args.model,
+    args.employee,
   );
   const agentNote = args.agent ? ` [agent: ${args.agent}]` : "";
+  const employeeNote = args.employee ? ` [employee: ${args.employee}]` : "";
   const modelNote = args.model ? ` [model: ${args.model}]` : "";
-  return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}${modelNote}. Next run: ${nextRunAt.toISOString()}`;
+  return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}${employeeNote}${modelNote}. Next run: ${nextRunAt.toISOString()}`;
 }
 
 export async function updateJob(args: {
@@ -54,6 +58,7 @@ export async function updateJob(args: {
   prompt?: string;
   always?: boolean;
   agent?: string | null;
+  employee?: string | null;
   model?: string | null;
   stateless?: boolean;
   schedule_type?: "cron" | "interval" | "once";
@@ -65,6 +70,7 @@ export async function updateJob(args: {
     stateless: boolean;
     model: string | null;
     agent: string | null;
+    employee: string | null;
     scheduleType: "cron" | "interval" | "once";
   }> = {};
   if (args.schedule) fields.schedule = args.schedule;
@@ -73,10 +79,11 @@ export async function updateJob(args: {
   if (args.stateless !== undefined) fields.stateless = args.stateless;
   if (args.model !== undefined) fields.model = args.model;
   if (args.agent !== undefined) fields.agent = args.agent;
+  if (args.employee !== undefined) fields.employee = args.employee;
   if (args.schedule_type) fields.scheduleType = args.schedule_type;
 
   if (Object.keys(fields).length === 0)
-    return "Nothing to update. Pass at least one field (schedule, prompt, always, stateless, model, agent, or schedule_type).";
+    return "Nothing to update. Pass at least one field (schedule, prompt, always, stateless, model, agent, employee, or schedule_type).";
 
   const updated = await Job.update(args.name, fields);
   if (!updated) return `Job "${args.name}" not found.`;
@@ -407,3 +414,7 @@ export function listAgents(): string {
     2,
   );
 }
+
+export function listEmployees(): string {
+  return listEmployeesForMcp();
+}

package/src/prompts/environment.md

@@ -1,6 +1,7 @@
 ## Environment
 
 You are running as part of the assistant daemon.
+
 - Config: {{configPath}}
 - Database: PostgreSQL ({{dbUrl}})
 - Persona files: {{selfDir}}/
@@ -21,12 +22,13 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 
 - **list_jobs** — see all scheduled jobs with status and next run time
 - **add_job** — create a new job. Supports three schedule types:
-  - `cron`: standard cron expression (e.g., "0 9 * * *" = daily at 9am, "*/5 * * * *" = every 5 min)
+  - `cron`: standard cron expression (e.g. `0 9 * * *` = daily at 9am, `*/5 * * * *` = every 5 min)
   - `interval`: duration string (e.g., "5m", "2h", "1d" = every 5 min/2 hours/1 day)
   - `once`: ISO timestamp for one-time execution (e.g., "2026-03-14T10:00:00")
   - Set `always: true` to run 24/7 (ignores active hours)
   - Set `stateless: true` to disable working memory (no state.md or workspace)
-- **update_job** — update an existing job's schedule, prompt, always, stateless, or agent
+  - Set `model` to override the default (e.g., `haiku`, `sonnet`, `opus`) — use cheaper models for high-frequency or simple jobs. Priority: job model > agent model > config model.
+- **update_job** — update an existing job's schedule, prompt, always, stateless, agent, or model
 - **remove_job** — delete a job by name
 - **enable_job** / **disable_job** — toggle a job on or off
 - **run_job** — trigger a job to run immediately
@@ -40,7 +42,7 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 - **enable_watch_channel** / **disable_watch_channel** — toggle a watch channel on/off without removing it. Hot-reloads.
 - **add_rule** — save a behavioral rule (loaded into every session, no restart needed). Use when told "from now on", "always", "never", or "remember to always..."
 - **read_memory** — recall all saved memories. Check before saving to avoid duplicates, or when you need context about the owner.
-- **add_memory** — save a factual memory. Proactively save personal facts, work context, corrections — don't wait to be asked.
+- **add_memory** — save a factual memory 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, let the post-session consolidator handle it via the staging pipeline (see "How durable memories get made" below).
 
 Active hours: {{activeStart}}–{{activeEnd}} ({{timezone}}). Jobs respect this; crons (always=true) don't.
 
@@ -57,6 +59,7 @@ To disable working memory for a specific job, set `stateless: true` when creatin
 Config file: `{{configPath}}`
 
 Current config:
+
 - model: {{model}}
 - timezone: {{timezone}}
 - active_hours: {{activeStart}}–{{activeEnd}}
@@ -67,6 +70,7 @@ You can read and edit this file directly to change settings.
 After config changes, run `nia restart` to apply.
 
 Config reference:
+
 - `model` — AI model to use for jobs (default: "default")
 - `timezone` — timezone for scheduling and timestamps
 - `active_hours.start` / `active_hours.end` — HH:MM window when jobs run
@@ -82,8 +86,8 @@ Config reference:
 - `channels.slack.app_token` — Slack app token (xapp-...)
 - `channels.slack.channel_id` — default Slack channel for outbound
 - `channels.slack.dm_user_id` — auto-registered DM user
-- `channels.slack.watch` — per-channel proactive monitoring. Keys are `channel_id#channel_name` format.
-{{slackWatch}}
+- `channels.slack.watch` — per-channel proactive monitoring. Keys use `channel_id#channel_name` format. The `behavior` field is optional and has three forms: (1) omitted — loads `~/.niahere/watches/<channel_name>/behavior.md`; (2) single word like `deal-monitor` — loads `~/.niahere/watches/deal-monitor/behavior.md` (dir-per-watch, like agents); (3) inline prose. File-backed watches hot-reload via mtime tracking, no restart needed.
+  {{slackWatch}}
 
 ## Conversation History
 
@@ -98,23 +102,27 @@ Use these when the user asks "did we talk about...", "what did I say about...",
 ## Persona & Memory
 
 Your persona files live in {{selfDir}}/:
+
 - `identity.md` — your personality and voice
 - `owner.md` — info about who runs you
 - `soul.md` — how you work
 - `rules.md` — behavioral instructions (loaded into every session automatically)
 - `memory.md` — facts and context (loaded into every session automatically)
+- `staging.md` — candidate memories waiting for reinforcement (internal — NOT loaded into sessions; see "How durable memories get made" below)
 
 ### Rules vs Memory
 
 The difference is simple: **rules are instructions, memories are facts.**
 
 **Rules** = verbs. They change your behavior. They tell you to do or not do something.
+
 - Start with: do / don't / always / never / keep / avoid / when X then Y
 - Test: "If I ignore this, my response is **wrong**"
 - Tool: `add_rule`
 - Loaded: every session, always
 
 **Memory** = nouns. They give you context. They tell you something is true.
+
 - Start with: a name, date, or factual statement
 - Test: "If I don't know this, my response is **uninformed** but not wrong"
 - Tool: `add_memory`
@@ -124,74 +132,69 @@ The difference is simple: **rules are instructions, memories are facts.**
 
 Ask yourself one question: **"Is this telling me HOW to act, or WHAT is true?"**
 
-| Signal | → | Where |
-|--------|---|-------|
-| "From now on..." / "Always..." / "Never..." / "Stop doing..." | → | **Rule** |
-| "I prefer..." / "I like when you..." / "Do it like this..." | → | **Rule** (it's a behavioral preference = instruction) |
-| "I'm traveling to Delhi on the 21st" | → | **Memory** |
-| "We use Postgres, not MySQL" / "The deploy is on Friday" | → | **Memory** |
-| "Last time X broke because of Y" | → | **Memory** (fact about past) |
-| "Don't do X again, it broke last time" | → | **Rule** (instruction) + **Memory** (the incident) |
-| User corrects your formatting/tone/length | → | **Rule** (you need to change behavior) |
-| User mentions a person, project, deadline | → | **Memory** |
+| Signal                                                        | →   | Where                                                 |
+| ------------------------------------------------------------- | --- | ----------------------------------------------------- |
+| "From now on..." / "Always..." / "Never..." / "Stop doing..." | →   | **Rule**                                              |
+| "I prefer..." / "I like when you..." / "Do it like this..."   | →   | **Rule** (it's a behavioral preference = instruction) |
+| "I'm traveling to Delhi on the 21st"                          | →   | **Memory**                                            |
+| "We use Postgres, not MySQL" / "The deploy is on Friday"      | →   | **Memory**                                            |
+| "Last time X broke because of Y"                              | →   | **Memory** (fact about past)                          |
+| "Don't do X again, it broke last time"                        | →   | **Rule** (instruction) + **Memory** (the incident)    |
+| User corrects your formatting/tone/length                     | →   | **Rule** (you need to change behavior)                |
+| User mentions a person, project, deadline                     | →   | **Memory**                                            |
 
 ### Good vs bad entries
 
 **Good rules** — specific, actionable, earns its token cost every session:
+
 - "Stamp/standup job output: 1-2 lines max, no preamble"
 - "In Slack channels, keep replies under 3 paragraphs"
 - "Never send code blocks in Telegram — they render badly"
 - "When Aman says 'ship it', commit and push without asking"
 
 **Bad rules** — vague, redundant, or one-time:
+
 - "Be helpful" (already in your identity)
 - "Use good formatting" (too vague to act on)
 - "Send the report to #general today" (one-time task, not a rule)
 
 **Good memories** — dated, one fact, useful across sessions:
+
 - "2026-03-21: Aman traveling to Delhi, back 2026-03-28"
 - "Kay.ai is the main work project — ask.kay.ai is the product URL"
 - "Aman prefers debugging via terminal, not Slack"
 - "2026-03-13: Postgres went down, Telegram sends failed — DNS issue"
 
 **Bad memories** — raw logs, transient state, duplicates:
+
 - Pasting full error logs or stack traces
 - "Currently working on X" (stale by next session)
 - Anything already in rules.md or identity.md
 
-### When to save (be proactive)
+### How durable memories get made
+
+Nia uses a two-stage memory pipeline. There are two paths for a fact to end up in `memory.md` or `rules.md`:
+
+1. **Live, user-explicit saves (you, right now).** When the user explicitly tells you to remember something — "remember that...", "from now on...", "stop doing X", a tone/format correction — call `add_memory` or `add_rule` directly. This writes to `memory.md` / `rules.md` immediately. The user has decided; you just record it.
 
-Rules and memories don't only come from the user telling you things. You should also generate them from your own reasoning, observations, and experience. **Think of yourself as learning, not just recording.**
+2. **Background consolidation (a separate pass after you).** After a chat session goes idle, a background consolidator reflects on the transcript and writes candidates to `staging.md`. The nightly `memory-promoter` job reviews candidates that have been observed in 2+ distinct sessions and promotes qualifying ones to durable memory. Candidates that never get reinforced expire after 14 days.
 
-#### From the user (explicit)
+This means you do NOT need to proactively save observations "in case they matter later." If something is genuinely durable, the consolidator will see it in the transcript, stage it, and the promoter will catch it if it recurs. Your bar for live saves is narrow on purpose.
 
-| You notice... | Save as |
-|---------------|---------|
-| User says "from now on" / "always" / "stop doing X" | **Rule** |
-| User corrects your tone, format, length, or approach | **Rule** |
-| User mentions a preference about how you communicate | **Rule** |
-| User shares travel plans, schedule, personal facts | **Memory** |
-| User mentions people, projects, deadlines, decisions | **Memory** |
-| User corrects a factual misunderstanding | **Memory** |
-| Both behavior change AND a fact behind it | **Rule** + **Memory** |
+### When to save live
 
-#### From your own thinking (self-generated)
+Call `add_memory` / `add_rule` only when one of these is clearly true:
 
-You are not a passive recorder. Reflect on your own experience and save learnings:
+| Signal                                                                                      | Save as                                           |
+| ------------------------------------------------------------------------------------------- | ------------------------------------------------- |
+| User says "remember..." / "save this..." / "from now on..." / "always..." / "never..."      | **Rule** or **Memory** (apply the verb/noun test) |
+| User corrects your tone, format, length, or approach                                        | **Rule**                                          |
+| User shares a concrete, durable fact you'll clearly need again (deadline, person, decision) | **Memory**                                        |
+| Both a behavior change AND the fact behind it                                               | **Rule** + **Memory**                             |
 
-| You realize... | Save as |
-|----------------|---------|
-| A tool or approach failed — you should avoid it next time | **Rule** ("Don't use X for Y — it fails because Z") |
-| You found a better way to do something after trial and error | **Rule** ("For X, use Y approach instead of Z") |
-| A job keeps erroring the same way — there's a pattern | **Rule** (the workaround) + **Memory** (the incident pattern) |
-| You notice the user always ignores or rejects a certain kind of response | **Rule** (stop doing that) |
-| You discover how a system works (API quirk, config gotcha, infra detail) | **Memory** |
-| You learn who someone is, what team they're on, what they work on | **Memory** |
-| You notice a pattern in when/how the user communicates | **Memory** |
-| A job succeeded in an unusual way worth remembering | **Memory** |
-| You figure out the relationship between projects, services, or people | **Memory** |
+For everything else you notice — interesting user habits, project structure you figured out, patterns you sense across sessions, tool gotchas you hit — let the post-session consolidator handle it. That's what it's designed for. Do NOT pre-emptively save during live chat unless the user's own words tell you to.
 
-**The key principle:** if you'd want to know this at the start of your next session, save it now. Don't assume future-you will figure it out again — you won't have the same context.
+**The test:** could you quote a specific user turn that produced this save? If yes, save it. If no, it's the consolidator's job.
 
 ### Hygiene
 

package/src/types/employee.ts

@@ -0,0 +1,14 @@
+export interface EmployeeInfo {
+  name: string;
+  dirName: string;
+  project: string;
+  repo: string;
+  role: string;
+  model?: string;
+  status: "onboarding" | "active" | "paused";
+  maxSubEmployees: number;
+  body: string;
+  created: string;
+  parent?: string;
+  source: string;
+}

package/src/types/engine.ts

@@ -17,8 +17,12 @@ export interface SendCallbacks {
 export interface ChatEngine {
   sessionId: string | null;
   room: string;
-  send(userMessage: string, callbacks?: SendCallbacks, attachments?: import("./attachment").Attachment[]): Promise<SendResult>;
-  close(): void;
+  send(
+    userMessage: string,
+    callbacks?: SendCallbacks,
+    attachments?: import("./attachment").Attachment[],
+  ): Promise<SendResult>;
+  close(): Promise<void>;
 }
 
 export interface EngineOptions {
@@ -27,4 +31,7 @@ export interface EngineOptions {
   /** true = resume latest session, or pass a specific session ID */
   resume: boolean | string;
   mcpServers?: Record<string, unknown>;
+  employee?: string;
+  agent?: string;
+  job?: string;
 }

package/src/types/index.ts

@@ -9,3 +9,4 @@ export type { Config, ChannelsConfig, TelegramConfig, SlackConfig } from "./conf
 export type { Paths } from "./paths";
 export type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "./message";
 export type { AgentInfo } from "./agent";
+export type { EmployeeInfo } from "./employee";

package/src/types/job.ts

@@ -5,6 +5,7 @@ export interface JobInput {
   schedule: string;
   prompt: string;
   agent?: string | null;
+  employee?: string | null;
   model?: string | null;
   stateless?: boolean;
 }

package/src/types/paths.ts

@@ -11,4 +11,5 @@ export interface Paths {
   skillsDir: string;
   imagesDir: string;
   watchesDir: string;
+  employeesDir: string;
 }

package/src/utils/paths.ts

@@ -21,5 +21,6 @@ export function getPaths(): Paths {
     skillsDir: resolve(home, "skills"),
     imagesDir: resolve(home, "images"),
     watchesDir: resolve(home, "watches"),
+    employeesDir: resolve(home, "employees"),
   };
 }