niahere 0.2.63 → 0.2.65

package/src/cli/job.ts

@@ -23,6 +23,7 @@ Commands:
       --type cron|interval|once   Schedule type (default: cron)
       --always                    Run 24/7 regardless of active hours
       --agent <name>              Assign an agent to the job
+      --employee <name>           Assign an employee to the job
       --model <model>             Model override (e.g. haiku, sonnet, opus)
       --stateless yes|no          Disable working memory for this job
   update <name>                 Update a job
@@ -32,6 +33,7 @@ Commands:
       --type cron|interval|once   Change schedule type
       --always / --no-always      Toggle 24/7 mode
       --agent <name>              Assign agent (--no-agent to remove)
+      --employee <name>           Assign employee (--no-employee to remove)
       --model <model>             Model override (--no-model to remove)
       --stateless yes|no            Toggle working memory
   remove <name>                 Delete a job
@@ -96,7 +98,8 @@ export async function jobCommand(): Promise<void> {
               const tag = job.always ? "  always" : "";
               const type = job.scheduleType !== "cron" ? ` (${job.scheduleType})` : "";
               const agentTag = job.agent ? `  [${job.agent}]` : "";
-              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}${agentTag}`);
+              const empTag = job.employee ? `  [emp:${job.employee}]` : "";
+              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}${agentTag}${empTag}`);
             }
           }
         });
