niahere 0.2.37 → 0.2.38

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.38",
   "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/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/daemon.ts

@@ -171,7 +171,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);
     }
 

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 {