niahere 0.2.63 → 0.2.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.63",
+  "version": "0.2.64",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/chat/employee-prompt.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getEmployee, getEmployeeDir } from "../core/employees";
+import { ONBOARDING_INSTRUCTIONS } from "../core/employees";
+import { getEnvironmentPrompt, getModePrompt } from "../prompts";
+import { getSkillsSummary } from "../core/skills";
+import { getAgentsSummary } from "../core/agents";
+
+function loadFile(dir: string, name: string): string {
+  const filePath = join(dir, name);
+  if (!existsSync(filePath)) return "";
+  return readFileSync(filePath, "utf8").trim();
+}
+
+export function buildEmployeePrompt(name: string): string {
+  const employee = getEmployee(name);
+  if (!employee) return "";
+
+  const dir = getEmployeeDir(name);
+  const parts: string[] = [];
+
+  // Core identity (the EMPLOYEE.md body)
+  if (employee.body) parts.push(employee.body);
+
+  // Environment + mode + capabilities
+  parts.push(getEnvironmentPrompt());
+
+  const modePrompt = getModePrompt("chat");
+  if (modePrompt) parts.push(modePrompt);
+
+  const skills = getSkillsSummary();
+  if (skills) parts.push(skills);
+
+  const agents = getAgentsSummary();
+  if (agents) parts.push(agents);
+
+  // Onboarding instructions (only when status=onboarding)
+  if (employee.status === "onboarding") {
+    parts.push(ONBOARDING_INSTRUCTIONS);
+  }
+
+  // Employee metadata context
+  parts.push(`## Your Profile
+- **Name:** ${employee.name}
+- **Role:** ${employee.role}
+- **Project:** ${employee.project}
+- **Repo:** ${employee.repo}
+- **Status:** ${employee.status}
+- **Max Sub-Employees:** ${employee.maxSubEmployees}`);
+
+  // State files
+  const goals = loadFile(dir, "goals.md");
+  if (goals) parts.push(`## Your Current Goals\n${goals}`);
+
+  const memory = loadFile(dir, "memory.md");
+  if (memory) parts.push(`## Your Memory\n${memory}`);
+
+  const decisions = loadFile(dir, "decisions.md");
+  if (decisions) parts.push(`## Decision Log\n${decisions}`);
+
+  const org = loadFile(dir, "org.md");
+  if (org) parts.push(`## Your Organization\n${org}`);
+
+  // Onboarding context
+  const brief = loadFile(join(dir, "onboarding"), "brief.md");
+  if (brief) parts.push(`## Onboarding Brief\n${brief}`);
+
+  const discovery = loadFile(join(dir, "onboarding"), "discovery.md");
+  if (discovery) parts.push(`## Self-Discovery Notes\n${discovery}`);
+
+  const plan = loadFile(join(dir, "onboarding"), "plan.md");
+  if (plan) parts.push(`## Initial Plan\n${plan}`);
+
+  return parts.join("\n\n");
+}

package/src/chat/engine.ts

@@ -6,8 +6,10 @@ import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
 import { buildSystemPrompt, getSessionContext } from "./identity";
-import { getAgentDefinitions } from "../core/agents";
-import { Session, Message, ActiveEngine } from "../db/models";
+import { buildEmployeePrompt } from "./employee-prompt";
+import { getEmployee } from "../core/employees";
+import { getAgentDefinitions, scanAgents } from "../core/agents";
+import { Session, Message, ActiveEngine, Job } from "../db/models";
 import type {
   Attachment,
   SendResult,
@@ -134,7 +136,36 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     systemPrompt += "\n\n" + sessionContext;
   }
 
