niahere 0.2.8 → 0.2.10

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.8",
+  "version": "0.2.10",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {
@@ -11,7 +11,8 @@
     "test": "tsc --noEmit && LOG_LEVEL=silent bun test --reporter=dots",
     "test:bun": "bun test",
     "typecheck": "tsc --noEmit",
-    "seed": "bun run src/db/seed.ts"
+    "seed": "bun run src/db/seed.ts",
+    "release": "npm version patch && npm publish && git push"
   },
   "keywords": [
     "ai",

package/skills/slack/SKILL.md

@@ -0,0 +1,49 @@
+---
+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
+
+## Design
+
+Each subcommand = one Slack API call. No bundled workflows.
+Features like "summarize channel" or "find discussions" are agent-level compositions of these primitives.

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,10 @@ 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})`);
+      }
     } else {
       console.log("Slack: not configured");
     }
@@ -72,6 +104,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

@@ -238,6 +238,12 @@ switch (command) {
     break;
   }
 
+  case "db": {
+    const { dbCommand } = await import("../commands/db");
+    await dbCommand();
+    break;
+  }
+
   case "test": {
     const verbose = process.argv.includes("-v") || process.argv.includes("--verbose");
     const extraArgs = process.argv.slice(3).filter((a) => a !== "-v" && a !== "--verbose");
@@ -285,6 +291,7 @@ switch (command) {
     console.log("  history [room]      — recent messages");
     console.log("  logs [-f]           — daemon logs");
     console.log("  job <sub>           — manage jobs");
+    console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");
     console.log("  send [-c ch] <msg>  — send a message via channel");
     console.log("  telegram <token>    — configure telegram");

package/src/commands/db.ts

@@ -0,0 +1,130 @@
+import { getConfig } from "../utils/config";
+import { runMigrations } from "../db/migrate";
+import { closeDb, getSql } from "../db/connection";
+import { errMsg } from "../utils/errors";
+
+export async function dbSetup(): Promise<void> {
+  console.log("Setting up PostgreSQL...\n");
+
+  const pgCheck = Bun.spawnSync(["which", "psql"]);
+  const hasPostgres = pgCheck.exitCode === 0;
+
+  if (!hasPostgres) {
+    if (process.platform === "darwin") {
+      console.log("  PostgreSQL not found. Installing via Homebrew...");
+      const brew = Bun.spawn(["brew", "install", "postgresql@17"], { stdout: "inherit", stderr: "inherit" });
+      if (await brew.exited !== 0) {
+        console.log("  \u2717 brew install failed. Install manually: brew install postgresql@17");
+        return;
+      }
+      console.log("  \u2713 PostgreSQL installed");
+
+      console.log("  Starting PostgreSQL...");
+      const start = Bun.spawn(["brew", "services", "start", "postgresql@17"], { stdout: "pipe", stderr: "pipe" });
+      if (await start.exited !== 0) {
+        console.log("  \u2717 could not start. Try: brew services start postgresql@17");
+        return;
+      }
+      console.log("  \u2713 PostgreSQL started");
+      await new Promise((r) => setTimeout(r, 2000));
+    } else {
+      console.log("  PostgreSQL not found.");
+      console.log("  Install it:");
+      console.log("    Ubuntu/Debian: sudo apt install postgresql");
+      console.log("    Fedora: sudo dnf install postgresql-server");
+      console.log("    Arch: sudo pacman -S postgresql");
+      return;
+    }
+  } else {
+    const ready = Bun.spawnSync(["pg_isready"]);
+    if (ready.exitCode !== 0) {
+      console.log("  PostgreSQL installed but not running.");
+      if (process.platform === "darwin") {
+        console.log("  Starting...");
+        const start = Bun.spawn(["brew", "services", "start", "postgresql@17"], { stdout: "pipe", stderr: "pipe" });
+        await start.exited;
+        await new Promise((r) => setTimeout(r, 2000));
+        if (Bun.spawnSync(["pg_isready"]).exitCode === 0) {
+          console.log("  \u2713 PostgreSQL started");
+        } else {
+          console.log("  \u2717 could not start. Check: brew services list");
+          return;
+        }
+      } else {
+        console.log("  Start it: sudo systemctl start postgresql");
+        return;
+      }
+    } else {
+      console.log("  \u2713 PostgreSQL running");
+    }
+  }
+
+  // Create database
+  const config = getConfig();
+  const dbName = config.database_url.split("/").pop() || "niahere";
+  const createDb = Bun.spawnSync(["createdb", dbName]);
+  if (createDb.exitCode === 0) {
+    console.log(`  \u2713 database "${dbName}" created`);
+  } else {
+    const stderr = new TextDecoder().decode(createDb.stderr);
+    if (stderr.includes("already exists")) {
+      console.log(`  \u2713 database "${dbName}" already exists`);
+    } else {
+      console.log(`  \u2717 createdb failed: ${stderr.trim()}`);
+      return;
+    }
+  }
+
+  // Run migrations
+  try {
+    await runMigrations();
+    console.log("  \u2713 migrations done");
+    await closeDb();
+  } catch (err) {
+    console.log(`  \u2717 migrations failed: ${errMsg(err)}`);
+  }
+
+  console.log("\nDatabase ready.");
+}
+
+export async function dbCommand(): Promise<void> {
+  const sub = process.argv[3];
+
+  switch (sub) {
+    case "setup":
+      await dbSetup();
+      break;
+
+    case "migrate": {
+      try {
+        await runMigrations();
+        console.log("Migrations done.");
+        await closeDb();
+      } catch (err) {
+        console.log(`Failed: ${errMsg(err)}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "status": {
+      try {
+        const sql = getSql();
+        await sql`SELECT 1`;
+        console.log("Database: connected");
+        await closeDb();
+      } catch (err) {
+        console.log(`Database: unavailable (${errMsg(err)})`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      console.log("Usage: nia db <command>\n");
+      console.log("  setup    — install PostgreSQL + create database + migrate");
+      console.log("  migrate  — run database migrations");
+      console.log("  status   — check database connection");
+      break;
+  }
+}

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");
@@ -114,7 +115,13 @@ export async function runInit(): Promise<void> {
     } catch (err) {
       const msg = errMsg(err);
       console.log(`  \u2717 could not connect: ${msg}`);
-      console.log(`  (you can fix this later in ${paths.config})\n`);
+      const setupDb = await ask(rl, "  Set up PostgreSQL now? (y/n)", "y");
+      if (setupDb.toLowerCase() === "y") {
+        const { dbSetup } = await import("./db");
+        await dbSetup();
+      } else {
+        console.log(`  (run 'nia db setup' later)\n`);
+      }
     }
     delete process.env.DATABASE_URL;
 
@@ -390,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/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 },
     },
   };
 }