niahere 0.2.9 → 0.2.11

package/README.md

@@ -9,9 +9,9 @@ A personal AI assistant that runs as a background daemon. Handles scheduled jobs
 ## Quick Start
 
 ```bash
-bun install -g niahere
-nia init          # guided setup (database, channels, persona, visual identity)
-nia start         # starts daemon + registers OS service
+npm i -g niahere        # installs globally (prompts to install Bun if missing)
+nia init                # guided setup (database, channels, persona, visual identity)
+nia start               # starts daemon + registers OS service
 ```
 
 ## Commands
@@ -19,40 +19,56 @@ nia start         # starts daemon + registers OS service
 ```
 nia init                       — interactive setup (db, channels, persona, images)
 nia start / stop               — daemon + OS service (launchd/systemd)
-nia restart                    — restart daemon
+nia restart                    — restart daemon (service-aware)
 nia status                     — show daemon, jobs, channels, chat rooms
 nia chat [-r|--resume]         — interactive terminal chat
 nia run <prompt>               — one-shot prompt execution
 nia history [room]             — recent messages
 nia logs [-f]                  — daemon logs (follow with -f)
-nia send <message>             — send a message via configured channel
+nia send [-c channel] <msg>    — send a message via channel
 nia skills                     — list available skills
-nia test [-v]                  — run tests
 nia version                    — show version
 
 nia job list                   — list all jobs
 nia job show [name]            — full details + recent runs
-nia job status [name]          — quick status check
 nia job add <n> <s> <p>        — add a job (active hours only)
 nia job add <n> <s> <p> --always — add a cron (runs 24/7)
 nia job remove <name>          — delete a job
 nia job enable / disable <n>   — toggle a job
 nia job run <name>             — run a job once
 nia job log [name]             — show recent run history
+
+nia db setup                   — install PostgreSQL + create database + migrate
+nia db migrate                 — run database migrations
+nia db status                  — check database connection
+
 nia channels                   — show channel status (on/off)
 nia channels on / off          — enable/disable channels
 ```
 
 ## Features
 
-- **Jobs & crons** — jobs run during active hours, crons run 24/7. Stored in PostgreSQL, auto-reload via LISTEN/NOTIFY. Full JSONL traces stored per run with Codex session IDs for inspection.
+- **Jobs & crons** — jobs run during active hours, crons run 24/7. Stored in PostgreSQL, auto-reload via LISTEN/NOTIFY. One-shot jobs auto-disable after execution. Full JSONL traces with Codex session IDs.
 - **Terminal chat** — REPL with session resume support
-- **Telegram** — bot with access control, typing indicator while processing, no placeholder messages
-- **Slack** — Socket Mode bot with thinking emoji reactions, thread awareness (auto-listens to follow-ups without @mention), thread context fetching
+- **Telegram** — bot with access control, typing indicator while processing
+- **Slack** — Socket Mode bot with thinking emoji reactions, thread awareness (auto-listens to follow-ups without @mention), thread context fetching, owner vs non-owner access control, prompt injection defense
 - **Persona system** — customizable identity, soul, owner profile, and on-demand memory
 - **Visual identity** — AI-generated profile pictures via Gemini, customizable during `nia init`
-- **Cross-platform service** — launchd (macOS), systemd (Linux), or plain daemon
-- **Skills** — loads user skills from `~/.shared/skills/`, `~/.claude/skills/`, `~/.codex/skills/`, and bundled skills
+- **Cross-platform service** — launchd (macOS), systemd (Linux), service-aware restart
+- **Skills** — loads skills from `~/.shared/skills/`, `~/.claude/skills/`, `~/.codex/skills/`, and bundled skills
+- **Dev mode** — `nia channels off` disables Telegram/Slack for local development without conflicts
+
+## Updating
+
+```bash
+npm i -g niahere         # pulls the latest version from npm
+```
+
+To publish a new version after making changes:
+
+```bash
+npm run release          # bumps patch version, publishes to npm, pushes git tag
+```
 
 ## Architecture
 
@@ -65,18 +81,18 @@ All config and data lives in `~/.niahere/`:
     identity.md     — agent personality and voice
     owner.md        — who runs this agent
     soul.md         — how the agent works