-  const cwd = homedir();
+  // Context overrides: employee > agent > job > default
+  let cwd = homedir();
+  if (opts.employee) {
+    const empPrompt = buildEmployeePrompt(opts.employee);
+    if (empPrompt) systemPrompt = empPrompt;
+    const emp = getEmployee(opts.employee);
+    if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
+  } else if (opts.agent) {
+    const agents = scanAgents();
+    const agentDef = agents.find((a) => a.name === opts.agent);
+    if (agentDef) systemPrompt = agentDef.body;
+  } else if (opts.job) {
+    // Job chat: load job and use its context
+    const jobData = await Job.get(opts.job);
+    if (jobData) {
+      // If job has an employee, use employee prompt
+      if (jobData.employee) {
+        const empPrompt = buildEmployeePrompt(jobData.employee);
+        if (empPrompt) systemPrompt = empPrompt;
+        const emp = getEmployee(jobData.employee);
+        if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
+      } else if (jobData.agent) {
+        // If job has an agent, use agent prompt
+        const agents = scanAgents();
+        const agentDef = agents.find((a) => a.name === jobData.agent);
+        if (agentDef) systemPrompt = agentDef.body;
+      }
+      systemPrompt += `\n\n## Job Context\nYou are chatting in the context of job "${jobData.name}" (schedule: ${jobData.schedule}).\n\nJob prompt:\n${jobData.prompt}`;
+    }
+  }
 
   let sessionId: string | null = null;
   if (typeof resume === "string") {
@@ -493,15 +524,17 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       });
     },
 
-    close() {
+    async close() {
       // Enqueue finalization — processed by daemon or inline if we are the daemon
       if (sessionId && messageCount > 0 && !pending) {
-        finalizeSession(sessionId, room).catch((err) => {
+        try {
+          await finalizeSession(sessionId, room);
+        } catch (err) {
           log.error({ err, room }, "finalization enqueue failed during close");
-        });
+        }
       }
       teardown();
-      ActiveEngine.unregister(room).catch(() => {});
+      await ActiveEngine.unregister(room).catch(() => {});
     },
   };
 }

package/src/chat/identity.ts

