niahere 0.2.64 → 0.2.66

package/package.json

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

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/consolidator.ts

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

package/src/core/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/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/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";