slackhive 0.4.8 → 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pelago Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,7 +6,7 @@
 # SlackHive
 
 ### Build your AI-first company on Slack
-#### A Karpathy-inspired team of humans and AI specialists, powered by Claude Code
+#### A Karpathy-inspired team of humans and AI specialists, powered by Codex/OpenAI or Claude/Anthropic
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![npm](https://img.shields.io/npm/v/slackhive?color=cb3837&logo=npm&logoColor=white)](https://www.npmjs.com/package/slackhive)
@@ -23,6 +23,12 @@
 
 <img src="https://raw.githubusercontent.com/pelago-labs/slackhive/main/docs/images/slack-ai-agent-team-dashboard-with-avatars.png" alt="SlackHive dashboard" style="border-radius: 12px;" />
 
+<br /><br />
+
+<sub><b>What it looks like in Slack</b> — a SlackHive agent collaborating with the team in a real channel: daily report, follow-up questions, metric correction, and an inline PR — all in the same thread.</sub>
+
+<img src="https://raw.githubusercontent.com/pelago-labs/slackhive/main/docs/images/slackhive-in-action-growth-analytics.png" alt="SlackHive agent collaborating in a Slack growth-analytics channel: daily growth report, follow-up questions, and an inline metric correction with a PR" style="border-radius: 12px;" />
+
 </div>
 
 ---
@@ -86,10 +92,10 @@ slackhive init
 ```
 
 The CLI will:
-1. Check prerequisites (Git, Node.js ≥ 20, Claude Code)
+1. Check prerequisites (Git and Node.js ≥ 20)
 2. Clone the repository
-3. Auto-detect your Claude installation (cross-platform compatible)
-4. Walk you through configuration (API key or subscription, admin credentials)
+3. Walk you through admin credentials and local configuration
+4. Tell you where to connect Codex/OpenAI or Claude/Anthropic in Settings
 5. Build and start the services natively - no Docker required
 
 Open `http://localhost:3001` and create your first agent.
@@ -121,7 +127,10 @@ Installing Node via [nvm](https://github.com/nvm-sh/nvm) or Homebrew (`brew inst
 
 ### Option B: Manual setup
 
-**Prerequisites:** Node.js ≥ 20, Git, [Claude Code](https://docs.anthropic.com/en/docs/claude-code/setup) on your PATH
+**Prerequisites:** Node.js ≥ 20, Git, and one AI backend:
+
+- OpenAI Codex / ChatGPT via `codex login` or `OPENAI_API_KEY`
+- Claude Code / Anthropic via `claude login` or `ANTHROPIC_API_KEY`
 
 ```bash
 git clone https://github.com/pelago-labs/slackhive.git
@@ -132,7 +141,8 @@ cp .env.example .env
 Edit `.env` with your credentials:
 
 ```env
-ANTHROPIC_API_KEY=sk-ant-...        # or use Claude Pro/Max subscription
+OPENAI_API_KEY=sk-...               # optional: OpenAI API billing
+ANTHROPIC_API_KEY=sk-ant-...        # optional: Anthropic API billing
 ADMIN_USERNAME=admin
 ADMIN_PASSWORD=<strong-random-password>
 AUTH_SECRET=                        # generate: openssl rand -hex 32
@@ -150,6 +160,8 @@ npx slackhive start
 
 Open `http://localhost:3001`, log in, and create your first agent.
 
+Choose the active runtime in **Settings → AI Backend**. API keys in `.env` are available there, but the backend choice itself is managed in the dashboard.
+
 > Full setup guide → [slackhive.mintlify.app/quickstart](https://slackhive.mintlify.app/quickstart)
 
 ---
@@ -158,7 +170,7 @@ Open `http://localhost:3001`, log in, and create your first agent.
 
 ### 🤖 Real AI Agents
 
-Every agent is a full **Claude Code** agent - with tools, memory, identity, and instructions. When you @mention one in Slack, you're running a real AI agent that can use tools, take action, and get smarter over time.
+Every agent has tools, memory, identity, and instructions. When you @mention one in Slack, you're running a real AI agent that can use tools, take action, and get smarter over time. SlackHive can run agents through OpenAI Codex/ChatGPT or Claude Code/Anthropic while keeping the same Slack, MCP, memory, jobs, and observability layers.
 
 | | |
 |---|---|
@@ -166,8 +178,9 @@ Every agent is a full **Claude Code** agent - with tools, memory, identity, and
 | 🔌 **MCP Tool Integration** | Connect any MCP server (Redshift, GitHub, Notion, Figma, custom APIs) - stdio, SSE, or HTTP transports. |
 | 📝 **Inline TypeScript MCPs** | Paste TypeScript source directly into the UI - no deployment needed. The runner compiles and executes it. |
 | 🧵 **Full Thread Context** | Agents fetch the entire Slack thread on every invocation - zero context lost in handoffs. |
-| 💾 **Session Continuity** | Slack thread ↔ Claude session mapping survives restarts. Pick up exactly where you left off. |
+| 💾 **Session Continuity** | Slack thread ↔ agent session mapping survives restarts. Pick up exactly where you left off. |
 | 🔐 **Encrypted Secret Store** | API keys encrypted at rest (AES-256). MCPs reference secrets by name - raw values never touch the API or UI. |
+| 🧯 **Backup & Recovery** | Scheduled SQLite backups, manual backup/download, password-wrapped recovery key export, and CLI-only restore with pre-restore safety snapshots. |
 | 🔁 **Hot Reload** | Edit instructions, skills, or tools and the agent picks up changes within seconds. No restart needed. |
 
 ### 👑 Boss + Specialist Hierarchy
@@ -177,20 +190,23 @@ Every agent is a full **Claude Code** agent - with tools, memory, identity, and
 | 👑 **Boss Orchestration** | Boss reads your message, finds the right specialist, delegates by @mention in the same thread, and summarizes the result. |
 | 🏢 **Multi-Boss Support** | Run multiple Boss agents for different domains (engineering, data, support). Specialists can report to more than one boss. |
 | 📋 **Auto-Generated Registries** | Every Boss gets a live team roster auto-regenerated whenever the team changes. No manual maintenance. |
-| 🛠 **Skills** | Markdown files deployed as Claude Code slash commands. Give agents SQL rules, writing guidelines, or domain playbooks. |
-| ⏰ **Scheduled Jobs** | Cron-based recurring tasks - daily reports, weekly digests, monitoring alerts - posted to any Slack channel or DM. |
+| 🛠 **Skills** | Markdown playbooks that travel with an agent. Give agents SQL rules, writing guidelines, or domain workflows. |
+| ⏰ **Scheduled Jobs** | Cron-based recurring tasks - daily reports, weekly digests, monitoring alerts - posted to any Slack channel or DM. Jobs can skip quiet notifications when nothing needs attention. |
 
 ### ⚙️ Platform
 
 | | |
 |---|---|
-| 🧙 **Onboarding Wizard** | 5-step guided setup: identity → Slack app → credentials → tools & skills → review. |
+| 🧙 **Agent Launch Wizard** | Two-step setup: define identity, then choose a starting profile or blank brief. Tune prompts, skills, tools, Slack, and access after creation. |
 | 🕓 **Version Control** | Every save auto-snapshots the full agent state. Browse history with line-level diffs, restore any version in one click. |
 | 🔒 **Auth & RBAC** | 4 roles (superadmin / admin / editor / viewer), HMAC-signed sessions, per-agent access grants (View or Edit). Agents are hidden by default — admins grant access explicitly. No external auth provider needed. |
 | 🚦 **Channel Restrictions** | Lock agents to specific Slack channels. Bot auto-leaves uninvited channels with a notice. |
 | 📊 **Live Logs** | SSE-streamed log output per agent - with level filters and search. |
 | 🧠 **Memory Viewer** | Browse, inspect, and delete agent memories by type - feedback, user, project, reference. |
-| 📡 **Activity Dashboard** | Live kanban of every task your agents are working on - Active, Completed, Errors - with drill-down to every tool call. A superadmin-only **Usage** tab breaks down token consumption per agent and ranks power users by tasks started. Admins see everything; editors see only agents they own or are granted access to; viewers are blocked. |
+| 📡 **Activity** | Live board of active, completed, and errored work, with initiator, agent, replay, and trace drill-down. |
+| 🔎 **Observability** | Operational view for sessions, tokens, model usage, latency, tool reliability, sensitive access, satisfaction, and replay. |
+| 🧪 **Agent Evals** | Static healthchecks plus approved regression cases with phrase, tool-call, and LLM-judge checks. |
+| 🛡️ **Sensitive Data Controls** | Per-agent detection modes, Smart sensitivity checks, redaction levels, and sensitive-event audit trails. |
 | 🌐 **Multi-Workspace** | Connect multiple Slack workspaces to a single SlackHive instance. Each workspace gets its own agents and configurations. |
 | 📚 **Knowledge Library** | Platform-level catalog of Karpathy-style wiki folders. Owners ingest a repo / file / URL into a folder; assign one folder to many agents. The agent's `/wiki` skill auto-enables when at least one assigned folder has built content. |
 
@@ -222,7 +238,7 @@ Slack Workspace (@boss, @data-bot, @writer, ...)
 **How a message flows:**
 1. User @mentions an agent in Slack
 2. Runner receives the event via Bolt Socket Mode
-3. Claude Code processes the message with the agent's compiled `CLAUDE.md`
+3. The selected AI backend processes the message with the agent's instructions and skills
 4. Agent uses MCP tools if needed (Redshift, GitHub, Notion, etc.)
 5. Response is formatted as Slack Block Kit and posted to the thread
 6. Memory files written during the session are synced to SQLite
@@ -230,17 +246,24 @@ Slack Workspace (@boss, @data-bot, @writer, ...)
 
 ---
 
-## 🔑 Claude Code Authentication
+## 🔑 AI Backend Authentication
+
+Use one backend to start; teams can migrate later without recreating agents.
+
+**OpenAI Codex / ChatGPT**
+```env
+OPENAI_API_KEY=sk-...
+```
 
-Two options - use whichever fits your setup:
+Then choose **OpenAI Codex** in **Settings → AI Backend**. You can also use a local Codex login when available on your machine.
 
-**Option A - API Key**
+**Claude Code / Anthropic**
 ```env
 ANTHROPIC_API_KEY=sk-ant-api03-...
 ```
 Billed per token via the Anthropic API. Best for teams and production.
 
-**Option B - Claude Pro or Max Subscription**
+Then choose **Claude Code** in **Settings → AI Backend**. You can also use Claude Pro or Max subscription auth:
 
 First, install Claude Code on your host machine:
 
@@ -277,9 +300,10 @@ Leave `ANTHROPIC_API_KEY` unset - the runner picks up credentials from the syste
 - [x] Encrypted environment variables
 - [x] Channel restrictions
 - [x] Multi-workspace support
+- [x] Multi-backend AI support
+- [x] Observability, traces, replay, tokens, and sensitive-access review
 - [ ] Webhook triggers (GitHub, Jira, PagerDuty → agent actions)
 - [ ] Agent-to-agent direct messaging
-- [ ] Analytics dashboard
 - [ ] Custom tool builder (no MCP server needed)
 - [ ] Agent templates marketplace
 - [ ] RAG integration - connect agents to document stores
@@ -337,5 +361,5 @@ Use [GitHub's private vulnerability reporting](https://github.com/pelago-labs/sl
 MIT © 2026 [Pelago Labs](https://github.com/pelago-labs)
 
 <div align="center">
-  <sub>Built with Claude Code, Slack Bolt, and a lot of ☕</sub>
+  <sub>Built with AI backends, Slack Bolt, and a lot of coffee</sub>
 </div>

package/cli/README.md

@@ -0,0 +1,341 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/pelago-labs/slackhive/main/apps/web/public/logo.svg" alt="SlackHive" width="80" />
+
+
+# SlackHive
+
+### Build your AI-first company on Slack
+#### A Karpathy-inspired team of humans and AI specialists, powered by Claude Code
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/slackhive?color=cb3837&logo=npm&logoColor=white)](https://www.npmjs.com/package/slackhive)
+[![npm downloads](https://img.shields.io/npm/dt/slackhive?color=cb3837&logo=npm&logoColor=white&label=installs)](https://www.npmjs.com/package/slackhive)
+[![Node.js](https://img.shields.io/badge/Node.js-≥20-339933?logo=node.js&logoColor=white)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178c6?logo=typescript&logoColor=white)](https://www.typescriptlang.org)
+[![SQLite](https://img.shields.io/badge/SQLite-embedded-003B57?logo=sqlite&logoColor=white)](https://sqlite.org)
+[![Documentation](https://img.shields.io/badge/docs-slackhive.mintlify.app-D97757?logo=gitbook&logoColor=white)](https://slackhive.mintlify.app)
+[![Security Audit](https://github.com/pelago-labs/slackhive/actions/workflows/audit.yml/badge.svg)](https://github.com/pelago-labs/slackhive/actions/workflows/audit.yml)
+
+[**Documentation**](https://slackhive.mintlify.app) · [Quick Start](#-quick-start) · [Features](#-features) · [Architecture](#-architecture) · [Contributing](#-contributing)
+
+<br />
+
+<img src="https://raw.githubusercontent.com/pelago-labs/slackhive/main/docs/images/slack-ai-agent-team-dashboard-with-avatars.png" alt="SlackHive dashboard" style="border-radius: 12px;" />
+
+</div>
+
+---
+
+## Why SlackHive?
+
+> **A workspace where humans and AI agents work side by side beats any team made of just one or the other.**
+
+That's the whole bet. Not "AI is going to replace your team." A genuinely hybrid team — your people plus a roster of role-specific AI agents — collaborating in the same Slack channels, on the same threads, with the same `@mention` your team already uses for each other.
+
+You don't switch to a separate AI app. You don't open a new tab. You `@data-analyst` in `#sales` the way you'd ping a real one. The agent reads the full thread, queries your warehouse, and posts the answer 40 seconds later — while another channel is `@designer`-ing mockups in Figma and your `@devops` agent is quietly opening a PR for the 500s the engineer just complained about.
+
+Why this beats the alternatives:
+- **Vs. an all-human team** — slower, more context-switching, "let me get back to you" everywhere
+- **Vs. one mega-AI assistant** (single ChatGPT-style entry point) — no domain expertise, no team patterns, lives outside your workflow
+- **Vs. AI tools with their own siloed UI** — separate interface = friction = nobody uses it after week two
+
+**Anyone on the team can create an agent.** No engineers, no platform team — if you can describe what you need, you can deploy it in minutes.
+
+```
+CEO:        @data-analyst revenue is down 8% this week, can you dig in?
+DataBot:    [queries Redshift across 6 dimensions]
+            Found it - enterprise churn spiked Tuesday after the pricing change.
+            3 accounts, $42k ARR at risk.
+
+Engineer:   @devops the checkout service is throwing 500s
+DevOps:     [reads logs, identifies root cause, opens PR]
+            Memory leak in the payment processor pool. PR #847 is up with the fix.
+
+PM:         @designer mock up a simpler onboarding flow
+Designer:   [creates Figma frames via MCP]
+            Done - 3 variants in Figma. Which direction do you want to take?
+```
+
+Tag a specialist directly when you know who to ask. Or tag `@boss` when you're not sure - Boss finds the right specialist, delegates, and summarizes the result:
+
+```
+You:        @boss can you analyze last week's conversion funnel?
+Boss:       That's right up @data-analyst's alley 👇
+            @data-analyst - conversion funnel analysis for last week.
+            When you're done, please tag @boss.
+DataBot:    Conversions up 12% WoW, checkout completion jumped 3×. @boss - done!
+Boss:       Conversions are up 12% WoW. The win was checkout - 3× completion rate.
+            Want me to pull a channel or cohort breakdown?
+```
+
+> **Under the hood:** small specialist agents instead of one mega-agent (Karpathy: *specialists beat generalists*), each grounded in a per-folder Karpathy-style wiki (LLMs read structured wikis better than raw file dumps), with a Boss agent that delegates so no single context window has to hold the whole company. The architecture is a means; the team-in-Slack experience is the point.
+
+---
+
+## 🚀 Quick Start
+
+### Option A: One-command install (recommended)
+
+```bash
+npm install -g slackhive
+```
+
+```bash
+slackhive init
+```
+
+The CLI will:
+1. Check prerequisites (Git, Node.js ≥ 20, Claude Code)
+2. Clone the repository
+3. Auto-detect your Claude installation (cross-platform compatible)
+4. Walk you through configuration (API key or subscription, admin credentials)
+5. Build and start the services natively - no Docker required
+
+Open `http://localhost:3001` and create your first agent.
+
+#### Hit `EACCES: permission denied` on install?
+
+If you installed Node from nodejs.org on macOS/Linux, `/usr/local/lib/node_modules` is root-owned and `npm install -g` fails without sudo. Point npm at a user-owned prefix once - no sudo needed again:
+
+```bash
+mkdir -p ~/.npm-global
+npm config set prefix '~/.npm-global'
+echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.zshrc   # or ~/.bashrc
+source ~/.zshrc
+npm install -g slackhive
+```
+
+Installing Node via [nvm](https://github.com/nvm-sh/nvm) or Homebrew (`brew install node`) puts it in a user-writable location by default and avoids this entirely. If you'd rather skip global install, `npx slackhive init` works too - just prefix every command with `npx`.
+
+### CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `slackhive init` | Clone, configure, and start SlackHive |
+| `slackhive start` | Start all services |
+| `slackhive stop` | Stop all services (and any orphaned runner processes) |
+| `slackhive status` | Show running services + ports |
+| `slackhive logs` | Tail runner logs |
+| `slackhive update` | Pull latest changes and rebuild |
+
+### Option B: Manual setup
+
+**Prerequisites:** Node.js ≥ 20, Git, [Claude Code](https://docs.anthropic.com/en/docs/claude-code/setup) on your PATH
+
+```bash
+git clone https://github.com/pelago-labs/slackhive.git
+cd slackhive
+cp .env.example .env
+```
+
+Edit `.env` with your credentials:
+
+```env
+ANTHROPIC_API_KEY=sk-ant-...        # or use Claude Pro/Max subscription
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=<strong-random-password>
+AUTH_SECRET=                        # generate: openssl rand -hex 32
+ENV_SECRET_KEY=                     # generate: openssl rand -hex 32
+DATABASE_TYPE=sqlite                # embedded - no external DB needed
+```
+
+```bash
+npm install
+npm run build
+
+# Start the stack (web on :3001, runner on :3002)
+npx slackhive start
+```
+
+Open `http://localhost:3001`, log in, and create your first agent.
+
+> Full setup guide → [slackhive.mintlify.app/quickstart](https://slackhive.mintlify.app/quickstart)
+
+---
+
+## ✨ Features
+
+### 🤖 Real AI Agents
+
+Every agent is a full **Claude Code** agent - with tools, memory, identity, and instructions. When you @mention one in Slack, you're running a real AI agent that can use tools, take action, and get smarter over time.
+
+| | |
+|---|---|
+| 🧠 **Persistent Memory** | Agents write memories during conversations - feedback, user context, project state. Synced to SQLite, injected on next start. They don't forget. |
+| 🔌 **MCP Tool Integration** | Connect any MCP server (Redshift, GitHub, Notion, Figma, custom APIs) - stdio, SSE, or HTTP transports. |
+| 📝 **Inline TypeScript MCPs** | Paste TypeScript source directly into the UI - no deployment needed. The runner compiles and executes it. |
+| 🧵 **Full Thread Context** | Agents fetch the entire Slack thread on every invocation - zero context lost in handoffs. |
+| 💾 **Session Continuity** | Slack thread ↔ Claude session mapping survives restarts. Pick up exactly where you left off. |
+| 🔐 **Encrypted Secret Store** | API keys encrypted at rest (AES-256). MCPs reference secrets by name - raw values never touch the API or UI. |
+| 🔁 **Hot Reload** | Edit instructions, skills, or tools and the agent picks up changes within seconds. No restart needed. |
+
+### 👑 Boss + Specialist Hierarchy
+
+| | |
+|---|---|
+| 👑 **Boss Orchestration** | Boss reads your message, finds the right specialist, delegates by @mention in the same thread, and summarizes the result. |
+| 🏢 **Multi-Boss Support** | Run multiple Boss agents for different domains (engineering, data, support). Specialists can report to more than one boss. |
+| 📋 **Auto-Generated Registries** | Every Boss gets a live team roster auto-regenerated whenever the team changes. No manual maintenance. |
+| 🛠 **Skills** | Markdown files deployed as Claude Code slash commands. Give agents SQL rules, writing guidelines, or domain playbooks. |
+| ⏰ **Scheduled Jobs** | Cron-based recurring tasks - daily reports, weekly digests, monitoring alerts - posted to any Slack channel or DM. |
+
+### ⚙️ Platform
+
+| | |
+|---|---|
+| 🧙 **Onboarding Wizard** | 5-step guided setup: identity → Slack app → credentials → tools & skills → review. |
+| 🕓 **Version Control** | Every save auto-snapshots the full agent state. Browse history with line-level diffs, restore any version in one click. |
+| 🔒 **Auth & RBAC** | 4 roles (superadmin / admin / editor / viewer), HMAC-signed sessions, per-agent access grants (View or Edit). Agents are hidden by default — admins grant access explicitly. No external auth provider needed. |
+| 🚦 **Channel Restrictions** | Lock agents to specific Slack channels. Bot auto-leaves uninvited channels with a notice. |
+| 📊 **Live Logs** | SSE-streamed log output per agent - with level filters and search. |
+| 🧠 **Memory Viewer** | Browse, inspect, and delete agent memories by type - feedback, user, project, reference. |
+| 📡 **Activity Dashboard** | Live kanban of every task your agents are working on - Active, Completed, Errors - with drill-down to every tool call. A superadmin-only **Usage** tab breaks down token consumption per agent and ranks power users by tasks started. Admins see everything; editors see only agents they own or are granted access to; viewers are blocked. |
+| 🌐 **Multi-Workspace** | Connect multiple Slack workspaces to a single SlackHive instance. Each workspace gets its own agents and configurations. |
+| 📚 **Knowledge Library** | Platform-level catalog of Karpathy-style wiki folders. Owners ingest a repo / file / URL into a folder; assign one folder to many agents. The agent's `/wiki` skill auto-enables when at least one assigned folder has built content. |
+
+---
+
+## 🏗 Architecture
+
+```
+Slack Workspace (@boss, @data-bot, @writer, ...)
+        │ Socket Mode (Bolt)
+        ▼
+┌──────────────────────────────────────────────────┐
+│  Local host - two Node.js processes              │
+│                                                  │
+│  Web (Next.js :3001) ──HTTP──► Runner (:3002)    │
+│            │                        │            │
+│            └───── SQLite file ──────┘            │
+│                   (./data/slackhive.db)          │
+└──────────────────────────────────────────────────┘
+```
+
+| Service | Description |
+|---------|-------------|
+| **Web** (Next.js 15) | Dashboard - create agents, edit skills, view logs, manage users |
+| **Runner** (Node.js) | Hosts all agent processes and Slack connections |
+| **SQLite** | Embedded - stores agents, memories, skills, sessions, users, history. No external DB to install |
+| **Event bus** | Web posts to the runner's internal HTTP port to deliver hot-reload events |
+
+**How a message flows:**
+1. User @mentions an agent in Slack
+2. Runner receives the event via Bolt Socket Mode
+3. Claude Code processes the message with the agent's compiled `CLAUDE.md`
+4. Agent uses MCP tools if needed (Redshift, GitHub, Notion, etc.)
+5. Response is formatted as Slack Block Kit and posted to the thread
+6. Memory files written during the session are synced to SQLite
+7. Next conversation starts with all accumulated knowledge
+
+---
+
+## 🔑 Claude Code Authentication
+
+Two options - use whichever fits your setup:
+
+**Option A - API Key**
+```env
+ANTHROPIC_API_KEY=sk-ant-api03-...
+```
+Billed per token via the Anthropic API. Best for teams and production.
+
+**Option B - Claude Pro or Max Subscription**
+
+First, install Claude Code on your host machine:
+
+> **Note:** Do not install via `npm` - the npm package is deprecated and incompatible with SlackHive.
+
+MacOS/Linux (Recommended):
+```bash
+curl -fsSL https://claude.ai/install.sh | bash
+```
+
+Homebrew (macOS/Linux):
+```bash
+brew install --cask claude-code
+```
+
+For more installation options, uninstall steps, and troubleshooting, see the [setup documentation](https://docs.anthropic.com/en/docs/claude-code/setup).
+
+Then log in:
+```bash
+claude login    # saves credentials to your system keychain / ~/.claude/
+```
+Leave `ANTHROPIC_API_KEY` unset - the runner picks up credentials from the system keychain automatically. Best for individual developers.
+
+> Full guide → [slackhive.mintlify.app/configuration/env-vars](https://slackhive.mintlify.app/configuration/env-vars)
+
+---
+
+## 🔮 Roadmap
+
+- [x] Boss orchestration + auto-generated team registries
+- [x] Persistent memory system
+- [x] Scheduled jobs
+- [x] Version control with diff view
+- [x] Encrypted environment variables
+- [x] Channel restrictions
+- [x] Multi-workspace support
+- [ ] Webhook triggers (GitHub, Jira, PagerDuty → agent actions)
+- [ ] Agent-to-agent direct messaging
+- [ ] Analytics dashboard
+- [ ] Custom tool builder (no MCP server needed)
+- [ ] Agent templates marketplace
+- [ ] RAG integration - connect agents to document stores
+
+Have an idea? [Open an issue](https://github.com/pelago-labs/slackhive/issues)
+
+---
+
+## 🤝 Contributing
+
+```bash
+git clone https://github.com/pelago-labs/slackhive.git
+cd slackhive && npm install
+
+# Configure
+cp .env.example .env    # then fill in ADMIN_PASSWORD, AUTH_SECRET, ENV_SECRET_KEY
+
+# Run locally (SQLite - no external services required)
+cd apps/web && npm run dev      # http://localhost:3000
+cd apps/runner && npm run dev   # http://localhost:3002
+```
+
+Open an issue before submitting large PRs so we can align on the approach.
+
+---
+
+## 👥 Contributors
+
+<a href="https://github.com/pelago-labs/slackhive/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=pelago-labs/slackhive" alt="Contributors" />
+</a>
+
+---
+
+## ⭐ Star History
+
+<a href="https://star-history.com/#pelago-labs/slackhive&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=pelago-labs/slackhive&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=pelago-labs/slackhive&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=pelago-labs/slackhive&type=Date" width="600" />
+  </picture>
+</a>
+
+---
+
+## 🔒 Security
+
+Use [GitHub's private vulnerability reporting](https://github.com/pelago-labs/slackhive/security/advisories/new) - click **"Report a vulnerability"** on the Security tab. Please don't open public issues for security bugs. We respond within 48 hours.
+
+---
+
+## 📄 License
+
+MIT © 2026 [Pelago Labs](https://github.com/pelago-labs)
+
+<div align="center">
+  <sub>Built with Claude Code, Slack Bolt, and a lot of ☕</sub>
+</div>

package/{dist → cli/dist}/index.js

@@ -6,11 +6,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -15210,7 +15219,9 @@ var require_prompts3 = __commonJS({
 // src/commands/manage.ts
 var manage_exports = {};
 __export(manage_exports, {
+  backup: () => backup,
   logs: () => logs,
+  restore: () => restore,
   start: () => start,
   status: () => status,
   stop: () => stop,
@@ -15561,13 +15572,178 @@ async function logs(opts) {
 async function update() {
   nativeUpdate(findProjectDir());
 }
-var import_child_process, import_fs, import_path, import_chalk, import_ora;
+function stamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}${p(d.getUTCMonth() + 1)}${p(d.getUTCDate())}-${p(d.getUTCHours())}${p(d.getUTCMinutes())}${p(d.getUTCSeconds())}`;
+}
+function unwrapRecoveryKey(blob, password) {
+  if (!blob || blob.v !== 1 || blob.kdf !== "scrypt") throw new Error("Unrecognized recovery-key file format.");
+  const sc = blob.scrypt ?? { N: 1 << 15, r: 8, p: 1 };
+  const key = (0, import_crypto.scryptSync)(password, Buffer.from(blob.salt, "base64"), 32, { N: sc.N, r: sc.r, p: sc.p, maxmem: 64 * 1024 * 1024 });
+  const decipher = (0, import_crypto.createDecipheriv)("aes-256-gcm", key, Buffer.from(blob.iv, "base64"));
+  decipher.setAuthTag(Buffer.from(blob.tag, "base64"));
+  try {
+    return Buffer.concat([decipher.update(Buffer.from(blob.ct, "base64")), decipher.final()]).toString("utf8");
+  } catch {
+    throw new Error("Wrong password or corrupted recovery-key file.");
+  }
+}
+function promptHidden(label) {
+  return new Promise((resolve2, reject) => {
+    const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    process.stdout.write(label);
+    rl._writeToOutput = () => {
+    };
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.stdout.write("\n");
+      reject(new Error("cancelled"));
+    });
+    rl.question("", (answer) => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve2(answer);
+    });
+  });
+}
+function writeEnvSecretKey(projectDir, key) {
+  const KEY_RE = /^\s*(?:export\s+)?ENV_SECRET_KEY=/;
+  const setKeyIn = (rel, createIfMissing) => {
+    const file = (0, import_path.join)(projectDir, rel);
+    if (!(0, import_fs.existsSync)(file)) {
+      if (!createIfMissing) return;
+      (0, import_fs.writeFileSync)(file, `ENV_SECRET_KEY=${key}
+`);
+      (0, import_fs.chmodSync)(file, 384);
+      console.log(import_chalk.default.gray(`  created ${rel} with ENV_SECRET_KEY`));
+      return;
+    }
+    const lines = (0, import_fs.readFileSync)(file, "utf-8").split("\n");
+    let found = false;
+    const next = lines.map((l) => KEY_RE.test(l) ? (found = true, `ENV_SECRET_KEY=${key}`) : l);
+    if (!found) next.push(`ENV_SECRET_KEY=${key}`);
+    (0, import_fs.writeFileSync)(file, next.join("\n"));
+    (0, import_fs.chmodSync)(file, 384);
+    console.log(import_chalk.default.gray(`  updated ENV_SECRET_KEY in ${rel}`));
+  };
+  setKeyIn(".env", true);
+  setKeyIn("apps/web/.env", false);
+  setKeyIn("apps/runner/.env", false);
+}
+function postBackupNow(internalPort) {
+  return new Promise((resolve2, reject) => {
+    const req = (0, import_http.request)({ host: "127.0.0.1", port: internalPort, path: "/backup-now", method: "POST" }, (res) => {
+      let body = "";
+      res.on("data", (c) => body += c);
+      res.on("end", () => {
+        try {
+          resolve2(JSON.parse(body || "{}"));
+        } catch {
+          reject(new Error("bad runner response"));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+async function backup(options) {
+  const dataDb = (0, import_path.join)(getSlackhiveDir(), "data.db");
+  if (!(0, import_fs.existsSync)(dataDb)) {
+    console.log(import_chalk.default.red("  Database not found at " + dataDb));
+    process.exit(1);
+  }
+  const info = readPidInfo();
+  const spinner = (0, import_ora.default)("Creating database backup...").start();
+  try {
+    if (info) {
+      const r = await postBackupNow(info.internalPort);
+      if (r.error) throw new Error(r.error);
+      spinner.succeed(`Backup created: ${r.path}`);
+    } else {
+      const dir = options.output ? (0, import_path.dirname)(options.output) : (0, import_path.join)(getSlackhiveDir(), "backups");
+      (0, import_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+      const dest = options.output ?? (0, import_path.join)(dir, `data-${stamp()}.db`);
+      (0, import_fs.copyFileSync)(dataDb, dest);
+      (0, import_fs.chmodSync)(dest, 384);
+      spinner.succeed(`Backup created: ${dest} (${((0, import_fs.statSync)(dest).size / 1024 / 1024).toFixed(1)} MB)`);
+    }
+  } catch (err) {
+    spinner.fail(`Backup failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function restore(options) {
+  if (!(0, import_fs.existsSync)(options.from)) {
+    console.log(import_chalk.default.red(`  Backup file not found: ${options.from}`));
+    process.exit(1);
+  }
+  if (options.recoveryKey && !(0, import_fs.existsSync)(options.recoveryKey)) {
+    console.log(import_chalk.default.red(`  Recovery-key file not found: ${options.recoveryKey}`));
+    process.exit(1);
+  }
+  if (options.env && !(0, import_fs.existsSync)(options.env)) {
+    console.log(import_chalk.default.red(`  Env file not found: ${options.env}`));
+    process.exit(1);
+  }
+  let encryptionKey = null;
+  if (options.recoveryKey) {
+    let blob;
+    try {
+      blob = JSON.parse((0, import_fs.readFileSync)(options.recoveryKey, "utf-8"));
+    } catch {
+      console.log(import_chalk.default.red("  Recovery-key file is not valid JSON"));
+      process.exit(1);
+    }
+    const pw = process.env.SLACKHIVE_RECOVERY_PASSWORD ?? await promptHidden("  Recovery-key password: ");
+    try {
+      encryptionKey = unwrapRecoveryKey(blob, pw);
+    } catch (err) {
+      console.log(import_chalk.default.red(`  ${err.message}`));
+      process.exit(1);
+    }
+    console.log(import_chalk.default.green("  Recovery key unwrapped"));
+  }
+  if (readPidInfo()) nativeStop();
+  const dir = getSlackhiveDir();
+  const dataDb = (0, import_path.join)(dir, "data.db");
+  if ((0, import_fs.existsSync)(dataDb)) {
+    const pre = (0, import_path.join)(dir, "backups", `pre-restore-${stamp()}.db`);
+    (0, import_fs.mkdirSync)((0, import_path.join)(dir, "backups"), { recursive: true, mode: 448 });
+    (0, import_fs.copyFileSync)(dataDb, pre);
+    (0, import_fs.chmodSync)(pre, 384);
+    console.log(import_chalk.default.gray(`  current DB snapshotted \u2192 ${pre}`));
+  }
+  const projectDir = findProjectDir();
+  if (encryptionKey) writeEnvSecretKey(projectDir, encryptionKey);
+  else if (options.env) for (const rel of [".env", "apps/web/.env", "apps/runner/.env"]) {
+    const file = (0, import_path.join)(projectDir, rel);
+    (0, import_fs.copyFileSync)(options.env, file);
+    (0, import_fs.chmodSync)(file, 384);
+    console.log(import_chalk.default.gray(`  copied env \u2192 ${rel}`));
+  }
+  (0, import_fs.copyFileSync)(options.from, dataDb);
+  (0, import_fs.chmodSync)(dataDb, 384);
+  for (const ext of ["-wal", "-shm"]) {
+    try {
+      (0, import_fs.unlinkSync)(dataDb + ext);
+    } catch {
+    }
+  }
+  console.log(import_chalk.default.green(`  Database restored from ${options.from}`));
+  console.log(import_chalk.default.gray("  Run `slackhive start` to boot the restored database."));
+}
+var import_child_process, import_fs, import_path, import_http, import_readline, import_crypto, import_chalk, import_ora;
 var init_manage = __esm({
   "src/commands/manage.ts"() {
     "use strict";
     import_child_process = require("child_process");
     import_fs = require("fs");
     import_path = require("path");
+    import_http = require("http");
+    import_readline = require("readline");
+    import_crypto = require("crypto");
     import_chalk = __toESM(require_source());
     import_ora = __toESM(require_ora());
   }
@@ -15578,7 +15754,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "slackhive",
-      version: "0.4.7",
+      version: "0.5.0",
       description: "CLI to install and manage SlackHive \u2014 AI agent teams on Slack",
       bin: {
         slackhive: "./dist/index.js"
@@ -15608,7 +15784,7 @@ var require_package = __commonJS({
         prompts: "^2.4.2"
       },
       devDependencies: {
-        "@types/node": "^20.0.0",
+        "@types/node": "^20.19.41",
         "@types/prompts": "^2.4.9",
         esbuild: "^0.28.0",
         typescript: "^5.3.0"
@@ -15649,57 +15825,6 @@ var import_chalk2 = __toESM(require_source());
 var import_ora2 = __toESM(require_ora());
 var import_prompts = __toESM(require_prompts3());
 var REPO_URL = "https://github.com/pelago-labs/slackhive.git";
-function parseOAuthFromJson(json) {
-  try {
-    const parsed = JSON.parse(json);
-    const oauth = parsed?.claudeAiOauth;
-    if (oauth?.accessToken && oauth?.refreshToken) {
-      return { accessToken: oauth.accessToken, refreshToken: oauth.refreshToken };
-    }
-  } catch {
-  }
-  return null;
-}
-function extractOAuthCredentials() {
-  try {
-    const creds = (0, import_child_process2.execSync)('security find-generic-password -s "Claude Code-credentials" -w', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-    const result = parseOAuthFromJson(creds);
-    if (result) return result;
-  } catch {
-  }
-  try {
-    const creds = (0, import_child_process2.execSync)('secret-tool lookup service "Claude Code-credentials"', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-    const result = parseOAuthFromJson(creds);
-    if (result) return result;
-  } catch {
-  }
-  try {
-    const credPath = (0, import_path2.join)(process.env.HOME || "~", ".claude", ".credentials.json");
-    if ((0, import_fs2.existsSync)(credPath)) {
-      const creds = (0, import_fs2.readFileSync)(credPath, "utf-8").trim();
-      const result = parseOAuthFromJson(creds);
-      if (result) return result;
-    }
-  } catch {
-  }
-  return null;
-}
-function syncCredentialsFile(creds) {
-  const credPath = (0, import_path2.join)(process.env.HOME || "~", ".claude", ".credentials.json");
-  const payload = JSON.stringify({
-    claudeAiOauth: {
-      accessToken: creds.accessToken,
-      refreshToken: creds.refreshToken
-    }
-  }, null, 2);
-  (0, import_fs2.writeFileSync)(credPath, payload, { mode: 384 });
-}
 async function init(opts) {
   const dir = (0, import_path2.resolve)(opts.dir);
   const O = import_chalk2.default.hex("#D97757").bold;
@@ -15750,75 +15875,20 @@ async function init(opts) {
   if (freshEnv) {
     console.log(import_chalk2.default.bold.hex("#D97757")("  [3/4]") + import_chalk2.default.bold(" Configure environment"));
     console.log("");
-    const authMode = await (0, import_prompts.default)({
-      type: "select",
-      name: "mode",
-      message: "Claude authentication",
-      choices: [
-        { title: "API Key \u2014 pay-per-use via Anthropic API", value: "apikey" },
-        { title: "Subscription \u2014 run `claude login` first", value: "subscription" }
-      ]
-    });
-    if (!authMode.mode) {
-      console.log(import_chalk2.default.red("\n  Setup cancelled."));
-      process.exit(1);
-    }
-    const questions = [];
-    let oauthCreds = null;
-    if (authMode.mode === "apikey") {
-      questions.push({
-        type: "text",
-        name: "anthropicKey",
-        message: "Anthropic API key",
-        validate: (v) => v.startsWith("sk-") ? true : "Must start with sk-"
-      });
-    } else {
-      const claudeDir = (0, import_path2.join)(process.env.HOME || "~", ".claude");
-      if (!(0, import_fs2.existsSync)(claudeDir)) {
-        console.log(import_chalk2.default.yellow("\n  warning: ~/.claude not found. Run `claude login` first, then re-run `slackhive init`."));
-        process.exit(1);
-      }
-      console.log(import_chalk2.default.green("  \u2713") + " Found ~/.claude credentials");
-      const spinner = (0, import_ora2.default)("  Extracting OAuth credentials...").start();
-      oauthCreds = extractOAuthCredentials();
-      if (oauthCreds) {
-        spinner.succeed("OAuth credentials extracted");
-        syncCredentialsFile(oauthCreds);
-      } else {
-        spinner.warn("Could not auto-extract credentials from keychain");
-        console.log(import_chalk2.default.gray("  On Linux/headless servers, paste your OAuth token manually."));
-        console.log(import_chalk2.default.gray("  Get it from a machine where you ran `claude login`:"));
-        console.log(import_chalk2.default.gray('    security find-generic-password -s "Claude Code-credentials" -w'));
-        console.log("");
-        const tokenResponse = await (0, import_prompts.default)([
-          { type: "password", name: "accessToken", message: "OAuth access token (sk-ant-oat01-...)", validate: (v) => v.startsWith("sk-ant-oat") ? true : "Must start with sk-ant-oat" },
-          { type: "password", name: "refreshToken", message: "OAuth refresh token (sk-ant-ort01-...)", validate: (v) => v.startsWith("sk-ant-ort") ? true : "Must start with sk-ant-ort" }
-        ]);
-        if (!tokenResponse.accessToken || !tokenResponse.refreshToken) {
-          console.log(import_chalk2.default.red("\n  Setup cancelled. Use API Key mode instead on headless servers."));
-          process.exit(1);
-        }
-        oauthCreds = { accessToken: tokenResponse.accessToken, refreshToken: tokenResponse.refreshToken };
-        syncCredentialsFile(oauthCreds);
-      }
-    }
-    questions.push(
+    console.log(import_chalk2.default.gray("  Agent backend & credentials (Claude Code or Codex) are configured"));
+    console.log(import_chalk2.default.gray("  in the web UI: Settings \u2192 Agent Backend, after first launch."));
+    console.log("");
+    const response = await (0, import_prompts.default)([
       { type: "text", name: "adminUsername", message: "Admin username", initial: "admin" },
       { type: "password", name: "adminPassword", message: "Admin password", validate: (v) => v.length >= 6 ? true : "At least 6 characters" }
-    );
-    const response = await (0, import_prompts.default)(questions);
+    ]);
     if (!response.adminPassword) {
       console.log(import_chalk2.default.red("\n  Setup cancelled."));
       process.exit(1);
     }
     let envContent = "# Generated by slackhive init\n\n";
-    if (authMode.mode === "apikey") {
-      envContent += `ANTHROPIC_API_KEY=${response.anthropicKey}
-`;
-    } else {
-      envContent += `# Claude Code subscription \u2014 auth handled by system (claude login)
+    envContent += `# Agent backend auth (Claude Code / Codex) is configured in Settings \u2192 Agent Backend
 `;
-    }
     envContent += `
 # SQLite, no Docker required
 `;
@@ -15858,20 +15928,8 @@ NODE_ENV=production
       envContents = (0, import_fs2.readFileSync)(envPath, "utf-8");
       console.log(import_chalk2.default.green("  \u2713") + " .env patched");
     }
-    if (envContents.includes("CLAUDE_CODE_OAUTH_TOKEN=")) {
-      const spinner = (0, import_ora2.default)("  Syncing OAuth credentials...").start();
-      const freshCreds = extractOAuthCredentials();
-      if (freshCreds) {
-        envContents = envContents.replace(/CLAUDE_CODE_OAUTH_TOKEN=.*/, `CLAUDE_CODE_OAUTH_TOKEN=${freshCreds.accessToken}`).replace(/CLAUDE_CODE_OAUTH_REFRESH_TOKEN=.*/, `CLAUDE_CODE_OAUTH_REFRESH_TOKEN=${freshCreds.refreshToken}`);
-        (0, import_fs2.writeFileSync)(envPath, envContents);
-        syncCredentialsFile(freshCreds);
-        spinner.succeed("OAuth credentials synced");
-      } else {
-        spinner.warn("Could not extract credentials \u2014 run `claude login` if agents fail to authenticate");
-      }
-    } else {
-      console.log(import_chalk2.default.yellow("  note: .env already exists \u2014 skipping configuration"));
-    }
+    console.log(import_chalk2.default.yellow("  note: .env already exists \u2014 skipping configuration"));
+    console.log(import_chalk2.default.gray("  Agent backend auth (Claude Code or Codex) is managed in Settings \u2192 Agent Backend."));
     console.log("");
   }
   let webReady = true;
@@ -15981,6 +16039,8 @@ program2.command("stop").description("Stop all SlackHive services (also kills or
 program2.command("status").description("Show running SlackHive containers").action(status);
 program2.command("logs").description("Tail runner service logs").option("-f, --follow", "Follow log output", true).action(logs);
 program2.command("update").description("Pull latest changes and rebuild").action(update);
+program2.command("backup").description("Create a database backup (consistent snapshot)").option("-o, --output <path>", "Write the backup to this path instead of ~/.slackhive/backups/").action(backup);
+program2.command("restore").description("Restore the database from a backup (stops the runner; the only restore path)").requiredOption("-f, --from <file>", "Backup .db file to restore").option("--recovery-key <file>", "Password-wrapped recovery-key file (prompts for password; set SLACKHIVE_RECOVERY_PASSWORD to skip the prompt)").option("--env <file>", "Plain .env file to install instead of a recovery key").action(restore);
 program2.parse(process.argv);
 /*! Bundled license information:
 

package/package.json

@@ -1,45 +1,55 @@
 {
   "name": "slackhive",
-  "version": "0.4.8",
-  "description": "CLI to install and manage SlackHive — AI agent teams on Slack",
+  "version": "0.5.0",
+  "private": false,
+  "description": "Open-source platform for managing teams of Claude Code Slack agents with a boss agent orchestrator",
+  "workspaces": [
+    "apps/*",
+    "packages/*",
+    "cli"
+  ],
   "bin": {
-    "slackhive": "./dist/index.js"
+    "slackhive": "cli/dist/index.js"
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js",
-    "dev": "ts-node src/index.ts"
+    "dev": "sh scripts/dev.sh",
+    "build": "npm run build -w packages/shared && npm run build --workspaces --if-present",
+    "prepare": "npm run build -w cli",
+    "postinstall": "node scripts/postinstall.js"
   },
-  "keywords": [
-    "slack",
-    "ai",
-    "agents",
-    "claude",
-    "claude-code",
-    "slackhive"
+  "files": [
+    "cli/dist",
+    "README.md",
+    "scripts/postinstall.js"
   ],
-  "author": "Aman Srivastava",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/pelago-labs/slackhive"
+  "engines": {
+    "node": ">=20.0.0"
   },
+  "license": "MIT",
   "dependencies": {
-    "chalk": "^4.1.2",
-    "commander": "^12.0.0",
-    "ora": "^5.4.1",
-    "prompts": "^2.4.2"
+    "@anthropic-ai/claude-agent-sdk": "0.2.118",
+    "@anthropic-ai/claude-code": "^2.1.118",
+    "@elastic/elasticsearch": "^9.3.4",
+    "@mozilla/readability": "^0.6.0",
+    "linkedom": "^0.18.12",
+    "pg": "^8.20.0",
+    "turndown": "^7.2.4"
   },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/prompts": "^2.4.9",
-    "esbuild": "^0.28.0",
-    "typescript": "^5.3.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
+  "overrides": {
+    "dompurify": "^3.4.0",
+    "vite": "^6.4.3",
+    "axios": "^1.16.0",
+    "hono": "^4.12.25",
+    "@hono/node-server": "^1.19.13",
+    "follow-redirects": "^1.15.12",
+    "fast-uri": "^3.1.2",
+    "ip-address": "^10.2.0",
+    "express-rate-limit": "^8.5.1",
+    "form-data": "^4.0.6",
+    "undici": "^7.28.0",
+    "ws": "^8.21.0"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ]
+  "devDependencies": {
+    "@types/turndown": "^5.0.6"
+  }
 }

package/scripts/postinstall.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// Remove the musl Claude binary on glibc Linux systems.
+// When npm install is run with --legacy-peer-deps, npm ignores the
+// libc:["musl"] constraint on @anthropic-ai/claude-agent-sdk-linux-x64-musl
+// and downloads the binary anyway. The claude-agent-sdk then picks musl first
+// (before glibc) and fails to spawn it because the musl dynamic linker is
+// absent on glibc systems. Removing the binary causes require.resolve to throw
+// for the musl path, so the SDK falls back to the glibc binary.
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+if (process.platform !== 'linux') process.exit(0);
+
+const muslBinary = path.join(__dirname, '..', 'node_modules', '@anthropic-ai', 'claude-agent-sdk-linux-x64-musl', 'claude');
+if (!fs.existsSync(muslBinary)) process.exit(0);
+
+try {
+  const ldd = execSync('ldd --version 2>&1').toString();
+  if (!ldd.includes('musl')) {
+    fs.unlinkSync(muslBinary);
+    console.log('postinstall: removed musl Claude binary (glibc system detected)');
+  }
+} catch {
+  // ldd not available or failed — leave binary as-is
+}