@@ -4,6 +4,7 @@ import { getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
 import { getSkillsSummary } from "../core/skills";
 import { getAgentsSummary } from "../core/agents";
+import { getEmployeesSummary } from "../core/employees";
 import { Session } from "../db/models";
 import type { Mode } from "../types";
 
@@ -19,7 +20,10 @@ function loadFile(dir: string, name: string): string {
 export function loadIdentity(): string {
   const { selfDir } = getPaths();
   const files = ["identity.md", "owner.md", "soul.md", "rules.md", "memory.md"];
-  return files.map((f) => loadFile(selfDir, f)).filter(Boolean).join("\n\n");
+  return files
+    .map((f) => loadFile(selfDir, f))
+    .filter(Boolean)
+    .join("\n\n");
 }
 
 export function buildSystemPrompt(mode: Mode = "chat", channel: string = "terminal"): string {
@@ -42,6 +46,9 @@ export function buildSystemPrompt(mode: Mode = "chat", channel: string = "termin
   const agents = getAgentsSummary();
   if (agents) parts.push(agents);
 
+  const employees = getEmployeesSummary();
+  if (employees) parts.push(employees);
+
   return parts.join("\n\n");
 }
 

package/src/chat/repl.ts

@@ -103,7 +103,18 @@ async function pickSession(): Promise<string | null> {
 
 export type ChatMode = "continue" | "new" | "pick";
 
-export async function startRepl(mode: ChatMode = "continue", simulateChannel?: string): Promise<void> {
+export interface ReplContext {
+  employee?: string;
+  agent?: string;
+  job?: string;
+  initialMessage?: string;
+}
+
+export async function startRepl(
+  mode: ChatMode = "continue",
+  simulateChannel?: string,
+  context?: ReplContext,
+): Promise<void> {
   try {
     await runMigrations();
   } catch (err) {
@@ -131,13 +142,24 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
   }
 
   const channel = simulateChannel || "terminal";
-  const engine = await createChatEngine({ room: "terminal", channel, resume, mcpServers: getMcpServers() });
+  const contextLabel = context?.employee || context?.agent || context?.job;
+  const room = contextLabel ? `chat-${contextLabel}` : "terminal";
+  const engine = await createChatEngine({
+    room,
+    channel,
+    resume,
+    mcpServers: getMcpServers(),
+    employee: context?.employee,
+    agent: context?.agent,
+    job: context?.job,
+  });
 
   // Welcome
   const isResumed = engine.sessionId && resume;
   const sessionNote = isResumed ? "resumed" : "new session";
   const channelNote = simulateChannel ? ` as ${simulateChannel}` : "";
-  console.log(`\n${DIM}nia chat${channelNote}${RESET} ${DIM}(${sessionNote})${RESET}`);
+  const contextNote = contextLabel ? ` as ${contextLabel}` : "";
+  console.log(`\n${DIM}nia chat${contextNote}${channelNote}${RESET} ${DIM}(${sessionNote})${RESET}`);
   console.log(`${DIM}type /exit to quit${RESET}\n`);
 
   const rl = readline.createInterface({
@@ -146,22 +168,7 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
     prompt: `${BOLD}>${RESET} `,
   });
 
-  rl.prompt();
-
-  rl.on("line", async (line: string) => {
-    const input = line.trim();
-
-    if (!input) {
-      rl.prompt();
-      return;
-    }
-
-    const exitCommands = ["/exit", "/quit", ".exit", ".quit", "exit", "quit"];
-    if (exitCommands.includes(input.toLowerCase())) {
-      rl.close();
-      return;
-    }
-
+  async function sendAndDisplay(input: string): Promise<void> {
     const status = new StatusLine();
     status.start("thinking");
 
@@ -171,7 +178,6 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
     try {
       const { result, costUsd, turns } = await engine.send(input, {
         onStream(textSoFar) {
-          // Stream response text as it arrives
           if (!responseStarted) {
             status.stop();
             process.stdout.write("\n");
@@ -190,12 +196,10 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
         },
       });
 
-      // If streaming didn't fire (e.g. tool-only turns), print the result
       if (!responseStarted && result.trim()) {
         status.stop();
         process.stdout.write(`\n${result.trim()}`);
       } else if (responseStarted) {
-        // Print any remaining text that wasn't streamed
         const remaining = result.slice(streamedLength);
         if (remaining.trim()) {
           process.stdout.write(remaining);
@@ -204,7 +208,6 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
         status.stop();
       }
 
-      // Cost line
       const costStr = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "";
       const turnsStr = turns > 0 ? `${turns} turn${turns !== 1 ? "s" : ""}` : "";
       const meta = [costStr, turnsStr].filter(Boolean).join(" · ");
@@ -218,13 +221,37 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`\n${DIM}error:${RESET} ${msg}\n`);
     }
+  }
+
+  // Auto-send initial message if provided (e.g. onboarding kickoff)
+  if (context?.initialMessage) {
+    await sendAndDisplay(context.initialMessage);
+  }
+
+  rl.prompt();
+
+  rl.on("line", async (line: string) => {
+    const input = line.trim();
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    const exitCommands = ["/exit", "/quit", ".exit", ".quit", "exit", "quit"];
+    if (exitCommands.includes(input.toLowerCase())) {
+      rl.close();
+      return;
+    }
+
+    await sendAndDisplay(input);
 
     rl.prompt();
   });
 
-  rl.on("close", () => {
+  rl.on("close", async () => {
     console.log(`\n${DIM}bye${RESET}`);
-    engine.close();
+    await engine.close();
     closeDb()
       .catch(() => {})
       .finally(() => process.exit(0));

package/src/cli/employee-add.ts

@@ -0,0 +1,124 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { getEmployee, getEmployeeDir } from "../core/employees";
+import { fail, BOLD, RESET } from "../utils/cli";
+import { startRepl } from "../chat/repl";
+
+// Permanent identity — stays in EMPLOYEE.md after onboarding
+const CORE_BODY = `You are {name}, a co-founder working with Aman.
+{projectLine}
+You operate independently but seek approval before externally visible actions.
+
+## Who You Are
+You are NOT an assistant. You are a co-founder and thought partner. This means:
+- Challenge ideas that seem weak, unfocused, or premature. Say "I don't think that's the right move because..." not "Great idea!"
+- Ask hard questions: "Who actually wants this?", "What's the evidence?", "Why this over the 5 easier things?"
+- Have strong opinions, loosely held. Push back, but update when presented with better reasoning.
+- Be direct. No filler, no sycophancy, no "Got it!", no performative enthusiasm.
+- Think critically about priorities. "We could, but should we?" is more valuable than "On it!"
+- When Aman tells you something, probe it. A real co-founder doesn't just accept the brief — they stress-test it.
+
+## Your Authority
+- Create and manage scheduled jobs scoped to your project
+- Create sub-employees (up to {maxSubEmployees}) and agents under your org
+- Read/write code in your project repo
+- Draft content, PRs, deployments (approval required before publishing)
+
+## Approval Required For
+- Deploying code to production
+- Publishing content externally
+- Creating sub-employees
+- Any action visible outside the project repo
+- Spending money or signing up for services
+
+## How You Work
+- Maintain your goals.md with current priorities
+- Log significant decisions in decisions.md with [pending] status when approval needed
+- Update memory.md with learnings after each session
+- When blocked or facing a big decision, write to decisions.md as [pending] and tell the user
+- At the start of each session, review your state files and what's changed in the repo
+
+## State Files
+You have persistent state files in your employee directory. Read and update them:
+- **goals.md** — your current goals and success criteria
+- **memory.md** — what you've learned, decided, observed across sessions
+- **decisions.md** — decision log (mark as [pending], [approved], or [rejected])
+- **org.md** — sub-employees and agents you've created`;
+
+export async function employeeAdd(): Promise<void> {
+  const args = process.argv.slice(4);
+
+  const flagValue = (flag: string): string | undefined => {
+    const idx = args.indexOf(flag);
+    return idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("--") ? args[idx + 1] : undefined;
+  };
+
+  const nameArg = args[0] && !args[0].startsWith("--") ? args[0] : undefined;
+  const name = nameArg || `new-employee-${Math.random().toString(36).slice(2, 6)}`;
+  const project = flagValue("--project") || "";
+  const repoArg = flagValue("--repo") || "";
+  const role = flagValue("--role") || "Co-Founder";
+  const model = flagValue("--model") || "opus";
+  const maxSubs = parseInt(flagValue("--max-sub-employees") || "3", 10);
+
+  if (getEmployee(name)) fail(`Employee "${name}" already exists.`);
+
+  const repo = repoArg ? resolve(repoArg) : "";
+  if (repo && !existsSync(repo)) fail(`Repo path does not exist: ${repo}`);
+
+  // Scaffold directory
+  const empDir = getEmployeeDir(name);
+  mkdirSync(empDir, { recursive: true });
+  mkdirSync(`${empDir}/onboarding`, { recursive: true });
+
+  const projectLine = project ? `You are responsible for ${project}.` : "";
+
+  const body = CORE_BODY.replace(/\{name\}/g, name)
+    .replace(/\{projectLine\}\n/g, projectLine ? `${projectLine}\n` : "")
+    .replace(/\{maxSubEmployees\}/g, String(maxSubs));
+
+  const frontmatter = [
+    "---",
+    `name: ${name}`,
+    `project: "${project}"`,
+    `repo: "${repo}"`,
+    `role: ${role}`,
+    `model: ${model}`,
+    `status: onboarding`,
+    `maxSubEmployees: ${maxSubs}`,
+    `created: ${new Date().toISOString().slice(0, 10)}`,
+    "---",
+  ].join("\n");
+
+  writeFileSync(`${empDir}/EMPLOYEE.md`, `${frontmatter}\n\n${body}\n`);
+  writeFileSync(`${empDir}/goals.md`, "# Goals\n\n");
+  writeFileSync(`${empDir}/memory.md`, "# Memory\n\n");
+  writeFileSync(`${empDir}/decisions.md`, "# Decisions\n\n");
+  writeFileSync(`${empDir}/org.md`, "# Organization\n\n");
+  writeFileSync(`${empDir}/onboarding/brief.md`, "");
+  writeFileSync(`${empDir}/onboarding/discovery.md`, "");
+  writeFileSync(`${empDir}/onboarding/plan.md`, "");
+
+  // Build a context-aware kickoff message so the agent starts proactively
+  const provided: string[] = [];
+  const missing: string[] = [];
+
+  if (nameArg) provided.push(`name: ${nameArg}`);
+  else missing.push("name (placeholder assigned — suggest a real one)");
+
+  if (project) provided.push(`project: ${project}`);
+  else missing.push("project");
+
+  if (repo) provided.push(`repo: ${repo}`);
+  else missing.push("repo path");
+
+  const initialMessage = [
+    "New employee created. Start onboarding.",
+    provided.length > 0 ? `Provided: ${provided.join(", ")}.` : "Nothing provided yet.",
+    missing.length > 0 ? `Missing: ${missing.join(", ")}.` : "All basics provided — proceed to brief.",
+  ].join(" ");
+
+  console.log(`\n${BOLD}${name}${RESET} created — starting onboarding...\n`);
+
+  await startRepl("new", undefined, { employee: name, initialMessage });
+}

package/src/cli/employee.ts

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { scanEmployees, getEmployee, getEmployeeDir } from "../core/employees";
+import { fail, DIM, RESET } from "../utils/cli";
+
+const HELP = `Usage: nia employee <command>
+
+Commands:
+  list                    List all employees
+  show <name>             Show employee details and state
+  add <name>              Create employee and start onboarding
+    --project <label>     Project name (required)
+    --repo <path>         Project repo path (required)
+    --role <role>         Role title (default: "Chief of Staff")
+    --model <model>       Model override (default: opus)
+    --max-sub-employees <n>  Max sub-employees (default: 3)
+  pause <name>            Pause an employee
+  resume <name>           Resume a paused employee
+  remove <name>           Remove an employee
+  approvals [name]        Show pending approvals`;
+
+export async function employeeCommand(): Promise<void> {
+  const subcommand = process.argv[3];
+
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    console.log(HELP);
+    return;
+  }
+
+  switch (subcommand) {
+    case "list": {
+      const employees = scanEmployees();
+      if (employees.length === 0) {
+        console.log("No employees. Create one with: nia employee add <name> --project <project> --repo <path>");
+      } else {
+        for (const e of employees) {
+          const model = e.model ? ` (${e.model})` : "";
+          const parent = e.parent ? ` → ${e.parent}` : "";
+          console.log(`  ${e.name}${model}  [${e.status}]${parent}`);
+          console.log(`    ${e.role} — ${e.project}`);
+        }
+      }
+      break;
+    }
+
+    case "show": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia employee show <name>");
+      const emp = getEmployee(name);
+      if (!emp) fail(`Employee "${name}" not found.`);
+      console.log(`Name:        ${emp.name}`);
+      console.log(`Role:        ${emp.role}`);
+      console.log(`Project:     ${emp.project}`);
+      console.log(`Repo:        ${emp.repo}`);
+      console.log(`Status:      ${emp.status}`);
+      console.log(`Model:       ${emp.model || "(default)"}`);
+      console.log(`Created:     ${emp.created}`);
+      if (emp.parent) console.log(`Parent:      ${emp.parent}`);
+      console.log(`Max Subs:    ${emp.maxSubEmployees}`);
+
+      const dir = getEmployeeDir(name);
+      const goals = loadFilePreview(join(dir, "goals.md"));
+      if (goals) console.log(`\n--- Goals ---\n${goals}`);
+      const pendingCount = loadFilePendingCount(join(dir, "decisions.md"));
+      if (pendingCount > 0) console.log(`\nPending approvals: ${pendingCount}`);
+      break;
+    }
+
+    case "pause": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia employee pause <name>");
+      updateStatus(name, "paused");
+      console.log(`${name} paused.`);
+      break;
+    }
+
+    case "resume": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia employee resume <name>");
+      updateStatus(name, "active");
+      console.log(`${name} resumed.`);
+      break;
+    }
+
+    case "remove": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia employee remove <name>");
+      const emp = getEmployee(name);
+      if (!emp) fail(`Employee "${name}" not found.`);
+      const dir = getEmployeeDir(name);
+      rmSync(dir, { recursive: true, force: true });
+      console.log(`${name} removed.`);
+      break;
+    }
+
+    case "approvals": {
+      const name = process.argv[4];
+      const employees = name ? [getEmployee(name)].filter(Boolean) : scanEmployees();
+      if (employees.length === 0) {
+        console.log(name ? `Employee "${name}" not found.` : "No employees.");
+        return;
+      }
+      let found = false;
+      for (const emp of employees) {
+        if (!emp) continue;
+        const dir = getEmployeeDir(emp.name);
+        const decisionsFile = join(dir, "decisions.md");
+        if (!existsSync(decisionsFile)) continue;
+        const content = readFileSync(decisionsFile, "utf8");
+        const pending = content.split(/^## /m).filter((s) => s.includes("[pending]"));
+        if (pending.length > 0) {
+          found = true;
+          console.log(`\n${DIM}${emp.name}:${RESET}`);
+          for (const p of pending) {
+            console.log(`  ${p.trim().split("\n")[0]}`);
+          }
+        }
+      }
+      if (!found) console.log("No pending approvals.");
+      break;
+    }
+
+    case "add": {
+      const { employeeAdd } = await import("./employee-add");
+      await employeeAdd();
+      break;
+    }
+
+    default: {
+      // If subcommand matches an employee name, start chat
+      if (subcommand) {
+        const emp = getEmployee(subcommand);
+        if (emp) {
+          const { startRepl } = await import("../chat/repl");
+          await startRepl("continue", undefined, { employee: emp.name });
+          break;
+        }
+      }
+      if (subcommand) console.error(`Unknown subcommand: ${subcommand}`);
+      console.log(HELP);
+      process.exit(subcommand ? 1 : 0);
+    }
+  }
+}
+
+function updateStatus(name: string, status: "active" | "paused"): void {
+  const emp = getEmployee(name);
+  if (!emp) fail(`Employee "${name}" not found.`);
+  const dir = getEmployeeDir(name);
+  const empFile = join(dir, "EMPLOYEE.md");
+  let content = readFileSync(empFile, "utf8");
+  content = content.replace(/^(status:\s*).+$/m, `$1${status}`);
+  writeFileSync(empFile, content);
+}
+
+function loadFilePreview(path: string): string {
+  if (!existsSync(path)) return "";
+  const content = readFileSync(path, "utf8").trim();
+  const lines = content.split("\n").slice(0, 10);
+  return lines.join("\n");
+}
+
+function loadFilePendingCount(path: string): number {
+  if (!existsSync(path)) return 0;
+  const content = readFileSync(path, "utf8");
+  return (content.match(/\[pending\]/g) || []).length;
+}

package/src/cli/index.ts

@@ -15,6 +15,7 @@ import { sendCommand, telegramCommand, slackCommand } from "./channels";
 import { rulesCommand, memoryCommand } from "./self";
 import { watchCommand } from "./watch";
 import { agentCommand } from "./agent";
+import { employeeCommand } from "./employee";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -215,7 +216,7 @@ switch (command) {
         if (meta) process.stderr.write(`\n${DIM}${meta}${RST}`);
         process.stdout.write("\n");
 
-        engine.close();
+        await engine.close();
       });
       process.exit(0);
     } else {
@@ -307,9 +308,18 @@ switch (command) {
         : chatArgs.includes("--resume") || chatArgs.includes("-r")
           ? ("pick" as const)
           : ("new" as const);
-    const chIdx = chatArgs.indexOf("--channel");
-    const simChannel = chIdx !== -1 && chatArgs[chIdx + 1] ? chatArgs[chIdx + 1] : undefined;
-    await startRepl(mode, simChannel);
+    const flagVal = (flag: string) => {
+      const idx = chatArgs.indexOf(flag);
+      return idx !== -1 && chatArgs[idx + 1] ? chatArgs[idx + 1] : undefined;
+    };
+    const simChannel = flagVal("--channel");
+    const context = {
+      employee: flagVal("--employee"),
+      agent: flagVal("--agent"),
+      job: flagVal("--job"),
+    };
+    const hasContext = context.employee || context.agent || context.job;
+    await startRepl(mode, simChannel, hasContext ? context : undefined);
     break;
   }
 
@@ -318,6 +328,11 @@ switch (command) {
     break;
   }
 
+  case "employee": {
+    await employeeCommand();
+    break;
+  }
+
   case "skills": {
     const { scanSkills: loadSkills } = await import("../core/skills");
     const filter = process.argv[3]; // e.g. "project", "nia", "shared", "claude"
@@ -545,7 +560,7 @@ Daemon:
   logs [-f] [--channel ch]        Daemon logs (filter by channel)
 
 Chat:
-  chat [-c] [-r] [--channel ch]   Interactive chat (new session by default)
+  chat [-c] [-r] [--employee|--agent|--job name]  Interactive chat
   run <prompt>                    One-shot execution
   history [room]                  Recent messages
   send [-c ch] <msg>              Send a message via channel
@@ -557,6 +572,7 @@ Persona:
   rules [show|reset]              View or reset rules.md
   memory [show|reset]             View or reset memory.md
   agent <sub>                     List/show agents
+  employee <sub>                  Manage employees
   skills [source]                 List available skills
 
 Channels:

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