opencode-swarm-plugin 0.56.0 → 0.57.0

package/claude-plugin/dist/hivemind-tools.d.ts

@@ -0,0 +1,479 @@
+/**
+ * Hivemind Tools - Unified Memory System
+ *
+ * Unifies semantic-memory and CASS tools under the hivemind namespace.
+ * Sessions and learnings are both memories with different sources.
+ *
+ * Key design decisions (ADR-011):
+ * - 8 tools instead of 15 (merged duplicates)
+ * - Collection filter: "default" for learnings, "claude" for Claude sessions, etc.
+ * - Unified search across learnings + sessions
+ * - No more naming collision with external semantic-memory MCP
+ *
+ * Tool mapping:
+ * - semantic-memory_store → hivemind_store
+ * - semantic-memory_find + cass_search → hivemind_find
+ * - semantic-memory_get + cass_view → hivemind_get
+ * - semantic-memory_remove → hivemind_remove
+ * - semantic-memory_validate → hivemind_validate
+ * - semantic-memory_stats + cass_stats + cass_health → hivemind_stats
+ * - cass_index → hivemind_index
+ * - NEW: hivemind_sync (sync to .hive/memories.jsonl)
+ */
+import { type MemoryAdapter, type StoreArgs, type FindArgs, type IdArgs, type StoreResult, type FindResult, type StatsResult, type OperationResult } from "./memory";
+export type { MemoryAdapter, StoreArgs, FindArgs, IdArgs, StoreResult, FindResult, StatsResult, OperationResult, };
+/**
+ * Get or create memory adapter for the current project
+ */
+declare function getMemoryAdapter(projectPath?: string): Promise<MemoryAdapter>;
+/**
+ * Get or create hivemind adapter (alias for getMemoryAdapter)
+ */
+export declare const getHivemindAdapter: typeof getMemoryAdapter;
+/**
+ * Reset adapter cache (for testing)
+ */
+export declare function resetHivemindCache(): void;
+/**
+ * hivemind_store - Store a memory with semantic embedding
+ */
+export declare const hivemind_store: {
+    description: string;
+    args: {
+        information: import("zod").ZodString;
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodString>;
+        confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        information: string;
+        collection?: string | undefined;
+        tags?: string | undefined;
+        metadata?: string | undefined;
+        confidence?: number | undefined;
+        autoTag?: boolean | undefined;
+        autoLink?: boolean | undefined;
+        extractEntities?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_find - Search all memories (learnings + sessions)
+ */
+export declare const hivemind_find: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+        expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        query: string;
+        limit?: number | undefined;
+        collection?: string | undefined;
+        expand?: boolean | undefined;
+        fts?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_get - Get a specific memory by ID
+ */
+export declare const hivemind_get: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_remove - Delete a memory
+ */
+export declare const hivemind_remove: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_validate - Validate a memory (reset decay timer)
+ */
+export declare const hivemind_validate: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_stats - Combined statistics and health check
+ */
+export declare const hivemind_stats: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_index - Index AI session directories
+ */
+export declare const hivemind_index: {
+    description: string;
+    args: {
+        full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        full?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_sync - Sync memories to .hive/memories.jsonl
+ */
+export declare const hivemind_sync: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+declare const semantic_memory_store: any;
+declare const semantic_memory_find: any;
+declare const semantic_memory_get: any;
+declare const semantic_memory_remove: any;
+declare const semantic_memory_validate: any;
+declare const semantic_memory_list: any;
+declare const semantic_memory_stats: any;
+declare const semantic_memory_check: any;
+declare const semantic_memory_upsert: any;
+declare const cass_search: any;
+declare const cass_view: any;
+declare const cass_expand: any;
+declare const cass_health: any;
+declare const cass_index: any;
+declare const cass_stats: any;
+/**
+ * All hivemind tools + deprecation aliases
+ *
+ * Register these in the plugin with spread operator: { ...hivemindTools }
+ */
+export declare const hivemindTools: {
+    readonly hivemind_store: {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_find: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            collection?: string | undefined;
+            expand?: boolean | undefined;
+            fts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export { semantic_memory_store, semantic_memory_find, semantic_memory_get, semantic_memory_remove, semantic_memory_validate, semantic_memory_list, semantic_memory_stats, semantic_memory_check, semantic_memory_upsert, cass_search, cass_view, cass_expand, cass_health, cass_index, cass_stats, };
+export { createMemoryAdapter } from "./memory";
+export declare const memoryTools: {
+    readonly hivemind_store: {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_find: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            collection?: string | undefined;
+            expand?: boolean | undefined;
+            fts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export declare const cassTools: {
+    readonly hivemind_store: {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_find: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            collection?: string | undefined;
+            expand?: boolean | undefined;
+            fts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export declare const resetMemoryCache: typeof resetHivemindCache;
+//# sourceMappingURL=hivemind-tools.d.ts.map

package/claude-plugin/dist/hivemind-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hivemind-tools.d.ts","sourceRoot":"","sources":["../src/hivemind-tools.ts"],"names":[],"mappings":"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"}

package/claude-plugin/dist/hooks/atomic-write.d.ts

@@ -0,0 +1,21 @@
+export interface AtomicWriteOptions {
+    append?: boolean;
+}
+/**
+ * Writes content to a file atomically using a temp file + rename pattern.
+ *
+ * @param path - Target file path
+ * @param content - Content to write
+ * @param options - Write options (append mode)
+ *
+ * @example
+ * ```typescript
+ * // Basic write
+ * await writeFileAtomic("output.txt", "Hello, World!");
+ *
+ * // Append mode
+ * await writeFileAtomic("log.txt", "New entry\n", { append: true });
+ * ```
+ */
+export declare function writeFileAtomic(path: string, content: string, options?: AtomicWriteOptions): Promise<void>;
+//# sourceMappingURL=atomic-write.d.ts.map

package/claude-plugin/dist/hooks/atomic-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.d.ts","sourceRoot":"","sources":["../../src/hooks/atomic-write.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/claude-plugin/dist/hooks/constants.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hook Constants
+ *
+ * Defines which OpenCode tools are hooked for observability.
+ * Used by the plugin to identify tool calls that should trigger
+ * tool.execute.after hooks for logging, learning, and analytics.
+ */
+export declare const HIVE_TOOLS: readonly ["hive_create", "hive_update", "hive_close", "hive_start", "hive_ready", "hive_query", "hive_sync", "hive_cells", "hive_create_epic"];
+export declare const SWARM_TOOLS: readonly ["swarm_spawn_subtask", "swarm_complete", "swarm_progress", "swarm_status", "swarm_record_outcome"];
+export declare const SWARMMAIL_TOOLS: readonly ["swarmmail_init", "swarmmail_send", "swarmmail_reserve", "swarmmail_release", "swarmmail_release_all", "swarmmail_release_agent", "swarmmail_inbox"];
+export declare const ALL_HOOKED_TOOLS: readonly ["hive_create", "hive_update", "hive_close", "hive_start", "hive_ready", "hive_query", "hive_sync", "hive_cells", "hive_create_epic", "swarm_spawn_subtask", "swarm_complete", "swarm_progress", "swarm_status", "swarm_record_outcome", "swarmmail_init", "swarmmail_send", "swarmmail_reserve", "swarmmail_release", "swarmmail_release_all", "swarmmail_release_agent", "swarmmail_inbox"];
+export type HookedTool = (typeof ALL_HOOKED_TOOLS)[number];
+/**
+ * Type guard to check if a tool name is a hooked tool.
+ *
+ * @param name - The tool name to check
+ * @returns true if the tool is hooked, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isHookedTool(toolName)) {
+ *   // toolName is narrowed to HookedTool
+ *   recordToolExecution(toolName);
+ * }
+ * ```
+ */
+export declare function isHookedTool(name: string): name is HookedTool;
+//# sourceMappingURL=constants.d.ts.map

package/claude-plugin/dist/hooks/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/hooks/constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,UAAU,gJAUb,CAAC;AAEX,eAAO,MAAM,WAAW,8GAMd,CAAC;AAEX,eAAO,MAAM,eAAe,gKAQlB,CAAC;AAEX,eAAO,MAAM,gBAAgB,wYAInB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,UAAU,CAE7D"}

package/claude-plugin/dist/hooks/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Hooks Index
+ *
+ * Re-exports all hook functionality for integration into the main plugin.
+ *
+ * @module hooks
+ */
+export { HIVE_TOOLS, SWARM_TOOLS, SWARMMAIL_TOOLS, ALL_HOOKED_TOOLS, isHookedTool } from "./constants";
+export type { HookedTool } from "./constants";
+export { handleToolComplete } from "./tool-complete";
+export type { ToolHookInput, ToolHookOutput } from "./tool-complete";
+export { injectSessionContext } from "./session-start";
+export type { SessionContext } from "./session-start";
+export { writeFileAtomic } from "./atomic-write";
+export type { AtomicWriteOptions } from "./atomic-write";
+//# sourceMappingURL=index.d.ts.map

package/claude-plugin/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACvG,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC"}

package/claude-plugin/dist/hooks/session-start.d.ts

@@ -0,0 +1,30 @@
+export interface SessionContext {
+    inProgressCells: Array<{
+        id: string;
+        title: string;
+    }>;
+    activeSwarms: Array<{
+        epicId: string;
+        title: string;
+    }>;
+}
+/**
+ * Injects session context by querying hive for in-progress work.
+ * Called on session.created event.
+ *
+ * Note: Can't inject into OpenCode context yet (limitation), just logs for now.
+ *
+ * @param sessionID - The OpenCode session ID
+ * @param projectKey - The project key (directory path)
+ * @returns Session context with in-progress cells and active swarms, or null on error
+ *
+ * @example
+ * ```typescript
+ * const context = await injectSessionContext("session-123", "/path/to/project");
+ * if (context) {
+ *   console.log(`Found ${context.inProgressCells.length} in-progress cells`);
+ * }
+ * ```
+ */
+export declare function injectSessionContext(sessionID: string, projectKey: string): Promise<SessionContext | null>;
+//# sourceMappingURL=session-start.d.ts.map

package/claude-plugin/dist/hooks/session-start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-start.d.ts","sourceRoot":"","sources":["../../src/hooks/session-start.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD,YAAY,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAkChC"}

package/claude-plugin/dist/hooks/tool-complete.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Tool Complete Hook Handler
+ *
+ * Dispatches PostToolUse hooks for hooked tools.
+ * Provides observability into tool execution without blocking the main flow.
+ */
+/**
+ * Input data for tool hook handlers.
+ */
+export interface ToolHookInput {
+    /** Name of the tool that was executed */
+    tool: string;
+    /** OpenCode session ID */
+    sessionID: string;
+    /** Unique identifier for this tool call */
+    callID: string;
+}
+/**
+ * Output data from tool execution.
+ */
+export interface ToolHookOutput {
+    /** Human-readable title for the result */
+    title?: string;
+    /** Raw output from the tool (often JSON) */
+    output?: string;
+    /** Additional metadata about the execution */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Main handler for tool completion hooks.
+ * Dispatches to specific handlers based on tool name.
+ *
+ * @param toolName - Name of the tool that was executed
+ * @param input - Input data for the hook
+ * @param output - Output data from the tool
+ *
+ * @remarks
+ * - Non-hooked tools are ignored (returns immediately)
+ * - Hooked tools without specific handlers get default logging
+ * - Errors are caught and logged but never thrown (hooks shouldn't break tool execution)
+ *
+ * @example
+ * ```typescript
+ * await handleToolComplete("hive_create", {
+ *   tool: "hive_create",
+ *   sessionID: "abc123",
+ *   callID: "call-456"
+ * }, {
+ *   output: JSON.stringify({ id: "cell-789", title: "New Task" })
+ * });
+ * ```
+ */
+export declare function handleToolComplete(toolName: string, input: ToolHookInput, output: ToolHookOutput): Promise<void>;
+//# sourceMappingURL=tool-complete.d.ts.map

package/claude-plugin/dist/hooks/tool-complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-complete.d.ts","sourceRoot":"","sources":["../../src/hooks/tool-complete.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAoFD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC,CAqBf"}