niahere 0.2.37 → 0.2.40

package/README.md

@@ -35,6 +35,7 @@ nia start               # starts daemon + registers OS service
 - **Terminal chat** — REPL with session resume support
 - **Scheduled jobs** — recurring jobs and crons that run Claude and can message you back
 - **Persona system** — customizable identity, soul, owner profile, and on-demand memory
+- **Agents** — domain specialists (marketer, senior-dev) via Claude Agent SDK subagents
 - **Skills** — loads skills from multiple directories, invokable as slash commands
 - **Cross-platform service** — launchd (macOS), systemd (Linux), service-aware restart
 - **MCP tools** — 18 tools for job management, messaging, memory, and channel control
@@ -58,12 +59,16 @@ nia version                    — show version
 nia job list                   — list all jobs
 nia job show [name]            — full details + recent runs
 nia job add <n> <s> <p>        — add a job (active hours only)
+nia job add <n> <s> <p> --agent <name> — add a job using an agent
 nia job add <n> <s> <p> --always — add a cron (runs 24/7)
 nia job remove <name>          — delete a job
 nia job enable / disable <n>   — toggle a job
 nia job run <name>             — run a job once
 nia job log [name]             — show recent run history
 
+nia agent list                 — list available agents
+nia agent show <name>          — show agent details and prompt
+
 nia db setup                   — install PostgreSQL + create database + migrate
 nia db migrate                 — run database migrations
 nia db status                  — check database connection

package/package.json

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

package/src/channels/slack.ts

@@ -120,7 +120,7 @@ class SlackChannel implements Channel {
       }
       const queued = state.lock !== Promise.resolve();
       if (queued) log.debug({ key }, "slack: message queued behind active lock");
-      state.lock = state.lock.then(fn, fn);
+      state.lock = state.lock.then(fn, fn).catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
     }
 
     const self = this;
