@sesamespace/hivemind 0.2.0 → 0.3.0

package/PLANNING.md

@@ -0,0 +1,383 @@
+# Hivemind — Cognitive Architecture for AI Agents
+
+## Vision
+
+Hivemind is an opinionated, high-performance agent runtime with a multi-layered memory architecture inspired by CPU cache hierarchies — not the flat-file, dump-everything-in-context approach of current agent frameworks. It enables agents that genuinely remember, learn, and work on multiple projects in parallel without context contamination.
+
+**Core thesis:** The bottleneck in AI agents isn't the model — it's memory management. Current systems either burn their entire context window on static files or lose everything between sessions. Hivemind solves this with continuous, incremental memory management across isolated project contexts.
+
+**Success criteria:** A Hivemind agent joins our Sesame channel. We have a conversation on Monday, come back Wednesday, and it recalls the context naturally — no hand-curated MEMORY.md, no post-it notes. It works on LinkZero and Untube simultaneously without cross-pollination. It runs across multiple Mac minis with true parallelism.
+
+---
+
+## Architecture
+
+### Memory Layers
+
+| Layer | Name | What | Storage | Management |
+|-------|------|------|---------|------------|
+| L1 | Working Memory | Current conversation + active task state | In-memory (runtime) | Deterministic eviction by relevance score |
+| L2 | Episodic Memory | Recent interactions, decisions, outcomes | LanceDB (vector) | Write-through on every interaction, continuous decay |
+| L3 | Semantic Memory | Distilled knowledge, patterns, project understanding | LanceDB (vector + structured) | Threshold-based promotion from L2, pull-based LLM synthesis |
+| L4 | External Memory | Git, filesystem, APIs, databases | Native tools | Accessed on demand; index of *what exists where* lives in L2/L3 |
+
+### Key Principle: No Batch Consolidation
+
+Memory management is **continuous and incremental**, like garbage collection in a runtime:
+
+- **Write-through:** Every interaction embedded + indexed into L2 immediately (local embedding model, no LLM)
+- **Decay/scoring:** Lightweight process continuously updates relevance scores (recency × access frequency × connection density) — pure math
+- **Promotion:** L2 episodes auto-promote to L3 when they cross access/connection thresholds — no LLM needed
+- **Eviction:** When L1 context fills, lowest-relevance items drop first — deterministic, predictable
+- **LLM synthesis on demand only:** Agent requests consolidated summaries when needed (pull, not push)
+
+No step functions. No discontinuities. No compaction surprises.
+
+### Context Isolation (Multi-Project)
+
+```
+┌─ Hivemind Agent ──────────────────────────────┐
+│                                               │
+│  ┌─────────────────────────────────────────┐  │
+│  │          Context Manager                │  │
+│  │  - Routes messages to correct context   │  │
+│  │  - Spawns/suspends/resumes contexts     │  │
+│  │  - Manages cross-context queries        │  │
+│  └──┬──────────┬──────────┬───────────┬────┘  │
+│     │          │          │           │        │
+│  ┌──▼───┐  ┌──▼───┐  ┌──▼───┐  ┌────▼────┐  │
+│  │ CTX: │  │ CTX: │  │ CTX: │  │  CTX:   │  │
+│  │Proj A│  │Proj B│  │Proj C│  │ Global  │  │
+│  │      │  │      │  │      │  │         │  │
+│  │ L1   │  │ L1   │  │ L1   │  │Identity │  │
+│  │ L2   │  │ L2   │  │ L2   │  │Prefs    │  │
+│  │ L3   │  │ L3   │  │ L3   │  │Skills   │  │
+│  │Tasks │  │Tasks │  │Tasks │  │Relations│  │
+│  └──────┘  └──────┘  └──────┘  └─────────┘  │
+│                                               │
+│  ┌─────────────────────────────────────────┐  │
+│  │        Shared Infrastructure            │  │
+│  │  Memory Daemon (Rust) · LanceDB         │  │
+│  │  Ollama (embeddings) · Sesame · Router  │  │
+│  └─────────────────────────────────────────┘  │
+└───────────────────────────────────────────────┘
+```
+
+Each context has:
+- Own L1/L2/L3 memory partitions (LanceDB namespaces)
+- Own relevance scoring and decay curves
+- Own task queue and working state
+- Own model preferences (via ClawRouter)
+
+Global context holds:
+- Agent identity and personality
+- Communication preferences
+- Cross-cutting skills and tool knowledge
+- Relationship maps (who is Ryan, what does he care about)
+
+**Cross-context communication:**
+- Default: **full isolation** — no cross-pollination
+- Explicit sharing: "Share X with context Y"
+- Cross-context search: query all contexts, results labeled by source
+- Auto-promotion to Global: knowledge referenced across 3+ contexts
+
+### Multi-Machine Distribution
+
+```
+Mac Mini 1 (Primary):
+  └─ Context Manager (coordinator)
+  └─ Global Context
+  └─ Active conversation handling
+  └─ Memory Daemon + LanceDB (primary)
+
+Mac Mini 2:
+  └─ Hivemind Worker
+  └─ CTX: Project A (autonomous background work)
+  └─ Local Memory Daemon + LanceDB partition
+  └─ Local Ollama (embeddings)
+
+Mac Mini 3:
+  └─ Hivemind Worker
+  └─ CTX: Project B (autonomous background work)
+  └─ Local Memory Daemon + LanceDB partition
+  └─ Local Ollama (embeddings)
+```
+
+Contexts can be **active** (attached to conversation) or **background** (autonomous task execution). Multiple contexts run truly in parallel across machines.
+
+---
+
+## Tech Stack
+
+| Component | Technology | Rationale |
+|-----------|-----------|-----------|
+| Agent Runtime | TypeScript | Fast iteration, Sesame SDK is TS, ClawRouter client TS, rich AI ecosystem |
+| Memory Daemon | Rust | Performance-critical hot path, reliability, native LanceDB bindings |
+| Vector Storage | LanceDB (embedded) | No server process, Rust-native, fast, partitioning support |
+| Embeddings | Ollama (local) | Apple Silicon optimized, zero-latency, `nomic-embed-text` or `mxbai-embed-large` |
+| Communications | Sesame SDK | Native agent participant, not bolted on |
+| Model Provider | ClawRouter | Drop-in OpenAI-compatible API, model routing/optimization |
+| Task/Queue | In-process (TS) | No external dependencies for MVP; upgrade to Redis/NATS if needed |
+| Config | TOML or YAML | Human-readable, easy to hand-edit |
+
+### Dependencies (External Services)
+
+- **Sesame** (sesame.space) — agent registration, messaging, channels
+- **ClawRouter** (clawrouter.app) — model API provider
+- **Ollama** — local embedding model server (runs on each Mac mini)
+
+---
+
+## Project Structure
+
+```
+hivemind/
+├── packages/
+│   ├── runtime/          # TypeScript agent runtime
+│   │   ├── src/
+│   │   │   ├── agent.ts          # Core agent loop
+│   │   │   ├── context.ts        # Context manager
+│   │   │   ├── memory-client.ts  # Client for memory daemon
+│   │   │   ├── task-engine.ts    # Task planning + execution
+│   │   │   ├── sesame.ts         # Sesame integration
+│   │   │   ├── router.ts         # ClawRouter client
+│   │   │   └── tools/            # Built-in tool implementations
+│   │   ├── package.json
+│   │   └── tsconfig.json
+│   │
+│   ├── memory/            # Rust memory daemon
+│   │   ├── src/
+│   │   │   ├── main.rs           # Daemon entry, HTTP/gRPC server
+│   │   │   ├── store.rs          # LanceDB operations
+│   │   │   ├── embeddings.rs     # Ollama embedding client
+│   │   │   ├── scoring.rs        # Relevance decay + scoring
+│   │   │   ├── context.rs        # Context/namespace management
+│   │   │   └── promotion.rs      # L2→L3 threshold logic
+│   │   ├── Cargo.toml
+│   │   └── proto/                # gRPC definitions (if used)
+│   │
+│   └── cli/               # CLI for management
+│       ├── src/
+│       │   ├── main.ts
+│       │   ├── commands/
+│       │   │   ├── start.ts      # Start agent
+│       │   │   ├── status.ts     # Check status
+│       │   │   ├── context.ts    # Manage contexts
+│       │   │   └── memory.ts     # Query/inspect memory
+│       └── package.json
+│
+├── config/
+│   ├── default.toml        # Default configuration
+│   └── example.toml        # Example with comments
+│
+├── PLANNING.md             # This file
+├── TASKS.md                # Task tracker (auto-maintained)
+├── ARCHITECTURE.md         # Deep-dive technical docs
+└── README.md               # Project overview + quickstart
+```
+
+---
+
+## Phases & Tasks
+
+### Phase 1 — Single Context, Prove the Memory Works
+
+**Goal:** One Hivemind agent on Sesame with working episodic memory. Conversation Monday → recall Wednesday.
+
+**Decision boundaries:** Bailey can make all implementation decisions. Ping Ryan only for: external service setup (Sesame agent registration, ClawRouter config), UX decisions about how the agent presents itself, or architectural changes that deviate from this plan.
+
+#### Tasks
+
+- [ ] **1.1 — Project scaffolding**
+  - Initialize monorepo (pnpm workspaces)
+  - Set up TypeScript config for runtime + cli packages
+  - Set up Rust project for memory daemon
+  - CI basics (lint, type-check, test)
+  - *Est: 1 session*
+
+- [ ] **1.2 — Memory daemon MVP**
+  - Rust HTTP server (axum or actix-web)
+  - LanceDB integration: create table, insert, query
+  - Ollama embedding client (HTTP to local Ollama)
+  - Core API endpoints:
+    - `POST /episodes` — store an episode (auto-embeds)
+    - `GET /search` — semantic search over episodes
+    - `GET /context/{name}` — get all episodes for a context
+    - `POST /contexts` — create a new context namespace
+  - Basic relevance scoring (recency-weighted)
+  - *Est: 2-3 sessions*
+
+- [ ] **1.3 — Agent runtime MVP**
+  - Core agent loop: receive message → query memory → build prompt → call model → respond → store episode
+  - Memory client (talks to daemon API)
+  - ClawRouter integration (OpenAI-compatible client, pointed at ClawRouter)
+  - Prompt construction: Global context + relevant L2 episodes + current message
+  - Basic personality/identity from config (not flat files)
+  - *Est: 2 sessions*
+
+- [ ] **1.4 — Sesame integration**
+  - Connect as Sesame agent (WebSocket)
+  - Receive messages, route to agent loop
+  - Send responses back to channel
+  - Handle DMs and group channels
+  - *Est: 1-2 sessions*
+
+- [ ] **1.5 — Write-through memory pipeline**
+  - Every conversation turn → episode stored in L2 automatically
+  - Embed + index happens synchronously (local Ollama = fast enough)
+  - Episode includes: timestamp, context name, role, content, embedding
+  - On next message: top-K relevant episodes pulled into L1 prompt
+  - *Est: 1 session*
+
+- [ ] **1.6 — Integration test: "Remember me"**
+  - Deploy on Mac mini
+  - Start Ollama with embedding model
+  - Start memory daemon
+  - Start agent runtime, connect to Sesame
+  - Have a conversation, wait 24h, verify recall
+  - *Est: 1 session + waiting*
+
+**Phase 1 deliverable:** A Hivemind agent in our Sesame channel that remembers conversations across sessions without any manual memory management.
+
+---
+
+### Phase 2 — Multi-Context with Isolation
+
+**Goal:** Multiple project contexts with full memory isolation. Work on two projects without contamination.
+
+#### Tasks
+
+- [ ] **2.1 — Context Manager**
+  - Context creation/deletion/listing
+  - Message routing: infer context from message content or explicit switching ("switch to LinkZero")
+  - Context metadata: name, description, created date, last active
+  - Global context (always loaded alongside active project context)
+  - *Est: 2 sessions*
+
+- [ ] **2.2 — Partitioned memory**
+  - LanceDB namespace per context (separate tables)
+  - Episode storage tagged with context ID
+  - Search scoped to active context + global
+  - Relevance scoring per-context (independent decay curves)
+  - *Est: 1-2 sessions*
+
+- [ ] **2.3 — L2→L3 promotion engine**
+  - Track access frequency per episode
+  - Track connection density (episodes referenced together)
+  - Threshold-based promotion: episode → semantic knowledge
+  - L3 entries are higher-level (patterns, decisions, architecture choices)
+  - No LLM involved — just metadata promotion + re-indexing
+  - *Est: 2 sessions*
+
+- [ ] **2.4 — Cross-context features**
+  - Cross-context search: query all contexts, results labeled by source
+  - Explicit sharing: "share this with [context]"
+  - Auto-promotion to Global: knowledge referenced in 3+ contexts
+  - *Est: 1-2 sessions*
+
+- [ ] **2.5 — Task engine (per-context)**
+  - Per-context task queue (TASKS stored in context memory)
+  - Task states: planned → active → complete → archived
+  - Task dependencies
+  - Agent can autonomously pick next task from queue
+  - *Est: 2 sessions*
+
+- [ ] **2.6 — Integration test: "Two projects, no bleed"**
+  - Create two project contexts
+  - Work on both interleaved
+  - Verify: searching in context A returns nothing from context B
+  - Verify: explicit cross-context search works when requested
+  - *Est: 1 session*
+
+**Phase 2 deliverable:** Hivemind handles multiple projects with isolated memory. Context switching is instant and clean.
+
+---
+
+### Phase 3 — Multi-Machine Fleet
+
+**Goal:** Contexts distributed across Mac minis. True parallel autonomous work.
+
+#### Tasks
+
+- [ ] **3.1 — Worker protocol**
+  - Define Primary ↔ Worker communication protocol
+  - Worker registration and health checks
+  - Context assignment: Primary tells Worker "you own context X"
+  - Worker reports status back to Primary
+  - *Est: 2 sessions*
+
+- [ ] **3.2 — Distributed context execution**
+  - Worker runs its own memory daemon + Ollama + agent runtime
+  - Context state is local to the worker (no shared DB needed for MVP)
+  - Worker executes tasks autonomously from its context's task queue
+  - *Est: 2-3 sessions*
+
+- [ ] **3.3 — Fleet Manager (Primary)**
+  - CLI/API to provision new workers
+  - Assign/migrate contexts between machines
+  - Aggregate status view: "what is each machine working on?"
+  - Sesame routing: messages for context X → forwarded to worker owning X
+  - *Est: 2 sessions*
+
+- [ ] **3.4 — Cross-machine memory sync**
+  - Worker periodically syncs key L3 knowledge back to Primary
+  - Primary can push Global context updates to workers
+  - Conflict resolution: last-write-wins for L3, append-only for L2
+  - *Est: 2 sessions*
+
+- [ ] **3.5 — Integration test: "The fleet"**
+  - 3 Mac minis running
+  - Each with a different project context
+  - All 3 making progress simultaneously
+  - Query any project's status via Sesame on Primary
+  - *Est: 1-2 sessions (plus hardware setup with Ryan)*
+
+**Phase 3 deliverable:** A fleet of Hivemind agents working autonomously across multiple machines, coordinated through a primary node, all accessible via Sesame.
+
+---
+
+## Decision Boundaries
+
+### Bailey decides autonomously:
+- Implementation details (function signatures, data structures, error handling)
+- Library/crate choices within the agreed stack
+- File organization within the agreed project structure
+- Test strategy and coverage
+- Git workflow (branching, commits, PRs)
+- Bug fixes and refactoring
+- Task ordering within a phase
+
+### Ping Ryan for:
+- External service setup (new Sesame agents, ClawRouter config changes)
+- Architectural changes that deviate from this plan
+- Adding new external dependencies or services not in the stack
+- UX decisions (how the agent presents itself, conversation style)
+- Scope changes (adding/removing features from a phase)
+- Any spend (new services, API costs beyond existing accounts)
+- Phase completion review before moving to next phase
+
+---
+
+## Open Questions (Resolve During Build)
+
+1. **Embedding model choice:** `nomic-embed-text` vs `mxbai-embed-large` — need to benchmark on Apple Silicon for latency/quality tradeoff
+2. **Memory daemon API:** REST (simpler) vs gRPC (faster, typed) — start REST, upgrade if latency matters
+3. **Episode granularity:** Per-message? Per-turn (user+assistant)? Per-conversation? Start per-turn, can adjust.
+4. **Context inference:** How smart does the Context Manager need to be about guessing which project a message relates to? Start with explicit switching, add inference later.
+5. **Sesame agent identity:** One Hivemind agent on Sesame, or one per context? Start with one, route internally.
+
+---
+
+## References
+
+- [LanceDB docs](https://lancedb.github.io/lancedb/)
+- [Ollama API](https://github.com/ollama/ollama/blob/main/docs/api.md)
+- [Sesame docs](https://sesame.space/docs)
+- [ClawRouter](https://clawrouter.app)
+- [Axum (Rust web framework)](https://github.com/tokio-rs/axum)
+
+---
+
+*Created: 2025-07-18*
+*Last updated: 2025-07-18*
+*Status: Planning complete — ready for Phase 1 execution*

package/TASKS.md

@@ -0,0 +1,60 @@
+# Hivemind — Task Tracker
+
+*Auto-maintained by Bailey. Updated after each coding session.*
+
+## Current Phase: 4 — Deployment & Distribution
+
+| # | Task | Status | Notes |
+|---|------|--------|-------|
+| 4.1 | Sesame integration fixes | ✅ done | sendMessage API, sender handles, group chat awareness |
+| 4.2 | Team Charter system | ✅ done | config/TEAM-CHARTER.md, __SKIP__ for group etiquette |
+| 4.3 | CLI commands | ✅ done | init, start, service, fleet |
+| 4.4 | Config layering | ✅ done | default.toml + local.toml + .env + env vars |
+| 4.5 | npm publish | ✅ done | @sesamespace/hivemind@0.1.0 (public) |
+| 4.6 | launchd services | ✅ done | hivemind service install/uninstall/status/logs |
+| 4.7 | Sesame bootstrap endpoint | ✅ done | GET /api/v1/hivemind/install (pushed, needs deploy) |
+| 4.8 | hivemind.team DNS | ⏳ pending | Ryan to configure, points to Sesame API |
+| 4.9 | Fresh machine test | ⏳ pending | Full bootstrap on new Mac mini |
+| 4.10 | Vault provisioning | ⏳ pending | Needs vault creation in Sesame |
+| 4.11 | hivemind update command | ⏳ queued | npm update + vault re-check |
+| 4.12 | hivemind-help channel | ⏳ queued | Create on Sesame, add to default channels |
+
+## Phase 3 — Multi-Machine Fleet ✅ COMPLETE
+
+| # | Task | Status | Notes |
+|---|------|--------|-------|
+| 3.1 | Worker protocol | ✅ done | Shared types, PrimaryClient, WorkerServer, 20 tests |
+| 3.2 | Distributed context execution | ✅ done | Worker mode, config, task loop |
+| 3.3 | Fleet Manager | ✅ done | CLI/API for provisioning, context migration, subnet discovery |
+| 3.4 | Cross-machine memory sync | ✅ done | L3 last-write-wins, L2 append-only, sync push/pull |
+| 3.5 | Integration test | ✅ done | 21 tests: multi-worker registration, context distribution, sync, dashboard |
+
+## Phase 2 — Multi-Context ✅ COMPLETE
+
+| # | Task | Status | Notes |
+|---|------|--------|-------|
+| 2.1 | Context Manager | ✅ done | Message routing, context-aware agent loop |
+| 2.2 | Partitioned memory | ✅ done | Per-context LanceDB namespaces, independent decay |
+| 2.3 | L2→L3 promotion engine | ✅ done | Access frequency + connection density, threshold promotion |
+| 2.4 | Cross-context features | ✅ done | Cross-context search, sharing, auto-promotion to Global |
+| 2.5 | Task engine (per-context) | ✅ done | Per-context task queues, chat commands, dependencies |
+| 2.6 | Integration tests | ✅ done | 8/8 tests passing |
+
+## Phase 1 — Single Context ✅ COMPLETE
+
+| # | Task | Status | Notes |
+|---|------|--------|-------|
+| 1.1 | Project scaffolding | ✅ done | pnpm monorepo, TS + Rust, config |
+| 1.2 | Memory daemon MVP | ✅ done | Rust/axum, LanceDB, Ollama embeddings |
+| 1.3 | Agent runtime MVP | ✅ done | Core agent loop, memory client, LLM client |
+| 1.4 | Sesame integration | ✅ done | WebSocket + REST, reconnection |
+| 1.5 | Write-through pipeline | ✅ done | Auto-embed every turn, top-K retrieval |
+
+---
+
+## Test Suite: 49 tests passing
+- 20 worker protocol
+- 8 memory integration
+- 21 fleet integration
+
+*Last updated: 2026-02-23*

package/install.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Hivemind — One-shot install for macOS (Apple Silicon)
+# Usage (from repo): cd hivemind && ./install.sh <sesame-api-key>
+# Preferred: curl -sL api.sesame.space/api/v1/hivemind/install | bash -s -- <sesame-api-key>
+
+BOLD='\033[1m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+info()  { echo -e "${GREEN}[✓]${NC} $1"; }
+warn()  { echo -e "${YELLOW}[!]${NC} $1"; }
+err()   { echo -e "${RED}[✗]${NC} $1"; }
+step()  { echo -e "\n${BOLD}→ $1${NC}"; }
+
+echo -e "${BOLD}"
+echo "  ╦ ╦╦╦  ╦╔═╗╔╦╗╦╔╗╔╔╦╗"
+echo "  ╠═╣║╚╗╔╝║╣ ║║║║║║║ ║║"
+echo "  ╩ ╩╩ ╚╝ ╚═╝╩ ╩╩╝╚╝═╩╝"
+echo -e "${NC}"
+echo "  Agent Runtime Installer"
+echo ""
+
+# --- 1. System dependencies ---
+step "Checking system dependencies"
+
+# Homebrew
+if ! command -v brew &>/dev/null; then
+  warn "Homebrew not found — installing..."
+  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+  eval "$(/opt/homebrew/bin/brew shellenv)"
+else
+  info "Homebrew found"
+fi
+
+# Node.js
+if ! command -v node &>/dev/null; then
+  warn "Node.js not found — installing via brew..."
+  brew install node
+else
+  NODE_VER=$(node -v | sed 's/v//' | cut -d. -f1)
+  if [ "$NODE_VER" -lt 20 ]; then
+    warn "Node.js v${NODE_VER} too old (need ≥20) — upgrading..."
+    brew upgrade node
+  else
+    info "Node.js $(node -v)"
+  fi
+fi
+
+# pnpm
+if ! command -v pnpm &>/dev/null; then
+  warn "pnpm not found — installing..."
+  npm install -g pnpm
+else
+  info "pnpm $(pnpm -v)"
+fi
+
+# Rust
+if ! command -v cargo &>/dev/null; then
+  warn "Rust not found — installing via rustup..."
+  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+  source "$HOME/.cargo/env"
+else
+  info "Rust $(rustc --version | awk '{print $2}')"
+fi
+
+# Ollama
+if ! command -v ollama &>/dev/null; then
+  warn "Ollama not found — installing via brew..."
+  brew install ollama
+else
+  info "Ollama found"
+fi
+
+# --- 2. Pull embedding model ---
+step "Setting up Ollama embedding model"
+
+# Start Ollama if not running
+if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+  warn "Ollama not running — starting..."
+  ollama serve &>/dev/null &
+  sleep 3
+fi
+
+if ollama list 2>/dev/null | grep -q "nomic-embed-text"; then
+  info "nomic-embed-text model ready"
+else
+  warn "Pulling nomic-embed-text (274MB)..."
+  ollama pull nomic-embed-text
+  info "nomic-embed-text ready"
+fi
+
+# --- 3. Build TypeScript packages ---
+step "Installing Node dependencies"
+pnpm install
+info "Dependencies installed"
+
+step "Building TypeScript"
+pnpm build
+info "TypeScript build complete"
+
+# --- 4. Build Rust memory daemon ---
+step "Building memory daemon (Rust — this takes ~60s first time)"
+cd packages/memory
+cargo build --release 2>&1 | tail -3
+cd ../..
+info "Memory daemon built"
+
+# --- 5. Configuration via Sesame ---
+step "Configuring agent via Sesame"
+
+if [ -f ".env" ]; then
+  info "Existing .env found — keeping it"
+else
+  SESAME_KEY="${1:-${SESAME_API_KEY:-}}"
+  if [ -z "$SESAME_KEY" ]; then
+    read -rp "  Sesame API key: " SESAME_KEY
+  fi
+  node packages/cli/dist/main.js init "$SESAME_KEY"
+fi
+
+# --- 6. Create launch script ---
+step "Creating launch script"
+
+cat > start.sh <<'LAUNCH'
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# Load env
+if [ -f .env ]; then
+  set -a; source .env; set +a
+fi
+
+# Start memory daemon if not running
+if ! curl -s http://localhost:3434/health &>/dev/null; then
+  echo "[hivemind] Starting memory daemon..."
+  nohup ./packages/memory/target/release/hivemind-memory > /tmp/hivemind-memory.log 2>&1 &
+  sleep 2
+  if curl -s http://localhost:3434/health &>/dev/null; then
+    echo "[hivemind] Memory daemon ready"
+  else
+    echo "[hivemind] WARNING: Memory daemon failed to start"
+  fi
+else
+  echo "[hivemind] Memory daemon already running"
+fi
+
+# Start Ollama if not running
+if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+  echo "[hivemind] Starting Ollama..."
+  ollama serve &>/dev/null &
+  sleep 3
+fi
+
+# Start agent (auto-restart on crash)
+echo "[hivemind] Starting agent..."
+while true; do
+  node packages/cli/dist/main.js start --config config/default.toml
+  EXIT_CODE=$?
+  echo "[hivemind] Agent exited with code $EXIT_CODE — restarting in 5s..."
+  sleep 5
+done
+LAUNCH
+
+chmod +x start.sh
+info "Created start.sh (with auto-restart)"
+
+# --- Done ---
+echo ""
+echo -e "${GREEN}${BOLD}  ✓ Hivemind installed successfully!${NC}"
+echo ""
+echo "  To start the agent:"
+echo "    ./start.sh"
+echo ""
+echo "  To start in background:"
+echo "    nohup ./start.sh > /tmp/hivemind.log 2>&1 &"
+echo ""
+echo "  Logs:"
+echo "    Agent:  stdout (or /tmp/hivemind.log)"
+echo "    Memory: /tmp/hivemind-memory.log"
+echo ""

package/npm-package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@sesamespace/hivemind",
+  "version": "0.2.0",
+  "description": "Cognitive architecture for AI agents with multi-layered memory",
+  "type": "module",
+  "bin": {
+    "hivemind": "dist/main.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "config",
+    "README.md"
+  ],
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@sesamespace/sdk": "^0.1.6",
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baileydavis2026/hivemind"
+  }
+}