niahere 0.2.65 → 0.2.67

package/package.json

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

package/src/channels/slack.ts

@@ -79,20 +79,26 @@ class SlackChannel implements Channel {
       return `slack-${key}-${index}`;
     }
 
-    async function getState(key: string): Promise<ChatState> {
+    async function getState(key: string, watchBehavior?: { channel: string; behavior: string }): Promise<ChatState> {
       let state = chats.get(key);
       if (!state) {
         const prefix = roomPrefix(key);
         const idx = await Session.getLatestRoomIndex(prefix);
         const room = roomName(key, idx);
-        const engine = await createChatEngine({ room, channel: "slack", resume: true, mcpServers: getMcpServers() });
+        const engine = await createChatEngine({
+          room,
+          channel: "slack",
+          resume: true,
+          mcpServers: getMcpServers(),
+          watchBehavior,
+        });
         state = { engine, roomIndex: idx, lock: Promise.resolve() };
         chats.set(key, state);
       }
       return state;
     }
 
-    async function restartChat(key: string): Promise<ChatState> {
+    async function restartChat(key: string, watchBehavior?: { channel: string; behavior: string }): Promise<ChatState> {
       const old = chats.get(key);
       if (old) old.engine.close();
 
@@ -106,7 +112,13 @@ class SlackChannel implements Channel {
       await Session.create(`placeholder-${room}`, room);
 
       log.info({ key, room }, "slack: creating chat engine");
-      const engine = await createChatEngine({ room, channel: "slack", resume: false, mcpServers: getMcpServers() });
+      const engine = await createChatEngine({
+        room,
+        channel: "slack",
+        resume: false,
+        mcpServers: getMcpServers(),
+        watchBehavior,
+      });
       const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
       chats.set(key, state);
       log.info({ key, room, activeSessions: chats.size }, "slack: engine ready");
@@ -504,11 +516,10 @@ class SlackChannel implements Channel {
         }
       }
 
-      // Prepend watch behavior context for watched channels
-      if (watchConfig) {
-        const behaviorLine = watchConfig.behavior ? `Behavior: ${watchConfig.behavior}\n` : "";
-        text = `[Watch mode — #${watchConfig.name}]\n${behaviorLine}Respond with [NO_REPLY] if no action needed.\n\n${text}`;
-      }
+      // Build watch behavior for system prompt injection (if watched channel)
+      const watchBehavior = watchConfig?.behavior
+        ? { channel: watchConfig.name, behavior: watchConfig.behavior }
+        : undefined;
 
       log.info(
         {
@@ -524,7 +535,7 @@ class SlackChannel implements Channel {
 
       let state: ChatState;
       try {
-        state = await getState(key);
+        state = await getState(key, watchBehavior);
       } catch (err) {
         log.error({ err, key }, "slack: failed to create chat engine");
         return;

package/src/chat/employee-prompt.ts

@@ -12,7 +12,7 @@ function loadFile(dir: string, name: string): string {
   return readFileSync(filePath, "utf8").trim();
 }
 
-export function buildEmployeePrompt(name: string): string {
+export function buildEmployeePrompt(name: string, mode: "chat" | "job" = "chat"): string {
   const employee = getEmployee(name);
   if (!employee) return "";
 
@@ -25,7 +25,7 @@ export function buildEmployeePrompt(name: string): string {
   // Environment + mode + capabilities
   parts.push(getEnvironmentPrompt());
 
-  const modePrompt = getModePrompt("chat");
+  const modePrompt = getModePrompt(mode);
   if (modePrompt) parts.push(modePrompt);
 
   const skills = getSkillsSummary();

package/src/chat/engine.ts

@@ -5,7 +5,7 @@ import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
-import { buildSystemPrompt, getSessionContext } from "./identity";
+import { buildSystemPrompt, buildContextSuffix, getSessionContext } from "./identity";
 import { buildEmployeePrompt } from "./employee-prompt";
 import { getEmployee } from "../core/employees";
 import { getAgentDefinitions, scanAgents } from "../core/agents";
@@ -146,7 +146,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
   } else if (opts.agent) {
     const agents = scanAgents();
     const agentDef = agents.find((a) => a.name === opts.agent);
-    if (agentDef) systemPrompt = agentDef.body;
+    if (agentDef) systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
   } else if (opts.job) {
     // Job chat: load job and use its context
     const jobData = await Job.get(opts.job);
@@ -158,15 +158,21 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         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
+        // If job has an agent, use agent prompt + context
         const agents = scanAgents();
         const agentDef = agents.find((a) => a.name === jobData.agent);
-        if (agentDef) systemPrompt = agentDef.body;
+        if (agentDef) systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
       }
       systemPrompt += `\n\n## Job Context\nYou are chatting in the context of job "${jobData.name}" (schedule: ${jobData.schedule}).\n\nJob prompt:\n${jobData.prompt}`;
     }
   }
 
+  // Watch mode: inject behavior into system prompt
+  if (opts.watchBehavior) {
+    const { channel: watchChannel, behavior } = opts.watchBehavior;
+    systemPrompt += `\n\n## Watch Mode — #${watchChannel}\n\nYou are monitoring this Slack channel. Follow the behavior instructions below.\nRespond with [NO_REPLY] if no action is needed — do not explain why.\n\n${behavior}`;
+  }
+
   let sessionId: string | null = null;
   if (typeof resume === "string") {
     // Specific session ID provided

package/src/chat/identity.ts

@@ -52,6 +52,30 @@ export function buildSystemPrompt(mode: Mode = "chat", channel: string = "termin
   return parts.join("\n\n");
 }
 
+/**
+ * Build the context suffix (env + mode + skills + agents + employees) that should
+ * be appended to any custom system prompt (agent body, watch behavior, etc).
+ * Does NOT include Nia's identity — that's the caller's responsibility.
+ */
+export function buildContextSuffix(mode: Mode = "chat"): string {
+  const parts: string[] = [];
+  parts.push(getEnvironmentPrompt());
+
+  const modePrompt = getModePrompt(mode);
+  if (modePrompt) parts.push(modePrompt);
+
+  const skills = getSkillsSummary();
+  if (skills) parts.push(skills);
+
+  const agents = getAgentsSummary();
+  if (agents) parts.push(agents);
+
+  const employees = getEmployeesSummary();
+  if (employees) parts.push(employees);
+
+  return parts.join("\n\n");
+}
+
 /**
  * Load recent session summaries for a room and format as a context block.
  * Returns empty string if no summaries are available.

package/src/cli/index.ts

@@ -16,6 +16,7 @@ import { rulesCommand, memoryCommand } from "./self";
 import { watchCommand } from "./watch";
 import { agentCommand } from "./agent";
 import { employeeCommand } from "./employee";
+import { guardActiveEngines, parseGuardFlags } from "../core/engine-guard";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -112,7 +113,8 @@ switch (command) {
 
   case "stop": {
     if (!isRunning()) fail("nia is not running");
-    // Unregister service first to prevent KeepAlive from respawning after kill
+    const stopGuard = parseGuardFlags(process.argv.slice(3));
+    if (!(await guardActiveEngines("stop", stopGuard))) process.exit(1);
     const { unregisterService } = await import("../commands/service");
     await unregisterService();
     stopDaemon();
@@ -132,9 +134,10 @@ switch (command) {
   }
 
   case "restart": {
+    const restartGuard = parseGuardFlags(process.argv.slice(3));
+    if (!(await guardActiveEngines("restart", restartGuard))) process.exit(1);
     const { isServiceInstalled, restartService } = await import("../commands/service");
     if (isServiceInstalled()) {
-      // Service-aware: unload (stops KeepAlive respawn), kill, then reload
       await restartService();
     } else {
       stopDaemon();
@@ -494,8 +497,13 @@ switch (command) {
   }
 
   case "update": {
+    const updateGuard = parseGuardFlags(process.argv.slice(3));
     const { version: currentVersion } = await import("../../package.json");
     console.log(`Current: v${currentVersion}`);
+
+    // Check active engines before doing anything destructive
+    if (isRunning() && !(await guardActiveEngines("update", updateGuard))) process.exit(1);
+
     // Auto-backup before update
     try {
       const { createBackup } = await import("../commands/backup");
@@ -553,8 +561,9 @@ switch (command) {
 
 Daemon:
   start                           Start daemon + register service
-  stop                            Stop daemon + unregister service
-  restart                         Restart daemon
+  stop [--wait N] [--force]       Stop daemon (guards active engines)
+  restart [--wait N] [--force]    Restart daemon
+  update [--wait N] [--force]     Update to latest version
   status [--json --rooms N --all] Show daemon, jobs, channels
   health                          Check daemon, db, channels, config
   logs [-f] [--channel ch]        Daemon logs (filter by channel)
@@ -586,7 +595,6 @@ System:
   backup [list]                   Create or list backups
   validate                        Validate config.yaml
   db <sub>                        Database setup/status/migrate
-  update                          Update to latest version
   init                            Initial setup
   test [-v]                       Run tests`;
 

package/src/cli/job.ts

@@ -39,6 +39,8 @@ Commands:
   remove <name>                 Delete a job
   enable <name>                 Enable a job
   disable <name>                Disable a job
+  archive <name>                Archive a job (out of sight)
+  unarchive <name>              Unarchive back to disabled
   run <name>                    Run a job once
   log [name]                    Show recent run history`;
 
@@ -46,7 +48,7 @@ async function pickJob(prompt = "Pick a job"): Promise<string> {
   let jobs: {
     name: string;
     schedule: string;
-    enabled: boolean;
+    status: string;
     prompt: string;
   }[] = [];
   try {
@@ -68,7 +70,7 @@ async function pickJob(prompt = "Pick a job"): Promise<string> {
   try {
     const items = jobs.map((j) => ({
       name: j.name,
-      label: `${j.enabled ? "●" : "○"} ${j.name}  ${j.schedule}`,
+      label: `${j.status === "active" ? "●" : "○"} ${j.name}  ${j.schedule}`,
     }));
     const name = await pickFromList(rl, items, prompt);
     if (!name) fail("Invalid selection.");
@@ -94,12 +96,20 @@ export async function jobCommand(): Promise<void> {
           if (jobs.length === 0) {
             console.log("No jobs configured. Use `nia job add` or `nia job import`.");
           } else {
-            for (const job of jobs) {
+            const visible = jobs.filter((j) => j.status !== "archived");
+            const archived = jobs.filter((j) => j.status === "archived");
+            for (const job of visible) {
+              const icon = job.status === "active" ? "●" : "○";
               const tag = job.always ? "  always" : "";
               const type = job.scheduleType !== "cron" ? ` (${job.scheduleType})` : "";
               const agentTag = job.agent ? `  [${job.agent}]` : "";
               const empTag = job.employee ? `  [emp:${job.employee}]` : "";
-              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}${agentTag}${empTag}`);
+              console.log(`  ${icon} ${job.name}  ${job.schedule}${type}${tag}${agentTag}${empTag}`);
+            }
+            if (archived.length > 0) {
+              console.log(
+                `\n  ${archived.length} archived job${archived.length > 1 ? "s" : ""} (nia job list --all to show)`,
+              );
             }
           }
         });
@@ -178,15 +188,23 @@ export async function jobCommand(): Promise<void> {
     }
 
     case "enable":
-    case "disable": {
+    case "disable":
+    case "archive":
+    case "unarchive": {
       const name = process.argv[4];
       if (!name) fail(`Usage: nia job ${subcommand} <name>`);
-      const enabled = subcommand === "enable";
+      const statusMap: Record<string, string> = {
+        enable: "active",
+        disable: "disabled",
+        archive: "archived",
+        unarchive: "disabled",
+      };
+      const newStatus = statusMap[subcommand] as "active" | "disabled" | "archived";
 
       try {
         await withDb(async () => {
-          const updated = await Job.update(name, { enabled });
-          console.log(updated ? `Job "${name}" ${subcommand}d.` : `Job not found: ${name}`);
+          const updated = await Job.update(name, { status: newStatus });
+          console.log(updated ? `Job "${name}" → ${newStatus}.` : `Job not found: ${name}`);
         });
       } catch (err) {
         fail(`Failed: ${errMsg(err)}`);
@@ -280,9 +298,10 @@ export async function jobCommand(): Promise<void> {
           const job = await Job.get(name);
           if (!job) fail(`Job not found: ${name}`);
 
-          console.log(`  ${job.enabled ? "●" : "○"} ${job.name}`);
+          const icon = job.status === "active" ? "●" : job.status === "archived" ? "◌" : "○";
+          console.log(`  ${icon} ${job.name}`);
           console.log(`  schedule: ${job.schedule} (${job.scheduleType})`);
-          console.log(`  enabled:  ${job.enabled}`);
+          console.log(`  status:   ${job.status}`);
           console.log(`  always:   ${job.always}`);
           if (job.agent) console.log(`  agent:    ${job.agent}`);
           if (job.employee) console.log(`  employee: ${job.employee}`);
@@ -333,7 +352,8 @@ export async function jobCommand(): Promise<void> {
             ? `${info.status} (${localTime(new Date(info.lastRun))}, ${formatDuration(info.duration_ms)})`
             : "never run";
           const tag = job.always ? " always" : "";
-          console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  [${job.schedule}]${tag}  ${status}`);
+          const icon = job.status === "active" ? "●" : job.status === "archived" ? "◌" : "○";
+          console.log(`  ${icon} ${job.name}  [${job.schedule}]${tag}  ${status}`);
           if (info?.error) console.log(`    error: ${info.error}`);
         });
       } catch (err) {

package/src/cli/status.ts

@@ -20,7 +20,7 @@ type StatusOptions = {
 type JobStatusLine = {
   name: string;
   schedule: string;
-  enabled: boolean;
+  jobStatus: string;
   always: boolean;
   scheduleType: ScheduleType;
   agent: string | null;
@@ -111,7 +111,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
   if (options.json) {
     const sortedJobs = [...jobs].sort(
       (a, b) =>
-        Number(b.enabled) - Number(a.enabled) ||
+        (b.status === "active" ? 1 : 0) - (a.status === "active" ? 1 : 0) ||
         dateSortValue(a.nextRunAt) - dateSortValue(b.nextRunAt) ||
         a.name.localeCompare(b.name),
     );
@@ -122,7 +122,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
       return {
         name: job.name,
         schedule: job.schedule,
-        enabled: job.enabled,
+        jobStatus: job.status,
         always: job.always,
         scheduleType: job.scheduleType,
         agent: job.agent,
@@ -144,7 +144,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
             return {
               name,
               schedule: "unavailable",
-              enabled: false,
+              jobStatus: "disabled",
               always: false,
               scheduleType: "cron",
               agent: null,
@@ -232,13 +232,15 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
       console.log("\nJobs:");
       const sortedJobs = [...jobs].sort(
         (a, b) =>
-          Number(b.enabled) - Number(a.enabled) ||
+          (b.status === "active" ? 1 : 0) - (a.status === "active" ? 1 : 0) ||
           dateSortValue(a.nextRunAt) - dateSortValue(b.nextRunAt) ||
           a.name.localeCompare(b.name),
       );
 
       // Hide completed one-shot jobs
-      const visibleJobs = sortedJobs.filter((j) => !(j.scheduleType === "once" && !j.enabled && j.lastRunAt));
+      const visibleJobs = sortedJobs.filter(
+        (j) => j.status !== "archived" && !(j.scheduleType === "once" && j.status !== "active" && j.lastRunAt),
+      );
 
       for (const job of visibleJobs) {
         const stateInfo = state[job.name];
@@ -246,7 +248,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
         const lastRun = stateInfo?.lastRun ?? job.lastRunAt ?? null;
         const nextRun = job.nextRunAt ?? null;
         const stale =
-          job.enabled &&
+          job.status === "active" &&
           status !== "running" &&
           nextRun !== null &&
           safeDate(nextRun) !== null &&
@@ -263,7 +265,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
         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}${empTag}`,
+          `  ${job.status === "active" ? "\u25cf" : "\u25cb"} ${job.name.padEnd(20)} ${job.status}${agentTag}${empTag}`,
         );
         console.log(
           `      ${statusIcon} ${status}   last: ${lastText}   next: ${nextText}   duration: ${durationText}${staleText}`,

package/src/core/engine-guard.ts

@@ -0,0 +1,98 @@
+/**
+ * Guard against stopping/restarting while active engines are running.
+ *
+ * Default: warn and refuse.
+ * --wait <minutes>: poll until engines clear, then proceed. Times out with error.
+ * --force: skip the check entirely.
+ */
+
+import { ActiveEngine } from "../db/models";
+import { withDb } from "../db/with-db";
+import { DIM, RESET, ICON_WARN } from "../utils/cli";
+
+export interface GuardOptions {
+  /** Wait up to this many minutes for engines to clear. 0 = don't wait (default). */
+  waitMinutes: number;
+  /** Skip the guard entirely. */
+  force: boolean;
+}
+
+export function parseGuardFlags(args: string[]): GuardOptions {
+  const force = args.includes("--force") || args.includes("-f");
+
+  let waitMinutes = 0;
+  const waitIdx = args.indexOf("--wait");
+  if (waitIdx !== -1 && args[waitIdx + 1]) {
+    const parsed = parseInt(args[waitIdx + 1], 10);
+    if (!isNaN(parsed) && parsed > 0) waitMinutes = parsed;
+  }
+
+  return { waitMinutes, force };
+}
+
+interface ActiveSummary {
+  count: number;
+  rooms: string[];
+}
+
+async function getActiveEngines(): Promise<ActiveSummary> {
+  let count = 0;
+  let rooms: string[] = [];
+  try {
+    await withDb(async () => {
+      const engines = await ActiveEngine.list();
+      count = engines.length;
+      rooms = engines.map((e) => `${e.room} (${e.channel})`);
+    });
+  } catch {
+    // DB unreachable — no engines to worry about
+  }
+  return { count, rooms };
+}
+
+/**
+ * Check for active engines before a destructive operation.
+ * Returns true if safe to proceed, false if blocked.
+ */
+export async function guardActiveEngines(action: string, opts: GuardOptions): Promise<boolean> {
+  if (opts.force) return true;
+
+  const { count, rooms } = await getActiveEngines();
+  if (count === 0) return true;
+
+  // Active engines found
+  console.log(`\n${ICON_WARN} ${count} active engine${count > 1 ? "s" : ""} running:`);
+  for (const room of rooms) {
+    console.log(`  ${DIM}${room}${RESET}`);
+  }
+
+  if (opts.waitMinutes === 0) {
+    // Default: refuse
+    console.log(`\nCannot ${action} while engines are active.`);
+    console.log(`${DIM}Options:${RESET}`);
+    console.log(`  --wait <minutes>  Wait for engines to finish (checks every 5s)`);
+    console.log(`  --force           ${action} immediately, killing active sessions`);
+    return false;
+  }
+
+  // --wait: poll until clear or timeout
+  const deadlineMs = opts.waitMinutes * 60 * 1000;
+  const deadline = Date.now() + deadlineMs;
+  console.log(`\nWaiting up to ${opts.waitMinutes}m for engines to finish...`);
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 5_000));
+    const { count: remaining } = await getActiveEngines();
+    if (remaining === 0) {
+      console.log("All engines finished.");
+      return true;
+    }
+    const left = Math.ceil((deadline - Date.now()) / 1000);
+    process.stdout.write(`\r${DIM}  ${remaining} active, ${left}s remaining${RESET}`);
+  }
+
+  process.stdout.write("\n");
+  console.log(`\nTimed out — ${count} engine${count > 1 ? "s" : ""} still active.`);
+  console.log(`Use --force to ${action} anyway.`);
+  return false;
+}

package/src/core/runner.ts

@@ -7,7 +7,7 @@ import type { JobInput, JobResult } from "../types";
 import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
-import { buildSystemPrompt } from "../chat/identity";
+import { buildSystemPrompt, buildContextSuffix } from "../chat/identity";
 import { buildEmployeePrompt } from "../chat/employee-prompt";
 import { getEmployee } from "./employees";
 import { scanAgents } from "./agents";
@@ -309,7 +309,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     let systemPrompt: string;
     let agentModel: string | undefined;
     if (job.employee) {
-      const empPrompt = buildEmployeePrompt(job.employee);
+      const empPrompt = buildEmployeePrompt(job.employee, "job");
       if (empPrompt) {
         systemPrompt = empPrompt;
       } else {
@@ -322,7 +322,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       const agents = scanAgents();
       const agentDef = agents.find((a) => a.name === job.agent);
       if (agentDef) {
-        systemPrompt = agentDef.body;
+        systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("job");
         agentModel = agentDef.model;
       } else {
         systemPrompt = buildSystemPrompt("job");

package/src/core/scheduler.ts

@@ -72,7 +72,7 @@ async function tick(): Promise<void> {
       nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
     } catch (err) {
       log.error({ err, job: job.name, schedule: job.schedule }, "scheduler: invalid schedule, disabling job");
-      await Job.update(job.name, { enabled: false }).catch(() => {});
+      await Job.update(job.name, { status: "disabled" }).catch(() => {});
       continue;
     }
     await Job.markRun(job.name, nextRun).catch((err) => {
@@ -81,7 +81,7 @@ async function tick(): Promise<void> {
 
     // Auto-disable one-shot jobs after execution
     if (job.scheduleType === "once") {
-      await Job.update(job.name, { enabled: false }).catch(() => {});
+      await Job.update(job.name, { status: "disabled" }).catch(() => {});
       log.info({ job: job.name }, "scheduler: one-shot job completed, auto-disabled");
     }
   }

package/src/db/migrations/016_jobs_status.ts

@@ -0,0 +1,10 @@
+import type postgres from "postgres";
+
+export const name = "016_jobs_status";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  // Add status column: active | disabled | archived
+  await sql`ALTER TABLE jobs ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'active'`;
+  // Backfill from enabled boolean
+  await sql`UPDATE jobs SET status = CASE WHEN enabled THEN 'active' ELSE 'disabled' END WHERE status = 'active'`;
+}

package/src/db/models/job.ts

@@ -3,7 +3,7 @@ import { CronExpressionParser } from "cron-parser";
 import { parseDuration } from "../../utils/duration";
 import { computeInitialNextRun } from "../../utils/schedule";
 import { getConfig } from "../../utils/config";
-import type { ScheduleType } from "../../types";
+import type { ScheduleType, JobLifecycle } from "../../types";
 
 /** Validate that a schedule string matches its declared type. Throws on mismatch. */
 function validateSchedule(schedule: string, scheduleType: ScheduleType): void {
@@ -36,7 +36,7 @@ export interface Job {
   name: string;
   schedule: string;
   prompt: string;
-  enabled: boolean;
+  status: JobLifecycle;
   always: boolean;
   scheduleType: ScheduleType;
   agent: string | null;
@@ -49,12 +49,23 @@ export interface Job {
   updatedAt: string;
 }
 
+const COLS =
+  "name, schedule, prompt, status, always, schedule_type, agent, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at";
+
 function toJob(r: Record<string, any>): Job {
+  // Support both old (enabled boolean) and new (status text) schema
+  let status: JobLifecycle;
+  if (typeof r.status === "string" && ["active", "disabled", "archived"].includes(r.status)) {
+    status = r.status as JobLifecycle;
+  } else {
+    status = r.enabled ? "active" : "disabled";
+  }
+
   return {
     name: r.name,
     schedule: r.schedule,
     prompt: r.prompt,
-    enabled: r.enabled,
+    status,
     always: r.always ?? false,
     scheduleType: r.schedule_type || "cron",
     agent: r.agent || null,
@@ -92,23 +103,21 @@ export async function create(
   }
   const sql = getSql();
   await sql`
-    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})
+    INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at, agent, stateless, model, employee, status)
+    VALUES (${name}, ${schedule}, ${prompt}, ${always}, ${scheduleType}, ${nextRunAt ?? null}, ${agent ?? null}, ${stateless}, ${model ?? null}, ${employee ?? null}, 'active')
   `;
   await notifyChange();
 }
 
 export async function list(): Promise<Job[]> {
   const sql = getSql();
-  const rows =
-    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`;
+  const rows = await sql`SELECT ${sql.unsafe(COLS)} 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, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE name = ${name}`;
+  const rows = await sql`SELECT ${sql.unsafe(COLS)} FROM jobs WHERE name = ${name}`;
   return rows.length > 0 ? toJob(rows[0]) : null;
 }
 
@@ -117,7 +126,7 @@ export async function update(
   fields: Partial<{
     schedule: string;
     prompt: string;
-    enabled: boolean;
+    status: JobLifecycle;
     always: boolean;
     agent: string | null;
     employee: string | null;
@@ -133,7 +142,7 @@ export async function update(
   const schedule = fields.schedule ?? existing.schedule;
   const scheduleType = fields.scheduleType ?? existing.scheduleType;
   const prompt = fields.prompt ?? existing.prompt;
-  const enabled = fields.enabled ?? existing.enabled;
+  const status = fields.status ?? existing.status;
   const always = fields.always ?? existing.always;
   const agent = fields.agent !== undefined ? fields.agent : existing.agent;
   const employee = fields.employee !== undefined ? fields.employee : existing.employee;
@@ -149,13 +158,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}, employee = ${employee}, model = ${model}, stateless = ${stateless}, next_run_at = ${nextRun}, updated_at = NOW()
+      SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, status = ${status}, 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}, employee = ${employee}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
+      SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, status = ${status}, always = ${always}, agent = ${agent}, employee = ${employee}, model = ${model}, stateless = ${stateless}, updated_at = NOW()
       WHERE name = ${name}
     `;
   }
@@ -172,17 +181,16 @@ 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, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at FROM jobs WHERE enabled = TRUE ORDER BY name`;
+  const rows = await sql`SELECT ${sql.unsafe(COLS)} FROM jobs WHERE status = 'active' 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, employee, model, stateless, next_run_at, last_run_at, created_at, updated_at
+    SELECT ${sql.unsafe(COLS)}
     FROM jobs
-    WHERE enabled = TRUE AND next_run_at <= NOW()
+    WHERE status = 'active' AND next_run_at <= NOW()
     ORDER BY next_run_at
   `;
   return rows.map(toJob);
@@ -193,7 +201,7 @@ export async function markRun(name: string, nextRunAt: Date | null): Promise<voi
   if (nextRunAt) {
     await sql`UPDATE jobs SET last_run_at = NOW(), next_run_at = ${nextRunAt}, updated_at = NOW() WHERE name = ${name}`;
   } else {
-    await sql`UPDATE jobs SET last_run_at = NOW(), enabled = FALSE, updated_at = NOW() WHERE name = ${name}`;
+    await sql`UPDATE jobs SET last_run_at = NOW(), status = 'disabled', updated_at = NOW() WHERE name = ${name}`;
   }
   await notifyChange();
 }

package/src/mcp/server.ts

@@ -106,6 +106,22 @@ export function createNiaMcpServer() {
           ],
         }),
       ),
+      tool(
+        "archive_job",
+        "Archive a job (out of sight, won't run). Use unarchive_job to bring it back.",
+        { name: z.string().describe("Job name to archive") },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.archiveJob(args.name) }],
+        }),
+      ),
+      tool(
+        "unarchive_job",
+        "Unarchive a job back to disabled state. Use enable_job after to start running it.",
+        { name: z.string().describe("Job name to unarchive") },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.unarchiveJob(args.name) }],
+        }),
+      ),
       tool(
         "run_job",
         "Trigger a job to run immediately on the next scheduler tick",

package/src/mcp/tools.ts

@@ -96,7 +96,7 @@ export async function removeJob(name: string): Promise<string> {
 }
 
 export async function enableJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { enabled: true });
+  const updated = await Job.update(name, { status: "active" });
   if (!updated) return `Job "${name}" not found.`;
 
   const job = await Job.get(name);
@@ -110,10 +110,20 @@ export async function enableJob(name: string): Promise<string> {
 }
 
 export async function disableJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { enabled: false });
+  const updated = await Job.update(name, { status: "disabled" });
   return updated ? `Job "${name}" disabled.` : `Job "${name}" not found.`;
 }
 
+export async function archiveJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "archived" });
+  return updated ? `Job "${name}" archived.` : `Job "${name}" not found.`;
+}
+
+export async function unarchiveJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "disabled" });
+  return updated ? `Job "${name}" unarchived (disabled). Enable with enable_job.` : `Job "${name}" not found.`;
+}
+
 export async function runJobNow(name: string): Promise<string> {
   const job = await Job.get(name);
   if (!job) return `Job "${name}" not found.`;

package/src/prompts/environment.md

@@ -20,7 +20,7 @@ Prefer MCP tools for job/message management (faster, no subprocess overhead), bu
 
 You have MCP tools for managing jobs directly (preferred over CLI for speed):
 
-- **list_jobs** — see all scheduled jobs with status and next run time
+- **list_jobs** — see all scheduled jobs with status and next run time. Jobs have three statuses: `active` (running on schedule), `disabled` (paused but visible), `archived` (hidden from list, won't run — use `nia job archive/unarchive` or MCP tools)
 - **add_job** — create a new job. Supports three schedule types:
   - `cron`: standard cron expression (e.g. `0 9 * * *` = daily at 9am, `*/5 * * * *` = every 5 min)
   - `interval`: duration string (e.g., "5m", "2h", "1d" = every 5 min/2 hours/1 day)
@@ -28,10 +28,14 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - Set `always: true` to run 24/7 (ignores active hours)
   - Set `stateless: true` to disable working memory (no state.md or workspace)
   - Set `model` to override the default (e.g., `haiku`, `sonnet`, `opus`) — use cheaper models for high-frequency or simple jobs. Priority: job model > agent model > config model.
-- **update_job** — update an existing job's schedule, prompt, always, stateless, agent, or model
+  - Set `employee` to assign the job to an employee (employee identity takes precedence over agent)
+- **update_job** — update an existing job's schedule, prompt, always, stateless, agent, model, or employee
 - **remove_job** — delete a job by name
 - **enable_job** / **disable_job** — toggle a job on or off
+- **archive_job** — archive a job (hidden from list, won't run)
+- **unarchive_job** — unarchive a job back to disabled state
 - **run_job** — trigger a job to run immediately
+- **list_employees** — list all employees with role, project, status
 - **send_message** — send a message to the user (via telegram, slack, or default channel). Supports `media_path` to send images/files.
 - **list_messages** — read recent chat history
 - **list_sessions** — browse past conversation sessions with previews and message counts. Returns session IDs.
@@ -89,6 +93,18 @@ Config reference:
 - `channels.slack.watch` — per-channel proactive monitoring. Keys use `channel_id#channel_name` format. The `behavior` field is optional and has three forms: (1) omitted — loads `~/.niahere/watches/<channel_name>/behavior.md`; (2) single word like `deal-monitor` — loads `~/.niahere/watches/deal-monitor/behavior.md` (dir-per-watch, like agents); (3) inline prose. File-backed watches hot-reload via mtime tracking, no restart needed.
   {{slackWatch}}
 
+## Employees
+
+Employees are persistent co-founders scoped to projects — not just role prompts like agents, but full identities with their own memory, goals, decisions, and org chart position.
+
+Each employee lives in `~/.niahere/employees/<name>/` and has an `EMPLOYEE.md` identity file plus working memory. Employee identity takes precedence over agent identity when both are present.
+
+CLI: `nia employee add|list|show|pause|resume|remove|approvals`
+Chat: `nia chat --employee <name>` or `nia employee <name>`
+Jobs: assign via `--employee` flag or `employee` parameter in MCP tools
+
+Use `list_employees` to see all employees with their role, project, and status.
+
 ## Conversation History
 
 You have access to all prior conversations stored in the database:

package/src/types/engine.ts

@@ -34,4 +34,6 @@ export interface EngineOptions {
   employee?: string;
   agent?: string;
   job?: string;
+  /** Watch channel behavior — injected into system prompt for watch-mode engines. */
+  watchBehavior?: { channel: string; behavior: string };
 }

package/src/types/enums.ts

@@ -4,6 +4,9 @@ export type JobStatus = "ok" | "error";
 /** Status of a job in the cron state (includes running). */
 export type JobStateStatus = "ok" | "error" | "running";
 
+/** Lifecycle state of a job. */
+export type JobLifecycle = "active" | "disabled" | "archived";
+
 /** Schedule type for jobs. */
 export type ScheduleType = "cron" | "interval" | "once";
 

package/src/types/index.ts

@@ -1,5 +1,5 @@
 export type { Attachment } from "./attachment";
-export type { JobStatus, JobStateStatus, ScheduleType, Mode, AttachmentType, ChannelName } from "./enums";
+export type { JobStatus, JobStateStatus, JobLifecycle, ScheduleType, Mode, AttachmentType, ChannelName } from "./enums";
 export type { JobInput, JobResult } from "./job";
 export type { SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "./engine";
 export type { AuditEntry, JobState, CronState } from "./audit";