-    memory.md       — persistent learnings (read/written on demand, not loaded into context)
+    memory.md       — persistent learnings (read/written on demand)
   images/
-    reference.webp   — visual identity reference image
-    profile.webp     — profile picture for Telegram/Slack
+    reference.webp  — visual identity reference image
+    profile.webp    — profile picture for Telegram/Slack
   tmp/
     nia.pid, daemon.log, cron-state.json, cron-audit.jsonl
 ```
 
 ## Requirements
 
-- [Bun](https://bun.sh) runtime
-- PostgreSQL database
+- [Bun](https://bun.sh) runtime (auto-installed if missing)
+- PostgreSQL (`nia db setup` handles installation)
 - Claude API access (via `@anthropic-ai/claude-agent-sdk`)
 - Gemini API key (optional, for image generation)
 

package/package.json

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

package/skills/slack/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: slack
+description: Atomic Slack primitives for agents. Send, reply, DM, read history, threads, list channels/users, search, react. Use when you need to interact with Slack.
+---
+
+# Slack — Atomic Primitives
+
+Single entry point, one subcommand per API call. Agents compose these to build any Slack workflow.
+
+## Setup
+
+Credentials: `~/.niahere/config.yaml` → `channels.slack.bot_token`
+
+## Primitives
+
+```bash
+S=~/.shared/skills/slack/slack.py
+
+# Send & reply
+python3 $S send      --channel C... --text "message"
+python3 $S reply     --channel C... --thread-ts 1... --text "reply"
+python3 $S dm        --text "message"                          # DMs dm_user_id
+python3 $S dm        --text "message" --user U...              # DMs specific user
+
+# Read
+python3 $S history   --channel C... [--limit 20]
+python3 $S thread    --channel C... --thread-ts 1... [--limit 50]
+
+# Discovery
+python3 $S channels  [--limit 200]
+python3 $S users     [--limit 200]
+python3 $S user-info --user U...
+python3 $S search    --query "text" [--limit 10]
+python3 $S identity
+
+# React
+python3 $S react     --channel C... --ts 1... --emoji thumbsup
+```
+
+## Extracting Thread Info from Slack URL
+
+URL format: `https://<workspace>.slack.com/archives/<CHANNEL_ID>/p<THREAD_TS_NO_DOT>`
+- **Channel ID:** the segment after `/archives/`
+- **Thread TS:** the `p` number with a `.` inserted before the last 6 digits
+
+## Beyond these primitives
+
+These commands cover common operations but the Slack API has 200+ methods. If you need something not listed here (e.g. managing bookmarks, setting channel topics, pinning messages, scheduling messages, managing user groups):
+
+1. **Check `slack.py --help`** for available subcommands first.
+2. **Use the Slack API directly** via `curl` with the bot token from `slack_helper.load_slack_config()["token"]`. The pattern is always: `curl -H "Authorization: Bearer $TOKEN" https://slack.com/api/<method>`.
+3. **Consult the [Slack API docs](https://api.slack.com/methods)** to find the right method and required scopes.
+4. **Compose primitives** to build workflows — "summarize channel" is just `history` + LLM reasoning. "Find discussions about X" is `search` + `thread`.
+
+The bot token and auth pattern are consistent across all Slack APIs. Don't limit yourself to what's explicitly in `slack.py` — treat it as a starting point, not a boundary.
+
+## Design
+
+Each subcommand = one Slack API call. No bundled workflows.
+Features are outcomes achieved by an agent composing these primitives in a loop.

package/skills/slack/slack.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Atomic Slack primitives. One subcommand = one API call.
+
+Usage: python3 slack.py <action> [args]
+
+Actions:
+  send       --channel C... --text "msg"           Post to a channel
+  reply      --channel C... --thread-ts 1... --text "msg"  Reply in thread
+  dm         --text "msg" [--user U...]            DM a user (default: dm_user_id)
+  history    --channel C... [--limit N]            Read channel messages
+  thread     --channel C... --thread-ts 1... [--limit N]  Read thread replies
+  channels   [--limit N]                           List channels
+  users      [--limit N]                           List workspace users
+  user-info  --user U...                           Get user profile
+  react      --channel C... --ts 1... --emoji name  Add reaction
+  search     --query "text" [--limit N]            Search messages
+  identity                                         Get bot/workspace info
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from slack_helper import load_slack_config, auth_headers, get_identity, open_dm
+
+import requests
+
+
+def _api(method, endpoint, **kwargs):
+    url = f"https://slack.com/api/{endpoint}"
+    if method == "get":
+        resp = requests.get(url, headers=auth_headers(), params=kwargs)
+    else:
+        resp = requests.post(url, headers={**auth_headers(), "Content-Type": "application/json"}, json=kwargs)
+    data = resp.json()
+    if not data.get("ok"):
+        print(json.dumps({"ok": False, "error": data.get("error")}))
+        sys.exit(1)
+    return data
+
+
+def _ts_to_time(ts):
+    try:
+        return datetime.fromtimestamp(float(ts)).strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, OSError):
+        return ts
+
+
+def cmd_send(args):
+    data = _api("post", "chat.postMessage", channel=args.channel, text=args.text)
+    print(json.dumps({"ok": True, "channel": args.channel, "ts": data.get("ts")}))
+
+
+def cmd_reply(args):
+    data = _api("post", "chat.postMessage", channel=args.channel, text=args.text, thread_ts=args.thread_ts)
+    print(json.dumps({"ok": True, "channel": args.channel, "thread_ts": args.thread_ts, "ts": data.get("ts")}))
+
+
+def cmd_dm(args):
+    config = load_slack_config()
+    user_id = args.user or config["dm_user_id"]
+    channel_id = open_dm(user_id)
+    data = _api("post", "chat.postMessage", channel=channel_id, text=args.text)
+    print(json.dumps({"ok": True, "dm_channel": channel_id, "user": user_id, "ts": data.get("ts")}))
+
+
+def cmd_history(args):
+    data = _api("get", "conversations.history", channel=args.channel, limit=args.limit)
+    for msg in data.get("messages", []):
+        print(f"[{_ts_to_time(msg.get('ts', ''))}] {msg.get('user', 'unknown')}: {msg.get('text', '')}")
+
+
+def cmd_thread(args):
+    data = _api("get", "conversations.replies", channel=args.channel, ts=args.thread_ts, limit=args.limit)
+    for msg in data.get("messages", []):
+        print(f"[{_ts_to_time(msg.get('ts', ''))}] {msg.get('user', 'unknown')}: {msg.get('text', '')}")
+
+
+def cmd_channels(args):
+    data = _api("get", "conversations.list", types="public_channel,private_channel", limit=args.limit)
+    channels = sorted(data.get("channels", []), key=lambda c: c.get("name", ""))
+    for ch in channels:
+        purpose = ch.get("purpose", {}).get("value", "")[:60]
+        print(f"#{ch.get('name', ''):<30} {ch.get('id', '')}  ({ch.get('num_members', 0)} members)  {purpose}")
+
+
+def cmd_users(args):
+    data = _api("get", "users.list", limit=args.limit)
+    for u in data.get("members", []):
+        if u.get("deleted") or u.get("is_bot"):
+            continue
+        name = u.get("real_name") or u.get("name", "unknown")
+        print(f"{u.get('id', ''):<12} @{u.get('name', ''):<20} {name}")
+
+
+def cmd_user_info(args):
+    data = _api("get", "users.info", user=args.user)
+    u = data.get("user", {})
+    profile = u.get("profile", {})
+    print(json.dumps({
+        "id": u.get("id"),
+        "name": u.get("name"),
+        "real_name": u.get("real_name"),
+        "title": profile.get("title"),
+        "email": profile.get("email"),
+        "status": profile.get("status_text"),
+        "tz": u.get("tz"),
+    }, indent=2))
+
+
+def cmd_react(args):
+    _api("post", "reactions.add", channel=args.channel, timestamp=args.ts, name=args.emoji)
+    print(json.dumps({"ok": True, "emoji": args.emoji, "channel": args.channel, "ts": args.ts}))
+
+
+def cmd_search(args):
+    data = _api("get", "search.messages", query=args.query, count=args.limit)
+    matches = data.get("messages", {}).get("matches", [])
+    for m in matches:
+        ch = m.get("channel", {}).get("name", "?")
+        print(f"[{_ts_to_time(m.get('ts', ''))}] #{ch} {m.get('username', 'unknown')}: {m.get('text', '')}")
+
+
+def cmd_identity(args):
+    info = get_identity()
+    print(json.dumps(info, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Atomic Slack primitives")
+    sub = parser.add_subparsers(dest="action", required=True)
+
+    p = sub.add_parser("send")
+    p.add_argument("--channel", required=True)
+    p.add_argument("--text", required=True)
+
+    p = sub.add_parser("reply")
+    p.add_argument("--channel", required=True)
+    p.add_argument("--thread-ts", required=True)
+    p.add_argument("--text", required=True)
+
+    p = sub.add_parser("dm")
+    p.add_argument("--text", required=True)
+    p.add_argument("--user", default=None)
+
+    p = sub.add_parser("history")
+    p.add_argument("--channel", required=True)
+    p.add_argument("--limit", type=int, default=20)
+
+    p = sub.add_parser("thread")
+    p.add_argument("--channel", required=True)
+    p.add_argument("--thread-ts", required=True)
+    p.add_argument("--limit", type=int, default=50)
+
+    p = sub.add_parser("channels")
+    p.add_argument("--limit", type=int, default=200)
+
+    p = sub.add_parser("users")
+    p.add_argument("--limit", type=int, default=200)
+
+    p = sub.add_parser("user-info")
+    p.add_argument("--user", required=True)
+
+    p = sub.add_parser("react")
+    p.add_argument("--channel", required=True)
+    p.add_argument("--ts", required=True)
+    p.add_argument("--emoji", required=True)
+
+    p = sub.add_parser("search")
+    p.add_argument("--query", required=True)
+    p.add_argument("--limit", type=int, default=10)
+
+    p = sub.add_parser("identity")
+
+    args = parser.parse_args()
+    {
+        "send": cmd_send,
+        "reply": cmd_reply,
+        "dm": cmd_dm,
+        "history": cmd_history,
+        "thread": cmd_thread,
+        "channels": cmd_channels,
+        "users": cmd_users,
+        "user-info": cmd_user_info,
+        "react": cmd_react,
+        "search": cmd_search,
+        "identity": cmd_identity,
+    }[args.action](args)
+
+
+if __name__ == "__main__":
+    main()

package/skills/slack/slack_helper.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Shared Slack config helper. Reads creds from ~/.niahere/config.yaml."""
+
+import yaml
+import requests
+from pathlib import Path
+
+CONFIG_PATH = Path.home() / ".niahere" / "config.yaml"
+
+_identity_cache = None
+
+def load_slack_config():
+    """Load Slack config from ~/.niahere/config.yaml."""
+    with open(CONFIG_PATH) as f:
+        config = yaml.safe_load(f)
+    slack = config["channels"]["slack"]
+    return {
+        "token": slack["bot_token"],
+        "app_token": slack.get("app_token"),
+        "dm_user_id": slack.get("dm_user_id"),
+    }
+
+def get_identity():
+    """Call auth.test to get bot identity and workspace info. Cached per process."""
+    global _identity_cache
+    if _identity_cache:
+        return _identity_cache
+    resp = requests.get("https://slack.com/api/auth.test", headers=auth_headers())
+    data = resp.json()
+    if not data.get("ok"):
+        raise RuntimeError(f"Slack auth failed: {data.get('error')}")
+    _identity_cache = {
+        "bot_user_id": data["user_id"],
+        "bot_id": data["bot_id"],
+        "bot_name": data["user"],
+        "workspace": data["team"],
+        "workspace_id": data["team_id"],
+        "workspace_url": data["url"],
+    }
+    return _identity_cache
+
+def auth_headers(token=None):
+    """Return Authorization headers for Slack API calls."""
+    if not token:
+        token = load_slack_config()["token"]
+    return {"Authorization": f"Bearer {token}"}
+
+def open_dm(user_id=None):
+    """Open a DM channel with a user. Defaults to dm_user_id from config."""
+    config = load_slack_config()
+    user_id = user_id or config["dm_user_id"]
+    resp = requests.post(
+        "https://slack.com/api/conversations.open",
+        headers={**auth_headers(), "Content-Type": "application/json"},
+        json={"users": user_id},
+    )
+    data = resp.json()
+    if not data.get("ok"):
+        raise RuntimeError(f"Failed to open DM: {data.get('error')}")
+    return data["channel"]["id"]

package/src/channels/slack.ts

@@ -13,12 +13,15 @@ class SlackChannel implements Channel {
   private app: App | null = null;
   private defaultChannelId: string | null = null;
   private dmUserId: string | null = null;
+  /** Timestamps of messages Nia posted proactively (used to detect replies to our own messages) */
+  private outboundTs = new Set<string>();
 
   async sendMessage(text: string): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
     const target = this.defaultChannelId || this.dmUserId;
     if (!target) throw new Error("No Slack recipient — DM the bot first, or set slack_channel_id in config");
-    await this.app.client.chat.postMessage({ channel: target, text });
+    const result = await this.app.client.chat.postMessage({ channel: target, text });
+    if (result.ts) this.outboundTs.add(result.ts);
   }
 
   async sendMedia(data: Buffer, mimeType: string, filename?: string): Promise<void> {
@@ -216,7 +219,8 @@ class SlackChannel implements Channel {
       const isMention = botUserId && msg.text?.includes(`<@${botUserId}>`);
       const hasFiles = msg.files && msg.files.length > 0;
 
-      // In threads where Nia already has a session (in-memory or DB), listen without @mention
+      // In threads where Nia already has a session (in-memory or DB), listen without @mention.
+      // Also catches replies to messages Nia posted proactively (outbound tracking + bot-authored fallback).
       let isActiveThread = false;
       if (!isDm && msg.thread_ts) {
         const channelName = await resolveChannelName(app, msg.channel);
@@ -230,6 +234,30 @@ class SlackChannel implements Channel {
           const sessionId = await Session.getLatest(latestRoom);
           isActiveThread = sessionId !== null;
         }
+
+        // Fast path: we tracked this ts when we sent it
+        if (!isActiveThread && self.outboundTs.has(msg.thread_ts)) {
+          isActiveThread = true;
+        }
+
+        // Fallback: check if the thread parent was posted by the bot
+        if (!isActiveThread && botUserId) {
+          try {
+            const parent = await client.conversations.replies({
+              channel: msg.channel,
+              ts: msg.thread_ts,
+              limit: 1,
+              inclusive: true,
+            });
+            const parentMsg = parent.messages?.[0];
+            if (parentMsg && (parentMsg.user === botUserId || parentMsg.bot_id)) {
+              isActiveThread = true;
+              log.debug({ channel: msg.channel, thread_ts: msg.thread_ts }, "thread parent is bot-authored, activating");
+            }
+          } catch (err) {
+            log.warn({ err, channel: msg.channel, thread_ts: msg.thread_ts }, "failed to check thread parent");
+          }
+        }
       }
 
       if (!isDm && !isMention && !isActiveThread) {

package/src/cli/channels.ts

@@ -2,6 +2,7 @@ import { getConfig, updateRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { errMsg } from "../utils/errors";
 import { fail } from "../utils/cli";
+import { log } from "../utils/log";
 
 export async function sendCommand(): Promise<void> {
   const args = process.argv.slice(3);
@@ -51,7 +52,34 @@ export function telegramCommand(): void {
   console.log("Run `nia restart` to activate.");
 }
 
-export function slackCommand(): void {
+/** Call Slack auth.test to enrich config with workspace/bot info. */
+export async function enrichSlackConfig(botToken: string): Promise<Record<string, unknown>> {
+  try {
+    const resp = await fetch("https://slack.com/api/auth.test", {
+      headers: { Authorization: `Bearer ${botToken}` },
+    });
+    const data = (await resp.json()) as Record<string, unknown>;
+    if (!data.ok) {
+      log.warn({ error: data.error }, "Slack auth.test failed, skipping enrichment");
+      return {};
+    }
+    const enriched = {
+      bot_user_id: data.user_id,
+      bot_name: data.user,
+      workspace: data.team,
+      workspace_id: data.team_id,
+      workspace_url: data.url,
+    };
+    console.log(`  Slack workspace: ${data.team} (${data.url})`);
+    console.log(`  Bot: @${data.user} (${data.user_id})`);
+    return enriched;
+  } catch (err) {
+    log.warn({ err }, "Failed to reach Slack API, skipping enrichment");
+    return {};
+  }
+}
+
+export async function slackCommand(): Promise<void> {
   const botToken = process.argv[3];
   const appToken = process.argv[4];
 
@@ -59,6 +87,32 @@ export function slackCommand(): void {
     const config = getConfig();
     if (config.channels.slack.bot_token) {
       console.log(`Slack: configured (...${config.channels.slack.bot_token.slice(-6)})`);
+      if (config.channels.slack.workspace) {
+        console.log(`  Workspace: ${config.channels.slack.workspace} (${config.channels.slack.workspace_url})`);
+        console.log(`  Bot: @${config.channels.slack.bot_name} (${config.channels.slack.bot_user_id})`);
+      }
+      // Verify auth is working
+      try {
+        const resp = await fetch("https://slack.com/api/auth.test", {
+          headers: { Authorization: `Bearer ${config.channels.slack.bot_token}` },
+        });
+        const data = (await resp.json()) as Record<string, unknown>;
+        if (data.ok) {
+          console.log(`  Auth: \u2713 valid`);
+          // Backfill workspace info if missing
+          if (!config.channels.slack.workspace) {
+            const enriched = await enrichSlackConfig(config.channels.slack.bot_token);
+            if (Object.keys(enriched).length > 0) {
+              updateRawConfig({ channels: { slack: enriched } });
+              console.log("  (workspace info backfilled)");
+            }
+          }
+        } else {
+          console.log(`  Auth: \u2717 ${data.error}`);
+        }
+      } catch (err) {
+        console.log(`  Auth: \u2717 could not reach Slack API`);
+      }
     } else {
       console.log("Slack: not configured");
     }
@@ -72,6 +126,11 @@ export function slackCommand(): void {
   const sl: Record<string, unknown> = { bot_token: botToken, app_token: appToken };
   const channelId = process.argv[5];
   if (channelId) sl.channel_id = channelId;
+
+  // Enrich with workspace/bot info from auth.test
+  const enriched = await enrichSlackConfig(botToken);
+  Object.assign(sl, enriched);
+
   updateRawConfig({ channels: { slack: sl } });
 
   console.log(`Slack tokens saved to ${getPaths().config}`);

package/src/cli/index.ts

@@ -219,7 +219,7 @@ switch (command) {
   }
 
   case "slack": {
-    slackCommand();
+    await slackCommand();
     break;
   }
 

package/src/cli/status.ts

@@ -7,6 +7,7 @@ import { Message, ActiveEngine, Job } from "../db/models";
 import type { ScheduleType, JobStateStatus, RoomStats } from "../types";
 import { withDb } from "../db/connection";
 import { errMsg } from "../utils/errors";
+import { checkForUpdate } from "../utils/update";
 
 type StatusOptions = {
   json: boolean;
@@ -306,4 +307,13 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
   } else {
     console.log("Tip: use --rooms N, --all, or --json for alternate views.");
   }
+
+  // Check for updates (non-blocking, cached 24h)
+  try {
+    const { version } = await import("../../package.json");
+    const update = await checkForUpdate(version);
+    if (update) {
+      console.log(`\n⚠ Update available: ${update.current} → ${update.latest} (run \`npm i -g niahere\` to update)`);
+    }
+  } catch {}
 }

package/src/commands/init.ts

@@ -8,6 +8,7 @@ import { runMigrations } from "../db/migrate";
 import { closeDb } from "../db/connection";
 import { startDaemon, isRunning } from "../core/daemon";
 import { errMsg } from "../utils/errors";
+import { enrichSlackConfig } from "../cli/channels";
 import yaml from "js-yaml";
 
 const DEFAULTS_DIR = resolve(import.meta.dir, "../../defaults/self");
@@ -396,6 +397,9 @@ export async function runInit(): Promise<void> {
     if (slackBotToken && slackAppToken) {
       const sl: Record<string, unknown> = { bot_token: slackBotToken, app_token: slackAppToken };
       if (slackChannelId) sl.channel_id = slackChannelId;
+      // Enrich with workspace/bot info from auth.test
+      const enriched = await enrichSlackConfig(slackBotToken);
+      Object.assign(sl, enriched);
       channels.slack = sl;
     }
     if (slackBotToken && !telegramToken) {

package/src/core/daemon.ts

@@ -162,6 +162,17 @@ export async function runDaemon(): Promise<void> {
   writePid(process.pid);
   log.info({ pid: process.pid }, "daemon started");
 
+  // Check for updates (non-blocking, logged only)
+  try {
+    const { checkForUpdate } = await import("../utils/update");
+    const { version } = await import("../../package.json");
+    const update = await checkForUpdate(version);
+    if (update) {
+      log.warn({ current: update.current, latest: update.latest }, "update available — run `npm i -g niahere` to update");
+    }
+  } catch {}
+
+
   // Startup recovery
   try {
     await runMigrations();

package/src/types/config.ts

@@ -9,6 +9,11 @@ export interface SlackConfig {
   app_token: string | null;
   channel_id: string | null;
   dm_user_id: string | null;
+  bot_user_id: string | null;
+  bot_name: string | null;
+  workspace: string | null;
+  workspace_id: string | null;
+  workspace_url: string | null;
 }
 
 export interface ChannelsConfig {

package/src/utils/config.ts

@@ -19,7 +19,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 },
+    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 },
   },
 };
 
@@ -127,6 +127,17 @@ export function loadConfig(): Config {
   const slDmUserId =
     typeof chSl.dm_user_id === "string" ? chSl.dm_user_id : null;
 
+  const slBotUserId =
+    typeof chSl.bot_user_id === "string" ? chSl.bot_user_id : null;
+  const slBotName =
+    typeof chSl.bot_name === "string" ? chSl.bot_name : null;
+  const slWorkspace =
+    typeof chSl.workspace === "string" ? chSl.workspace : null;
+  const slWorkspaceId =
+    typeof chSl.workspace_id === "string" ? chSl.workspace_id : null;
+  const slWorkspaceUrl =
+    typeof chSl.workspace_url === "string" ? chSl.workspace_url : null;
+
   return {
     model,
     timezone,
@@ -138,7 +149,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 },
+      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 },
     },
   };
 }

package/src/utils/update.ts

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { getNiaHome } from "./paths";
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const PACKAGE_NAME = "niahere";
+
+type UpdateCache = {
+  latest: string;
+  checkedAt: number;
+};
+
+function cachePath(): string {
+  return resolve(getNiaHome(), "tmp/update-check.json");
+}
+
+function readCache(): UpdateCache | null {
+  const path = cachePath();
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    if (data.latest && data.checkedAt && Date.now() - data.checkedAt < CACHE_TTL_MS) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+
+function writeCache(latest: string): void {
+  const path = cachePath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify({ latest, checkedAt: Date.now() }));
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const resp = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json() as { version?: string };
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function isNewer(latest: string, current: string): boolean {
+  const [la, lb, lc] = latest.split(".").map(Number);
+  const [ca, cb, cc] = current.split(".").map(Number);
+  if (la !== ca) return la > ca;
+  if (lb !== cb) return lb > cb;
+  return lc > cc;
+}
+
+/** Check if a newer version is available. Returns update info or null. Non-blocking, cached 24h. */
+export async function checkForUpdate(currentVersion: string): Promise<{ current: string; latest: string } | null> {
+  const cached = readCache();
+  if (cached) {
+    return isNewer(cached.latest, currentVersion) ? { current: currentVersion, latest: cached.latest } : null;
+  }
+
+  const latest = await fetchLatestVersion();
+  if (!latest) return null;
+
+  writeCache(latest);
+  return isNewer(latest, currentVersion) ? { current: currentVersion, latest } : null;
+}