@inixiative/hivemind 0.1.5 → 0.1.8

package/dist/db/schema.sql

@@ -0,0 +1,134 @@
+-- Hivemind Schema
+-- Timestamps: yyyy/mm/dd hh:mm:ss TZ
+
+-- Agents: active Claude instances
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,                    -- agt_7a3f2b or agt_7a3f2b_alice
+  hex TEXT NOT NULL,                      -- 7a3f2b
+  label TEXT,                             -- alice (optional)
+  status TEXT DEFAULT 'active',           -- active/idle/dead
+  pid INTEGER,                            -- listener process ID
+  session_id TEXT,                        -- for claude --resume
+  last_seen_at TEXT,                      -- heartbeat/lease timestamp
+  current_plan_id TEXT,                   -- pln_e9d2c1_auth
+  current_task_id TEXT,                   -- tsk_e9d2c1_001
+  worktree_id TEXT,                       -- wkt_a1b2c3
+  context_summary TEXT,                   -- what this agent knows
+  created_at TEXT NOT NULL,
+
+  FOREIGN KEY (current_plan_id) REFERENCES plans(id),
+  FOREIGN KEY (current_task_id) REFERENCES tasks(id),
+  FOREIGN KEY (worktree_id) REFERENCES worktrees(id)
+);
+
+-- Worktrees: git worktrees being used
+CREATE TABLE IF NOT EXISTS worktrees (
+  id TEXT PRIMARY KEY,                    -- wkt_a1b2c3
+  hex TEXT NOT NULL,                      -- a1b2c3
+  label TEXT,                             -- feature-auth (optional)
+  path TEXT NOT NULL UNIQUE,              -- /path/to/worktree
+  branch TEXT,                            -- feature/auth
+  commit_hash TEXT,                       -- current commit hash
+  is_main INTEGER DEFAULT 0,              -- 1 if main worktree
+  status TEXT DEFAULT 'active',           -- active/stale
+  created_at TEXT NOT NULL,
+  last_seen TEXT
+);
+
+-- Plans: coordinated work streams
+CREATE TABLE IF NOT EXISTS plans (
+  id TEXT PRIMARY KEY,                    -- pln_e9d2c1_auth
+  hex TEXT NOT NULL,                      -- e9d2c1
+  label TEXT,                             -- auth (optional)
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'active',           -- active/paused/complete
+  branch TEXT,                            -- associated git branch
+  worktree_id TEXT,                       -- associated worktree
+  claude_session_id TEXT,                 -- claude --resume session ID
+  created_at TEXT NOT NULL,
+  created_by TEXT,                        -- agt_7a3f2b
+
+  FOREIGN KEY (created_by) REFERENCES agents(id),
+  FOREIGN KEY (worktree_id) REFERENCES worktrees(id)
+);
+
+-- Tasks: atomic units of work within plans
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,                    -- tsk_e9d2c1_001_jwt
+  plan_hex TEXT NOT NULL,                 -- e9d2c1 (inherited from plan)
+  seq TEXT NOT NULL,                      -- 001 or 001.1
+  label TEXT,                             -- jwt (optional)
+  plan_id TEXT NOT NULL,                  -- pln_e9d2c1_auth
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'pending',          -- pending/claimed/in_progress/blocked/done
+  branch TEXT,                            -- feature/auth (can differ from plan branch)
+  worktree_id TEXT,                       -- wkt_a1b2c3 (where task is being worked)
+  claimed_by TEXT,                        -- agt_7a3f2b
+  claimed_at TEXT,
+  completed_at TEXT,
+  outcome TEXT,
+  parent_task_id TEXT,                    -- for subtasks
+
+  FOREIGN KEY (plan_id) REFERENCES plans(id),
+  FOREIGN KEY (worktree_id) REFERENCES worktrees(id),
+  FOREIGN KEY (claimed_by) REFERENCES agents(id),
+  FOREIGN KEY (parent_task_id) REFERENCES tasks(id)
+);
+
+-- Events: append-only log of all activity
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,                    -- evt_f1a2b3_00001
+  hex TEXT NOT NULL,                      -- f1a2b3
+  seq INTEGER NOT NULL,                   -- 1, 2, 3...
+  timestamp TEXT NOT NULL,
+  agent_id TEXT NOT NULL,                 -- agt_7a3f2b
+  plan_id TEXT,                           -- pln_e9d2c1_auth (optional)
+  task_id TEXT,                           -- tsk_e9d2c1_001 (optional)
+  worktree_id TEXT,                       -- wkt_a1b2c3 (optional)
+  branch TEXT,                            -- feature/auth (optional, git context)
+  event_type TEXT NOT NULL,               -- decision/claim/complete/etc
+  content TEXT,                           -- event-specific content
+  metadata TEXT,                          -- JSON blob
+
+  FOREIGN KEY (agent_id) REFERENCES agents(id),
+  FOREIGN KEY (plan_id) REFERENCES plans(id),
+  FOREIGN KEY (task_id) REFERENCES tasks(id),
+  FOREIGN KEY (worktree_id) REFERENCES worktrees(id)
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);
+CREATE INDEX IF NOT EXISTS idx_agents_last_seen ON agents(last_seen_at);
+CREATE INDEX IF NOT EXISTS idx_agents_plan ON agents(current_plan_id);
+CREATE INDEX IF NOT EXISTS idx_agents_worktree ON agents(worktree_id);
+
+CREATE INDEX IF NOT EXISTS idx_worktrees_path ON worktrees(path);
+CREATE INDEX IF NOT EXISTS idx_worktrees_branch ON worktrees(branch);
+CREATE INDEX IF NOT EXISTS idx_worktrees_status ON worktrees(status);
+
+CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+CREATE INDEX IF NOT EXISTS idx_plans_created_by ON plans(created_by);
+CREATE INDEX IF NOT EXISTS idx_plans_worktree ON plans(worktree_id);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by ON tasks(claimed_by);
+CREATE INDEX IF NOT EXISTS idx_tasks_branch ON tasks(branch);
+CREATE INDEX IF NOT EXISTS idx_tasks_worktree ON tasks(worktree_id);
+
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_agent ON events(agent_id);
+CREATE INDEX IF NOT EXISTS idx_events_plan ON events(plan_id);
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+CREATE INDEX IF NOT EXISTS idx_events_worktree ON events(worktree_id);
+CREATE INDEX IF NOT EXISTS idx_events_branch ON events(branch);
+
+-- Sequence counter for events
+CREATE TABLE IF NOT EXISTS sequences (
+  name TEXT PRIMARY KEY,
+  value INTEGER DEFAULT 0
+);
+
+INSERT OR IGNORE INTO sequences (name, value) VALUES ('events', 0);

