niahere 0.2.70 → 0.2.71

package/package.json

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

package/src/channels/slack.ts

@@ -35,6 +35,14 @@ class SlackChannel implements Channel {
     if (result.ts) this.outboundTs.add(result.ts);
   }
 
+  async sendToThread(channelId: string, text: string, threadTs?: string): Promise<void> {
+    if (!this.app) throw new Error("Slack not started");
+    const opts: Record<string, unknown> = { channel: channelId, text };
+    if (threadTs) opts.thread_ts = threadTs;
+    const result = await this.app.client.chat.postMessage(opts as any);
+    if (result.ts) this.outboundTs.add(result.ts);
+  }
+
   async sendMedia(data: Buffer, mimeType: string, filename?: string): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
     const target = this.defaultChannelId || this.dmUserId;
@@ -79,7 +87,12 @@ class SlackChannel implements Channel {
       return `slack-${key}-${index}`;
     }
 
-    async function getState(key: string, watchBehavior?: { channel: string; behavior: string }): Promise<ChatState> {
+    interface SlackContext {
+      slackChannelId?: string;
+      slackThreadTs?: string;
+    }
+
+    async function getState(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
       let state = chats.get(key);
       if (!state) {
         const prefix = roomPrefix(key);
@@ -89,7 +102,7 @@ class SlackChannel implements Channel {
           room,
           channel: "slack",
           resume: true,
-          mcpServers: getMcpServers(),
+          mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
           watchBehavior,
         });
         state = { engine, roomIndex: idx, lock: Promise.resolve() };
@@ -98,7 +111,7 @@ class SlackChannel implements Channel {
       return state;
     }
 
-    async function restartChat(key: string, watchBehavior?: { channel: string; behavior: string }): Promise<ChatState> {
+    async function restartChat(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
       const old = chats.get(key);
       if (old) old.engine.close();
 
@@ -116,7 +129,7 @@ class SlackChannel implements Channel {
         room,
         channel: "slack",
         resume: false,
-        mcpServers: getMcpServers(),
+        mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
         watchBehavior,
       });
       const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
@@ -446,7 +459,9 @@ class SlackChannel implements Channel {
       }
 
       // Build session key:
-      // - DMs: flat, one session per user → slack-dm-{userId}
+      // - DMs: flat by default, threaded if replying in a thread
+      //   - Flat: slack-dm-{userId}
+      //   - Threaded: slack-dm-{userId}-t{threadTs} (scoped to that thread)
       // - Channels: per-thread → slack-{channelName}-t{threadTs}
       //   - Top-level @mention starts a new thread (uses msg.ts as thread root)
       //   - Reply in thread continues that thread's session
@@ -454,8 +469,13 @@ class SlackChannel implements Channel {
       let replyThreadTs: string | undefined;
 
       if (isDm) {
-        key = `dm-${msg.user}`;
-        // DMs stay flat, no threading
+        if (msg.thread_ts) {
+          // Thread reply in DM — scoped session for this thread
+          key = `dm-${msg.user}-t${msg.thread_ts}`;
+          replyThreadTs = msg.thread_ts;
+        } else {
+          key = `dm-${msg.user}`;
+        }
       } else {
         const channelName = await resolveChannelName(app, msg.channel);
         const threadTs = msg.thread_ts || msg.ts; // existing thread or start new one
@@ -540,14 +560,37 @@ class SlackChannel implements Channel {
       );
 
       let state: ChatState;
+      const slackCtx: SlackContext = {
+        slackChannelId: msg.channel,
+        slackThreadTs: replyThreadTs,
+      };
       try {
-        state = await getState(key, watchBehavior);
+        state = await getState(key, watchBehavior, slackCtx);
       } catch (err) {
         log.error({ err, key }, "slack: failed to create chat engine");
         return;
       }
 
       withLock(key, async () => {
+        // For flat DM messages (no thread), prepend recent notifications so
+        // the bot knows what jobs/watches recently sent to this user.
+        if (isDm && !msg.thread_ts) {
+          try {
+            const dmPrefix = `slack-dm-${msg.user}`;
+            const notifications = await Message.getRecentNotifications(dmPrefix);
+            if (notifications.length > 0) {
+              const lines = notifications.map((n) => {
+                const ago = relativeTime(new Date(n.createdAt), new Date());
+                const src = n.source ? ` via ${n.source}` : "";
+                return `- (${ago}${src}): ${n.content}`;
+              });
+              text = `[Recent notifications you sent to the user]\n${lines.join("\n")}\n\n[Current message]\n${text}`;
+            }
+          } catch (err) {
+            log.warn({ err }, "slack: failed to load recent notifications for DM context");
+          }
+        }
+
         // Add thinking reaction inside the lock so cleanup is guaranteed
         await client.reactions
           .add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })

package/src/chat/repl.ts

@@ -126,7 +126,7 @@ export async function startRepl(
 
   // Initialize MCP server factory if not already set (standalone chat mode)
   if (!getMcpServers()) {
-    setMcpFactory(() => ({ nia: createNiaMcpServer() }));
+    setMcpFactory((ctx) => ({ nia: createNiaMcpServer(ctx) }));
   }
 
   // Determine session to use

package/src/core/daemon.ts

@@ -263,7 +263,7 @@ export async function runDaemon(): Promise<void> {
   }
 
   // Initialize MCP server factory (each query gets its own Protocol instance)
-  setMcpFactory(() => ({ nia: createNiaMcpServer() }));
+  setMcpFactory((ctx) => ({ nia: createNiaMcpServer(ctx) }));
   log.info("MCP server factory initialized");
 
   // Register and start channels

package/src/core/runner.ts

@@ -12,7 +12,7 @@ import { buildEmployeePrompt } from "../chat/employee-prompt";
 import { getEmployee } from "./employees";
 import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
-import { getMcpServers } from "../mcp";
+import { getMcpServers, type McpSourceContext } from "../mcp";
 import { ActiveEngine } from "../db/models";
 import { getPaths } from "../utils/paths";
 import { log } from "../utils/log";
@@ -97,6 +97,7 @@ export async function runJobWithClaude(
   cwd: string,
   onActivity?: ActivityCallback,
   model?: string,
+  sourceCtx?: McpSourceContext,
 ): Promise<RunnerOutput> {
   const sessionId = randomUUID();
 
@@ -121,7 +122,7 @@ export async function runJobWithClaude(
     options.model = model;
   }
 
-  const mcpServers = getMcpServers();
+  const mcpServers = getMcpServers(sourceCtx);
   if (mcpServers) {
     options.mcpServers = mcpServers;
   }
@@ -345,11 +346,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     const MAX_API_RETRIES = 2;
     const RETRY_DELAYS = [3_000, 8_000]; // 3s, then 8s
 
+    const jobSourceCtx: McpSourceContext = { jobName: job.name, channel: "system" };
+
     if (config.runner === "codex") {
       const fullPrompt = `${systemPrompt}\n\n---\n\n${jobPrompt}`;
       output = await runJobWithCodex(fullPrompt, cwd, resolvedModel);
     } else {
-      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel);
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx);
 
       for (let attempt = 0; attempt < MAX_API_RETRIES && output.error && isRetryableApiError(output.error); attempt++) {
         const delay = RETRY_DELAYS[attempt] ?? 8_000;
@@ -358,7 +361,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
           "retrying after transient API error",
         );
         await sleep(delay);
-        output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel);
+        output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx);
       }
     }
 

package/src/db/models/message.ts

@@ -1,4 +1,5 @@
 import { getSql } from "../connection";
+import { escapeRegex } from "./session";
 import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "../../types";
 
 export type DeliveryStatus = "pending" | "sent" | "failed";
@@ -102,6 +103,45 @@ export async function getBySession(sessionId: string): Promise<SessionMessage[]>
   }));
 }
 
