niahere 0.2.63 → 0.2.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.63",
+  "version": "0.2.65",
   "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: