opencode-swarm-plugin 0.42.5 → 0.42.6

package/dist/plugin.js

@@ -27652,6 +27652,178 @@ echo "Project directory: $1"
   };
 });
 
+// src/swarm-insights.ts
+var exports_swarm_insights = {};
+__export(exports_swarm_insights, {
+  getStrategyInsights: () => getStrategyInsights,
+  getPatternInsights: () => getPatternInsights,
+  getFileInsights: () => getFileInsights,
+  getCachedInsights: () => getCachedInsights,
+  formatInsightsForPrompt: () => formatInsightsForPrompt,
+  clearInsightsCache: () => clearInsightsCache
+});
+async function getStrategyInsights(swarmMail, _task) {
+  const db = await swarmMail.getDatabase();
+  const query = `
+		SELECT 
+			json_extract(data, '$.strategy') as strategy,
+			COUNT(*) as total_attempts,
+			SUM(CASE WHEN json_extract(data, '$.success') = 'true' THEN 1 ELSE 0 END) as successes
+		FROM events
+		WHERE type = 'subtask_outcome'
+		AND json_extract(data, '$.strategy') IS NOT NULL
+		GROUP BY json_extract(data, '$.strategy')
+		ORDER BY total_attempts DESC
+	`;
+  const result = await db.query(query, []);
+  const rows = result.rows;
+  return rows.map((row) => {
+    const successRate = row.successes / row.total_attempts * 100;
+    return {
+      strategy: row.strategy,
+      successRate: Math.round(successRate * 100) / 100,
+      totalAttempts: row.total_attempts,
+      recommendation: getStrategyRecommendation(row.strategy, successRate)
+    };
+  });
+}
+function getStrategyRecommendation(strategy, successRate) {
+  if (successRate >= 80) {
+    return `${strategy} is performing well (${successRate.toFixed(0)}% success)`;
+  }
+  if (successRate >= 60) {
+    return `${strategy} is moderate - monitor for issues`;
+  }
+  if (successRate >= 40) {
+    return `${strategy} has low success - consider alternatives`;
+  }
+  return `AVOID ${strategy} - high failure rate (${successRate.toFixed(0)}%)`;
+}
+async function getFileInsights(swarmMail, files) {
+  if (files.length === 0)
+    return [];
+  const db = await swarmMail.getDatabase();
+  const insights = [];
+  for (const file2 of files) {
+    const query = `
+			SELECT 
+				COUNT(*) as failure_count,
+				MAX(timestamp) as last_failure
+			FROM events
+			WHERE type = 'subtask_outcome'
+			AND json_extract(data, '$.success') = 'false'
+			AND json_extract(data, '$.files_touched') LIKE ?
+		`;
+    const result = await db.query(query, [`%${file2}%`]);
+    const row = result.rows[0];
+    if (row && row.failure_count > 0) {
+      const gotchas = await getFileGotchas(swarmMail, file2);
+      insights.push({
+        file: file2,
+        failureCount: row.failure_count,
+        lastFailure: row.last_failure,
+        gotchas
+      });
+    }
+  }
+  return insights;
+}
+async function getFileGotchas(_swarmMail, _file2) {
+  return [];
+}
+async function getPatternInsights(swarmMail) {
+  const db = await swarmMail.getDatabase();
+  const patterns = [];
+  const query = `
+		SELECT 
+			json_extract(data, '$.error_type') as error_type,
+			COUNT(*) as frequency
+		FROM events
+		WHERE type = 'subtask_outcome'
+		AND json_extract(data, '$.success') = 'false'
+		AND json_extract(data, '$.error_type') IS NOT NULL
+		GROUP BY json_extract(data, '$.error_type')
+		HAVING COUNT(*) >= 2
+		ORDER BY frequency DESC
+		LIMIT 5
+	`;
+  const result = await db.query(query, []);
+  const rows = result.rows;
+  for (const row of rows) {
+    patterns.push({
+      pattern: row.error_type,
+      frequency: row.frequency,
+      recommendation: getPatternRecommendation(row.error_type)
+    });
+  }
+  return patterns;
+}
+function getPatternRecommendation(errorType) {
+  const recommendations = {
+    type_error: "Add explicit type annotations and null checks",
+    timeout: "Consider breaking into smaller tasks",
+    conflict: "Check file reservations before editing",
+    test_failure: "Run tests incrementally during implementation"
+  };
+  return recommendations[errorType] || `Address ${errorType} issues`;
+}
+function formatInsightsForPrompt(bundle, options2 = {}) {
+  const { maxTokens = 500 } = options2;
+  const sections = [];
+  if (bundle.strategies && bundle.strategies.length > 0) {
+    const strategyLines = bundle.strategies.slice(0, 3).map((s) => `- ${s.strategy}: ${s.successRate.toFixed(0)}% success (${s.totalAttempts} attempts)`);
+    sections.push(`**Strategy Performance:**
+${strategyLines.join(`
+`)}`);
+  }
+  if (bundle.files && bundle.files.length > 0) {
+    const fileLines = bundle.files.slice(0, 5).map((f) => {
+      const gotchaStr = f.gotchas.length > 0 ? ` - ${f.gotchas[0]}` : "";
+      return `- ${f.file}: ${f.failureCount} past failures${gotchaStr}`;
+    });
+    sections.push(`**File-Specific Gotchas:**
+${fileLines.join(`
+`)}`);
+  }
+  if (bundle.patterns && bundle.patterns.length > 0) {
+    const patternLines = bundle.patterns.slice(0, 3).map((p) => `- ${p.pattern} (${p.frequency}x): ${p.recommendation}`);
+    sections.push(`**Common Pitfalls:**
+${patternLines.join(`
+`)}`);
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  let result = sections.join(`
+
+`);
+  const maxChars = maxTokens * 4;
+  if (result.length > maxChars) {
+    result = result.slice(0, maxChars - 3) + "...";
+  }
+  return result;
+}
+async function getCachedInsights(_swarmMail, cacheKey, computeFn) {
+  const cached5 = insightsCache.get(cacheKey);
+  if (cached5 && cached5.expires > Date.now()) {
+    return cached5.data;
+  }
+  const data = await computeFn();
+  insightsCache.set(cacheKey, {
+    data,
+    expires: Date.now() + CACHE_TTL_MS
+  });
+  return data;
+}
+function clearInsightsCache() {
+  insightsCache.clear();
+}
+var insightsCache, CACHE_TTL_MS;
+var init_swarm_insights = __esm(() => {
+  insightsCache = new Map;
+  CACHE_TTL_MS = 5 * 60 * 1000;
+});
+
 // src/model-selection.ts
 var exports_model_selection = {};
 __export(exports_model_selection, {
@@ -91404,6 +91576,7 @@ var CellQueryArgsSchema = exports_external.object({
   status: CellStatusSchema.optional(),
   type: CellTypeSchema.optional(),
   ready: exports_external.boolean().optional(),
+  parent_id: exports_external.string().optional(),
   limit: exports_external.number().int().positive().default(20)
 });
 var SubtaskSpecSchema = exports_external.object({
@@ -92205,6 +92378,7 @@ var hive_query = tool({
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["bug", "feature", "task", "epic", "chore"]).optional().describe("Filter by type"),
     ready: tool.schema.boolean().optional().describe("Only show unblocked cells"),
+    parent_id: tool.schema.string().optional().describe("Filter by parent epic ID (returns children of an epic)"),
     limit: tool.schema.number().optional().describe("Max results to return (default: 20)")
   },
   async execute(args, ctx) {
@@ -92220,6 +92394,7 @@ var hive_query = tool({
         cells = await adapter.queryCells(projectKey, {
           status: validated.status,
           type: validated.type,
+          parent_id: validated.parent_id,
           limit: validated.limit || 20
         });
       }
@@ -92356,6 +92531,7 @@ USE THIS TOOL TO:
 - Find cells by type: hive_cells({ type: "bug" })
 - Get a specific cell by partial ID: hive_cells({ id: "mjkmd" })
 - Get the next ready (unblocked) cell: hive_cells({ ready: true })
+- Get children of an epic: hive_cells({ parent_id: "epic-id" })
 - Combine filters: hive_cells({ status: "open", type: "task" })
 
 RETURNS: Array of cells with id, title, status, priority, type, parent_id, created_at, updated_at
@@ -92369,6 +92545,7 @@ PREFER THIS OVER hive_query when you need to:
     id: tool.schema.string().optional().describe("Partial or full cell ID to look up"),
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["task", "bug", "feature", "epic", "chore"]).optional().describe("Filter by type"),
+    parent_id: tool.schema.string().optional().describe("Filter by parent epic ID (returns children of an epic)"),
     ready: tool.schema.boolean().optional().describe("If true, return only the next unblocked cell"),
     limit: tool.schema.number().optional().describe("Max cells to return (default 20)")
   },
@@ -92396,6 +92573,7 @@ PREFER THIS OVER hive_query when you need to:
       const cells = await adapter.queryCells(projectKey, {
         status: args.status,
         type: args.type,
+        parent_id: args.parent_id,
         limit: args.limit || 20
       });
       const formatted = cells.map((c) => formatCellForOutput(c));
@@ -113687,38 +113865,28 @@ async function getPromptInsights(options2) {
 }
 async function getCoordinatorInsights(project_key) {
   try {
-    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2, strategySuccessRates } = await import("swarm-mail");
+    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { getStrategyInsights: getStrategyInsights2, getPatternInsights: getPatternInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
     const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
     const adapter = createSwarmMailAdapter2(dbAdapter, project_key || "default");
-    const db = await adapter.getDatabase();
-    const query = strategySuccessRates({ project_key });
-    const result = await db.query(query.sql, Object.values(query.parameters || {}));
-    if (!result || !result.rows || result.rows.length === 0) {
+    const [strategies, patterns] = await Promise.all([
+      getStrategyInsights2(adapter, ""),
+      getPatternInsights2(adapter)
+    ]);
+    const bundle = {
+      strategies,
+      patterns
+    };
+    const formatted = formatInsightsForPrompt2(bundle, { maxTokens: 500 });
+    if (!formatted) {
       return "";
     }
-    const rows = result.rows.map((r) => {
-      const strategy = r.strategy || "unknown";
-      const total = r.total_attempts || 0;
-      const successRate = r.success_rate || 0;
-      const emoji3 = successRate >= 80 ? "✅" : successRate >= 60 ? "⚠️" : "❌";
-      return `| ${emoji3} ${strategy} | ${successRate.toFixed(1)}% | ${total} |`;
-    });
-    const topRows = rows.slice(0, 5);
-    const antiPatterns = result.rows.filter((r) => r.success_rate < 60).map((r) => `- AVOID: ${r.strategy} strategy (${r.success_rate.toFixed(1)}% success rate)`).slice(0, 3);
-    const antiPatternsSection = antiPatterns.length > 0 ? `
-
-**Anti-Patterns:**
-${antiPatterns.join(`
-`)}` : "";
     return `
-## \uD83D\uDCCA Swarm Insights (Strategy Success Rates)
+## \uD83D\uDCCA Historical Insights
 
-| Strategy | Success Rate | Total Attempts |
-|----------|--------------|----------------|
-${topRows.join(`
-`)}
+${formatted}
 
-**Use these insights to select decomposition strategies.**${antiPatternsSection}
+**Use these learnings when selecting decomposition strategies and planning subtasks.**
 `;
   } catch (e) {
     console.warn("Failed to get coordinator insights:", e);
@@ -113727,7 +113895,9 @@ ${topRows.join(`
 }
 async function getWorkerInsights(files, domain2) {
   try {
-    const adapter = await getMemoryAdapter();
+    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { getFileInsights: getFileInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
+    const memoryAdapter = await getMemoryAdapter();
     let query = "";
     if (files && files.length > 0) {
       const keywords = files.flatMap((f) => f.split(/[\/\\.]/).filter((part) => part.length > 2)).slice(0, 5);
@@ -113737,25 +113907,48 @@ async function getWorkerInsights(files, domain2) {
     } else {
       return "";
     }
-    const result = await adapter.find({
-      query: `${query} gotcha pitfall pattern bug`,
-      limit: 3
-    });
-    if (result.count === 0) {
-      return "";
-    }
-    const learnings = result.results.map((r) => {
-      const content = r.content.length > 150 ? r.content.slice(0, 150) + "..." : r.content;
-      return `- ${content}`;
-    });
-    return `
-## \uD83D\uDCA1 Relevant Learnings (from past agents)
+    const [fileInsights, memoryResult] = await Promise.all([
+      (async () => {
+        if (!files || files.length === 0)
+          return [];
+        try {
+          const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
+          const swarmMail = createSwarmMailAdapter2(dbAdapter, "default");
+          return await getFileInsights2(swarmMail, files);
+        } catch (e) {
+          console.warn("Failed to get file insights from event store:", e);
+          return [];
+        }
+      })(),
+      memoryAdapter.find({
+        query: `${query} gotcha pitfall pattern bug`,
+        limit: 3
+      })
+    ]);
+    const bundle = {
+      files: fileInsights
+    };
+    const formattedFileInsights = formatInsightsForPrompt2(bundle, { maxTokens: 300 });
+    let formattedMemory = "";
+    if (memoryResult.count > 0) {
+      const learnings = memoryResult.results.map((r) => {
+        const content = r.content.length > 150 ? r.content.slice(0, 150) + "..." : r.content;
+        return `- ${content}`;
+      });
+      formattedMemory = `## \uD83D\uDCA1 Relevant Learnings (from past agents)
 
 ${learnings.join(`
 `)}
 
-**Check semantic-memory for full details if needed.**
-`;
+**Check semantic-memory for full details if needed.**`;
+    }
+    const sections = [formattedFileInsights, formattedMemory].filter((s) => s.length > 0);
+    if (sections.length === 0) {
+      return "";
+    }
+    return sections.join(`
+
+`);
   } catch (e) {
     console.warn("Failed to get worker insights:", e);
     return "";
@@ -120450,7 +120643,8 @@ var allTools = {
   ...repoCrawlTools,
   ...skillsTools,
   ...mandateTools,
-  ...memoryTools
+  ...memoryTools,
+  ...observabilityTools
 };
 
 // src/plugin.ts

package/dist/schemas/cell.d.ts

@@ -130,6 +130,7 @@ export declare const CellQueryArgsSchema: z.ZodObject<{
         chore: "chore";
     }>>;
     ready: z.ZodOptional<z.ZodBoolean>;
+    parent_id: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CellQueryArgs = z.infer<typeof CellQueryArgsSchema>;
@@ -376,6 +377,7 @@ export declare const BeadQueryArgsSchema: z.ZodObject<{
         chore: "chore";
     }>>;
     ready: z.ZodOptional<z.ZodBoolean>;
+    parent_id: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 /** @deprecated Use CellQueryArgs instead */

package/dist/schemas/cell.d.ts.map

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

package/dist/swarm-insights.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Swarm Insights Data Layer
+ *
+ * Aggregates insights from swarm coordination for prompt injection.
+ * Provides concise, context-efficient summaries for coordinators and workers.
+ *
+ * Data sources:
+ * - Event store (subtask_outcome, eval_finalized)
+ * - Semantic memory (file-specific learnings)
+ * - Anti-pattern registry
+ */
+import type { SwarmMailAdapter } from "swarm-mail";
+export interface StrategyInsight {
+    strategy: string;
+    successRate: number;
+    totalAttempts: number;
+    recommendation: string;
+}
+export interface FileInsight {
+    file: string;
+    failureCount: number;
+    lastFailure: string | null;
+    gotchas: string[];
+}
+export interface PatternInsight {
+    pattern: string;
+    frequency: number;
+    recommendation: string;
+}
+export interface InsightsBundle {
+    strategies?: StrategyInsight[];
+    files?: FileInsight[];
+    patterns?: PatternInsight[];
+}
+export interface FormatOptions {
+    maxTokens?: number;
+}
+/**
+ * Get strategy success rates and recommendations for a task.
+ *
+ * Queries the event store for subtask_outcome events and calculates
+ * success rates by strategy. Returns recommendations based on historical data.
+ */
+export declare function getStrategyInsights(swarmMail: SwarmMailAdapter, _task: string): Promise<StrategyInsight[]>;
+/**
+ * Get insights for specific files based on historical outcomes.
+ *
+ * Queries the event store for failures involving these files and
+ * semantic memory for file-specific gotchas.
+ */
+export declare function getFileInsights(swarmMail: SwarmMailAdapter, files: string[]): Promise<FileInsight[]>;
+/**
+ * Get common failure patterns and anti-patterns.
+ *
+ * Analyzes event store for recurring failure patterns and
+ * queries the anti-pattern registry.
+ */
+export declare function getPatternInsights(swarmMail: SwarmMailAdapter): Promise<PatternInsight[]>;
+/**
+ * Format insights bundle for prompt injection.
+ *
+ * Produces a concise, context-efficient summary suitable for
+ * inclusion in coordinator or worker prompts.
+ *
+ * @param bundle - Insights to format
+ * @param options - Formatting options (maxTokens)
+ * @returns Formatted string for prompt injection
+ */
+export declare function formatInsightsForPrompt(bundle: InsightsBundle, options?: FormatOptions): string;
+/**
+ * Get cached insights or compute fresh ones.
+ */
+export declare function getCachedInsights(_swarmMail: SwarmMailAdapter, cacheKey: string, computeFn: () => Promise<InsightsBundle>): Promise<InsightsBundle>;
+/**
+ * Clear the insights cache.
+ */
+export declare function clearInsightsCache(): void;
+//# sourceMappingURL=swarm-insights.d.ts.map

package/dist/swarm-insights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm-insights.d.ts","sourceRoot":"","sources":["../src/swarm-insights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMnD,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC9B,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAMD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,EAAE,CAAC,CA+B5B;AAsBD;;;;;GAKG;AACH,wBAAsB,eAAe,CACpC,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,WAAW,EAAE,CAAC,CAsCxB;AAsBD;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,SAAS,EAAE,gBAAgB,GACzB,OAAO,CAAC,cAAc,EAAE,CAAC,CAkC3B;AAqBD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,aAAkB,GACzB,MAAM,CA8CR;AAaD;;GAEG;AACH,wBAAsB,iBAAiB,CACtC,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,GACtC,OAAO,CAAC,cAAc,CAAC,CAazB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/swarm-prompts.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.42.5",
+  "version": "0.42.6",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,7 +47,7 @@
     "minimatch": "^10.1.1",
     "pino": "^9.6.0",
     "pino-roll": "^1.3.0",
-    "swarm-mail": "1.5.4",
+    "swarm-mail": "1.5.5",
     "yaml": "^2.8.2",
     "zod": "4.1.8"
   },

package/src/hive.integration.test.ts

@@ -17,6 +17,7 @@ import {
   hive_close,
   hive_start,
   hive_ready,
+  hive_cells,
   hive_link_thread,
   hive_sync,
   HiveError,
@@ -2133,4 +2134,108 @@ describe("beads integration", () => {
       }
     });
   });
+
+  describe("parent_id filter", () => {
+    it("hive_query filters by parent_id to get epic children", async () => {
+      const { rmSync } = await import("node:fs");
+      const tempProject = join(tmpdir(), `hive-parent-filter-${Date.now()}`);
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create an epic
+        const epicResponse = await hive_create.execute(
+          { title: "Epic Task", type: "epic", priority: 1 },
+          mockContext
+        );
+        const epic = parseResponse<Cell>(epicResponse);
+
+        // Create children of the epic
+        const child1Response = await hive_create.execute(
+          { title: "Subtask 1", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child1 = parseResponse<Cell>(child1Response);
+
+        const child2Response = await hive_create.execute(
+          { title: "Subtask 2", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child2 = parseResponse<Cell>(child2Response);
+
+        // Create unrelated cell
+        await hive_create.execute(
+          { title: "Unrelated Task", type: "task" },
+          mockContext
+        );
+
+        // Query by parent_id
+        const queryResponse = await hive_query.execute(
+          { parent_id: epic.id },
+          mockContext
+        );
+        const children = parseResponse<Cell[]>(queryResponse);
+
+        // Should only return the 2 children
+        expect(children).toHaveLength(2);
+        expect(children.map(c => c.id)).toContain(child1.id);
+        expect(children.map(c => c.id)).toContain(child2.id);
+        expect(children.every(c => c.parent_id === epic.id)).toBe(true);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("hive_cells filters by parent_id to get epic children", async () => {
+      const { rmSync } = await import("node:fs");
+      const tempProject = join(tmpdir(), `hive-cells-parent-filter-${Date.now()}`);
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create an epic
+        const epicResponse = await hive_create.execute(
+          { title: "Epic with Children", type: "epic", priority: 1 },
+          mockContext
+        );
+        const epic = parseResponse<Cell>(epicResponse);
+
+        // Create children
+        const child1Response = await hive_create.execute(
+          { title: "Child A", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child1 = parseResponse<Cell>(child1Response);
+
+        const child2Response = await hive_create.execute(
+          { title: "Child B", type: "bug", parent_id: epic.id },
+          mockContext
+        );
+        const child2 = parseResponse<Cell>(child2Response);
+
+        // Create unrelated cells
+        await hive_create.execute(
+          { title: "Orphan Task", type: "task" },
+          mockContext
+        );
+
+        // Query using hive_cells with parent_id
+        const cellsResponse = await hive_cells.execute(
+          { parent_id: epic.id },
+          mockContext
+        );
+        const cells = parseResponse<Cell[]>(cellsResponse);
+
+        // Should only return the 2 children
+        expect(cells).toHaveLength(2);
+        expect(cells.map(c => c.id)).toContain(child1.id);
+        expect(cells.map(c => c.id)).toContain(child2.id);
+        expect(cells.every(c => c.parent_id === epic.id)).toBe(true);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
 });

package/src/hive.ts

@@ -873,6 +873,10 @@ export const hive_query = tool({
       .boolean()
       .optional()
       .describe("Only show unblocked cells"),
+    parent_id: tool.schema
+      .string()
+      .optional()
+      .describe("Filter by parent epic ID (returns children of an epic)"),
     limit: tool.schema
       .number()
       .optional()
@@ -893,6 +897,7 @@ export const hive_query = tool({
         cells = await adapter.queryCells(projectKey, {
           status: validated.status,
           type: validated.type,
+          parent_id: validated.parent_id,
           limit: validated.limit || 20,
         });
       }
@@ -1139,6 +1144,7 @@ USE THIS TOOL TO:
 - Find cells by type: hive_cells({ type: "bug" })
 - Get a specific cell by partial ID: hive_cells({ id: "mjkmd" })
 - Get the next ready (unblocked) cell: hive_cells({ ready: true })
+- Get children of an epic: hive_cells({ parent_id: "epic-id" })
 - Combine filters: hive_cells({ status: "open", type: "task" })
 
 RETURNS: Array of cells with id, title, status, priority, type, parent_id, created_at, updated_at
@@ -1152,6 +1158,7 @@ PREFER THIS OVER hive_query when you need to:
     id: tool.schema.string().optional().describe("Partial or full cell ID to look up"),
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["task", "bug", "feature", "epic", "chore"]).optional().describe("Filter by type"),
+    parent_id: tool.schema.string().optional().describe("Filter by parent epic ID (returns children of an epic)"),
     ready: tool.schema.boolean().optional().describe("If true, return only the next unblocked cell"),
     limit: tool.schema.number().optional().describe("Max cells to return (default 20)"),
   },
@@ -1185,6 +1192,7 @@ PREFER THIS OVER hive_query when you need to:
       const cells = await adapter.queryCells(projectKey, {
         status: args.status,
         type: args.type,
+        parent_id: args.parent_id,
         limit: args.limit || 20,
       });