niahere 0.2.75 → 0.2.77

package/package.json

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

package/src/channels/slack.ts

@@ -259,8 +259,8 @@ class SlackChannel implements Channel {
     });
 
     // Disk-backed file cache: download once, read from disk on subsequent requests
-    const attachDir = join(getNiaHome(), "tmp", "attachments");
-    mkdirSync(attachDir, { recursive: true });
+    const attachRoot = join(getNiaHome(), "tmp", "attachments");
+    mkdirSync(attachRoot, { recursive: true });
 
     interface CachedFile {
       path: string;
@@ -292,26 +292,39 @@ class SlackChannel implements Channel {
       return Buffer.from(await resp.arrayBuffer());
     }
 
-    async function extractSlackAttachments(files: any[]): Promise<Attachment[]> {
+    function cacheDirForScope(scope: string): string {
+      const safeScope = scope.replace(/[^a-zA-Z0-9._-]/g, "_");
+      const dir = join(attachRoot, safeScope);
+      mkdirSync(dir, { recursive: true });
+      return dir;
+    }
+
+    function cacheKey(scope: string, url: string): string {
+      return `${scope}:${url}`;
+    }
+
+    async function extractSlackAttachments(files: any[], scope: string): Promise<Attachment[]> {
       const attachments: Attachment[] = [];
-      for (const file of files.slice(0, 5)) {
+      const scopedAttachDir = cacheDirForScope(scope);
+      for (const file of files) {
         const mime = file.mimetype || "application/octet-stream";
         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);
+        const indexedKey = cacheKey(scope, file.url_private_download);
+        const cached = fileIndex.get(indexedKey);
         if (cached && existsSync(cached.path)) {
           attachments.push(loadCached(cached));
           continue;
         }
 
-        // Check disk (survives daemon restarts) — keyed by URL hash only (global dedup)
+        // Check disk (survives daemon restarts) — scoped by Slack room/thread.
         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`);
+        const diskPath = join(scopedAttachDir, `${hash}.${ext}`);
+        const metaPath = join(scopedAttachDir, `${hash}.meta.json`);
         if (existsSync(diskPath) && existsSync(metaPath)) {
           try {
             const meta = JSON.parse(readFileSync(metaPath, "utf8"));
@@ -321,7 +334,7 @@ class SlackChannel implements Channel {
               mimeType: meta.mimeType || mime,
               filename: meta.filename || file.name,
             };
-            fileIndex.set(file.url_private_download, entry);
+            fileIndex.set(indexedKey, entry);
             attachments.push(loadCached(entry));
             continue;
           } catch {
@@ -348,7 +361,7 @@ class SlackChannel implements Channel {
           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);
+          fileIndex.set(indexedKey, entry);
 
           attachments.push({ type: attType, data: finalData, mimeType: finalMime, filename: file.name, sourcePath: diskPath });
         } catch (err) {
@@ -484,7 +497,7 @@ class SlackChannel implements Channel {
       // Download any file attachments
       let attachments: Attachment[] | undefined;
       if (hasFiles) {
-        attachments = await extractSlackAttachments(msg.files!);
+        attachments = await extractSlackAttachments(msg.files!, roomPrefix(key));
       }
 
       if (!text && (!attachments || attachments.length === 0)) return;
@@ -516,25 +529,20 @@ class SlackChannel implements Channel {
             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)
+          // Download files from fetched thread messages.
           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");
+          const messagesWithFiles = priorMessages.filter((m: any) => m.files?.length > 0);
+          let threadFilesAdded = 0;
+          for (const m of messagesWithFiles) {
+            const extracted = await extractSlackAttachments(m.files || [], roomPrefix(key));
+            for (const att of extracted) {
+              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");
         }

package/src/chat/engine.ts

@@ -23,6 +23,7 @@ import { truncate, formatToolUse } from "../utils/format-activity";
 import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
+import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
@@ -52,7 +53,7 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
     .map((att, idx) => {
       if (!att.sourcePath) return "";
       const label = att.filename || `${att.type}-${idx + 1}`;
-      return `- ${idx + 1}. ${label} -> ${att.sourcePath}`;
+      return `- ${idx + 1}. ${label} (${att.type}, ${att.mimeType}) -> ${att.sourcePath}`;
     })
     .filter(Boolean);
 
@@ -61,12 +62,14 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
       type: "text",
       text:
         "[Attachment local paths]\n" +
-        "If you need to resend/forward an attachment, call send_message with media_path set to one of these absolute paths.\n" +
+        "Use these absolute paths to inspect attachments. To resend/forward one, call send_message with media_path set to its path.\n" +
         pathHints.join("\n"),
     });
   }
 
   for (const att of attachments) {
+    if (att.sourcePath) continue;
+
     if (att.type === "image") {
       blocks.push({
         type: "image",
@@ -270,9 +273,20 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       queryHandle.close();
       queryHandle = null;
     }
+    unregisterActiveHandle(room);
     alive = false;
   }
 
+  async function abortActiveQuery(reason: string) {
+    const activePending = pending;
+    pending = null;
+    if (activePending) {
+      activePending.reject(new Error(reason));
+    }
+    teardown();
+    await ActiveEngine.unregister(room).catch(() => {});
+  }
+
   function startQuery() {
     stream = new MessageStream();
     alive = true;
@@ -307,6 +321,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       prompt: stream as any,
       options: options as any,
     });
+    registerActiveHandle(room, abortActiveQuery);
 
     // Background consumer — runs for the lifetime of the query
     (async () => {
@@ -521,6 +536,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         }
       } finally {
         clearLongRunningTimer();
+        unregisterActiveHandle(room);
         alive = false;
         stream = null;
         queryHandle = null;
@@ -594,8 +610,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           log.error({ err, room }, "finalization enqueue failed during close");
         }
       }
-      teardown();
-      await ActiveEngine.unregister(room).catch(() => {});
+      await abortActiveQuery("chat engine closed");
     },
   };
 }

package/src/cli/index.ts

@@ -116,8 +116,8 @@ switch (command) {
     const stopGuard = parseGuardFlags(process.argv.slice(3));
     if (!(await guardActiveEngines("stop", stopGuard))) process.exit(1);
     const { unregisterService } = await import("../commands/service");
-    await unregisterService();
-    stopDaemon();
+    await unregisterService({ force: stopGuard.force });
+    stopDaemon({ force: stopGuard.force });
     console.log("nia stopped");
     break;
   }
@@ -138,9 +138,9 @@ switch (command) {
     if (!(await guardActiveEngines("restart", restartGuard))) process.exit(1);
     const { isServiceInstalled, restartService } = await import("../commands/service");
     if (isServiceInstalled()) {
-      await restartService();
+      await restartService({ force: restartGuard.force });
     } else {
-      stopDaemon();
+      stopDaemon({ force: restartGuard.force });
       startDaemon();
     }
     const restartPid = readPid();
@@ -536,9 +536,9 @@ switch (command) {
         console.log("Restarting daemon...");
         const { isServiceInstalled, restartService } = await import("../commands/service");
         if (isServiceInstalled()) {
-          await restartService();
+          await restartService({ force: updateGuard.force });
         } else {
-          stopDaemon();
+          stopDaemon({ force: updateGuard.force });
           startDaemon();
         }
         console.log("Restarted.");

package/src/commands/service.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { getPaths } from "../utils/paths";
 import { findDaemonPids } from "../core/daemon";
+import { clearForceShutdownRequest, requestForceShutdown } from "../core/force-shutdown";
 
 const PLIST_NAME = "com.niahere.agent";
 const SYSTEMD_UNIT = "niahere.service";
@@ -173,7 +174,8 @@ export async function registerService(): Promise<void> {
   // Windows/other: no-op, daemon still works via startDaemon()
 }
 
-export async function unregisterService(): Promise<void> {
+export async function unregisterService(opts: { force?: boolean } = {}): Promise<void> {
+  if (opts.force) requestForceShutdown(findDaemonPids());
   if (process.platform === "darwin") {
     await uninstallLaunchd();
   } else if (process.platform === "linux") {
@@ -188,7 +190,9 @@ export function isServiceInstalled(): boolean {
 }
 
 /** Restart via service manager. Waits for old process to fully exit before starting new one. */
-export async function restartService(): Promise<void> {
+export async function restartService(opts: { force?: boolean } = {}): Promise<void> {
+  if (opts.force) requestForceShutdown(findDaemonPids());
+  const waitMs = opts.force ? 30_000 : 310_000;
   if (process.platform === "darwin") {
     const path = plistPath();
     // Unload — sends SIGTERM and disables KeepAlive respawn
@@ -198,7 +202,8 @@ export async function restartService(): Promise<void> {
       console.error(`  warning: launchctl unload failed: ${stderr.trim()}`);
     }
     // Wait for old daemon to fully exit (graceful shutdown may take time for active engines)
-    await waitForDaemonExit(310_000);
+    await waitForDaemonExit(waitMs);
+    if (opts.force) clearForceShutdownRequest();
     // Load — starts a fresh single instance
     const load = Bun.spawn(["launchctl", "load", path], { stdout: "pipe", stderr: "pipe" });
     if (await load.exited !== 0) {
@@ -209,6 +214,8 @@ export async function restartService(): Promise<void> {
     // systemd restart handles stop-wait-start internally
     const restart = Bun.spawn(["systemctl", "--user", "restart", SYSTEMD_UNIT], { stdout: "pipe", stderr: "pipe" });
     await restart.exited;
+    if (opts.force) await waitForDaemonExit(waitMs);
+    if (opts.force) clearForceShutdownRequest();
   }
 }
 

package/src/constants/attachment.ts

@@ -1,4 +1,4 @@
-export const MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024; // 10MB
+export const MAX_ATTACHMENT_SIZE = 25 * 1024 * 1024; // 25MB
 
 export const IMAGE_MIMES = new Set([
   "image/jpeg",

package/src/core/active-handles.ts

@@ -0,0 +1,31 @@
+import { log } from "../utils/log";
+
+type CloseHandle = (reason: string) => void | Promise<void>;
+
+const handles = new Map<string, CloseHandle>();
+
+export function registerActiveHandle(room: string, close: CloseHandle): void {
+  handles.set(room, close);
+}
+
+export function unregisterActiveHandle(room: string): void {
+  handles.delete(room);
+}
+
+export function activeHandleCount(): number {
+  return handles.size;
+}
+
+export async function closeAllActiveHandles(reason: string): Promise<number> {
+  const entries = [...handles.entries()];
+  for (const [room, close] of entries) {
+    try {
+      await close(reason);
+    } catch (err) {
+      log.warn({ err, room }, "failed to close active handle");
+    } finally {
+      handles.delete(room);
+    }
+  }
+  return entries.length;
+}

package/src/core/daemon.ts

@@ -15,6 +15,8 @@ import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
 import { setMcpFactory } from "../mcp";
 import { processPending, cleanupOldRequests } from "./finalizer";
+import { closeAllActiveHandles } from "./active-handles";
+import { clearForceShutdownRequest, consumeForceShutdownRequest, requestForceShutdown } from "./force-shutdown";
 
 export { isRunning, readPid, removePid, writePid };
 
@@ -46,8 +48,11 @@ export function startDaemon(): number {
   return pid;
 }
 
-export function stopDaemon(): boolean {
+export function stopDaemon(opts: { force?: boolean } = {}): boolean {
   const pidfilePid = readPid();
+  if (opts.force) {
+    requestForceShutdown([...(pidfilePid ? [pidfilePid] : []), ...findDaemonPids()]);
+  }
   removePid();
 
   // Kill all daemon processes — pidfile PID plus any orphans.
@@ -55,7 +60,8 @@ export function stopDaemon(): boolean {
   if (killed === 0 && pidfilePid === null) return false;
 
   // Wait for processes to finish (up to 5 min for active engines, then SIGKILL)
-  waitForExit(310_000);
+  waitForExit(opts.force ? 30_000 : 310_000);
+  if (opts.force) clearForceShutdownRequest();
   return true;
 }
 
@@ -361,16 +367,21 @@ export async function runDaemon(): Promise<void> {
   const shutdown = async () => {
     if (shuttingDown) return;
     shuttingDown = true;
+    const force = consumeForceShutdownRequest(process.pid);
 
-    log.info("shutting down...");
+    log.info({ force }, "shutting down...");
 
     stopAlive();
     stopScheduler();
     await stopChannels(channels);
 
     try {
+      if (force) {
+        const closed = await closeAllActiveHandles("force shutdown");
+        log.warn({ closed }, "force closed active engines");
+      }
       const engines = await ActiveEngine.list();
-      if (engines.length > 0) {
+      if (engines.length > 0 && !force) {
         log.info({ count: engines.length }, "waiting for active engines to finish");
         const deadline = Date.now() + 300_000;
         while (Date.now() < deadline) {
@@ -378,8 +389,8 @@ export async function runDaemon(): Promise<void> {
           if (remaining.length === 0) break;
           await new Promise((r) => setTimeout(r, 1000));
         }
-        await ActiveEngine.clearAll();
       }
+      if (engines.length > 0 || force) await ActiveEngine.clearAll();
     } catch {
       // postgres may be gone
     }

package/src/core/engine-guard.ts

@@ -3,7 +3,7 @@
  *
  * Default: warn and refuse.
  * --wait <minutes>: poll until engines clear, then proceed. Times out with error.
- * --force: skip the check entirely.
+ * --force: skip the guard and ask the daemon to close active handles.
  */
 
 import { ActiveEngine } from "../db/models";

package/src/core/force-shutdown.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { getNiaHome } from "../utils/paths";
+
+const FORCE_MARKER_MAX_AGE_MS = 10 * 60 * 1000;
+
+interface ForceShutdownMarker {
+  createdAt: number;
+  pids: number[];
+}
+
+function markerPath(): string {
+  return join(getNiaHome(), "tmp", "force-shutdown.json");
+}
+
+export function requestForceShutdown(pids: number[] = []): void {
+  const path = markerPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const uniquePids = [...new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+  const marker: ForceShutdownMarker = { createdAt: Date.now(), pids: uniquePids };
+  writeFileSync(path, JSON.stringify(marker));
+}
+
+export function clearForceShutdownRequest(): void {
+  try {
+    unlinkSync(markerPath());
+  } catch {
+    // already gone
+  }
+}
+
+export function consumeForceShutdownRequest(pid: number = process.pid): boolean {
+  const path = markerPath();
+  if (!existsSync(path)) return false;
+
+  let marker: ForceShutdownMarker;
+  try {
+    marker = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    clearForceShutdownRequest();
+    return false;
+  }
+
+  if (Date.now() - marker.createdAt > FORCE_MARKER_MAX_AGE_MS) {
+    clearForceShutdownRequest();
+    return false;
+  }
+
+  const applies = marker.pids.length === 0 || marker.pids.includes(pid);
+  if (applies) clearForceShutdownRequest();
+  return applies;
+}

package/src/core/runner.ts

@@ -17,6 +17,7 @@ import { ActiveEngine } from "../db/models";
 import { getPaths } from "../utils/paths";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
+import { registerActiveHandle, unregisterActiveHandle } from "./active-handles";
 
 export type ActivityCallback = (line: string) => void;
 
@@ -98,6 +99,7 @@ export async function runJobWithClaude(
   onActivity?: ActivityCallback,
   model?: string,
   sourceCtx?: McpSourceContext,
+  activeRoom?: string,
 ): Promise<RunnerOutput> {
   const sessionId = randomUUID();
 
@@ -131,6 +133,13 @@ export async function runJobWithClaude(
     prompt: singleMessage() as any,
     options: options as any,
   });
+  let abortReason: string | null = null;
+  if (activeRoom) {
+    registerActiveHandle(activeRoom, (reason) => {
+      abortReason = reason;
+      handle.close();
+    });
+  }
 
   let agentText = "";
   let actualSessionId = sessionId;
@@ -214,8 +223,28 @@ export async function runJobWithClaude(
         }
       }
     }
+  } catch (err) {
+    if (abortReason) {
+      return {
+        agentText: "",
+        sessionId: actualSessionId,
+        terminalReason: "aborted",
+        error: abortReason,
+      };
+    }
+    throw err;
   } finally {
     handle.close();
+    if (activeRoom) unregisterActiveHandle(activeRoom);
+  }
+
+  if (abortReason) {
+    return {
+      agentText: "",
+      sessionId: actualSessionId,
+      terminalReason: "aborted",
+      error: abortReason,
+    };
   }
 
   return { agentText, sessionId: actualSessionId, terminalReason };
@@ -243,7 +272,7 @@ export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
   await ActiveEngine.register(room, "system").catch(() => {});
   try {
     const systemPrompt = opts.systemPrompt || buildSystemPrompt("job");
-    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir());
+    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir(), undefined, undefined, undefined, room);
     if (output.error) {
       log.error({ task: opts.name, error: output.error }, "task failed");
     } else {
@@ -297,11 +326,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
   const config = getConfig();
   const timestamp = new Date().toISOString();
   const startMs = performance.now();
+  const room = `job/${job.name}`;
 
   // Update state: running
   const state: Record<string, JobState> = { ...readState() };
   state[job.name] = { lastRun: timestamp, status: "running", duration_ms: 0 };
   writeState(state);
+  await ActiveEngine.register(room, "job").catch(() => {});
 
   try {
     let cwd = homedir();
@@ -352,7 +383,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       const fullPrompt = `${systemPrompt}\n\n---\n\n${jobPrompt}`;
       output = await runJobWithCodex(fullPrompt, cwd, resolvedModel);
     } else {
-      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx);
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx, room);
 
       for (let attempt = 0; attempt < MAX_API_RETRIES && output.error && isRetryableApiError(output.error); attempt++) {
         const delay = RETRY_DELAYS[attempt] ?? 8_000;
@@ -361,7 +392,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, jobSourceCtx);
+        output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx, room);
       }
     }
 
@@ -435,5 +466,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     writeState(freshState);
 
     return result;
+  } finally {
+    await ActiveEngine.unregister(room).catch(() => {});
   }
 }

package/src/prompts/channel-slack.md

@@ -24,7 +24,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.
 - `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.
+- If the user wants you to inspect or send a file/image, use the absolute paths in the `[Attachment local paths]` block. Use `send_message` with `media_path` when forwarding one.
 
 ### Who's talking
 - Multiple users may message you. Slack messages are prefixed with [user:ID] so you know who's talking (in channels and DMs).

package/src/prompts/environment.md

@@ -9,6 +9,13 @@ You are running as part of the assistant daemon.
 - Current date (authoritative): {{currentDate}}
 - Current time: {{currentTime}}
 
+## Runtime OS
+
+- OS: {{osName}} ({{osType}} {{osRelease}})
+- Platform: {{osPlatform}}
+- Architecture: {{osArch}}
+- Shell: {{shell}}
+
 When writing calendar digests, standups, reminders, or any dated message, preserve the weekday/date pairing from the authoritative current date above. If a weekday/date mismatch would matter, verify with the system date or source calendar before sending.
 
 ## Nia CLI
@@ -43,7 +50,7 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - `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.
+  For inbound channel files, check the message context for an `[Attachment local paths]` block and use those absolute paths for inspection or 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/prompts/index.ts

@@ -3,6 +3,7 @@ import { join, resolve } from "path";
 import { getPaths } from "../utils/paths";
 import { getConfig } from "../utils/config";
 import { formatPromptDate, formatPromptDateTime } from "../utils/time";
+import { getRuntimeOsInfo } from "../utils/os";
 import type { Mode } from "../types";
 
 const PROMPTS_DIR = resolve(import.meta.dir);
@@ -21,6 +22,7 @@ export function getEnvironmentPrompt(): string {
   const paths = getPaths();
   const config = getConfig();
   const now = new Date();
+  const osInfo = getRuntimeOsInfo();
 
   // Build watch channel summary if Slack is configured with watch channels
   let slackWatch = "";
@@ -37,6 +39,12 @@ export function getEnvironmentPrompt(): string {
     timezone: config.timezone,
     currentDate: formatPromptDate(now, config.timezone),
     currentTime: formatPromptDateTime(now, config.timezone),
+    osName: osInfo.osName,
+    osType: osInfo.osType,
+    osRelease: osInfo.osRelease,
+    osPlatform: osInfo.osPlatform,
+    osArch: osInfo.osArch,
+    shell: osInfo.shell,
     activeStart: config.activeHours.start,
     activeEnd: config.activeHours.end,
     model: config.model,

package/src/utils/os.ts

@@ -0,0 +1,33 @@
+import { arch, platform, release, type } from "os";
+
+function shellName(): string {
+  const raw = process.env.SHELL || process.env.ComSpec || "";
+  if (!raw) return "unknown";
+  const normalized = raw.replace(/\\/g, "/");
+  return normalized.split("/").filter(Boolean).pop() || "unknown";
+}
+
+function osName(osPlatform: NodeJS.Platform): string {
+  switch (osPlatform) {
+    case "darwin":
+      return "macOS";
+    case "linux":
+      return "Linux";
+    case "win32":
+      return "Windows";
+    default:
+      return type();
+  }
+}
+
+export function getRuntimeOsInfo(): Record<string, string> {
+  const osPlatform = platform();
+  return {
+    osName: osName(osPlatform),
+    osType: type(),
+    osRelease: release(),
+    osPlatform,
+    osArch: arch(),
+    shell: shellName(),
+  };
+}