package/dist/git/getBranch.d.ts

@@ -1,4 +1,4 @@
 /**
  * Get current git branch name
  */
-export declare function getBranch(): string | null;
+export declare function getBranch(cwd?: string): string | null;

package/dist/git/getBranch.js

@@ -2,9 +2,9 @@ import { execSync } from 'child_process';
 /**
  * Get current git branch name
  */
-export function getBranch() {
+export function getBranch(cwd) {
     try {
-        return execSync('git branch --show-current', { stdio: 'pipe' })
+        return execSync('git branch --show-current', { stdio: 'pipe', cwd })
             .toString()
             .trim() || null;
     }

package/dist/git/getCurrentWorktree.d.ts

@@ -1,5 +1,5 @@
 import { type Worktree } from './getWorktrees';
 /**
- * Get the worktree for current directory
+ * Get the worktree for a directory (defaults to process.cwd())
  */
-export declare function getCurrentWorktree(): Worktree | null;
+export declare function getCurrentWorktree(cwd?: string): Worktree | null;

package/dist/git/getCurrentWorktree.js

@@ -1,13 +1,13 @@
 import { getWorktrees } from './getWorktrees';
 /**
- * Get the worktree for current directory
+ * Get the worktree for a directory (defaults to process.cwd())
  */
-export function getCurrentWorktree() {
-    const cwd = process.cwd();
-    const worktrees = getWorktrees();
-    // Find worktree that contains current directory
+export function getCurrentWorktree(cwd) {
+    const targetDir = cwd ?? process.cwd();
+    const worktrees = getWorktrees(cwd);
+    // Find worktree that contains target directory
     for (const wt of worktrees) {
-        if (cwd.startsWith(wt.path)) {
+        if (targetDir.startsWith(wt.path)) {
             return wt;
         }
     }

package/dist/git/getGitInfo.d.ts

@@ -5,6 +5,6 @@ export type GitInfo = {
     root: string | null;
 };
 /**
- * Get all git info for current directory
+ * Get all git info for a directory (defaults to process.cwd())
  */
-export declare function getGitInfo(): GitInfo;
+export declare function getGitInfo(cwd?: string): GitInfo;

package/dist/git/getGitInfo.js

@@ -3,10 +3,10 @@ import { getRepoName } from './getRepoName';
 import { getBranch } from './getBranch';
 import { getRepoRoot } from './getRepoRoot';
 /**
- * Get all git info for current directory
+ * Get all git info for a directory (defaults to process.cwd())
  */
-export function getGitInfo() {
-    if (!isGitRepo()) {
+export function getGitInfo(cwd) {
+    if (!isGitRepo(cwd)) {
         return {
             isRepo: false,
             repoName: null,
@@ -16,8 +16,8 @@ export function getGitInfo() {
     }
     return {
         isRepo: true,
-        repoName: getRepoName(),
-        branch: getBranch(),
-        root: getRepoRoot(),
+        repoName: getRepoName(cwd),
+        branch: getBranch(cwd),
+        root: getRepoRoot(cwd),
     };
 }

package/dist/git/getRepoName.d.ts

@@ -1,4 +1,4 @@
 /**
  * Get repository name from git remote or directory
  */
-export declare function getRepoName(): string | null;
+export declare function getRepoName(cwd?: string): string | null;

package/dist/git/getRepoName.js

@@ -2,10 +2,10 @@ import { execSync } from 'child_process';
 /**
  * Get repository name from git remote or directory
  */
-export function getRepoName() {
+export function getRepoName(cwd) {
     try {
         // Try to get from remote origin
-        const remote = execSync('git remote get-url origin', { stdio: 'pipe' })
+        const remote = execSync('git remote get-url origin', { stdio: 'pipe', cwd })
             .toString()
             .trim();
         // Extract repo name from URL
@@ -19,7 +19,7 @@ export function getRepoName() {
     catch {
         // No remote, try repo root directory name
         try {
-            const root = execSync('git rev-parse --show-toplevel', { stdio: 'pipe' })
+            const root = execSync('git rev-parse --show-toplevel', { stdio: 'pipe', cwd })
                 .toString()
                 .trim();
             return root.split('/').pop() || null;

package/dist/git/getRepoRoot.d.ts

@@ -1,4 +1,4 @@
 /**
  * Get git repository root path
  */
-export declare function getRepoRoot(): string | null;
+export declare function getRepoRoot(cwd?: string): string | null;

package/dist/git/getRepoRoot.js

@@ -2,9 +2,9 @@ import { execSync } from 'child_process';
 /**
  * Get git repository root path
  */
-export function getRepoRoot() {
+export function getRepoRoot(cwd) {
     try {
-        return execSync('git rev-parse --show-toplevel', { stdio: 'pipe' })
+        return execSync('git rev-parse --show-toplevel', { stdio: 'pipe', cwd })
             .toString()
             .trim() || null;
     }

package/dist/git/getWorktrees.d.ts

@@ -7,4 +7,4 @@ export type Worktree = {
 /**
  * Get all git worktrees for the repository
  */
-export declare function getWorktrees(): Worktree[];
+export declare function getWorktrees(cwd?: string): Worktree[];

package/dist/git/getWorktrees.js

@@ -2,9 +2,9 @@ import { execSync } from 'child_process';
 /**
  * Get all git worktrees for the repository
  */
-export function getWorktrees() {
+export function getWorktrees(cwd) {
     try {
-        const output = execSync('git worktree list --porcelain', { stdio: 'pipe' })
+        const output = execSync('git worktree list --porcelain', { stdio: 'pipe', cwd })
             .toString()
             .trim();
         if (!output)

package/dist/git/isGitRepo.d.ts

@@ -1,4 +1,4 @@
 /**
- * Check if current directory is inside a git repo
+ * Check if directory is inside a git repo
  */
-export declare function isGitRepo(): boolean;
+export declare function isGitRepo(cwd?: string): boolean;

package/dist/git/isGitRepo.js

@@ -1,10 +1,10 @@
 import { execSync } from 'child_process';
 /**
- * Check if current directory is inside a git repo
+ * Check if directory is inside a git repo
  */
-export function isGitRepo() {
+export function isGitRepo(cwd) {
     try {
-        execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+        execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe', cwd });
         return true;
     }
     catch {

package/dist/hooks/sessionStart.d.ts

@@ -17,5 +17,5 @@ type HookInput = {
     cwd?: string;
     permission_mode?: string;
 };
-export declare function runSessionStartHook(input?: HookInput): void;
+export declare function runSessionStartHook(input?: HookInput): Promise<void>;
 export {};

package/dist/hooks/sessionStart.js

@@ -11,9 +11,22 @@
  *
  * Claude Code passes JSON via stdin with session_id, transcript_path, cwd, etc.
  */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { executeRegister } from '../mcp/tools/register';
 import { executeStatus } from '../mcp/tools/status';
 import { getGitInfo } from '../git/getGitInfo';
+function getTextContent(result, errorPrefix) {
+    if (!result || typeof result !== 'object') {
+        throw new Error(`${errorPrefix} returned invalid payload`);
+    }
+    const content = result.content;
+    const text = content?.find((item) => item?.type === 'text')?.text;
+    if (!text) {
+        throw new Error(`${errorPrefix} returned no text content`);
+    }
+    return text;
+}
 function readStdinSync() {
     try {
         // Bun supports reading stdin synchronously
@@ -37,24 +50,75 @@ function readStdinSync() {
         return '';
     }
 }
-export function runSessionStartHook(input) {
-    const gitInfo = getGitInfo();
+export async function runSessionStartHook(input) {
+    // Use cwd from hook input (Claude's actual working directory), not process.cwd()
+    const gitInfo = getGitInfo(input?.cwd);
     if (!gitInfo.isRepo || !gitInfo.repoName) {
         return;
     }
     const sessionId = input?.session_id;
     const label = process.env.CLAUDE_AGENT_LABEL;
     try {
-        // process.ppid is Claude's process (or close to it in the process tree)
-        const pid = process.ppid;
-        const result = executeRegister({
-            project: gitInfo.repoName,
-            label,
-            sessionId,
-            pid,
-        });
-        // Get status to show other agents
-        const status = executeStatus({ project: gitInfo.repoName });
+        const remoteUrl = process.env.HIVEMIND_REMOTE_URL?.trim();
+        let result;
+        let status;
+        if (remoteUrl) {
+            const token = process.env.HIVEMIND_API_TOKEN?.trim();
+            if (!token) {
+                throw new Error('HIVEMIND_API_TOKEN is required when HIVEMIND_REMOTE_URL is set');
+            }
+            const client = new Client({
+                name: 'hivemind-session-start',
+                version: '0.1.0',
+            }, { capabilities: {} });
+            const transport = new StreamableHTTPClientTransport(new URL(remoteUrl), {
+                requestInit: {
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                    },
+                },
+            });
+            await client.connect(transport);
+            try {
+                const registerCall = await client.callTool({
+                    name: 'hivemind_register',
+                    arguments: {
+                        project: gitInfo.repoName,
+                        label,
+                        sessionId,
+                        cwd: input?.cwd,
+                    },
+                });
+                const registerText = getTextContent(registerCall, 'Remote hivemind_register');
+                result = JSON.parse(registerText);
+                const statusCall = await client.callTool({
+                    name: 'hivemind_status',
+                    arguments: {
+                        project: gitInfo.repoName,
+                        agentId: result.agentId,
+                        sessionId,
+                    },
+                });
+                const statusText = getTextContent(statusCall, 'Remote hivemind_status');
+                status = JSON.parse(statusText);
+            }
+            finally {
+                await client.close();
+            }
+        }
+        else {
+            // process.ppid is Claude's process (or close to it in the process tree)
+            const pid = process.ppid;
+            result = executeRegister({
+                project: gitInfo.repoName,
+                label,
+                sessionId,
+                pid,
+                cwd: input?.cwd,
+            });
+            // Get status to show other agents
+            status = executeStatus({ project: gitInfo.repoName });
+        }
         const otherAgents = status.activeAgents?.filter((a) => a.id !== result.agentId) || [];
         // Output agent info for Claude's context
         const lines = [
@@ -89,5 +153,5 @@ if (import.meta.main) {
             // Not valid JSON, ignore
         }
     }
-    runSessionStartHook(input);
+    await runSessionStartHook(input);
 }

package/dist/init/claudeConfig.d.ts

@@ -14,15 +14,25 @@
  */
 export declare function extractMarkdownSection(content: string, heading: string): string | null;
 /**
- * Build the CLAUDE.md content, optionally with custom events section
+ * Build the CLAUDE.md content with project name and optional custom events section
  */
-export declare function buildHivemindClaudeMd(customEventsSection?: string): string;
+export declare function buildHivemindClaudeMd(projectName: string, customEventsSection?: string): string;
 /**
  * Settings.json hooks for auto-registration
+ *
+ * SessionStart matchers:
+ * - startup: New session
+ * - resume: --resume, --continue, /resume
+ * - clear: /clear command
+ * - compact: Auto or manual compact (new session ID assigned)
+ *
+ * We register on all events to handle compaction gracefully.
+ * The hook checks PID to reuse existing agent when session ID changes.
  */
 export declare function getHivemindHooks(hivemindRoot: string): {
     hooks: {
         SessionStart: {
+            matcher: string;
             hooks: {
                 type: string;
                 command: string;
@@ -33,7 +43,7 @@ export declare function getHivemindHooks(hivemindRoot: string): {
 /**
  * Initialize Claude Code configuration for hivemind
  */
-export declare function initClaudeConfig(projectRoot: string, _project: string, hivemindRoot: string): {
+export declare function initClaudeConfig(projectRoot: string, project: string, hivemindRoot: string): {
     created: string[];
     updated: string[];
 };

package/dist/init/claudeConfig.js

@@ -13,19 +13,26 @@ import { join } from 'path';
 /**
  * Default events instructions (used if project doesn't define custom ones)
  */
-const DEFAULT_EVENTS_SECTION = `## Hivemind Events
+const DEFAULT_EVENTS_SECTION = `## Events
 
-Emit concise events to coordinate. **Under 80 chars.** Map, not territory.
+Keep events **under 80 chars**. Map, not territory.
 
+**One event per accomplishment.** If you complete 3 tasks, emit 3 notes:
 \`\`\`
-hivemind_emit type=decision content="Redis for cache, Postgres for persistence"
-hivemind_emit type=context content="API rate limit: 100/min per key"
-hivemind_emit type=note content="003 done, starting 004"
+hivemind_emit type=note content="Added Redis caching layer"
+hivemind_emit type=note content="Updated API rate limiting to 100/min"
+hivemind_emit type=note content="Fixed auth token refresh bug"
 \`\`\`
 
-**Emit for:** architectural decisions, discoveries others need, blockers, questions.
+Not one combined note. Other agents need granular visibility.
 
-**Skip:** routine progress, obvious steps, anything verbose.`;
+**Event types:**
+- \`decision\` - Architectural choices others should know
+- \`context\` - Discovered constraints, gotchas
+- \`note\` - Task completions, progress updates
+- \`question\` - When blocked and need input
+
+**Skip:** routine progress on obvious steps, verbose explanations.`;
 /**
  * Extract a markdown section by heading from content
  * Returns the section content (including heading) or null if not found
@@ -51,50 +58,85 @@ export function extractMarkdownSection(content, heading) {
     return lines.slice(startIdx, endIdx).join('\n').trim();
 }
 /**
- * Build the CLAUDE.md content, optionally with custom events section
+ * Build the CLAUDE.md content with project name and optional custom events section
  */
-export function buildHivemindClaudeMd(customEventsSection) {
+export function buildHivemindClaudeMd(projectName, customEventsSection) {
     const eventsSection = customEventsSection || DEFAULT_EVENTS_SECTION;
     return `# Hivemind Agent Instructions
 
 You are part of a **hivemind** - a coordinated group of Claude agents working together.
 
-## Automatic Behaviors
-
-**Your todos are automatically synced to hivemind.** When you use TodoWrite, the hivemind watcher detects changes and syncs them to a shared plan. Other agents can see your progress in real-time.
+## Lifecycle
 
 Your lifecycle is tracked by PID - no heartbeats needed. When you exit, hivemind automatically marks you as inactive.
 
-## MCP Tools
+## MCP Tools - USE THESE
+
+**\`hivemind_status\`** - CALL THIS FIRST when you start a session. Shows active agents, what they're working on, and recent events. Prevents duplicate work.
+
+**\`hivemind_emit\`** - Share important context with other agents. Use for:
+- \`type=decision\` - Architectural choices others should know
+- \`type=context\` - Discovered constraints (rate limits, gotchas)
+- \`type=question\` - When you're blocked and need input
 
-- \`hivemind_status\` - View active agents, plans, and recent activity
-- \`hivemind_query\` - See what other agents are doing
-- \`hivemind_emit\` - Share notes, decisions, questions with other agents
+**\`hivemind_query\`** - Ask questions about the hivemind state.
 
 ${eventsSection}
 
 ## Coordination Protocol
 
-1. **Before starting work**: Check \`hivemind_status\` to see what others are doing
-2. **When making decisions**: Use \`hivemind_emit\` with type "decision" to share
-3. **When blocked**: Use \`hivemind_emit\` with type "question" to ask for help
-4. **Just work**: Your todos sync automatically - focus on the task!
+1. **Session start**: Run \`hivemind_status\` to see who's online and what's happening
+2. **Architectural decisions**: Emit with \`type=decision\` so others know
+3. **Blockers**: Emit with \`type=question\` - another agent may have context
+4. **Focus on work**: The system tracks your lifecycle automatically
+
+## Plan Mode
+
+When creating plan files in ~/.claude/plans/, **always start with frontmatter**:
+
+\`\`\`yaml
+---
+project: ${projectName}
+---
+\`\`\`
+
+This ensures plans are synced to the correct hivemind project database.
 `;
 }
 /**
  * Settings.json hooks for auto-registration
+ *
+ * SessionStart matchers:
+ * - startup: New session
+ * - resume: --resume, --continue, /resume
+ * - clear: /clear command
+ * - compact: Auto or manual compact (new session ID assigned)
+ *
+ * We register on all events to handle compaction gracefully.
+ * The hook checks PID to reuse existing agent when session ID changes.
  */
 export function getHivemindHooks(hivemindRoot) {
+    const sessionStartCommand = {
+        type: 'command',
+        command: `bun run ${hivemindRoot}/src/hooks/sessionStart.ts`,
+    };
     return {
         hooks: {
             SessionStart: [
+                // Handle new sessions
+                {
+                    matcher: 'startup',
+                    hooks: [sessionStartCommand],
+                },
+                // Handle compaction (session ID changes, but PID stays same)
+                {
+                    matcher: 'compact',
+                    hooks: [sessionStartCommand],
+                },
+                // Handle resume scenarios
                 {
-                    hooks: [
-                        {
-                            type: 'command',
-                            command: `bun run ${hivemindRoot}/src/hooks/sessionStart.ts`,
-                        },
-                    ],
+                    matcher: 'resume',
+                    hooks: [sessionStartCommand],
                 },
             ],
         },
@@ -103,7 +145,7 @@ export function getHivemindHooks(hivemindRoot) {
 /**
  * Initialize Claude Code configuration for hivemind
  */
-export function initClaudeConfig(projectRoot, _project, hivemindRoot) {
+export function initClaudeConfig(projectRoot, project, hivemindRoot) {
     const claudeDir = join(projectRoot, '.claude');
     const settingsPath = join(claudeDir, 'settings.json');
     const claudeMdPath = join(claudeDir, 'CLAUDE.md');
@@ -141,8 +183,8 @@ export function initClaudeConfig(projectRoot, _project, hivemindRoot) {
             customEventsSection = extracted;
         }
     }
-    // Build the hivemind instructions (with custom or default events section)
-    const hivemindClaudeMd = buildHivemindClaudeMd(customEventsSection);
+    // Build the hivemind instructions (with project name and custom or default events section)
+    const hivemindClaudeMd = buildHivemindClaudeMd(project, customEventsSection);
     // Create or update .claude/CLAUDE.md
     if (!existsSync(claudeMdPath)) {
         writeFileSync(claudeMdPath, hivemindClaudeMd);