niahere 0.2.27 → 0.2.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/channels/slack.ts

@@ -1,15 +1,16 @@
 import { App } from "@slack/bolt";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
 import { createChatEngine } from "../chat/engine";
 import type { Channel, ChatState, Attachment, AttachmentType } from "../types";
-import { getConfig, updateRawConfig } from "../utils/config";
+import { getConfig, updateRawConfig, resetConfig } from "../utils/config";
+import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
 import { Session } from "../db/models";
 import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
-import { getNiaHome } from "../utils/paths";
+import { getNiaHome, getPaths } from "../utils/paths";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
@@ -132,9 +133,41 @@ class SlackChannel implements Channel {
 
     let botUserId: string | undefined;
 
-    // Watch channels: resolved after app.start() via conversations.list
-    // Maps channel ID → { name, behavior }
-    const watchChannels = new Map<string, { name: string; behavior: string }>();
+    // Watch channels: mtime-based hot-reload from config.yaml
+    // Keys are always channel_id#channel_name format
+    let watchCache: Map<string, { name: string; behavior: string }> = new Map();
+    let watchConfigMtime = 0;
+
+    function reloadWatchChannels(): Map<string, { name: string; behavior: string }> {
+      const configPath = getPaths().config;
+      let mtime = 0;
+      try { mtime = statSync(configPath).mtimeMs; } catch { return watchCache; }
+      if (mtime === watchConfigMtime) return watchCache;
+
+      watchConfigMtime = mtime;
+      resetConfig(); // clear cached config so getConfig() re-reads from disk
+      const cfg = getConfig();
+      const watch = cfg.channels.slack.watch;
+      const fresh = new Map<string, { name: string; behavior: string }>();
+      if (watch) {
+        for (const [key, entry] of Object.entries(watch)) {
+          if (!entry.enabled) continue;
+          const hashIdx = key.indexOf("#");
+          if (hashIdx === -1) {
+            log.warn({ channel: key }, "slack: watch key must use channel_id#name format, skipping");
+            continue;
+          }
+          const id = key.slice(0, hashIdx);
+          const name = key.slice(hashIdx + 1);
+          fresh.set(id, { name, behavior: entry.behavior });
+        }
+      }
+      if (fresh.size !== watchCache.size) {
+        log.info({ count: fresh.size }, "slack: watch channels reloaded");
+      }
+      watchCache = fresh;
+      return watchCache;
+    }
 
     // Slash command: /nia
     app.command("/nia", async ({ command, ack, respond }) => {
@@ -329,8 +362,9 @@ class SlackChannel implements Channel {
         }
       }
 
-      // Check if this is a watched channel
-      const watchConfig = watchChannels.get(msg.channel);
+      // Check if this is a watched channel (hot-reloads from config.yaml via mtime)
+      const currentWatch = reloadWatchChannels();
+      const watchConfig = currentWatch.get(msg.channel);
       const isWatched = !!watchConfig;
 
       if (!isDm && !isMention && !isActiveThread && !isWatched) {
@@ -403,10 +437,12 @@ class SlackChannel implements Channel {
           const priorMessages = (replies.messages || [])
             .filter((m: any) => m.ts !== msg.ts); // exclude the triggering message
 
+          const now = new Date();
           const threadMessages = priorMessages.map((m: any) => {
             const sender = m.bot_id ? "bot" : (m.user || "unknown");
             const fileHint = m.files?.length ? ` [${m.files.length} file(s) attached]` : "";
-            return `[${sender}]: ${m.text || "(no text)"}${fileHint}`;
+            const age = m.ts ? ` (${relativeTime(new Date(parseFloat(m.ts) * 1000), now)})` : "";
+            return `[${sender}]${age}: ${m.text || "(no text)"}${fileHint}`;
           });
           if (threadMessages.length > 0) {
             text = `[Thread context]\n${threadMessages.join("\n")}\n\n[Current message]\n${text}`;
@@ -508,47 +544,8 @@ class SlackChannel implements Channel {
       log.warn({ err }, "could not get slack bot user ID");
     }
 
-    // Parse watch channels — keys are "channel_id#channel_name" or just "channel_name"
-    const rawWatchConfig = config.channels.slack.watch;
-    if (rawWatchConfig) {
-      for (const [key, cfg] of Object.entries(rawWatchConfig)) {
-        const hashIdx = key.indexOf("#");
-        if (hashIdx !== -1) {
-          // channel_id#channel_name format — use ID directly, no API call needed
-          const id = key.slice(0, hashIdx);
-          const name = key.slice(hashIdx + 1);
-          watchChannels.set(id, { name, behavior: cfg.behavior });
-          log.info({ channel: name, id }, "slack: watching channel");
-        } else {
-          // Legacy: plain channel name — resolve via API
-          try {
-            const channelList: { id: string; name: string }[] = [];
-            let cursor: string | undefined;
-            do {
-              const resp = await app.client.conversations.list({
-                types: "public_channel,private_channel",
-                exclude_archived: true,
-                limit: 200,
-                cursor,
-              });
-              for (const ch of resp.channels || []) {
-                if (ch.id && ch.name) channelList.push({ id: ch.id, name: ch.name });
-              }
-              cursor = resp.response_metadata?.next_cursor || undefined;
-            } while (cursor);
-            const match = channelList.find((c) => c.name === key);
-            if (match) {
-              watchChannels.set(match.id, { name: key, behavior: cfg.behavior });
-              log.info({ channel: key, id: match.id }, "slack: watching channel (resolved by name)");
-            } else {
-              log.warn({ channel: key }, "slack: watch channel not found");
-            }
-          } catch (err) {
-            log.warn({ err, channel: key }, "slack: failed to resolve watch channel");
-          }
-        }
-      }
-    }
+    // Initial watch channel load
+    reloadWatchChannels();
 
     log.info("slack bot started (Socket Mode)");
     this.app = app;

package/src/cli/index.ts

@@ -13,6 +13,7 @@ import { jobCommand } from "./job";
 import { statusCommand } from "./status";
 import { sendCommand, telegramCommand, slackCommand } from "./channels";
 import { rulesCommand, memoryCommand } from "./self";
+import { watchCommand } from "./watch";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -216,6 +217,11 @@ switch (command) {
     break;
   }
 
+  case "watch": {
+    watchCommand();
+    break;
+  }
+
   case "history": {
     const room = process.argv[3];
     try {
@@ -440,6 +446,7 @@ switch (command) {
     console.log("  memory [show|reset] — view or reset memory.md");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");
+    console.log("  watch <sub>         — manage Slack watch channels");
     console.log("  validate            — validate config.yaml");
     console.log("  config <sub>        — get/set/list config values");
     console.log("  send [-c ch] <msg>  — send a message via channel");

package/src/cli/watch.ts

@@ -0,0 +1,71 @@
+import { readRawConfig } from "../utils/config";
+import { addWatchChannel, removeWatchChannel, enableWatchChannel, disableWatchChannel } from "../mcp/tools";
+import { fail, ICON_PASS, ICON_FAIL } from "../utils/cli";
+
+export function watchCommand(): void {
+  const sub = process.argv[3];
+
+  switch (sub) {
+    case "list":
+    case undefined: {
+      const raw = readRawConfig();
+      const channels = (raw.channels || {}) as Record<string, unknown>;
+      const slack = (channels.slack || {}) as Record<string, unknown>;
+      const watch = (slack.watch || {}) as Record<string, unknown>;
+
+      const entries = Object.entries(watch);
+      if (entries.length === 0) {
+        console.log("No watch channels configured.");
+        break;
+      }
+      for (const [key, val] of entries) {
+        const cfg = val as Record<string, unknown>;
+        const enabled = cfg.enabled !== false;
+        const icon = enabled ? ICON_PASS : ICON_FAIL;
+        const behavior = typeof cfg.behavior === "string" ? cfg.behavior.slice(0, 80).replace(/\n/g, " ") : "";
+        console.log(`  ${icon} ${key}  ${behavior}${behavior.length >= 80 ? "..." : ""}`);
+      }
+      break;
+    }
+
+    case "add": {
+      const name = process.argv[4];
+      const behavior = process.argv.slice(5).join(" ");
+      if (!name || !behavior) {
+        fail('Usage: nia watch add <channel_id#name> <behavior>');
+      }
+      console.log(addWatchChannel(name, behavior));
+      break;
+    }
+
+    case "remove": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch remove <channel_id#name>");
+      console.log(removeWatchChannel(name));
+      break;
+    }
+
+    case "enable": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch enable <channel_id#name>");
+      console.log(enableWatchChannel(name));
+      break;
+    }
+
+    case "disable": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch disable <channel_id#name>");
+      console.log(disableWatchChannel(name));
+      break;
+    }
+
+    default:
+      console.log("Usage: nia watch <list|add|remove|enable|disable>\n");
+      console.log("  list                              — list watch channels (default)");
+      console.log("  add <channel_id#name> <behavior>  — add a watch channel");
+      console.log("  remove <channel_id#name>          — remove a watch channel");
+      console.log("  enable <channel_id#name>          — enable a watch channel");
+      console.log("  disable <channel_id#name>         — disable a watch channel");
+      process.exit(sub ? 1 : 0);
+  }
+}

package/src/commands/health.ts

@@ -16,6 +16,10 @@ export async function healthCommand(): Promise<void> {
   const checks: Check[] = [];
   const paths = getPaths();
 
+  // 0. Version
+  const { version } = await import("../../package.json");
+  push(checks, "nia", "ok", "v" + version);
+
   // 1. Daemon
   const pid = readPid();
   if (isRunning()) {

package/src/commands/validate.ts

@@ -127,11 +127,12 @@ export function validateConfig(): Result {
             ok = false;
             continue;
           }
-          const hasId = key.includes("#");
-          if (hasId) {
-            messages.push(`${PASS} slack.watch: ${key}`);
+          if (key.includes("#")) {
+            const enabled = (val as Record<string, unknown>).enabled !== false;
+            messages.push(`${enabled ? PASS : WARN} slack.watch: ${key}${enabled ? "" : " (disabled)"}`);
           } else {
-            messages.push(`${WARN} slack.watch.${key}: using channel name — prefer "channel_id#${key}" format for reliability`);
+            messages.push(`${FAIL} slack.watch.${key}: must use "channel_id#${key}" format`);
+            ok = false;
           }
         }
       }

package/src/core/alive.ts

@@ -0,0 +1,181 @@
+import { log } from "../utils/log";
+import { getConfig } from "../utils/config";
+import { getSql, closeDb } from "../db/connection";
+
+const HEARTBEAT_INTERVAL = 60_000; // 60s
+const RECOVERY_THRESHOLD = 30; // 30 consecutive failures = ~30 min
+
+let timer: ReturnType<typeof setInterval> | null = null;
+let consecutiveFailures = 0;
+let recoveryAttempted = false;
+
+async function checkDb(): Promise<boolean> {
+  try {
+    const sql = getSql();
+    await sql`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function attemptReconnect(): Promise<boolean> {
+  try {
+    await closeDb();
+    // getSql() will create a fresh connection on next call
+    const sql = getSql();
+    await sql`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Send a raw message via channel API — no DB needed, no agent needed. */
+async function notifyUser(message: string): Promise<void> {
+  const config = getConfig();
+
+  // Try Telegram first
+  const tgToken = config.channels.telegram.bot_token;
+  const tgChatId = config.channels.telegram.chat_id;
+  if (tgToken && tgChatId) {
+    try {
+      const { Bot } = await import("grammy");
+      const bot = new Bot(tgToken);
+      await bot.api.sendMessage(tgChatId, message);
+      log.info("alive: notified user via telegram");
+      return;
+    } catch (err) {
+      log.warn({ err }, "alive: telegram notification failed");
+    }
+  }
+
+  // Fall back to Slack
+  const slToken = config.channels.slack.bot_token;
+  const slRecipient = config.channels.slack.dm_user_id || config.channels.slack.channel_id;
+  if (slToken && slRecipient) {
+    try {
+      const resp = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${slToken}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ channel: slRecipient, text: message }),
+      });
+      if (resp.ok) {
+        log.info("alive: notified user via slack");
+        return;
+      }
+    } catch (err) {
+      log.warn({ err }, "alive: slack notification failed");
+    }
+  }
+
+  log.error("alive: could not notify user — no channel available");
+}
+
+/** Layer 1: Run an LLM recovery agent to diagnose and fix the issue. */
+async function runRecoveryAgent(error: string): Promise<{ recovered: boolean; report: string }> {
+  try {
+    const { runJobWithClaude } = await import("./runner");
+    const { homedir } = await import("os");
+
+    const systemPrompt = [
+      "You are a system recovery agent for the Nia daemon.",
+      "The database connection has been failing for 30+ minutes.",
+      "Your job: diagnose the issue, attempt to fix it, and report the outcome.",
+      "",
+      "Steps:",
+      "1. Check if PostgreSQL is running: pg_isready, brew services list (macOS), systemctl status postgresql (Linux)",
+      "2. If stopped, try to start it: brew services start postgresql@17 (macOS) or systemctl start postgresql (Linux)",
+      "3. Wait a few seconds, then verify connectivity: psql -d niahere -c 'SELECT 1'",
+      "4. If it's a different issue (disk space, permissions, etc), diagnose and report",
+      "",
+      "Respond with a brief postmortem:",
+      "- What was wrong",
+      "- What you did to fix it",
+      "- Whether it's recovered or still failing",
+      "- Any recommendations",
+    ].join("\n");
+
+    const jobPrompt = `Database has been unreachable for 30+ minutes.\nLast error: ${error}\n\nDiagnose and fix if possible.`;
+
+    const result = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
+    const recovered = await checkDb();
+
+    return {
+      recovered,
+      report: result.agentText || "Recovery agent returned no output.",
+    };
+  } catch (err) {
+    return {
+      recovered: false,
+      report: `Recovery agent failed to run: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+async function heartbeat(): Promise<void> {
+  const ok = await checkDb();
+
+  if (ok) {
+    if (consecutiveFailures > 0) {
+      log.info({ previousFailures: consecutiveFailures }, "alive: database recovered");
+      if (consecutiveFailures >= RECOVERY_THRESHOLD) {
+        await notifyUser(`Database recovered after ${consecutiveFailures} minutes of downtime.`);
+      }
+    }
+    consecutiveFailures = 0;
+    recoveryAttempted = false;
+    return;
+  }
+
+  consecutiveFailures++;
+  log.warn({ consecutiveFailures }, "alive: database unreachable");
+
+  // Try reconnect on every failure
+  const reconnected = await attemptReconnect();
+  if (reconnected) {
+    log.info("alive: reconnected to database");
+    consecutiveFailures = 0;
+    recoveryAttempted = false;
+    return;
+  }
+
+  // After threshold, trigger recovery (once)
+  if (consecutiveFailures >= RECOVERY_THRESHOLD && !recoveryAttempted) {
+    recoveryAttempted = true;
+    log.info("alive: triggering recovery after " + consecutiveFailures + " failures");
+
+    // Layer 1: LLM recovery agent
+    const lastError = "PostgreSQL unreachable after " + consecutiveFailures + " consecutive heartbeat failures";
+    const { recovered, report } = await runRecoveryAgent(lastError);
+
+    if (recovered) {
+      log.info("alive: recovery agent succeeded");
+      await notifyUser(`Database was down for ~${consecutiveFailures} min. Recovery agent fixed it.\n\n${report}`);
+      consecutiveFailures = 0;
+      recoveryAttempted = false;
+    } else {
+      // Layer 2: Direct notification
+      log.error("alive: recovery agent failed, notifying user");
+      await notifyUser(
+        `Database has been down for ~${consecutiveFailures} min and auto-recovery failed.\n\n` +
+        `Recovery report:\n${report}\n\n` +
+        `Run \`nia health\` to check status. You may need to restart PostgreSQL manually.`
+      );
+    }
+  }
+}
+
+export function startAlive(): void {
+  log.info("alive started (60s heartbeat)");
+  // Initial check after a short delay (let startup finish)
+  setTimeout(heartbeat, 10_000);
+  timer = setInterval(heartbeat, HEARTBEAT_INTERVAL);
+}
+
+export function stopAlive(): void {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+}

package/src/core/daemon.ts

@@ -9,6 +9,7 @@ import { closeDb, getSql } from "../db/connection";
 import { registerAllChannels, startChannels, stopChannels } from "../channels";
 import type { Channel } from "../types";
 import { startScheduler, stopScheduler, recomputeAllNextRuns } from "./scheduler";
+import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
 import { setMcpServers } from "../mcp";
 
@@ -229,6 +230,9 @@ export async function runDaemon(): Promise<void> {
   // Start unified scheduler (replaces node-cron)
   startScheduler();
 
+  // Start alive monitor (DB heartbeat + recovery)
+  startAlive();
+
   // Listen for job changes via Postgres LISTEN/NOTIFY
   try {
     const sql = getSql();
@@ -257,6 +261,7 @@ export async function runDaemon(): Promise<void> {
 
     log.info("shutting down...");
 
+    stopAlive();
     stopScheduler();
     await stopChannels(channels);
 

package/src/core/runner.ts

@@ -65,7 +65,7 @@ async function runJobWithCodex(fullPrompt: string, cwd: string, model: string):
 // Claude Agent SDK runner
 // ---------------------------------------------------------------------------
 
-async function runJobWithClaude(systemPrompt: string, jobPrompt: string, cwd: string): Promise<RunnerOutput> {
+export async function runJobWithClaude(systemPrompt: string, jobPrompt: string, cwd: string): Promise<RunnerOutput> {
   const sessionId = randomUUID();
 
   // One-shot async iterable: emit a single user message then close

package/src/mcp/server.ts

@@ -86,7 +86,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "add_watch_channel",
-        "Add or update a Slack watch channel. Watch channels receive ALL messages (not just @mentions) and act based on the behavior prompt. Requires daemon restart to take effect.",
+        "Add or update a Slack watch channel. Watch channels receive ALL messages (not just @mentions) and act based on the behavior prompt. Takes effect on next message (hot-reloads).",
         {
           name: z.string().describe("Slack channel key as 'channel_id#channel_name', e.g. 'C1234567890#ask-kay-thread-notifications'"),
           behavior: z.string().describe("What to monitor and how to respond, e.g. 'Monitor thread notifications. Flag failures to #tech.'"),
@@ -97,7 +97,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "remove_watch_channel",
-        "Remove a Slack watch channel. Requires daemon restart to take effect.",
+        "Remove a Slack watch channel. Takes effect on next message (hot-reloads).",
         {
           name: z.string().describe("Slack channel key to stop watching (e.g. 'C1234567890#ask-kay-thread-notifications')"),
         },
@@ -105,6 +105,26 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: handlers.removeWatchChannel(args.name) }],
         }),
       ),
+      tool(
+        "enable_watch_channel",
+        "Enable a disabled Slack watch channel. Takes effect on next message (hot-reloads).",
+        {
+          name: z.string().describe("Slack channel key to enable"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.enableWatchChannel(args.name) }],
+        }),
+      ),
+      tool(
+        "disable_watch_channel",
+        "Disable a Slack watch channel without removing it. Takes effect on next message (hot-reloads).",
+        {
+          name: z.string().describe("Slack channel key to disable"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.disableWatchChannel(args.name) }],
+        }),
+      ),
       tool(
         "add_rule",
         "Add a behavioral rule. Rules are loaded into every session and take effect without restart. Use for 'from now on' / 'always' / 'never' type instructions.",

package/src/mcp/tools.ts

@@ -3,7 +3,7 @@ import type { ScheduleType } from "../types";
 import { basename, join } from "path";
 import { Job, Message, Session } from "../db/models";
 import { computeInitialNextRun } from "../core/scheduler";
-import { getConfig, readRawConfig, updateRawConfig } from "../utils/config";
+import { getConfig, readRawConfig, updateRawConfig, writeRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
@@ -233,20 +233,44 @@ export function addWatchChannel(name: string, behavior: string): string {
   const raw = readRawConfig();
   const channels = (raw.channels || {}) as Record<string, unknown>;
   const slack = (channels.slack || {}) as Record<string, unknown>;
-  const watch = { ...((slack.watch || {}) as Record<string, unknown>), [name]: { behavior } };
+  const watch = { ...((slack.watch || {}) as Record<string, unknown>), [name]: { behavior, enabled: true } };
   updateRawConfig({ channels: { slack: { watch } } });
-  return `Watch channel "${name}" added. Restart daemon to apply.`;
+  return `Watch channel "${name}" added (enabled). Takes effect on next message.`;
 }
 
 export function removeWatchChannel(name: string): string {
   const raw = readRawConfig();
   const channels = (raw.channels || {}) as Record<string, unknown>;
   const slack = (channels.slack || {}) as Record<string, unknown>;
-  const watch = { ...((slack.watch || {}) as Record<string, unknown>) };
+  const watch = (slack.watch || {}) as Record<string, unknown>;
   if (!watch[name]) return `Watch channel "${name}" not found.`;
   delete watch[name];
+  writeRawConfig(raw);
+  return `Watch channel "${name}" removed. Takes effect on next message.`;
+}
+
+export function enableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = true;
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" enabled. Takes effect on next message.`;
+}
+
+export function disableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = false;
   updateRawConfig({ channels: { slack: { watch } } });
-  return `Watch channel "${name}" removed. Restart daemon to apply.`;
+  return `Watch channel "${name}" disabled. Takes effect on next message.`;
 }
 
 export function addMemory(entry: string): string {

package/src/prompts/channel-slack.md

@@ -47,4 +47,4 @@
 - Use `[NO_REPLY]` for messages that don't need action. Most watch messages will be `[NO_REPLY]`.
 - To escalate to a different channel, use `send_message` with the channel name (e.g. `send_message("deploy failed: ...", "slack")`). To DM the owner, use `send_message` with no channel (uses default).
 - Your reply goes in-thread in the watched channel. Use `send_message` when you need to notify elsewhere.
-- You can manage watch channels via `add_watch_channel` / `remove_watch_channel` MCP tools (requires daemon restart).
+- You can manage watch channels via `add_watch_channel` / `remove_watch_channel` / `enable_watch_channel` / `disable_watch_channel` MCP tools. Changes take effect on the next message (hot-reloads via config.yaml mtime).

package/src/prompts/environment.md

@@ -7,9 +7,17 @@ You are running as part of the assistant daemon.
 - Timezone: {{timezone}}
 - Current time: {{currentTime}}
 
+## Nia CLI
+
+You are `nia` — the CLI and daemon. You have access to Bash, so you can run `nia` commands directly.
+If unsure about available commands, run `nia` or `nia <command>` with no args to see usage/help.
+Prefer MCP tools for job/message management (faster, no subprocess overhead), but use the CLI when MCP tools don't cover it.
+
+> **`nia run` ≠ `nia job run`**: `nia run <prompt>` starts a new one-shot chat. `nia job run <name>` executes a saved job by name. When asked to run a job, use the `run_job` MCP tool or `nia job run` — never `nia run`.
+
 ## Managing Jobs
 
-You have MCP tools for managing jobs directly — no need for shell commands:
+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
 - **add_job** — create a new job. Supports three schedule types:
@@ -22,8 +30,9 @@ You have MCP tools for managing jobs directly — no need for shell commands:
 - **run_job** — trigger a job to run immediately
 - **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
-- **add_watch_channel** — add a Slack channel for proactive monitoring. Specify channel name and behavior prompt. Requires daemon restart.
-- **remove_watch_channel** — stop watching a Slack channel. Requires daemon restart.
+- **add_watch_channel** — add a Slack channel for proactive monitoring. Specify channel key (`channel_id#name`) and behavior prompt. Hot-reloads.
+- **remove_watch_channel** — stop watching a Slack channel. Hot-reloads.
+- **enable_watch_channel** / **disable_watch_channel** — toggle a watch channel on/off without removing it. Hot-reloads.
 - **add_rule** — save a behavioral rule (loaded into every session, no restart needed). Use when told "from now on", "always", "never", or "remember to always..."
 - **add_memory** — save a factual memory (read on demand). Use when told "remember that...", or when you learn something surprising worth keeping
 

package/src/types/config.ts

@@ -6,6 +6,7 @@ export interface TelegramConfig {
 
 export interface SlackWatchChannel {
   behavior: string;
+  enabled: boolean;
 }
 
 export interface SlackConfig {

package/src/utils/config.ts

@@ -144,12 +144,13 @@ export function loadConfig(): Config {
 
   // Slack watch channels
   const rawWatch = chSl.watch as Record<string, unknown> | undefined;
-  let slWatch: Record<string, { behavior: string }> | null = null;
+  let slWatch: Record<string, { behavior: string; enabled: boolean }> | null = null;
   if (rawWatch && typeof rawWatch === "object") {
     slWatch = {};
     for (const [name, val] of Object.entries(rawWatch)) {
       if (val && typeof val === "object" && typeof (val as any).behavior === "string") {
-        slWatch[name] = { behavior: (val as any).behavior };
+        const enabled = (val as any).enabled !== false; // default true
+        slWatch[name] = { behavior: (val as any).behavior, enabled };
       }
     }
     if (Object.keys(slWatch).length === 0) slWatch = null;
@@ -199,16 +200,19 @@ function deepMerge(target: Record<string, unknown>, source: Record<string, unkno
 
 /** Deep-merge fields into config.yaml and write back atomically. */
 export function updateRawConfig(fields: Record<string, unknown>): void {
-  const { config } = getPaths();
   const raw = readRawConfig();
   deepMerge(raw, fields);
+  writeRawConfig(raw);
+}
+
+/** Write a full config object to config.yaml atomically (backup + temp + rename). */
+export function writeRawConfig(raw: Record<string, unknown>): void {
+  const { config } = getPaths();
   const dir = dirname(config);
   mkdirSync(dir, { recursive: true });
-  // Back up current config before overwriting
   if (existsSync(config)) {
     copyFileSync(config, join(dir, "config.yaml.bak"));
   }
-  // Write to temp file then rename for atomic update (prevents corruption on crash)
   const tmp = join(dir, `.config.yaml.tmp.${process.pid}`);
   writeFileSync(tmp, yaml.dump(raw, { lineWidth: -1 }));
   renameSync(tmp, config);