@@ -479,7 +479,13 @@ class SlackChannel implements Channel {
 
       log.info({ channel: msg.channel, key, text: text.slice(0, 100), isDm, watched: isWatched, attachments: attachments?.length || 0 }, "slack message received");
 
-      const state = await getState(key);
+      let state: ChatState;
+      try {
+        state = await getState(key);
+      } catch (err) {
+        log.error({ err, key }, "slack: failed to create chat engine");
+        return;
+      }
 
       withLock(key, async () => {
         // Add thinking reaction inside the lock so cleanup is guaranteed

package/src/chat/engine.ts

@@ -6,6 +6,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
 import { buildSystemPrompt } 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";
@@ -177,6 +178,11 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       options.mcpServers = mcpServers;
     }
 
+    const agentDefs = getAgentDefinitions();
+    if (Object.keys(agentDefs).length > 0) {
+      options.agents = agentDefs;
+    }
+
     queryHandle = query({
       prompt: stream as any,
       options: options as any,

package/src/chat/identity.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 import { getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
 import { getSkillsSummary } from "../core/skills";
+import { getAgentsSummary } from "../core/agents";
 import type { Mode } from "../types";
 
 // Re-export for backwards compat
@@ -37,5 +38,8 @@ export function buildSystemPrompt(mode: Mode = "chat", channel: string = "termin
   const skills = getSkillsSummary();
   if (skills) parts.push(skills);
 
+  const agents = getAgentsSummary();
+  if (agents) parts.push(agents);
+
   return parts.join("\n\n");
 }

package/src/cli/agent.ts

@@ -0,0 +1,47 @@
+import { scanAgents } from "../core/agents";
+
+export async function agentCommand(): Promise<void> {
+  const subcommand = process.argv[3];
+
+  switch (subcommand) {
+    case "list": {
+      const agents = scanAgents();
+      if (agents.length === 0) {
+        console.log("No agents found. Create agents in ~/.niahere/agents/<name>/AGENT.md");
+      } else {
+        for (const a of agents) {
+          const model = a.model ? `  (${a.model})` : "";
+          console.log(`  ${a.name}${model}  [${a.source}]`);
+          if (a.description) console.log(`    ${a.description}`);
+        }
+      }
+      break;
+    }
+
+    case "show": {
+      const name = process.argv[4];
+      if (!name) {
+        console.error("Usage: nia agent show <name>");
+        process.exit(1);
+      }
+      const agents = scanAgents();
+      const agent = agents.find((a) => a.name === name);
+      if (!agent) {
+        console.error(`Agent "${name}" not found.`);
+        process.exit(1);
+      }
+      console.log(`Name:        ${agent.name}`);
+      console.log(`Description: ${agent.description}`);
+      if (agent.model) console.log(`Model:       ${agent.model}`);
+      console.log(`Source:      ${agent.source}`);
+      console.log(`\n--- Prompt ---\n`);
+      console.log(agent.body);
+      break;
+    }
+
+    default:
+      console.log("Usage: nia agent <list|show>");
+      console.log("  list          List all available agents");
+      console.log("  show <name>   Show agent details and prompt");
+  }
+}

package/src/cli/index.ts

@@ -14,6 +14,7 @@ import { statusCommand } from "./status";
 import { sendCommand, telegramCommand, slackCommand } from "./channels";
 import { rulesCommand, memoryCommand } from "./self";
 import { watchCommand } from "./watch";
+import { agentCommand } from "./agent";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -286,6 +287,11 @@ switch (command) {
     break;
   }
 
+  case "agent": {
+    await agentCommand();
+    break;
+  }
+
   case "skills": {
     const { scanSkills: loadSkills } = await import("../core/skills");
     const filter = process.argv[3]; // e.g. "project", "nia", "shared", "claude"
@@ -485,6 +491,7 @@ switch (command) {
     console.log("  rules [show|reset]  — view or reset rules.md");
     console.log("  memory [show|reset] — view or reset memory.md");
     console.log("  db <sub>            — database setup/status/migrate");
+    console.log("  agent <sub>         — list/show agents");
     console.log("  skills              — list available skills");
     console.log("  watch <sub>         — manage Slack watch channels");
     console.log("  validate            — validate config.yaml");

package/src/cli/job.ts

@@ -50,7 +50,8 @@ export async function jobCommand(): Promise<void> {
             for (const job of jobs) {
               const tag = job.always ? "  always" : "";
               const type = job.scheduleType !== "cron" ? ` (${job.scheduleType})` : "";
-              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}`);
+              const agentTag = job.agent ? `  [${job.agent}]` : "";
+              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}${agentTag}`);
             }
           }
         });
@@ -75,12 +76,20 @@ export async function jobCommand(): Promise<void> {
         }
       }
 
+      // Parse --agent flag
+      let agent: string | undefined;
+      const agentIdx = cliArgs.indexOf("--agent");
+      if (agentIdx !== -1 && cliArgs[agentIdx + 1]) {
+        agent = cliArgs[agentIdx + 1];
+        cliArgs.splice(agentIdx, 2);
+      }
+
       const name = cliArgs[0];
       const schedule = cliArgs[1];
       const prompt = cliArgs.slice(2).join(" ");
 
       if (!name || !schedule || !prompt) {
-        console.log('Usage: nia job add <name> <schedule> <prompt> [--always] [--type cron|interval|once]');
+        console.log('Usage: nia job add <name> <schedule> <prompt> [--always] [--type cron|interval|once] [--agent <name>]');
         fail('Example: nia job add heartbeat "*/10 * * * *" Check system health --always');
       }
 
@@ -93,7 +102,7 @@ export async function jobCommand(): Promise<void> {
         const config = getConfig();
         const nextRunAt = computeInitialNextRun(scheduleType, schedule, config.timezone);
         await withDb(async () => {
-          await Job.create(name, schedule, prompt, always, scheduleType, nextRunAt);
+          await Job.create(name, schedule, prompt, always, scheduleType, nextRunAt, agent);
           console.log(`Job "${name}" added (${scheduleType}: ${schedule}).${always ? " (runs 24/7)" : ""}`);
         });
       } catch (err) {
@@ -178,6 +187,7 @@ export async function jobCommand(): Promise<void> {
           console.log(`  schedule: ${job.schedule}`);
           console.log(`  enabled:  ${job.enabled}`);
           console.log(`  type:     ${job.always ? "cron (runs 24/7)" : "job (active hours only)"}`);
+          if (job.agent) console.log(`  agent:    ${job.agent}`);
           console.log(`  prompt:   ${job.prompt}`);
 
           const state = readState();
@@ -307,6 +317,7 @@ export async function jobCommand(): Promise<void> {
       console.log("  status [name]                 — quick status check");
       console.log("  add <name> <schedule> <prompt> — add a job (active hours only)")
       console.log("      --always                  — run 24/7 regardless of active hours");
+      console.log("      --agent <name>            — assign an agent to the job");
       console.log("  update <name> [--schedule s] [--prompt p] [--always] — update a job");
       console.log("  remove <name>                 — delete a job");
       console.log("  enable <name>                 — enable a job");

package/src/cli/status.ts

@@ -23,6 +23,7 @@ type JobStatusLine = {
   enabled: boolean;
   always: boolean;
   scheduleType: ScheduleType;
+  agent: string | null;
   status: JobStateStatus | "never";
   lastRun: string | null;
   nextRunAt: string | null;
@@ -121,6 +122,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
         enabled: job.enabled,
         always: job.always,
         scheduleType: job.scheduleType,
+        agent: job.agent,
         status: stateInfo?.status ?? (job.lastRunAt ? "ok" : "never"),
         lastRun: safeDate(lastRun)?.toISOString() ?? null,
         nextRunAt: safeDate(job.nextRunAt)?.toISOString() ?? null,
@@ -142,6 +144,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
               enabled: false,
               always: false,
               scheduleType: "cron",
+              agent: null,
               status: info.status,
               lastRun,
               nextRunAt: null,
@@ -253,7 +256,8 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
         const lastText = lastRun ? formatTimeLine(lastRun, now) : "never";
         const staleText = stale ? "  ⚠ stale" : "";
 
-        console.log(`  ${job.enabled ? "\u25cf" : "\u25cb"} ${job.name.padEnd(20)} ${job.enabled ? "enabled" : "disabled"}`);
+        const agentTag = job.agent ? `  [${job.agent}]` : "";
+        console.log(`  ${job.enabled ? "\u25cf" : "\u25cb"} ${job.name.padEnd(20)} ${job.enabled ? "enabled" : "disabled"}${agentTag}`);
         console.log(`      ${statusIcon} ${status}   last: ${lastText}   next: ${nextText}   duration: ${durationText}${staleText}`);
       }
     } else {

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/agents.ts

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import yaml from "js-yaml";
+import { getNiaHome } from "../utils/paths";
+import { log } from "../utils/log";
+import type { AgentInfo } from "../types/agent";
+
+// niahere project root (resolved from this file's location)
+const PROJECT_ROOT = resolve(import.meta.dir, "../..");
+
+function getAgentDirs(): { dir: string; source: string }[] {
+  const niaHome = getNiaHome();
+  const dirs: { dir: string; source: string }[] = [
+    { dir: join(process.cwd(), "agents"), source: "cwd" },
+    { dir: join(PROJECT_ROOT, "agents"), source: "project" },
+    { dir: join(niaHome, "agents"), source: "nia" },
+    { dir: join(homedir(), ".shared", "agents"), source: "shared" },
+  ];
+  // Deduplicate paths (cwd, project, and nia may overlap)
+  const seen = new Set<string>();
+  return dirs.filter(({ dir }) => {
+    const resolved = resolve(dir);
+    if (seen.has(resolved)) return false;
+    seen.add(resolved);
+    return true;
+  });
+}
+
+export function scanAgents(): AgentInfo[] {
+  const agents: AgentInfo[] = [];
+  const seen = new Set<string>();
+
+  for (const { dir, source } of getAgentDirs()) {
+    if (!existsSync(dir)) continue;
+
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+
+      const agentFile = join(dir, entry.name, "AGENT.md");
+      if (!existsSync(agentFile)) continue;
+
+      const content = readFileSync(agentFile, "utf8");
+      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!fmMatch) continue;
+
+      let meta: Record<string, unknown> = {};
+      try {
+        meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
+      } catch (err) {
+        log.warn({ err, agent: entry.name, path: agentFile }, "failed to parse agent metadata, skipping");
+        continue;
+      }
+      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
+
+      if (seen.has(name)) continue;
+      seen.add(name);
+
+      const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+
+      agents.push({
+        name,
+        description: typeof meta.description === "string" ? meta.description : "",
+        body,
+        model: typeof meta.model === "string" ? meta.model : undefined,
+        source,
+      });
+    }
+  }
+
+  return agents;
+}
+
+export function getAgentsSummary(): string {
+  const agents = scanAgents();
+  if (agents.length === 0) return "";
+  const lines = agents.map((a) => a.description ? `- @${a.name}: ${a.description}` : `- @${a.name}`);
+  return `Available agents:\n${lines.join("\n")}`;
+}
+
+export function getAgentDefinitions(): Record<string, { description: string; prompt: string; model?: string }> {
+  const agents = scanAgents();
+  const defs: Record<string, { description: string; prompt: string; model?: string }> = {};
+
+  for (const agent of agents) {
+    defs[agent.name] = {
+      description: agent.description,
+      prompt: agent.body,
+      ...(agent.model ? { model: agent.model } : {}),
+    };
+  }
+
+  return defs;
+}

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.
@@ -171,7 +174,8 @@ export async function runDaemon(): Promise<void> {
     process.exit(1);
   });
   process.on("unhandledRejection", (reason) => {
-    log.fatal({ reason }, "unhandled rejection — cleaning up");
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    log.fatal({ err }, "unhandled rejection — cleaning up");
     removePid();
     process.exit(1);
   });

package/src/core/runner.ts

@@ -7,6 +7,7 @@ import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
+import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
 
 export type ActivityCallback = (line: string) => void;
@@ -195,12 +196,30 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     const cwd = homedir();
     let output: RunnerOutput;
 
+    // Resolve system prompt: use agent body if job references an agent, else default
+    let systemPrompt: string;
+    let agentModel: string | undefined;
+    if (job.agent) {
+      const agents = scanAgents();
+      const agentDef = agents.find((a) => a.name === job.agent);
+      if (agentDef) {
+        systemPrompt = agentDef.body;
+        agentModel = agentDef.model;
+      } else {
+        systemPrompt = buildSystemPrompt("job");
+      }
+    } else {
+      systemPrompt = buildSystemPrompt("job");
+    }
+
+    const jobPrompt = job.prompt
+      ? `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`
+      : `Job: ${job.name} (schedule: ${job.schedule})\n\nExecute your scheduled tasks.`;
+
     if (config.runner === "codex") {
-      const fullPrompt = `${buildSystemPrompt("job")}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
-      output = await runJobWithCodex(fullPrompt, cwd, config.model);
+      const fullPrompt = `${systemPrompt}\n\n---\n\n${jobPrompt}`;
+      output = await runJobWithCodex(fullPrompt, cwd, agentModel || config.model);
     } else {
-      const systemPrompt = buildSystemPrompt("job");
-      const jobPrompt = `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
       output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity);
     }
 
@@ -228,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) {
@@ -259,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/migrations/007_jobs_agent.ts

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

package/src/db/models/job.ts

@@ -8,6 +8,7 @@ export interface Job {
   enabled: boolean;
   always: boolean;
   scheduleType: ScheduleType;
+  agent: string | null;
   nextRunAt: string | null;
   lastRunAt: string | null;
   createdAt: string;
@@ -22,6 +23,7 @@ function toJob(r: Record<string, any>): Job {
     enabled: r.enabled,
     always: r.always ?? false,
     scheduleType: r.schedule_type || "cron",
+    agent: r.agent || null,
     nextRunAt: r.next_run_at ? String(r.next_run_at) : null,
     lastRunAt: r.last_run_at ? String(r.last_run_at) : null,
     createdAt: String(r.created_at),
@@ -41,6 +43,7 @@ export async function create(
   always = false,
   scheduleType: ScheduleType = "cron",
   nextRunAt?: Date,
+  agent?: string,
 ): Promise<void> {
   const existing = await get(name);
   if (existing) {
@@ -48,27 +51,27 @@ export async function create(
   }
   const sql = getSql();
   await sql`
-    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at)
-    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null})
+    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent)
+    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null})
   `;
   await notifyChange();
 }
 
 export async function list(): Promise<Job[]> {
   const sql = getSql();
-  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, next_run_at, last_run_at, created_at, updated_at FROM jobs ORDER BY name`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, 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, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
   return rows.length > 0 ? toJob(rows[0]) : null;
 }
 
 export async function update(
   name: string,
-  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean }>,
+  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean; agent: string | null }>,
 ): Promise<boolean> {
   const sql = getSql();
   const existing = await get(name);
@@ -78,10 +81,11 @@ export async function update(
   const prompt = fields.prompt ?? existing.prompt;
   const enabled = fields.enabled ?? existing.enabled;
   const always = fields.always ?? existing.always;
+  const agent = fields.agent !== undefined ? fields.agent : existing.agent;
 
   await sql`
     UPDATE jobs
-    SET schedule = ${schedule}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, updated_at = NOW()
+    SET schedule = ${schedule}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, updated_at = NOW()
     WHERE name = ${name}
   `;
   await notifyChange();
@@ -97,14 +101,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, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
+  const rows = await sql`SELECT name, schedule, prompt, enabled, always, schedule_type, agent, 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, next_run_at, last_run_at, created_at, updated_at
+    SELECT name, schedule, prompt, enabled, always, schedule_type, agent, 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

package/src/mcp/server.ts

@@ -24,6 +24,7 @@ export function createNiaMcpServer() {
           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"),
+          agent: z.string().optional().describe("Agent name to use for this job (loads agent's AGENT.md as system prompt)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: await handlers.addJob(args) }],
@@ -31,12 +32,13 @@ export function createNiaMcpServer() {
       ),
       tool(
         "update_job",
-        "Update an existing job's schedule, prompt, or always flag. Only pass fields you want to change.",
+        "Update an existing job's schedule, prompt, always flag, or agent. Only pass fields you want to change.",
         {
           name: z.string().describe("Job name to update"),
           schedule: z.string().optional().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)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: await handlers.updateJob(args) }],
@@ -166,6 +168,14 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: handlers.addMemory(args.entry) }],
         }),
       ),
+      tool(
+        "list_agents",
+        "List all available agents. Agents are role/domain specialists that can be delegated to via the Agent tool or referenced by jobs.",
+        {},
+        async () => ({
+          content: [{ type: "text" as const, text: handlers.listAgents() }],
+        }),
+      ),
     ],
   });
 }