@@ -122,6 +125,7 @@ export async function jobCommand(): Promise<void> {
       const statelessRaw = args.getString("stateless");
       const stateless = statelessRaw ? ["yes", "y", "true", "t", "1"].includes(statelessRaw.toLowerCase()) : false;
       const agent = args.getString("agent");
+      const employee = args.getString("employee");
       const model = args.getString("model");
 
       const [name, schedule, ...promptParts] = args.positional;
@@ -149,7 +153,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, agent, stateless, model);
+          await Job.create(name, schedule, prompt, always, scheduleType, nextRunAt, agent, stateless, model, employee);
           console.log(`Job "${name}" added (${scheduleType}: ${schedule}).${always ? " (runs 24/7)" : ""}`);
         });
       } catch (err) {
@@ -213,6 +217,7 @@ export async function jobCommand(): Promise<void> {
         model: string | null;
         scheduleType: ScheduleType;
         agent: string | null;
+        employee: string | null;
       }> = {};
       const schedule = args.getString("schedule");
       const promptFile = args.getString("prompt-file");
@@ -227,6 +232,8 @@ export async function jobCommand(): Promise<void> {
       const statelessRaw = args.getString("stateless");
       const agent = args.getString("agent");
       const noAgent = args.getBool("agent");
+      const employeeFlag = args.getString("employee");
+      const noEmployee = args.getBool("employee");
 
       if (schedule) fields.schedule = schedule;
       if (prompt) fields.prompt = prompt;
@@ -240,6 +247,8 @@ export async function jobCommand(): Promise<void> {
       if (statelessRaw) fields.stateless = ["yes", "y", "true", "t", "1"].includes(statelessRaw.toLowerCase());
       if (agent) fields.agent = agent;
       if (noAgent === false) fields.agent = null;
+      if (employeeFlag) fields.employee = employeeFlag;
+      if (noEmployee === false) fields.employee = null;
       const modelFlag = args.getString("model");
       const noModel = args.getBool("model");
       if (modelFlag) fields.model = modelFlag;
@@ -247,7 +256,7 @@ export async function jobCommand(): Promise<void> {
 
       if (Object.keys(fields).length === 0) {
         fail(
-          "Nothing to update. Pass at least one flag (--schedule, --prompt, --type, --always, --stateless, --model, --agent).",
+          "Nothing to update. Pass at least one flag (--schedule, --prompt, --type, --always, --stateless, --model, --agent, --employee).",
         );
       }
 
@@ -276,6 +285,7 @@ export async function jobCommand(): Promise<void> {
           console.log(`  enabled:  ${job.enabled}`);
           console.log(`  always:   ${job.always}`);
           if (job.agent) console.log(`  agent:    ${job.agent}`);
+          if (job.employee) console.log(`  employee: ${job.employee}`);
           if (job.model) console.log(`  model:    ${job.model}`);
           if (job.stateless) console.log(`  stateless: true`);
           console.log(`  prompt:   ${job.prompt}`);

package/src/cli/status.ts

@@ -261,8 +261,9 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
         const staleText = stale ? "  ⚠ stale" : "";
 
         const agentTag = job.agent ? `  [${job.agent}]` : "";
+        const empTag = job.employee ? `  [emp:${job.employee}]` : "";
         console.log(
-          `  ${job.enabled ? "\u25cf" : "\u25cb"} ${job.name.padEnd(20)} ${job.enabled ? "enabled" : "disabled"}${agentTag}`,
+          `  ${job.enabled ? "\u25cf" : "\u25cb"} ${job.name.padEnd(20)} ${job.enabled ? "enabled" : "disabled"}${agentTag}${empTag}`,
         );
         console.log(
           `      ${statusIcon} ${status}   last: ${lastText}   next: ${nextText}   duration: ${durationText}${staleText}`,

package/src/commands/backup.ts

@@ -49,6 +49,7 @@ export async function createBackup(silent = false): Promise<string> {
   if (existsSync(join(home, "self"))) includes.push("self");
   if (existsSync(join(home, "agents"))) includes.push("agents");
   if (existsSync(join(home, "skills"))) includes.push("skills");
+  if (existsSync(join(home, "employees"))) includes.push("employees");
 
   // Database dump
   const config = getConfig();
@@ -65,10 +66,7 @@ export async function createBackup(silent = false): Promise<string> {
     if (url.port) pgArgs.push("-p", url.port);
     if (url.username) pgArgs.push("-U", decodeURIComponent(url.username));
     if (dbName) pgArgs.push("-d", dbName);
-    const pgEnv: Record<string, string> = { ...process.env } as Record<
-      string,
-      string
-    >;
+    const pgEnv: Record<string, string> = { ...process.env } as Record<string, string>;
     if (url.password) pgEnv.PGPASSWORD = decodeURIComponent(url.password);
     const sslmode = url.searchParams.get("sslmode");
     if (sslmode) pgEnv.PGSSLMODE = sslmode;
@@ -87,9 +85,7 @@ export async function createBackup(silent = false): Promise<string> {
       dbDumped = true;
     } else if (!silent) {
       const stderr = await new Response(pg.stderr).text();
-      console.log(
-        `  ⚠ db dump skipped: ${stderr.trim() || `exit ${exitCode}`}`,
-      );
+      console.log(`  ⚠ db dump skipped: ${stderr.trim() || `exit ${exitCode}`}`);
     }
   }
 

package/src/core/agents.ts

@@ -34,7 +34,8 @@ export function scanAgents(): AgentInfo[] {
   for (const { dir, source } of getAgentDirs()) {
     if (!existsSync(dir)) continue;
 
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
 
       const agentFile = join(dir, entry.name, "AGENT.md");

package/src/core/consolidator.ts

@@ -58,8 +58,9 @@ Nia uses a two-stage memory architecture. You are stage 1.
 
 Your persona includes guidance to "save proactively" — that guidance applies
 to LIVE chat, where you act on immediate user instruction. In THIS
-consolidation pass, your default action is to do nothing. You only act when
-you can point to a specific user turn that taught you something durable.
+consolidation pass, be selective but not paralyzed. If you see a genuine
+learning, stage it. The promoter handles quality gating — your job is to
+not miss real signals, not to be maximally conservative.
 
 ## Transcript
 
@@ -81,13 +82,20 @@ Answer these questions silently. If the answer to all of them is "nothing",
 stop here and do not write anything.
 
 1. What did the user correct, clarify, or teach you in this session?
+   (Includes: "no, do it this way", "don't use X", "always check Y first")
 2. What NEW fact about the user, their projects, or their systems do you
    now know that you did not at session start?
+   (Includes: architecture decisions, workflow patterns, tool preferences,
+   team structure, external system details discovered during task execution)
 3. What decision was made that will constrain future work?
+   (Includes: "we're using X not Y", config changes, deployment patterns)
+4. What did the user explicitly ask to be remembered?
 
-Trivial small talk, greetings, task-execution chatter, and status updates
-are NOT answers. If you cannot quote a specific user turn that produced the
-learning, you are fishing — stop.
+Trivial small talk, greetings, and pure status updates are NOT answers.
+But corrections made DURING task execution ("no, check DynamoDB not S3"),
+architecture learned while debugging ("ah, this service talks to X via Y"),
+and workflow patterns revealed by how the user works — these ARE answers.
+The bar is: would a fresh Nia session benefit from knowing this?
 
 ## Step 3 — Update staging.md
 
@@ -118,7 +126,8 @@ For each substantive answer:
 - Do NOT write to \`memory.md\` or \`rules.md\`. Only the promoter job can.
 - Do NOT use \`add_memory\` or \`add_rule\` MCP tools. Edit staging.md directly.
 - Do NOT message the user.
-- Default action is to do nothing. Most sessions have nothing to stage.
+- If nothing qualifies, do nothing. But don't be so conservative that the
+  pipeline starves — if you're skipping every session, your bar is too high.
 
 Report a one-line summary of what you did: "staged N new / reinforced M /
 skipped (trivial session)". No preamble.`;

package/src/core/employees.ts

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import yaml from "js-yaml";
+import { getNiaHome } from "../utils/paths";
+import { log } from "../utils/log";
+import type { EmployeeInfo } from "../types/employee";
+
+function getEmployeesDir(): string {
+  return join(getNiaHome(), "employees");
+}
+
+export function scanEmployees(): EmployeeInfo[] {
+  const employees: EmployeeInfo[] = [];
+  const dir = getEmployeesDir();
+  if (!existsSync(dir)) return employees;
+
+  const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+
+    const empFile = join(dir, entry.name, "EMPLOYEE.md");
+    if (!existsSync(empFile)) continue;
+
+    const content = readFileSync(empFile, "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, employee: entry.name, path: empFile }, "failed to parse employee metadata, skipping");
+      continue;
+    }
+
+    const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
+    const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+
+    employees.push({
+      name,
+      dirName: entry.name,
+      project: typeof meta.project === "string" ? meta.project : "",
+      repo: typeof meta.repo === "string" ? meta.repo : "",
+      role: typeof meta.role === "string" ? meta.role : "Employee",
+      model: typeof meta.model === "string" ? meta.model : undefined,
+      status:
+        meta.status === "onboarding" || meta.status === "active" || meta.status === "paused"
+          ? meta.status
+          : "onboarding",
+      maxSubEmployees: typeof meta.maxSubEmployees === "number" ? meta.maxSubEmployees : 3,
+      body,
+      created: typeof meta.created === "string" ? meta.created : new Date().toISOString().slice(0, 10),
+      parent: typeof meta.parent === "string" ? meta.parent : undefined,
+      source: "nia",
+    });
+  }
+
+  return employees;
+}
+
+export function getEmployee(name: string): EmployeeInfo | undefined {
+  return scanEmployees().find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+
+export function getEmployeeDir(name: string): string {
+  // Look up actual directory — name in frontmatter may differ from dir name
+  const emp = scanEmployees().find((e) => e.name.toLowerCase() === name.toLowerCase());
+  if (emp) return join(getEmployeesDir(), emp.dirName);
+  // Fallback for new employees being created (not yet on disk)
+  return join(getEmployeesDir(), name);
+}
+
+export function getEmployeesSummary(): string {
+  const employees = scanEmployees();
+  if (employees.length === 0) return "";
+  const lines = employees.map((e) => `- @${e.name}: ${e.role} — ${e.project || "(no project)"} [${e.status}]`);
+  return `Available employees:\n${lines.join("\n")}`;
+}
+
+export function listEmployeesForMcp(): string {
+  const employees = scanEmployees();
+  if (employees.length === 0) return "No employees found.";
+  return JSON.stringify(
+    employees.map((e) => ({
+      name: e.name,
+      role: e.role,
+      project: e.project,
+      repo: e.repo,
+      status: e.status,
+      model: e.model,
+    })),
+    null,
+    2,
+  );
+}
+
+/** Injected into employee prompt only when status=onboarding. */
+export const ONBOARDING_INSTRUCTIONS = `## Onboarding
+
+You are in onboarding status. Be proactive — don't wait for the user to drive. You're a co-founder getting up to speed, not an assistant being briefed.
+
+IMPORTANT: One thing at a time. Each message should focus on ONE step. Don't dump all steps on the user at once. Move to the next step only after the current one is resolved.
+
+During the brief, don't just record — challenge. Ask follow-up questions. If the vision sounds vague, say so. If the goals are unrealistic, push back. If something sounds like it matters more than what the user is focused on, flag it.
+
+### Steps (do these in order, one per message)
+1. **Identity** — If your name is a placeholder (starts with "new-employee"), suggest 3-4 real names and ask the user to pick. Update the name field in your EMPLOYEE.md frontmatter. Do NOT rename the directory — the system resolves it from frontmatter.
+2. **Project & Repo** — If project or repo are empty, ask what you'll be working on. Get the repo path. Update your EMPLOYEE.md.
+3. **Brief** — Ask the user about the project: goals, what's working, what's not, their vision. Save to onboarding/brief.md.
+4. **Self-Discovery** — Explore the repo autonomously. Read code, README, recent commits, deployment config. Save findings to onboarding/discovery.md. Report back to user for corrections.
+5. **Initial Plan** — Propose top 3-5 priorities with first actions for each. Save to onboarding/plan.md. Get user approval.
+
+After all steps are done, update your EMPLOYEE.md status from "onboarding" to "active".
+
+Skip any step where the info is already filled in.`;

package/src/core/runner.ts

@@ -8,6 +8,8 @@ import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
+import { buildEmployeePrompt } from "../chat/employee-prompt";
+import { getEmployee } from "./employees";
 import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
 import { getMcpServers } from "../mcp";
@@ -300,13 +302,23 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
   writeState(state);
 
   try {
-    const cwd = homedir();
+    let cwd = homedir();
     let output: RunnerOutput;
 
-    // Resolve system prompt: use agent body if job references an agent, else default
+    // Resolve system prompt: employee > agent > default
     let systemPrompt: string;
     let agentModel: string | undefined;
-    if (job.agent) {
+    if (job.employee) {
+      const empPrompt = buildEmployeePrompt(job.employee);
+      if (empPrompt) {
+        systemPrompt = empPrompt;
+      } else {
+        systemPrompt = buildSystemPrompt("job");
+      }
+      const emp = getEmployee(job.employee);
+      if (emp?.model) agentModel = emp.model;
+      if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
+    } else if (job.agent) {
       const agents = scanAgents();
       const agentDef = agents.find((a) => a.name === job.agent);
       if (agentDef) {

package/src/core/skills.ts

@@ -26,7 +26,8 @@ export function scanSkills(): SkillInfo[] {
   for (const { dir, source } of SKILL_DIRS) {
     if (!existsSync(dir)) continue;
 
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
 
       const skillFile = join(dir, entry.name, "SKILL.md");

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

@@ -40,6 +40,7 @@ export interface Job {
   always: boolean;
   scheduleType: ScheduleType;
   agent: string | null;
+  employee: string | null;
   model: string | null;
   stateless: boolean;
   nextRunAt: string | null;
@@ -57,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,
@@ -81,6 +83,7 @@ export async function create(
   agent?: string,
   stateless = false,
   model?: string,
+  employee?: string,
 ): Promise<void> {
   validateSchedule(schedule, scheduleType);
   const existing = await get(name);
@@ -89,8 +92,8 @@ export async function create(
   }
   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();
 }
@@ -98,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;
 }
 
@@ -117,6 +120,7 @@ export async function update(
     enabled: boolean;
     always: boolean;
     agent: string | null;
+    employee: string | null;
     model: string | null;
     stateless: boolean;
     scheduleType: ScheduleType;
@@ -132,6 +136,7 @@ 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;
 
@@ -144,13 +149,13 @@ export async function update(
     const nextRun = computeInitialNextRun(scheduleType, schedule, getConfig().timezone);
     await sql`
       UPDATE jobs
-      SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, model = ${model}, stateless = ${stateless}, next_run_at = ${nextRun}, updated_at = NOW()
+      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}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
+      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}
     `;
   }
@@ -168,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

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()
@@ -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/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"),
   };
 }