niahere 0.2.21 → 0.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "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,11 +1,15 @@
 import { App } from "@slack/bolt";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
 import { createChatEngine } from "../chat/engine";
-import type { Channel, ChatState, Attachment } from "../types";
+import type { Channel, ChatState, Attachment, AttachmentType } from "../types";
 import { getConfig, updateRawConfig } from "../utils/config";
 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 { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
@@ -128,6 +132,10 @@ 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 }>();
+
     // Slash command: /nia
     app.command("/nia", async ({ command, ack, respond }) => {
       await ack();
@@ -172,6 +180,26 @@ class SlackChannel implements Channel {
       await respond("New conversation started.");
     });
 
+    // Disk-backed file cache: download once, read from disk on subsequent requests
+    const attachDir = join(getNiaHome(), "tmp", "attachments");
+    mkdirSync(attachDir, { recursive: true });
+
+    interface CachedFile {
+      path: string;
+      type: AttachmentType;
+      mimeType: string;
+      filename?: string;
+    }
+    const fileIndex = new Map<string, CachedFile>();
+
+    function urlHash(url: string): string {
+      return createHash("sha256").update(url).digest("hex").slice(0, 16);
+    }
+
+    function loadCached(entry: CachedFile): Attachment {
+      return { type: entry.type, data: readFileSync(entry.path), mimeType: entry.mimeType, filename: entry.filename };
+    }
+
     async function downloadSlackFile(url: string): Promise<Buffer> {
       const resp = await fetch(url, {
         headers: { Authorization: `Bearer ${botToken}` },
@@ -187,6 +215,31 @@ class SlackChannel implements Channel {
         const attType = classifyMime(mime);
         if (!attType) continue;
         if (!file.url_private_download) continue;
+
+        // Check in-memory index first
+        const cached = fileIndex.get(file.url_private_download);
+        if (cached && existsSync(cached.path)) {
+          attachments.push(loadCached(cached));
+          continue;
+        }
+
+        // Check disk (survives daemon restarts) — keyed by URL hash only (global dedup)
+        const hash = urlHash(file.url_private_download);
+        const ext = file.name?.split(".").pop() || "bin";
+        const diskPath = join(attachDir, `${hash}.${ext}`);
+        const metaPath = join(attachDir, `${hash}.meta.json`);
+        if (existsSync(diskPath) && existsSync(metaPath)) {
+          try {
+            const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+            const entry: CachedFile = { path: diskPath, type: meta.type || attType, mimeType: meta.mimeType || mime, filename: meta.filename || file.name };
+            fileIndex.set(file.url_private_download, entry);
+            attachments.push(loadCached(entry));
+            continue;
+          } catch {
+            // Corrupt meta — re-download
+          }
+        }
+
         try {
           const data = await downloadSlackFile(file.url_private_download);
           const error = validateAttachment(data, mime);
@@ -201,6 +254,13 @@ class SlackChannel implements Channel {
             finalData = prepared.data;
             finalMime = prepared.mimeType;
           }
+
+          // Save file + metadata to disk
+          writeFileSync(diskPath, finalData);
+          writeFileSync(metaPath, JSON.stringify({ type: attType, mimeType: finalMime, filename: file.name }));
+          const entry: CachedFile = { path: diskPath, type: attType, mimeType: finalMime, filename: file.name };
+          fileIndex.set(file.url_private_download, entry);
+
           attachments.push({ type: attType, data: finalData, mimeType: finalMime, filename: file.name });
         } catch (err) {
           log.warn({ err, file: file.name }, "failed to download slack file");
@@ -269,7 +329,11 @@ class SlackChannel implements Channel {
         }
       }
 
-      if (!isDm && !isMention && !isActiveThread) {
+      // Check if this is a watched channel
+      const watchConfig = watchChannels.get(msg.channel);
+      const isWatched = !!watchConfig;
+
+      if (!isDm && !isMention && !isActiveThread && !isWatched) {
         log.debug({
           channel: msg.channel,
           text: (msg.text || "").slice(0, 80),
@@ -294,15 +358,6 @@ class SlackChannel implements Channel {
         text = `[user:${msg.user}] ${text}`;
       }
 
-      // Download any file attachments
-      let attachments: Attachment[] | undefined;
-      if (hasFiles) {
-        attachments = await extractSlackAttachments(msg.files!);
-      }
-
-      if (!text && (!attachments || attachments.length === 0)) return;
-      if (!text) text = attachments?.some(a => a.type === "image") ? "What's in this image?" : "Here's a file.";
-
       // Auto-register DM user for outbound messages
       if (isDm && !self.dmUserId && msg.user) {
         self.dmUserId = msg.user;
@@ -328,29 +383,65 @@ class SlackChannel implements Channel {
         replyThreadTs = threadTs;
       }
 
+      // Download any file attachments
+      let attachments: Attachment[] | undefined;
+      if (hasFiles) {
+        attachments = await extractSlackAttachments(msg.files!);
+      }
+
+      if (!text && (!attachments || attachments.length === 0)) return;
+      if (!text) text = attachments?.some(a => a.type === "image") ? "What's in this image?" : "Here's a file.";
+
       // When replying in a thread, fetch thread context so Nia can see the full conversation
       if (msg.thread_ts) {
         try {
           const replies = await client.conversations.replies({
             channel: msg.channel,
             ts: msg.thread_ts,
-            limit: 20,
+            limit: 50,
+          });
+          const priorMessages = (replies.messages || [])
+            .filter((m: any) => m.ts !== msg.ts); // exclude the triggering message
+
+          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 threadMessages = (replies.messages || [])
-            .filter((m: any) => m.ts !== msg.ts) // exclude the triggering message
-            .map((m: any) => {
-              const sender = m.bot_id ? "bot" : (m.user || "unknown");
-              return `[${sender}]: ${m.text || "(no text)"}`;
-            });
           if (threadMessages.length > 0) {
             text = `[Thread context]\n${threadMessages.join("\n")}\n\n[Current message]\n${text}`;
           }
+
+          // Download files from recent thread messages (last 5 messages, max 5 files total)
+          if (!attachments) attachments = [];
+          const threadFileBudget = 5 - attachments.length;
+          if (threadFileBudget > 0) {
+            const messagesWithFiles = priorMessages.filter((m: any) => m.files?.length > 0).slice(-5);
+            let threadFilesAdded = 0;
+            for (const m of messagesWithFiles) {
+              if (threadFilesAdded >= threadFileBudget) break;
+              const extracted = await extractSlackAttachments(m.files || []);
+              for (const att of extracted) {
+                if (threadFilesAdded >= threadFileBudget) break;
+                attachments.push(att);
+                threadFilesAdded++;
+              }
+            }
+            if (threadFilesAdded > 0) {
+              log.info({ threadFiles: threadFilesAdded, channel: msg.channel }, "slack: downloaded thread attachments");
+            }
+          }
         } catch (err) {
           log.warn({ err, channel: msg.channel, thread_ts: msg.thread_ts }, "failed to fetch thread context");
         }
       }
 
-      log.info({ channel: msg.channel, key, text: text.slice(0, 100), isDm, attachments: attachments?.length || 0 }, "slack message received");
+      // Prepend watch behavior context for watched channels
+      if (watchConfig) {
+        text = `[Watch mode — #${watchConfig.name}]\nBehavior: ${watchConfig.behavior}\nRespond with [NO_REPLY] if no action needed.\n\n${text}`;
+      }
+
+      log.info({ channel: msg.channel, key, text: text.slice(0, 100), isDm, watched: isWatched, attachments: attachments?.length || 0 }, "slack message received");
 
       const state = await getState(key);
 
@@ -417,6 +508,48 @@ 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");
+          }
+        }
+      }
+    }
+
     log.info("slack bot started (Socket Mode)");
     this.app = app;
   }

package/src/cli/index.ts

@@ -412,6 +412,14 @@ switch (command) {
     process.exit(exitCode);
   }
 
+  case "validate": {
+    const { validateConfig } = await import("../commands/validate");
+    const result = validateConfig();
+    for (const msg of result.messages) console.log(`  ${msg}`);
+    console.log(result.ok ? "\nConfig is valid." : "\nConfig has errors.");
+    process.exit(result.ok ? 0 : 1);
+  }
+
   case "init": {
     const { runInit } = await import("../commands/init");
     await runInit();
@@ -434,6 +442,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("  validate            — validate config.yaml");
     console.log("  config <sub>        — get/set/list config values");
     console.log("  send [-c ch] <msg>  — send a message via channel");
     console.log("  telegram <token>    — configure telegram");

package/src/commands/validate.ts

@@ -0,0 +1,153 @@
+import { existsSync, readFileSync } from "fs";
+import yaml from "js-yaml";
+import { getPaths } from "../utils/paths";
+
+const PASS = "\u2713";
+const FAIL = "\u2717";
+const WARN = "\u26A0";
+
+interface Result {
+  ok: boolean;
+  messages: string[];
+}
+
+function check(label: string, fn: () => string | null): { icon: string; label: string; detail?: string } {
+  const err = fn();
+  if (err) return { icon: FAIL, label, detail: err };
+  return { icon: PASS, label };
+}
+
+function warn(label: string, detail: string): { icon: string; label: string; detail?: string } {
+  return { icon: WARN, label, detail };
+}
+
+export function validateConfig(): Result {
+  const { config: configPath } = getPaths();
+  const messages: string[] = [];
+  let ok = true;
+
+  // File exists
+  if (!existsSync(configPath)) {
+    return { ok: false, messages: [`${FAIL} config.yaml not found at ${configPath}`] };
+  }
+
+  // Valid YAML
+  let raw: Record<string, unknown>;
+  try {
+    const parsed = yaml.load(readFileSync(configPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return { ok: false, messages: [`${FAIL} config.yaml is empty or not an object`] };
+    }
+    raw = parsed as Record<string, unknown>;
+    messages.push(`${PASS} valid YAML`);
+  } catch (err) {
+    return { ok: false, messages: [`${FAIL} invalid YAML: ${(err as Error).message}`] };
+  }
+
+  // Timezone
+  if (raw.timezone) {
+    try {
+      Intl.DateTimeFormat(undefined, { timeZone: raw.timezone as string });
+      messages.push(`${PASS} timezone: ${raw.timezone}`);
+    } catch {
+      messages.push(`${FAIL} invalid timezone: ${raw.timezone}`);
+      ok = false;
+    }
+  }
+
+  // Active hours
+  const ah = raw.active_hours as Record<string, string> | undefined;
+  if (ah) {
+    const timeRe = /^\d{2}:\d{2}$/;
+    if (ah.start && !timeRe.test(ah.start)) {
+      messages.push(`${FAIL} active_hours.start invalid: "${ah.start}" (expected HH:MM)`);
+      ok = false;
+    } else if (ah.start) {
+      messages.push(`${PASS} active_hours: ${ah.start}–${ah.end || "?"}`);
+    }
+    if (ah.end && !timeRe.test(ah.end)) {
+      messages.push(`${FAIL} active_hours.end invalid: "${ah.end}" (expected HH:MM)`);
+      ok = false;
+    }
+  }
+
+  // Database URL
+  const dbUrl = (process.env.DATABASE_URL || raw.database_url) as string | undefined;
+  if (dbUrl && dbUrl.startsWith("postgres")) {
+    messages.push(`${PASS} database_url set`);
+  } else if (!dbUrl) {
+    messages.push(`${WARN} database_url not set (will use default)`);
+  }
+
+  // Runner
+  const runner = raw.runner as string | undefined;
+  if (runner && runner !== "claude" && runner !== "codex") {
+    messages.push(`${FAIL} runner must be "claude" or "codex", got "${runner}"`);
+    ok = false;
+  } else if (runner) {
+    messages.push(`${PASS} runner: ${runner}`);
+  }
+
+  // Channels
+  const ch = raw.channels as Record<string, unknown> | undefined;
+  if (ch) {
+    // Telegram
+    const tg = ch.telegram as Record<string, unknown> | undefined;
+    if (tg) {
+      if (tg.bot_token) {
+        messages.push(`${PASS} telegram.bot_token set`);
+      } else {
+        messages.push(`${WARN} telegram.bot_token missing — telegram won't start`);
+      }
+    }
+
+    // Slack
+    const sl = ch.slack as Record<string, unknown> | undefined;
+    if (sl) {
+      if (!sl.bot_token) {
+        messages.push(`${WARN} slack.bot_token missing — slack won't start`);
+      } else {
+        messages.push(`${PASS} slack.bot_token set`);
+      }
+      if (!sl.app_token) {
+        messages.push(`${WARN} slack.app_token missing — slack won't start (Socket Mode requires app_token)`);
+      } else {
+        messages.push(`${PASS} slack.app_token set`);
+      }
+
+      // Watch channels
+      const watch = sl.watch as Record<string, unknown> | undefined;
+      if (watch) {
+        for (const [key, val] of Object.entries(watch)) {
+          if (!val || typeof val !== "object") {
+            messages.push(`${FAIL} slack.watch.${key}: must be an object with "behavior" field`);
+            ok = false;
+            continue;
+          }
+          const behavior = (val as Record<string, unknown>).behavior;
+          if (typeof behavior !== "string" || !behavior.trim()) {
+            messages.push(`${FAIL} slack.watch.${key}: missing "behavior" string`);
+            ok = false;
+            continue;
+          }
+          const hasId = key.includes("#");
+          if (hasId) {
+            messages.push(`${PASS} slack.watch: ${key}`);
+          } else {
+            messages.push(`${WARN} slack.watch.${key}: using channel name — prefer "channel_id#${key}" format for reliability`);
+          }
+        }
+      }
+    }
+
+    // Unknown channel keys
+    const knownChannelKeys = new Set(["enabled", "default", "telegram", "slack"]);
+    for (const key of Object.keys(ch)) {
+      if (!knownChannelKeys.has(key)) {
+        messages.push(`${WARN} unknown channel key: "channels.${key}" — did you mean "channels.slack"?`);
+      }
+    }
+  }
+
+  return { ok, messages };
+}

package/src/mcp/server.ts

@@ -84,6 +84,27 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: await handlers.listMessages(args.limit, args.room) }],
         }),
       ),
+      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.",
+        {
+          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.'"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.addWatchChannel(args.name, args.behavior) }],
+        }),
+      ),
+      tool(
+        "remove_watch_channel",
+        "Remove a Slack watch channel. Requires daemon restart to take effect.",
+        {
+          name: z.string().describe("Slack channel key to stop watching (e.g. 'C1234567890#ask-kay-thread-notifications')"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.removeWatchChannel(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.",
@@ -96,9 +117,9 @@ export function createNiaMcpServer() {
       ),
       tool(
         "add_memory",
-        "Save a concise factual memory for future reference. Memories are read on demand, not loaded automatically. Use for preferences, corrections, or patterns worth keeping. RULES: Max 200 chars. One insight per entry. NO raw logs, NO conversation transcripts, NO status dumps, NO duplicate observations. Bad: pasting nia status output. Good: 'curator job can get stuck in running state — needs timeout recovery'.",
+        "Save a concise factual memory for future reference. Memories are read on demand, not loaded automatically. Use for preferences, corrections, or patterns worth keeping. RULES: Max 300 chars. One insight per entry. NO raw logs, NO conversation transcripts, NO status dumps, NO duplicate observations. Bad: pasting nia status output. Good: 'curator job can get stuck in running state — needs timeout recovery'.",
         {
-          entry: z.string().max(300).describe("A single concise insight (max 200 chars, no raw logs or transcripts)"),
+          entry: z.string().max(300).describe("A single concise insight (max 300 chars, no raw logs or transcripts)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: handlers.addMemory(args.entry) }],

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 } from "../utils/config";
+import { getConfig, readRawConfig, updateRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
@@ -229,6 +229,26 @@ export function addRule(rule: string): string {
   return `Rule added to rules.md. Takes effect on next new session.`;
 }
 
+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 } };
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" added. Restart daemon to apply.`;
+}
+
+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>) };
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  delete watch[name];
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" removed. Restart daemon to apply.`;
+}
+
 export function addMemory(entry: string): string {
   // Guard: reject raw logs, transcripts, and overly long entries
   const trimmed = entry.trim();
@@ -241,19 +261,7 @@ export function addMemory(entry: string): string {
   const memoryPath = join(selfDir, "memory.md");
   const existing = existsSync(memoryPath) ? readFileSync(memoryPath, "utf8") : "";
 
-  // Deduplicate: skip if a substantially similar entry already exists
-  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9 ]/g, "");
-  const lines = existing.split("\n").filter((l) => l.startsWith("- "));
-  for (const line of lines) {
-    const norm = line.slice(2).toLowerCase().replace(/[^a-z0-9 ]/g, "");
-    // Check if >60% of words overlap
-    const newWords = new Set(normalized.split(/\s+/).filter(Boolean));
-    const oldWords = new Set(norm.split(/\s+/).filter(Boolean));
-    if (newWords.size === 0) continue;
-    let overlap = 0;
-    for (const w of newWords) { if (oldWords.has(w)) overlap++; }
-    if (overlap / newWords.size > 0.6) return "Rejected: similar memory already exists.";
-  }
+  // TODO: add semantic dedup later (embeddings or similar)
 
   const date = new Date().toISOString().slice(0, 10);
   const header = `\n## ${date}`;

package/src/prompts/channel-slack.md

@@ -24,4 +24,12 @@
   - Stay quiet if: users are talking to each other, the message is clearly not directed at you, or it's a reaction/acknowledgement between humans.
   - When in doubt, stay quiet. Better to miss one than to interrupt a human conversation.
   - Never say "was that for me?" or similar — just respond or don't.
-  - To stay quiet, respond with exactly `[NO_REPLY]` and nothing else. This tells the system to skip sending a message.
+  - To stay quiet, respond with exactly `[NO_REPLY]` and nothing else. This tells the system to skip sending a message.
+
+### Watch mode
+- Some channels are configured for proactive monitoring via `channels.slack.watch` in config.
+- Watch channel keys use the format `channel_id#channel_name` (e.g. `C1234567890#ask-kay-thread-notifications`). The ID is used for matching; the name is for readability.
+- In watch channels, you receive ALL messages — not just @mentions. Messages are prefixed with `[Watch mode — #channel-name]` and a behavior prompt.
+- Follow the behavior prompt to decide what to do: flag issues, escalate, or stay quiet.
+- Use `[NO_REPLY]` for messages that don't need action. Most watch messages will be `[NO_REPLY]`.
+- You can manage watch channels via `add_watch_channel` / `remove_watch_channel` MCP tools (requires daemon restart).

package/src/prompts/environment.md

@@ -22,6 +22,8 @@ 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_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
 
@@ -57,6 +59,8 @@ Config reference:
 - `channels.slack.app_token` — Slack app token (xapp-...)
 - `channels.slack.channel_id` — default Slack channel for outbound
 - `channels.slack.dm_user_id` — auto-registered DM user
+- `channels.slack.watch` — per-channel proactive monitoring. Keys are `channel_id#channel_name` format.
+{{slackWatch}}
 
 ## Persona & Memory
 

package/src/prompts/index.ts

@@ -21,6 +21,14 @@ export function getEnvironmentPrompt(): string {
   const paths = getPaths();
   const config = getConfig();
 
+  // Build watch channel summary if Slack is configured with watch channels
+  let slackWatch = "";
+  const watch = config.channels.slack.watch;
+  if (watch) {
+    const entries = Object.entries(watch).map(([name, cfg]) => `  - #${name}: ${cfg.behavior}`);
+    slackWatch = `\nActive watch channels:\n${entries.join("\n")}`;
+  }
+
   return interpolate(loadPrompt("environment.md"), {
     configPath: paths.config,
     dbUrl: config.database_url.replace(/\/\/.*@/, "//***@"),
@@ -31,6 +39,7 @@ export function getEnvironmentPrompt(): string {
     activeEnd: config.activeHours.end,
     model: config.model,
     logLevel: config.log_level,
+    slackWatch,
   });
 }
 

package/src/types/config.ts

@@ -4,6 +4,10 @@ export interface TelegramConfig {
   open: boolean;
 }
 
+export interface SlackWatchChannel {
+  behavior: string;
+}
+
 export interface SlackConfig {
   bot_token: string | null;
   app_token: string | null;
@@ -14,6 +18,7 @@ export interface SlackConfig {
   workspace: string | null;
   workspace_id: string | null;
   workspace_url: string | null;
+  watch: Record<string, SlackWatchChannel> | null;
 }
 
 export interface ChannelsConfig {

package/src/utils/config.ts

@@ -20,7 +20,7 @@ const DEFAULTS: Config = {
     enabled: true,
     default: "telegram",
     telegram: { bot_token: null, chat_id: null, open: false },
-    slack: { bot_token: null, app_token: null, channel_id: null, dm_user_id: null, bot_user_id: null, bot_name: null, workspace: null, workspace_id: null, workspace_url: null },
+    slack: { bot_token: null, app_token: null, channel_id: null, dm_user_id: null, bot_user_id: null, bot_name: null, workspace: null, workspace_id: null, workspace_url: null, watch: null },
   },
 };
 
@@ -142,6 +142,19 @@ export function loadConfig(): Config {
   const slWorkspaceUrl =
     typeof chSl.workspace_url === "string" ? chSl.workspace_url : null;
 
+  // Slack watch channels
+  const rawWatch = chSl.watch as Record<string, unknown> | undefined;
+  let slWatch: Record<string, { behavior: string }> | 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 };
+      }
+    }
+    if (Object.keys(slWatch).length === 0) slWatch = null;
+  }
+
   return {
     model,
     runner,
@@ -154,7 +167,7 @@ export function loadConfig(): Config {
       enabled: channelsEnabled,
       default: defaultChannel,
       telegram: { bot_token: tgBotToken, chat_id: tgChatId, open: tgOpen },
-      slack: { bot_token: slBotToken, app_token: slAppToken, channel_id: slChannelId, dm_user_id: slDmUserId, bot_user_id: slBotUserId, bot_name: slBotName, workspace: slWorkspace, workspace_id: slWorkspaceId, workspace_url: slWorkspaceUrl },
+      slack: { bot_token: slBotToken, app_token: slAppToken, channel_id: slChannelId, dm_user_id: slDmUserId, bot_user_id: slBotUserId, bot_name: slBotName, workspace: slWorkspace, workspace_id: slWorkspaceId, workspace_url: slWorkspaceUrl, watch: slWatch },
     },
   };
 }