@inixiative/hivemind 0.1.0

package/dist/hooks/sessionStart.js

@@ -0,0 +1,93 @@
+/**
+ * Session start hook - auto-join hivemind when starting a Claude session
+ *
+ * Installation: Add to .claude/settings.json:
+ *   "hooks": {
+ *     "SessionStart": [{
+ *       "matcher": "startup",
+ *       "hooks": [{ "type": "command", "command": "bun run /path/to/hivemind/src/hooks/sessionStart.ts" }]
+ *     }]
+ *   }
+ *
+ * Claude Code passes JSON via stdin with session_id, transcript_path, cwd, etc.
+ */
+import { executeRegister } from '../mcp/tools/register';
+import { executeStatus } from '../mcp/tools/status';
+import { getGitInfo } from '../git/getGitInfo';
+function readStdinSync() {
+    try {
+        // Bun supports reading stdin synchronously
+        const chunks = [];
+        const fd = 0; // stdin
+        const buf = Buffer.alloc(1024);
+        let bytesRead;
+        // Non-blocking check for stdin data
+        const fs = require('fs');
+        try {
+            while ((bytesRead = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
+                chunks.push(buf.subarray(0, bytesRead));
+            }
+        }
+        catch {
+            // No more data or stdin not ready
+        }
+        return Buffer.concat(chunks).toString('utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+export function runSessionStartHook(input) {
+    const gitInfo = getGitInfo();
+    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 otherAgents = status.activeAgents?.filter((a) => a.id !== result.agentId) || [];
+        // Output agent info for Claude's context
+        const lines = [
+            `hivemind: ${result.agentId} joined ${gitInfo.repoName}`,
+        ];
+        if (result.branch) {
+            lines[0] += ` (${result.branch})`;
+        }
+        // Include session_id so Claude can use it for MCP calls
+        if (sessionId) {
+            lines.push(`  session: ${sessionId}`);
+        }
+        if (otherAgents.length > 0) {
+            lines.push(`  active: ${otherAgents.map((a) => a.id).join(', ')}`);
+        }
+        console.log(lines.join('\n'));
+    }
+    catch (error) {
+        console.error(`hivemind error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// CLI entry point
+if (import.meta.main) {
+    // Read hook input from stdin (Claude Code passes JSON)
+    const stdin = readStdinSync();
+    let input;
+    if (stdin.trim()) {
+        try {
+            input = JSON.parse(stdin);
+        }
+        catch {
+            // Not valid JSON, ignore
+        }
+    }
+    runSessionStartHook(input);
+}

package/dist/ids/generateHex.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate a 6-character hex string for use in IDs
+ */
+export declare function generateHex(): string;

package/dist/ids/generateHex.js

@@ -0,0 +1,7 @@
+import { randomBytes } from 'crypto';
+/**
+ * Generate a 6-character hex string for use in IDs
+ */
+export function generateHex() {
+    return randomBytes(3).toString('hex');
+}

package/dist/ids/getParentTaskId.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get parent task ID from a subtask ID
+ *
+ * Example: tsk_e9d2c1_001.1 → tsk_e9d2c1_001
+ *          tsk_e9d2c1_001   → null (not a subtask)
+ */
+export declare function getParentTaskId(subtaskId: string): string | null;

package/dist/ids/getParentTaskId.js

@@ -0,0 +1,15 @@
+import { parseId } from './parseId';
+/**
+ * Get parent task ID from a subtask ID
+ *
+ * Example: tsk_e9d2c1_001.1 → tsk_e9d2c1_001
+ *          tsk_e9d2c1_001   → null (not a subtask)
+ */
+export function getParentTaskId(subtaskId) {
+    const parsed = parseId(subtaskId);
+    if (!parsed.seq?.includes('.')) {
+        return null;
+    }
+    const parentSeq = parsed.seq.split('.')[0];
+    return `tsk_${parsed.hex}_${parentSeq}`;
+}

package/dist/ids/getPlanHexFromTaskId.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extract plan hex from a task ID
+ *
+ * Example: tsk_e9d2c1_001 → 'e9d2c1'
+ */
+export declare function getPlanHexFromTaskId(taskId: string): string;

package/dist/ids/getPlanHexFromTaskId.js

@@ -0,0 +1,9 @@
+import { parseId } from './parseId';
+/**
+ * Extract plan hex from a task ID
+ *
+ * Example: tsk_e9d2c1_001 → 'e9d2c1'
+ */
+export function getPlanHexFromTaskId(taskId) {
+    return parseId(taskId).hex;
+}

package/dist/ids/ids.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ids/ids.test.js

@@ -0,0 +1,215 @@
+import { describe, it, expect } from 'bun:test';
+import { generateHex } from './generateHex';
+import { makeAgentId } from './makeAgentId';
+import { makePlanId } from './makePlanId';
+import { makeTaskId } from './makeTaskId';
+import { makeEventId } from './makeEventId';
+import { makeWorktreeId } from './makeWorktreeId';
+import { makeSubtaskId } from './makeSubtaskId';
+import { parseId } from './parseId';
+import { isValidId } from './isValidId';
+import { sanitizeLabel } from './sanitizeLabel';
+import { getPlanHexFromTaskId } from './getPlanHexFromTaskId';
+import { isSubtask } from './isSubtask';
+import { getParentTaskId } from './getParentTaskId';
+import { isAgentId, isPlanId, isTaskId, isEventId, isWorktreeId, taskId } from './typedIds';
+describe('generateHex', () => {
+    it('generates 6 character hex strings', () => {
+        const hex = generateHex();
+        expect(hex).toHaveLength(6);
+        expect(hex).toMatch(/^[a-f0-9]{6}$/);
+    });
+    it('generates unique values', () => {
+        const hexes = new Set();
+        for (let i = 0; i < 100; i++) {
+            hexes.add(generateHex());
+        }
+        expect(hexes.size).toBe(100);
+    });
+});
+describe('makeAgentId', () => {
+    it('creates agent id without label', () => {
+        const id = makeAgentId();
+        expect(id).toMatch(/^agt_[a-f0-9]{6}$/);
+        expect(isAgentId(id)).toBe(true);
+    });
+    it('creates agent id with label', () => {
+        const id = makeAgentId('main');
+        expect(id).toMatch(/^agt_[a-f0-9]{6}_main$/);
+    });
+    it('sanitizes label (removes non-alphanumeric)', () => {
+        const id = makeAgentId('My Agent!');
+        expect(id).toMatch(/^agt_[a-f0-9]{6}_myagent$/);
+    });
+});
+describe('makePlanId', () => {
+    it('creates plan id and returns hex', () => {
+        const { id, hex } = makePlanId();
+        expect(id).toMatch(/^pln_[a-f0-9]{6}$/);
+        expect(hex).toMatch(/^[a-f0-9]{6}$/);
+        expect(isPlanId(id)).toBe(true);
+    });
+    it('creates plan id with label', () => {
+        const { id } = makePlanId('auth-feature');
+        expect(id).toMatch(/^pln_[a-f0-9]{6}_authfeature$/);
+    });
+});
+describe('makeTaskId', () => {
+    it('creates task id with plan hex and sequence (3-digit padded)', () => {
+        const id = makeTaskId('abc123', 1);
+        expect(id).toBe(taskId('tsk_abc123_001'));
+        expect(isTaskId(id)).toBe(true);
+    });
+    it('creates task id with label', () => {
+        const id = makeTaskId('abc123', 1, 'setup');
+        expect(id).toBe(taskId('tsk_abc123_001_setup'));
+    });
+    it('pads sequence correctly', () => {
+        expect(makeTaskId('abc123', 1)).toBe(taskId('tsk_abc123_001'));
+        expect(makeTaskId('abc123', 10)).toBe(taskId('tsk_abc123_010'));
+        expect(makeTaskId('abc123', 100)).toBe(taskId('tsk_abc123_100'));
+    });
+});
+describe('makeSubtaskId', () => {
+    it('creates subtask id from parent task', () => {
+        const parentId = taskId('tsk_abc123_001');
+        const id = makeSubtaskId(parentId, 1);
+        expect(id).toBe(taskId('tsk_abc123_001.1'));
+    });
+    it('creates subtask id with label', () => {
+        const parentId = taskId('tsk_abc123_001');
+        const id = makeSubtaskId(parentId, 2, 'validate');
+        expect(id).toBe(taskId('tsk_abc123_001.2_validate'));
+    });
+});
+describe('makeEventId', () => {
+    it('creates event id with hex and sequence (5-digit padded)', () => {
+        const { id, hex } = makeEventId(1);
+        expect(id).toMatch(/^evt_[a-f0-9]{6}_00001$/);
+        expect(hex).toMatch(/^[a-f0-9]{6}$/);
+        expect(isEventId(id)).toBe(true);
+    });
+});
+describe('makeWorktreeId', () => {
+    it('creates worktree id without label', () => {
+        const id = makeWorktreeId();
+        expect(id).toMatch(/^wkt_[a-f0-9]{6}$/);
+        expect(isWorktreeId(id)).toBe(true);
+    });
+    it('creates worktree id with label', () => {
+        const id = makeWorktreeId('feature-auth');
+        expect(id).toMatch(/^wkt_[a-f0-9]{6}_featureauth$/);
+    });
+});
+describe('parseId', () => {
+    it('parses agent id without label', () => {
+        const parsed = parseId('agt_abc123');
+        expect(parsed.type).toBe('agt');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.label).toBeUndefined();
+    });
+    it('parses agent id with label', () => {
+        const parsed = parseId('agt_abc123_main');
+        expect(parsed.type).toBe('agt');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.label).toBe('main');
+    });
+    it('parses task id', () => {
+        const parsed = parseId('tsk_abc123_001');
+        expect(parsed.type).toBe('tsk');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.seq).toBe('001');
+    });
+    it('parses task id with label', () => {
+        const parsed = parseId('tsk_abc123_001_setup');
+        expect(parsed.type).toBe('tsk');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.seq).toBe('001');
+        expect(parsed.label).toBe('setup');
+    });
+    it('parses subtask id (seq includes dot notation)', () => {
+        const parsed = parseId('tsk_abc123_001.2');
+        expect(parsed.type).toBe('tsk');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.seq).toBe('001.2');
+    });
+    it('parses event id', () => {
+        const parsed = parseId('evt_abc123_00005');
+        expect(parsed.type).toBe('evt');
+        expect(parsed.hex).toBe('abc123');
+        expect(parsed.seq).toBe('00005');
+    });
+});
+describe('isValidId', () => {
+    it('validates correct ids', () => {
+        expect(isValidId('agt_abc123')).toBe(true);
+        expect(isValidId('agt_abc123_main')).toBe(true);
+        expect(isValidId('pln_abc123')).toBe(true);
+        expect(isValidId('tsk_abc123_001')).toBe(true);
+        expect(isValidId('evt_abc123_00001')).toBe(true);
+        expect(isValidId('wkt_abc123')).toBe(true);
+    });
+    it('rejects invalid ids', () => {
+        expect(isValidId('invalid')).toBe(false);
+        expect(isValidId('agt_')).toBe(false);
+        expect(isValidId('xxx_abc123')).toBe(false);
+        expect(isValidId('')).toBe(false);
+        expect(isValidId('agt_ABC123')).toBe(false); // uppercase hex invalid
+    });
+});
+describe('sanitizeLabel', () => {
+    it('lowercases', () => {
+        expect(sanitizeLabel('MyLabel')).toBe('mylabel');
+    });
+    it('removes non-alphanumeric characters', () => {
+        expect(sanitizeLabel('test-label')).toBe('testlabel');
+        expect(sanitizeLabel('Test Label!')).toBe('testlabel');
+        expect(sanitizeLabel('test_123')).toBe('test123');
+    });
+    it('truncates long labels to 20 chars', () => {
+        const long = 'a'.repeat(30);
+        expect(sanitizeLabel(long)).toHaveLength(20);
+    });
+    it('handles empty string', () => {
+        expect(sanitizeLabel('')).toBe('');
+    });
+});
+describe('getPlanHexFromTaskId', () => {
+    it('extracts plan hex from task id', () => {
+        expect(getPlanHexFromTaskId('tsk_abc123_001')).toBe('abc123');
+        expect(getPlanHexFromTaskId('tsk_abc123_001_label')).toBe('abc123');
+    });
+});
+describe('isSubtask', () => {
+    it('identifies subtasks (contains dot in seq)', () => {
+        expect(isSubtask('tsk_abc123_001.1')).toBe(true);
+        expect(isSubtask('tsk_abc123_001.2_label')).toBe(true);
+    });
+    it('identifies non-subtasks', () => {
+        expect(isSubtask('tsk_abc123_001')).toBe(false);
+        expect(isSubtask('tsk_abc123_001_label')).toBe(false);
+    });
+});
+describe('getParentTaskId', () => {
+    it('gets parent task id from subtask', () => {
+        expect(getParentTaskId('tsk_abc123_001.2')).toBe('tsk_abc123_001');
+        expect(getParentTaskId('tsk_abc123_001.2_label')).toBe('tsk_abc123_001');
+    });
+    it('returns null for non-subtask', () => {
+        expect(getParentTaskId('tsk_abc123_001')).toBeNull();
+    });
+});
+describe('typed id guards', () => {
+    it('correctly identifies id types', () => {
+        expect(isAgentId('agt_abc123')).toBe(true);
+        expect(isAgentId('pln_abc123')).toBe(false);
+        expect(isPlanId('pln_abc123')).toBe(true);
+        expect(isPlanId('agt_abc123')).toBe(false);
+        expect(isTaskId('tsk_abc123_001')).toBe(true);
+        expect(isTaskId('pln_abc123')).toBe(false);
+        expect(isEventId('evt_abc123_00001')).toBe(true);
+        expect(isEventId('tsk_abc123_001')).toBe(false);
+        expect(isWorktreeId('wkt_abc123')).toBe(true);
+        expect(isWorktreeId('agt_abc123')).toBe(false);
+    });
+});

package/dist/ids/index.d.ts

@@ -0,0 +1,16 @@
+export type { IdType, ParsedId } from './types';
+export type { AgentId, PlanId, TaskId, EventId, WorktreeId, HivemindIdType, } from './typedIds';
+export { agentId, planId, taskId, eventId, worktreeId, isAgentId, isPlanId, isTaskId, isEventId, isWorktreeId, } from './typedIds';
+export { generateHex } from './generateHex';
+export { makeAgentId } from './makeAgentId';
+export { makePlanId } from './makePlanId';
+export { makeTaskId } from './makeTaskId';
+export { makeSubtaskId } from './makeSubtaskId';
+export { makeEventId } from './makeEventId';
+export { makeWorktreeId } from './makeWorktreeId';
+export { parseId } from './parseId';
+export { sanitizeLabel } from './sanitizeLabel';
+export { getPlanHexFromTaskId } from './getPlanHexFromTaskId';
+export { getParentTaskId } from './getParentTaskId';
+export { isSubtask } from './isSubtask';
+export { isValidId } from './isValidId';

package/dist/ids/index.js

@@ -0,0 +1,17 @@
+export { agentId, planId, taskId, eventId, worktreeId, isAgentId, isPlanId, isTaskId, isEventId, isWorktreeId, } from './typedIds';
+// Generators
+export { generateHex } from './generateHex';
+export { makeAgentId } from './makeAgentId';
+export { makePlanId } from './makePlanId';
+export { makeTaskId } from './makeTaskId';
+export { makeSubtaskId } from './makeSubtaskId';
+export { makeEventId } from './makeEventId';
+export { makeWorktreeId } from './makeWorktreeId';
+// Parsing
+export { parseId } from './parseId';
+export { sanitizeLabel } from './sanitizeLabel';
+// Helpers
+export { getPlanHexFromTaskId } from './getPlanHexFromTaskId';
+export { getParentTaskId } from './getParentTaskId';
+export { isSubtask } from './isSubtask';
+export { isValidId } from './isValidId';

package/dist/ids/isSubtask.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if a task ID is a subtask (contains a dot in seq)
+ *
+ * Example: tsk_e9d2c1_001.1 → true
+ *          tsk_e9d2c1_001   → false
+ */
+export declare function isSubtask(taskId: string): boolean;

package/dist/ids/isSubtask.js

@@ -0,0 +1,11 @@
+import { parseId } from './parseId';
+/**
+ * Check if a task ID is a subtask (contains a dot in seq)
+ *
+ * Example: tsk_e9d2c1_001.1 → true
+ *          tsk_e9d2c1_001   → false
+ */
+export function isSubtask(taskId) {
+    const parsed = parseId(taskId);
+    return parsed.seq?.includes('.') ?? false;
+}

package/dist/ids/isValidId.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Validate an ID format
+ *
+ * Checks:
+ *   - Has at least 2 parts (type_hex)
+ *   - Type is valid (agt, pln, tsk, evt, wkt)
+ *   - Hex is 6 lowercase hex chars
+ */
+export declare function isValidId(id: string): boolean;

package/dist/ids/isValidId.js

@@ -0,0 +1,22 @@
+/**
+ * Validate an ID format
+ *
+ * Checks:
+ *   - Has at least 2 parts (type_hex)
+ *   - Type is valid (agt, pln, tsk, evt, wkt)
+ *   - Hex is 6 lowercase hex chars
+ */
+export function isValidId(id) {
+    const validTypes = ['agt', 'pln', 'tsk', 'evt', 'wkt'];
+    const parts = id.split('_');
+    if (parts.length < 2) {
+        return false;
+    }
+    if (!validTypes.includes(parts[0])) {
+        return false;
+    }
+    if (!/^[a-f0-9]{6}$/.test(parts[1])) {
+        return false;
+    }
+    return true;
+}

package/dist/ids/makeAgentId.d.ts

@@ -0,0 +1,8 @@
+import type { AgentId } from './typedIds';
+/**
+ * Create an agent ID
+ *
+ * Format: agt_{6hex}[_{label}]
+ * Examples: agt_7a3f2b, agt_7a3f2b_alice
+ */
+export declare function makeAgentId(label?: string): AgentId;

package/dist/ids/makeAgentId.js

@@ -0,0 +1,15 @@
+import { generateHex } from './generateHex';
+import { sanitizeLabel } from './sanitizeLabel';
+/**
+ * Create an agent ID
+ *
+ * Format: agt_{6hex}[_{label}]
+ * Examples: agt_7a3f2b, agt_7a3f2b_alice
+ */
+export function makeAgentId(label) {
+    const hex = generateHex();
+    if (label) {
+        return `agt_${hex}_${sanitizeLabel(label)}`;
+    }
+    return `agt_${hex}`;
+}

package/dist/ids/makeEventId.d.ts

@@ -0,0 +1,11 @@
+import type { EventId } from './typedIds';
+/**
+ * Create an event ID
+ *
+ * Format: evt_{6hex}_{seq}
+ * Example: evt_f1a2b3_00001
+ */
+export declare function makeEventId(seq: number): {
+    id: EventId;
+    hex: string;
+};

package/dist/ids/makeEventId.js

@@ -0,0 +1,12 @@
+import { generateHex } from './generateHex';
+/**
+ * Create an event ID
+ *
+ * Format: evt_{6hex}_{seq}
+ * Example: evt_f1a2b3_00001
+ */
+export function makeEventId(seq) {
+    const hex = generateHex();
+    const seqStr = String(seq).padStart(5, '0');
+    return { id: `evt_${hex}_${seqStr}`, hex };
+}

package/dist/ids/makePlanId.d.ts

@@ -0,0 +1,11 @@
+import type { PlanId } from './typedIds';
+/**
+ * Create a plan ID
+ *
+ * Format: pln_{6hex}[_{label}]
+ * Examples: pln_e9d2c1, pln_e9d2c1_auth
+ */
+export declare function makePlanId(label?: string): {
+    id: PlanId;
+    hex: string;
+};

package/dist/ids/makePlanId.js

@@ -0,0 +1,15 @@
+import { generateHex } from './generateHex';
+import { sanitizeLabel } from './sanitizeLabel';
+/**
+ * Create a plan ID
+ *
+ * Format: pln_{6hex}[_{label}]
+ * Examples: pln_e9d2c1, pln_e9d2c1_auth
+ */
+export function makePlanId(label) {
+    const hex = generateHex();
+    if (label) {
+        return { id: `pln_${hex}_${sanitizeLabel(label)}`, hex };
+    }
+    return { id: `pln_${hex}`, hex };
+}

package/dist/ids/makeSubtaskId.d.ts

@@ -0,0 +1,8 @@
+import type { TaskId } from './typedIds';
+/**
+ * Create a subtask ID from a parent task ID
+ *
+ * Format: tsk_{planHex}_{parentSeq}.{subSeq}[_{label}]
+ * Example: tsk_e9d2c1_001 + subSeq 1 → tsk_e9d2c1_001.1
+ */
+export declare function makeSubtaskId(parentTaskId: TaskId, subSeq: number, label?: string): TaskId;

package/dist/ids/makeSubtaskId.js

@@ -0,0 +1,15 @@
+import { sanitizeLabel } from './sanitizeLabel';
+/**
+ * Create a subtask ID from a parent task ID
+ *
+ * Format: tsk_{planHex}_{parentSeq}.{subSeq}[_{label}]
+ * Example: tsk_e9d2c1_001 + subSeq 1 → tsk_e9d2c1_001.1
+ */
+export function makeSubtaskId(parentTaskId, subSeq, label) {
+    const parts = parentTaskId.split('_');
+    const base = parts.slice(0, 3).join('_'); // tsk_e9d2c1_001
+    if (label) {
+        return `${base}.${subSeq}_${sanitizeLabel(label)}`;
+    }
+    return `${base}.${subSeq}`;
+}

package/dist/ids/makeTaskId.d.ts

@@ -0,0 +1,8 @@
+import type { TaskId } from './typedIds';
+/**
+ * Create a task ID (inherits plan's hex)
+ *
+ * Format: tsk_{planHex}_{seq}[_{label}]
+ * Examples: tsk_e9d2c1_001, tsk_e9d2c1_002_jwt
+ */
+export declare function makeTaskId(planHex: string, seq: number, label?: string): TaskId;

package/dist/ids/makeTaskId.js

@@ -0,0 +1,14 @@
+import { sanitizeLabel } from './sanitizeLabel';
+/**
+ * Create a task ID (inherits plan's hex)
+ *
+ * Format: tsk_{planHex}_{seq}[_{label}]
+ * Examples: tsk_e9d2c1_001, tsk_e9d2c1_002_jwt
+ */
+export function makeTaskId(planHex, seq, label) {
+    const seqStr = String(seq).padStart(3, '0');
+    if (label) {
+        return `tsk_${planHex}_${seqStr}_${sanitizeLabel(label)}`;
+    }
+    return `tsk_${planHex}_${seqStr}`;
+}

package/dist/ids/makeWorktreeId.d.ts

@@ -0,0 +1,5 @@
+import type { WorktreeId } from './typedIds';
+/**
+ * Create a worktree ID: wkt_{hex}[_{label}]
+ */
+export declare function makeWorktreeId(label?: string): WorktreeId;

package/dist/ids/makeWorktreeId.js

@@ -0,0 +1,12 @@
+import { generateHex } from './generateHex';
+import { sanitizeLabel } from './sanitizeLabel';
+/**
+ * Create a worktree ID: wkt_{hex}[_{label}]
+ */
+export function makeWorktreeId(label) {
+    const hex = generateHex();
+    if (label) {
+        return `wkt_${hex}_${sanitizeLabel(label)}`;
+    }
+    return `wkt_${hex}`;
+}

package/dist/ids/parseId.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedId } from './types';
+/**
+ * Parse any hivemind ID into its components
+ *
+ * Examples:
+ *   parseId('agt_7a3f2b')           → { type: 'agt', hex: '7a3f2b' }
+ *   parseId('agt_7a3f2b_alice')     → { type: 'agt', hex: '7a3f2b', label: 'alice' }
+ *   parseId('tsk_e9d2c1_001')       → { type: 'tsk', hex: 'e9d2c1', seq: '001' }
+ *   parseId('tsk_e9d2c1_001.1')     → { type: 'tsk', hex: 'e9d2c1', seq: '001.1' }
+ */
+export declare function parseId(id: string): ParsedId;

package/dist/ids/parseId.js

@@ -0,0 +1,26 @@
+/**
+ * Parse any hivemind ID into its components
+ *
+ * Examples:
+ *   parseId('agt_7a3f2b')           → { type: 'agt', hex: '7a3f2b' }
+ *   parseId('agt_7a3f2b_alice')     → { type: 'agt', hex: '7a3f2b', label: 'alice' }
+ *   parseId('tsk_e9d2c1_001')       → { type: 'tsk', hex: 'e9d2c1', seq: '001' }
+ *   parseId('tsk_e9d2c1_001.1')     → { type: 'tsk', hex: 'e9d2c1', seq: '001.1' }
+ */
+export function parseId(id) {
+    const parts = id.split('_');
+    const type = parts[0];
+    const hex = parts[1];
+    if (type === 'tsk') {
+        const seq = parts[2];
+        const label = parts[3];
+        return { type, hex, seq, label, raw: id };
+    }
+    if (type === 'evt') {
+        const seq = parts[2];
+        return { type, hex, seq, raw: id };
+    }
+    // agt or pln: type_hex or type_hex_label
+    const label = parts[2];
+    return { type, hex, label, raw: id };
+}

package/dist/ids/sanitizeLabel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sanitize a label for use in IDs
+ * - lowercase
+ * - remove special chars (keep alphanumeric only)
+ * - max 20 chars
+ */
+export declare function sanitizeLabel(label: string): string;