package/src/mcp/tools.ts

@@ -8,6 +8,7 @@ import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
 import { classifyMime } from "../utils/attachment";
+import { scanAgents } from "../core/agents";
 
 export async function listJobs(): Promise<string> {
   const jobs = await Job.list();
@@ -21,14 +22,16 @@ export async function addJob(args: {
   prompt: string;
   schedule_type?: ScheduleType;
   always?: boolean;
+  agent?: string;
 }): Promise<string> {
   const scheduleType = args.schedule_type || "cron";
   const always = args.always || false;
   const config = getConfig();
 
   const nextRunAt = computeInitialNextRun(scheduleType, args.schedule, config.timezone);
-  await Job.create(args.name, args.schedule, args.prompt, always, scheduleType, nextRunAt);
-  return `Job "${args.name}" created (${scheduleType}: ${args.schedule}). Next run: ${nextRunAt.toISOString()}`;
+  await Job.create(args.name, args.schedule, args.prompt, always, scheduleType, nextRunAt, args.agent);
+  const agentNote = args.agent ? ` [agent: ${args.agent}]` : "";
+  return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}. Next run: ${nextRunAt.toISOString()}`;
 }
 
 export async function updateJob(args: {
@@ -36,13 +39,15 @@ export async function updateJob(args: {
   schedule?: string;
   prompt?: string;
   always?: boolean;
+  agent?: string | null;
 }): Promise<string> {
-  const fields: Partial<{ schedule: string; prompt: string; always: boolean }> = {};
+  const fields: Partial<{ schedule: string; prompt: string; always: boolean; agent: string | null }> = {};
   if (args.schedule) fields.schedule = args.schedule;
   if (args.prompt) fields.prompt = args.prompt;
   if (args.always !== undefined) fields.always = args.always;
+  if (args.agent !== undefined) fields.agent = args.agent;
 
-  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, or always).";
+  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, always, or agent).";
 
   const updated = await Job.update(args.name, fields);
   if (!updated) return `Job "${args.name}" not found.`;
@@ -327,3 +332,13 @@ export function addMemory(entry: string): string {
   }
   return `Memory saved.`;
 }
+
+export function listAgents(): string {
+  const agents = scanAgents();
+  if (agents.length === 0) return "No agents found.";
+  return JSON.stringify(
+    agents.map((a) => ({ name: a.name, description: a.description, model: a.model, source: a.source })),
+    null,
+    2,
+  );
+}

package/src/types/agent.ts

@@ -0,0 +1,7 @@
+export interface AgentInfo {
+  name: string;
+  description: string;
+  body: string;
+  model?: string;
+  source: string;
+}

package/src/types/index.ts

@@ -8,3 +8,4 @@ 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 { AgentInfo } from "./agent";

package/src/types/job.ts

@@ -4,6 +4,7 @@ export interface JobInput {
   name: string;
   schedule: string;
   prompt: string;
+  agent?: string | null;
 }
 
 export interface JobResult {