+/**
+ * Fetch recent bot-authored notification messages for a room prefix.
+ * Used to inject context into flat DM replies so the user can reply
+ * to job/watch notifications without the bot losing context.
+ * Returns messages since the last user message, capped at 72h and limit.
+ */
+export async function getRecentNotifications(
+  roomPrefix: string,
+  limit = 10,
+): Promise<Array<{ content: string; source: string | null; createdAt: string }>> {
+  const sql = getSql();
+  const pattern = `^${escapeRegex(roomPrefix)}-\\d+$`;
+  const rows = await sql`
+    SELECT m.content, m.metadata->>'source' AS source, m.created_at
+    FROM messages m
+    JOIN sessions s ON m.session_id = s.id
+    WHERE s.room ~ ${pattern}
+      AND m.is_from_agent = true
+      AND m.metadata->>'kind' = 'notification'
+      AND m.delivery_status != 'failed'
+      AND m.created_at >= GREATEST(
+        COALESCE(
+          (SELECT MAX(m2.created_at) FROM messages m2
+           JOIN sessions s2 ON m2.session_id = s2.id
+           WHERE s2.room ~ ${pattern} AND m2.is_from_agent = false),
+          NOW() - INTERVAL '72 hours'
+        ),
+        NOW() - INTERVAL '72 hours'
+      )
+    ORDER BY m.created_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.reverse().map((r) => ({
+    content: r.content,
+    source: r.source || null,
+    createdAt: String(r.created_at),
+  }));
+}
+
 export async function getRoomStats(): Promise<RoomStats[]> {
   const sql = getSql();
   const rows = await sql`

package/src/db/models/session.ts

@@ -1,5 +1,10 @@
 import { getSql } from "../connection";
 
+/** Escape regex metacharacters so a literal string can be used in a PostgreSQL ~ pattern. */
+export function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 export interface SessionSummary {
   id: string;
   room: string;
@@ -98,10 +103,11 @@ export async function getRecentSummaries(room: string, limit = 3): Promise<Array
   // Match summaries from sessions in the same channel (e.g. slack-dm-U...-*)
   // by extracting the room prefix (everything before the last -N index)
   const prefix = room.replace(/-\d+$/, "");
+  const pattern = `^${escapeRegex(prefix)}-\\d+$`;
   const rows = await sql`
     SELECT summary, updated_at
     FROM sessions
-    WHERE room LIKE ${prefix + "-%"}
+    WHERE room ~ ${pattern}
       AND summary IS NOT NULL
       AND id != ${""}
     ORDER BY updated_at DESC
@@ -167,9 +173,10 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
 
 export async function getLatestRoomIndex(prefix: string): Promise<number> {
   const sql = getSql();
+  const pattern = `^${escapeRegex(prefix)}-\\d+$`;
   const rows = await sql`
     SELECT room FROM sessions
-    WHERE room LIKE ${prefix + "-%"}
+    WHERE room ~ ${pattern}
     ORDER BY updated_at DESC
     LIMIT 1
   `;

package/src/mcp/index.ts

@@ -1,10 +1,24 @@
+/** Source context passed through the MCP factory so tools know who called them. */
+export interface McpSourceContext {
+  /** Job name if called from a job runner, e.g. "scout" */
+  jobName?: string;
+  /** Channel name: "slack" | "telegram" | "terminal" */
+  channel?: string;
+  /** The room the calling engine is operating in */
+  room?: string;
+  /** Slack channel ID where the current session lives (for thread replies) */
+  slackChannelId?: string;
+  /** Slack thread timestamp (for replying back to the current thread) */
+  slackThreadTs?: string;
+}
+
 /** Factory for per-query MCP servers — each query gets its own Protocol instance. */
-let _mcpFactory: (() => Record<string, unknown>) | null = null;
+let _mcpFactory: ((ctx?: McpSourceContext) => Record<string, unknown>) | null = null;
 
-export function setMcpFactory(factory: () => Record<string, unknown>): void {
+export function setMcpFactory(factory: (ctx?: McpSourceContext) => Record<string, unknown>): void {
   _mcpFactory = factory;
 }
 
-export function getMcpServers(): Record<string, unknown> | undefined {
-  return _mcpFactory?.() ?? undefined;
+export function getMcpServers(ctx?: McpSourceContext): Record<string, unknown> | undefined {
+  return _mcpFactory?.(ctx) ?? undefined;
 }

package/src/mcp/server.ts

@@ -1,8 +1,9 @@
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
 import * as handlers from "./tools";
+import type { McpSourceContext } from "./index";
 
-export function createNiaMcpServer() {
+export function createNiaMcpServer(sourceCtx?: McpSourceContext) {
   return createSdkMcpServer({
     name: "nia",
     version: "0.1.0",
@@ -137,7 +138,7 @@ export function createNiaMcpServer() {
       ),
       tool(
         "send_message",
-        "Send a message to the user via configured channel (telegram, slack). Uses default_channel from config if not specified. Can also send a file/image by providing media_path.",
+        "Send a message via configured channel. By default sends to the current context (if in a Slack thread, replies there; otherwise DMs the owner). Use target='dm' to force a DM regardless of context, or target='thread' to explicitly reply in the current thread.",
         {
           text: z.string().describe("Message text to send"),
           channel: z.string().optional().describe("Channel name (telegram, slack). Omit to use default."),
@@ -145,12 +146,16 @@ export function createNiaMcpServer() {
             .string()
             .optional()
             .describe("Absolute path to a file to send as an attachment (image, document)"),
+          target: z
+            .enum(["auto", "dm", "thread"])
+            .default("auto")
+            .describe("Where to send: 'auto' (current context — thread if in one, else DM), 'dm' (always DM the owner), 'thread' (reply in current thread)"),
         },
         async (args) => ({
           content: [
             {
               type: "text" as const,
-              text: await handlers.sendMessage(args.text, args.channel, args.media_path),
+              text: await handlers.sendMessage(args.text, args.channel, args.media_path, sourceCtx, args.target),
             },
           ],
         }),

package/src/mcp/tools.ts

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
 import type { ScheduleType } from "../types";
 import { basename, join } from "path";
+import { randomUUID } from "crypto";
 import { Job, Message, Session } from "../db/models";
 import { computeInitialNextRun } from "../core/scheduler";
 import { getConfig, readRawConfig, updateRawConfig, writeRawConfig } from "../utils/config";
@@ -10,6 +11,7 @@ import { log } from "../utils/log";
 import { classifyMime } from "../utils/attachment";
 import { scanAgents } from "../core/agents";
 import { listEmployeesForMcp } from "../core/employees";
+import type { McpSourceContext } from "./index";
 
 export async function listJobs(): Promise<string> {
   const jobs = await Job.list();
@@ -219,17 +221,80 @@ async function sendMediaDirect(target: string, data: Buffer, mimeType: string, f
   throw new Error(`Channel "${target}" not configured`);
 }
 
-export async function sendMessage(text: string, channelName?: string, mediaPath?: string): Promise<string> {
+export async function sendMessage(text: string, channelName?: string, mediaPath?: string, sourceCtx?: McpSourceContext, target: "auto" | "dm" | "thread" = "auto"): Promise<string> {
   const config = getConfig();
-  const target = channelName || config.channels.default;
+  const channelTarget = channelName || config.channels.default;
 
   // Use started channel if available (daemon), otherwise call API directly (CLI)
-  const channel = getChannel(target);
+  const channel = getChannel(channelTarget);
+
+  // Resolve send target: thread reply vs DM
+  // "auto" = if we have thread context, reply there; otherwise DM
+  // "dm" = always DM the owner
+  // "thread" = reply in current thread (falls back to DM if no thread context)
+  const hasThreadCtx = sourceCtx?.slackChannelId && sourceCtx?.slackThreadTs;
+  const useThread = (target === "auto" && hasThreadCtx) || (target === "thread" && hasThreadCtx);
+
+  // Compute room prefix for DB storage BEFORE sending
+  let roomPrefix: string | undefined;
+  if (channelTarget === "telegram") {
+    const chatId = config.channels.telegram.chat_id;
+    if (chatId) roomPrefix = `tg-${chatId}`;
+  } else if (channelTarget === "slack") {
+    if (useThread && sourceCtx?.room) {
+      // Replying in-thread: use the source session's room prefix
+      roomPrefix = sourceCtx.room.replace(/-\d+$/, "");
+    } else {
+      const channelId = config.channels.slack.channel_id;
+      const dmUserId = config.channels.slack.dm_user_id;
+      if (channelId) {
+        roomPrefix = `slack-${channelId}`;
+      } else if (dmUserId) {
+        roomPrefix = `slack-dm-${dmUserId}`;
+      }
+    }
+  }
+
+  // Save pending notification to DB before sending (avoids race with fast replies)
+  let messageId: number | undefined;
+  if (roomPrefix) {
+    try {
+      const idx = await Session.getLatestRoomIndex(roomPrefix);
+      const fullRoom = `${roomPrefix}-${idx}`;
+      let sessionId = await Session.getLatest(fullRoom);
+
+      // Auto-create a backing session if none exists (e.g. first proactive DM)
+      if (!sessionId) {
+        sessionId = randomUUID();
+        await Session.create(sessionId, fullRoom);
+      }
+
+      const content = mediaPath ? `${text} [media: ${basename(mediaPath)}]` : text;
+      const source = sourceCtx?.jobName ? `job:${sourceCtx.jobName}` : sourceCtx?.channel || undefined;
+      const metadata: Record<string, unknown> = { kind: useThread ? "thread_reply" : "notification" };
+      if (source) metadata.source = source;
+
+      messageId = await Message.save({
+        sessionId,
+        room: fullRoom,
+        sender: "nia",
+        content,
+        isFromAgent: true,
+        deliveryStatus: "pending",
+        metadata,
+      });
+    } catch (err) {
+      log.warn({ err, channelTarget, roomPrefix }, "sendMessage: failed to save pending notification to DB");
+    }
+  }
 
   try {
     // Handle media attachment if provided
     if (mediaPath) {
-      if (!existsSync(mediaPath)) return `Failed to send: file not found: ${mediaPath}`;
+      if (!existsSync(mediaPath)) {
+        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        return `Failed to send: file not found: ${mediaPath}`;
+      }
       const data = readFileSync(mediaPath);
       const mimeType = guessMime(mediaPath);
       const filename = basename(mediaPath);
@@ -237,55 +302,40 @@ export async function sendMessage(text: string, channelName?: string, mediaPath?
       if (channel?.sendMedia) {
         await channel.sendMedia(data, mimeType, filename);
       } else {
-        await sendMediaDirect(target, data, mimeType, filename);
+        await sendMediaDirect(channelTarget, data, mimeType, filename);
       }
 
       // Also send text if provided (as a separate message)
       if (text) {
-        if (channel?.sendMessage) {
+        if (useThread && channel?.sendToThread) {
+          await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
+        } else if (channel?.sendMessage) {
           await channel.sendMessage(text);
         } else {
-          await sendDirect(target, text);
+          await sendDirect(channelTarget, text);
         }
       }
     } else {
-      if (channel?.sendMessage) {
+      if (useThread && channel?.sendToThread) {
+        await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
+      } else if (channel?.sendMessage) {
         await channel.sendMessage(text);
       } else {
-        await sendDirect(target, text);
+        await sendDirect(channelTarget, text);
       }
     }
 
-    // Store in messages table (best-effort)
-    try {
-      let room: string | undefined;
-      if (target === "telegram") {
-        const chatId = config.channels.telegram.chat_id;
-        if (chatId) room = `tg-${chatId}`;
-      } else if (target === "slack") {
-        const channelId = config.channels.slack.channel_id;
-        if (channelId) room = `slack-${channelId}`;
-      }
-
-      if (room) {
-        const idx = await Session.getLatestRoomIndex(room);
-        const fullRoom = `${room}-${idx}`;
-        const sessionId = await Session.getLatest(fullRoom);
-        if (sessionId) {
-          const content = mediaPath ? `${text} [media: ${basename(mediaPath)}]` : text;
-          await Message.save({
-            sessionId,
-            room: fullRoom,
-            sender: "nia",
-            content,
-            isFromAgent: true,
-          });
-        }
-      }
-    } catch {}
+    // Mark as sent
+    if (messageId) {
+      await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+    }
 
     return mediaPath ? "Message with media sent." : "Message sent.";
   } catch (err) {
+    // Mark as failed
+    if (messageId) {
+      await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+    }
     const msg = err instanceof Error ? err.message : String(err);
     return `Failed to send: ${msg}`;
   }

package/src/prompts/channel-slack.md

@@ -23,7 +23,7 @@
 
 ### Reply routing
 - Always reply in the same thread you received the message in. Don't DM someone unless the conversation is already in DMs.
-- For watch mode escalation, use `send_message` to post to a different channel — but still reply in-thread too if relevant.
+- `send_message` defaults to your current context (thread if in one, DM if in DM). For escalations, mention the owner in-thread rather than DMing — keeps context where the conversation is.
 - If the user wants a file/image sent, use `send_message` with `media_path`. When a Slack file was attached to the message, use the `[Attachment local paths]` block from context.
 
 ### Who's talking
@@ -46,6 +46,7 @@
 - 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]`.
-- 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.
+- `send_message` defaults to replying in your current thread (target=auto). To post to a different channel, specify the channel name.
+- To escalate in a watch thread, **mention the owner** (e.g. `<@U06PBA2P680> heads up — this workflow is stuck`) in your thread reply. Don't DM — keep the context where the conversation is. The owner's Slack ID is in config (`channels.slack.dm_user_id`) or owner.md.
+- Your normal reply (via the chat response) goes in-thread automatically. Use `send_message` only when you need to notify *elsewhere* (different channel) or send a proactive update mid-task.
 - 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

@@ -39,7 +39,11 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 - **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. For inbound channel files, check the message context for an `[Attachment local paths]` block and reuse those absolute paths when forwarding.
+- **send_message** — send a message via configured channel. Supports `media_path` to send images/files. The `target` param controls routing:
+  - `auto` (default) — replies in the current Slack thread if you're in one, otherwise DMs the owner. This means watch sessions and thread chats reply in-thread by default.
+  - `dm` — always DMs the owner, regardless of current context. Use sparingly — prefer @mentioning the owner in-thread to keep context visible.
+  - `thread` — explicitly reply in the current thread (same as auto when in a thread, falls back to DM otherwise).
+  For inbound channel files, check the message context for an `[Attachment local paths]` block and reuse those absolute paths when forwarding.
 - **list_messages** — read recent chat history
 - **list_sessions** — browse past conversation sessions with previews and message counts. Returns session IDs.
 - **search_messages** — keyword search across all past messages. Find when something was discussed.

package/src/types/channel.ts

@@ -4,6 +4,8 @@ export interface Channel {
   stop(): Promise<void>;
   sendMessage?(text: string): Promise<void>;
   sendMedia?(data: Buffer, mimeType: string, filename?: string): Promise<void>;
+  /** Send a message to a specific channel/thread (e.g. reply back to a Slack thread). */
+  sendToThread?(channelId: string, text: string, threadTs?: string): Promise<void>;
 }
 
 export type ChannelFactory = () => Channel | null;