opencode-swarm-plugin 0.57.6 → 0.58.4

package/dist/bin/swarm.js

@@ -27719,14 +27719,17 @@ class FlushManager {
   outputPath;
   debounceMs;
   onFlush;
+  onError;
   timer = null;
   flushing = false;
+  lastError = null;
   constructor(options2) {
     this.adapter = options2.adapter;
     this.projectKey = options2.projectKey;
     this.outputPath = options2.outputPath;
     this.debounceMs = options2.debounceMs ?? 30000;
     this.onFlush = options2.onFlush;
+    this.onError = options2.onError;
   }
   scheduleFlush() {
     if (this.timer) {
@@ -27734,7 +27737,11 @@ class FlushManager {
     }
     this.timer = setTimeout(() => {
       this.flush().catch((err) => {
+        this.lastError = err instanceof Error ? err : new Error(String(err));
         console.error("[FlushManager] Flush error:", err);
+        if (this.onError) {
+          this.onError(this.lastError);
+        }
       });
     }, this.debounceMs);
   }
@@ -27796,6 +27803,15 @@ class FlushManager {
       this.flushing = false;
     }
   }
+  hasError() {
+    return this.lastError !== null;
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  clearError() {
+    this.lastError = null;
+  }
   stop() {
     if (this.timer) {
       clearTimeout(this.timer);
@@ -144240,14 +144256,17 @@ class FlushManager2 {
   outputPath;
   debounceMs;
   onFlush;
+  onError;
   timer = null;
   flushing = false;
+  lastError = null;
   constructor(options2) {
     this.adapter = options2.adapter;
     this.projectKey = options2.projectKey;
     this.outputPath = options2.outputPath;
     this.debounceMs = options2.debounceMs ?? 30000;
     this.onFlush = options2.onFlush;
+    this.onError = options2.onError;
   }
   scheduleFlush() {
     if (this.timer) {
@@ -144255,7 +144274,11 @@ class FlushManager2 {
     }
     this.timer = setTimeout(() => {
       this.flush().catch((err) => {
+        this.lastError = err instanceof Error ? err : new Error(String(err));
         console.error("[FlushManager] Flush error:", err);
+        if (this.onError) {
+          this.onError(this.lastError);
+        }
       });
     }, this.debounceMs);
   }
@@ -144317,6 +144340,15 @@ class FlushManager2 {
       this.flushing = false;
     }
   }
+  hasError() {
+    return this.lastError !== null;
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  clearError() {
+    this.lastError = null;
+  }
   stop() {
     if (this.timer) {
       clearTimeout(this.timer);
@@ -278218,13 +278250,13 @@ Scripts run in the skill's directory with the project directory as an argument.`
       }
       const scriptPath = join47(skill.directory, "scripts", args5.script);
       const scriptArgs = args5.args || [];
+      const TIMEOUT_MS = 60000;
+      const proc = Bun.spawn([scriptPath, skillsProjectDirectory2, ...scriptArgs], {
+        cwd: skill.directory,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
       try {
-        const TIMEOUT_MS = 60000;
-        const proc = Bun.spawn([scriptPath, skillsProjectDirectory2, ...scriptArgs], {
-          cwd: skill.directory,
-          stdout: "pipe",
-          stderr: "pipe"
-        });
         const timeoutPromise = new Promise((resolve9) => {
           setTimeout(() => resolve9({ timedOut: true }), TIMEOUT_MS);
         });
@@ -278238,7 +278270,6 @@ Scripts run in the skill's directory with the project directory as an argument.`
         })();
         const result = await Promise.race([resultPromise, timeoutPromise]);
         if (result.timedOut) {
-          proc.kill();
           return `Script timed out after ${TIMEOUT_MS / 1000} seconds.`;
         }
         const output = result.stdout + result.stderr;
@@ -278250,6 +278281,8 @@ ${output}`;
         }
       } catch (error56) {
         return `Failed to execute script: ${error56 instanceof Error ? error56.message : String(error56)}`;
+      } finally {
+        proc.kill();
       }
     }
   });
@@ -279152,9 +279185,11 @@ async function execSemanticMemory2(args5) {
       stderr: "pipe"
     });
     try {
+      const TIMEOUT_MS = 30000;
+      const timeoutPromise = new Promise((_, reject4) => setTimeout(() => reject4(new Error("Process timed out after 30s")), TIMEOUT_MS));
       const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
       const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
-      const exitCode = await proc.exited;
+      const exitCode = await Promise.race([proc.exited, timeoutPromise]);
       return { exitCode, stdout, stderr };
     } finally {
       proc.kill();
@@ -305134,12 +305169,16 @@ async function runGitCommand(args2) {
     stdout: "pipe",
     stderr: "pipe"
   });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
-  ]);
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
+  try {
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    return { exitCode, stdout, stderr };
+  } finally {
+    proc.kill();
+  }
 }
 
 class HiveError extends Error {
@@ -305430,9 +305469,9 @@ var hive_create = tool({
   }
 });
 var hive_create_epic = tool({
-  description: "Create epic with subtasks in one atomic operation",
+  description: "Create epic with subtasks atomically. REQUIRED: epic_title, subtasks (array with {title, files?}). Use after swarm_validate_decomposition confirms your decomposition is valid. Each subtask should list files it will modify to enable parallel work without conflicts.",
   args: {
-    epic_title: tool.schema.string().describe("Epic title"),
+    epic_title: tool.schema.string().describe("Epic title (e.g., 'Implement user auth')"),
     epic_description: tool.schema.string().optional().describe("Epic description"),
     epic_id: tool.schema.string().optional().describe("Custom ID for the epic (e.g., 'phase-0')"),
     subtasks: tool.schema.array(tool.schema.object({
@@ -305451,6 +305490,28 @@ var hive_create_epic = tool({
     }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args2, ctx) {
+    const missing = [];
+    if (!args2.epic_title)
+      missing.push("epic_title");
+    if (!args2.subtasks || args2.subtasks.length === 0)
+      missing.push("subtasks (array of subtask objects)");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "hive_create_epic creates an epic with subtasks atomically.",
+        example: {
+          epic_title: "Implement user authentication",
+          epic_description: "Add login, logout, and session management",
+          subtasks: [
+            { title: "Create auth service", files: ["src/auth/service.ts"] },
+            { title: "Add login endpoint", files: ["src/api/login.ts"] },
+            { title: "Add session middleware", files: ["src/middleware/session.ts"] }
+          ]
+        },
+        tip: "Each subtask should have a title and optionally files it will modify. This helps with file reservation and parallel execution."
+      }, null, 2);
+    }
     const validated = EpicCreateArgsSchema.parse(args2);
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
@@ -324176,13 +324237,13 @@ Scripts run in the skill's directory with the project directory as an argument.`
       }
       const scriptPath = join33(skill.directory, "scripts", args2.script);
       const scriptArgs = args2.args || [];
+      const TIMEOUT_MS = 60000;
+      const proc = Bun.spawn([scriptPath, skillsProjectDirectory, ...scriptArgs], {
+        cwd: skill.directory,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
       try {
-        const TIMEOUT_MS = 60000;
-        const proc = Bun.spawn([scriptPath, skillsProjectDirectory, ...scriptArgs], {
-          cwd: skill.directory,
-          stdout: "pipe",
-          stderr: "pipe"
-        });
         const timeoutPromise = new Promise((resolve23) => {
           setTimeout(() => resolve23({ timedOut: true }), TIMEOUT_MS);
         });
@@ -324196,7 +324257,6 @@ Scripts run in the skill's directory with the project directory as an argument.`
         })();
         const result = await Promise.race([resultPromise, timeoutPromise]);
         if (result.timedOut) {
-          proc.kill();
           return `Script timed out after ${TIMEOUT_MS / 1000} seconds.`;
         }
         const output = result.stdout + result.stderr;
@@ -324208,6 +324268,8 @@ ${output}`;
         }
       } catch (error452) {
         return `Failed to execute script: ${error452 instanceof Error ? error452.message : String(error452)}`;
+      } finally {
+        proc.kill();
       }
     }
   });
@@ -325114,9 +325176,11 @@ async function execSemanticMemory(args2) {
       stderr: "pipe"
     });
     try {
+      const TIMEOUT_MS = 30000;
+      const timeoutPromise = new Promise((_, reject3) => setTimeout(() => reject3(new Error("Process timed out after 30s")), TIMEOUT_MS));
       const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
       const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
-      const exitCode = await proc.exited;
+      const exitCode = await Promise.race([proc.exited, timeoutPromise]);
       return { exitCode, stdout, stderr };
     } finally {
       proc.kill();
@@ -347714,13 +347778,17 @@ var toolCheckers = {
         stderr: "pipe"
       });
       const timeout7 = setTimeout(() => proc.kill(), BUNX_TIMEOUT_MS);
-      const exitCode = await proc.exited;
-      clearTimeout(timeout7);
-      return {
-        available: exitCode === 0,
-        checkedAt: new Date().toISOString(),
-        version: "bunx"
-      };
+      try {
+        const exitCode = await proc.exited;
+        return {
+          available: exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "bunx"
+        };
+      } finally {
+        clearTimeout(timeout7);
+        proc.kill();
+      }
     } catch (e) {
       return {
         available: false,
@@ -347793,13 +347861,17 @@ var toolCheckers = {
         stderr: "pipe"
       });
       const timeout7 = setTimeout(() => proc.kill(), BUNX_TIMEOUT_MS);
-      const exitCode = await proc.exited;
-      clearTimeout(timeout7);
-      return {
-        available: exitCode === 0,
-        checkedAt: new Date().toISOString(),
-        version: "bunx-semantic-memory"
-      };
+      try {
+        const exitCode = await proc.exited;
+        return {
+          available: exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "bunx-semantic-memory"
+        };
+      } finally {
+        clearTimeout(timeout7);
+        proc.kill();
+      }
     } catch (e) {
       return {
         available: false,
@@ -347949,12 +348021,16 @@ async function runGitCommand2(args3) {
     stdout: "pipe",
     stderr: "pipe"
   });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
-  ]);
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
+  try {
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    return { exitCode, stdout, stderr };
+  } finally {
+    proc.kill();
+  }
 }
 
 class HiveError2 extends Error {
@@ -348111,9 +348187,9 @@ var hive_create2 = tool2({
   }
 });
 var hive_create_epic2 = tool2({
-  description: "Create epic with subtasks in one atomic operation",
+  description: "Create epic with subtasks atomically. REQUIRED: epic_title, subtasks (array with {title, files?}). Use after swarm_validate_decomposition confirms your decomposition is valid. Each subtask should list files it will modify to enable parallel work without conflicts.",
   args: {
-    epic_title: tool2.schema.string().describe("Epic title"),
+    epic_title: tool2.schema.string().describe("Epic title (e.g., 'Implement user auth')"),
     epic_description: tool2.schema.string().optional().describe("Epic description"),
     epic_id: tool2.schema.string().optional().describe("Custom ID for the epic (e.g., 'phase-0')"),
     subtasks: tool2.schema.array(tool2.schema.object({
@@ -348132,6 +348208,28 @@ var hive_create_epic2 = tool2({
     }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args3, ctx) {
+    const missing = [];
+    if (!args3.epic_title)
+      missing.push("epic_title");
+    if (!args3.subtasks || args3.subtasks.length === 0)
+      missing.push("subtasks (array of subtask objects)");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "hive_create_epic creates an epic with subtasks atomically.",
+        example: {
+          epic_title: "Implement user authentication",
+          epic_description: "Add login, logout, and session management",
+          subtasks: [
+            { title: "Create auth service", files: ["src/auth/service.ts"] },
+            { title: "Add login endpoint", files: ["src/api/login.ts"] },
+            { title: "Add session middleware", files: ["src/middleware/session.ts"] }
+          ]
+        },
+        tip: "Each subtask should have a title and optionally files it will modify. This helps with file reservation and parallel execution."
+      }, null, 2);
+    }
     const validated = EpicCreateArgsSchema2.parse(args3);
     const projectKey = getHiveWorkingDirectory2();
     const adapter5 = await getHiveAdapter2(projectKey);
@@ -350101,17 +350199,41 @@ var swarm_status = tool2({
   }
 });
 var swarm_progress = tool2({
-  description: "Report progress on a subtask to coordinator",
+  description: "Report progress on a subtask to coordinator. REQUIRED: project_key, agent_name, bead_id, status. Call periodically (every 25% or when blocked) to keep coordinator informed. Use status='blocked' with message explaining the blocker if you're stuck.",
   args: {
-    project_key: tool2.schema.string().describe("Project path"),
-    agent_name: tool2.schema.string().describe("Your Agent Mail name"),
-    bead_id: tool2.schema.string().describe("Subtask bead ID"),
+    project_key: tool2.schema.string().describe("Project path (e.g., '/Users/name/project')"),
+    agent_name: tool2.schema.string().describe("Your agent name from swarmmail_init"),
+    bead_id: tool2.schema.string().describe("Task ID from your spawn prompt or hive cell"),
     status: tool2.schema.enum(["in_progress", "blocked", "completed", "failed"]).describe("Current status"),
     message: tool2.schema.string().optional().describe("Progress message or blockers"),
     progress_percent: tool2.schema.number().min(0).max(100).optional().describe("Completion percentage"),
     files_touched: tool2.schema.array(tool2.schema.string()).optional().describe("Files modified so far")
   },
   async execute(args3) {
+    const missing = [];
+    if (!args3.bead_id)
+      missing.push("bead_id");
+    if (!args3.project_key)
+      missing.push("project_key");
+    if (!args3.agent_name)
+      missing.push("agent_name");
+    if (!args3.status)
+      missing.push("status");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "swarm_progress reports task progress to the coordinator.",
+        example: {
+          project_key: "/path/to/project",
+          agent_name: "your-agent-name",
+          bead_id: "your-task-id from spawn",
+          status: "in_progress",
+          progress_percent: 50,
+          message: "Completed X, working on Y"
+        }
+      }, null, 2);
+    }
     const progress = {
       bead_id: args3.bead_id,
       agent_name: args3.agent_name,
@@ -350237,12 +350359,12 @@ ${args3.files_affected.map((f) => `- \`${f}\``).join(`
   }
 });
 var swarm_complete = tool2({
-  description: "Mark subtask complete with Verification Gate. Runs typecheck and tests before allowing completion.",
+  description: "Mark subtask complete with Verification Gate. REQUIRED: project_key, agent_name, bead_id (from your task assignment), summary, start_time (Date.now() from when you started). Before calling: 1) hivemind_store your learnings, 2) list files_touched for verification. Runs typecheck/tests before finalizing.",
   args: {
-    project_key: tool2.schema.string().describe("Project path"),
-    agent_name: tool2.schema.string().describe("Your Agent Mail name"),
-    bead_id: tool2.schema.string().describe("Subtask bead ID"),
-    summary: tool2.schema.string().describe("Brief summary of work done"),
+    project_key: tool2.schema.string().describe("Project path (e.g., '/Users/name/project')"),
+    agent_name: tool2.schema.string().describe("Your agent name from swarmmail_init"),
+    bead_id: tool2.schema.string().describe("Task ID from your spawn prompt or hive cell"),
+    summary: tool2.schema.string().describe("What you accomplished (1-3 sentences)"),
     evaluation: tool2.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
     files_touched: tool2.schema.array(tool2.schema.string()).optional().describe("Files modified - will be verified (typecheck, tests)"),
     skip_verification: tool2.schema.boolean().optional().describe("Skip ALL verification (typecheck, tests). Use sparingly! (default: false)"),
@@ -350253,6 +350375,33 @@ var swarm_complete = tool2({
     skip_review: tool2.schema.boolean().optional().describe("Skip review gate check (default: false). Use only for tasks that don't require coordinator review.")
   },
   async execute(args3, _ctx) {
+    const missing = [];
+    if (!args3.bead_id)
+      missing.push("bead_id");
+    if (!args3.project_key)
+      missing.push("project_key");
+    if (!args3.agent_name)
+      missing.push("agent_name");
+    if (!args3.summary)
+      missing.push("summary");
+    if (args3.start_time === undefined)
+      missing.push("start_time");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "swarm_complete marks a subtask as done. All parameters are required.",
+        example: {
+          project_key: "/path/to/project",
+          agent_name: "your-agent-name",
+          bead_id: "epic-id.subtask-num OR cell-id from hive",
+          summary: "Brief description of what you completed",
+          start_time: Date.now(),
+          files_touched: ["src/file1.ts", "src/file2.ts"]
+        },
+        tip: "The bead_id comes from swarm_spawn_subtask or hive_create. Check your task assignment for the correct ID."
+      }, null, 2);
+    }
     const epicId = args3.bead_id.includes(".") ? args3.bead_id.split(".")[0] : args3.bead_id;
     if (!args3.skip_review) {
       const reviewStatusResult = getReviewStatus(args3.bead_id);
@@ -351638,6 +351787,26 @@ Before writing code:
 Begin work on your subtask now.`;
 var SUBTASK_PROMPT_V2 = `You are a swarm agent working on: **{subtask_title}**
 
+╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                                                               ║
+║   \uD83D\uDED1  STOP - READ THIS FIRST - BEFORE ANY EDIT OR WRITE  \uD83D\uDED1                  ║
+║                                                                               ║
+║   You MUST do these 3 things BEFORE your first Edit/Write call:              ║
+║                                                                               ║
+║   1️⃣  hivemind_find(query="<your task keywords>", limit=5, expand=true)      ║
+║       → Check if past agents already solved this                              ║
+║       → Find gotchas, patterns, warnings                                      ║
+║                                                                               ║
+║   2️⃣  skills_list() then skills_use(name="<relevant>")                       ║
+║       → testing-patterns, swarm-coordination, system-design                   ║
+║                                                                               ║
+║   3️⃣  swarmmail_send(to=["coordinator"], ...) when blocked                   ║
+║       → Don't spin >5min - ASK FOR HELP                                       ║
+║                                                                               ║
+║   SKIPPING THESE = wasted time repeating solved problems                      ║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝
+
 ## [IDENTITY]
 Agent: (assigned at spawn)
 Cell: {bead_id}
@@ -353422,10 +353591,13 @@ async function executePresetQuery(db, presetName) {
   const sql3 = presetQueries[presetName];
   return executeQuery(db, sql3);
 }
+async function executeQueryCLI(projectPath, sql3) {
+  const db = await createDbAdapter();
+  return executeQuery(db, sql3);
+}
 async function executePreset(projectPath, presetName) {
   const db = await createDbAdapter();
-  const result = await executePresetQuery(db, presetName);
-  return result.rows;
+  return executePresetQuery(db, presetName);
 }
 function formatAsTable(result) {
   const { rows, columns, rowCount, executionTimeMs } = result;
@@ -356594,12 +356766,16 @@ async function runGitCommand3(args5) {
     stdout: "pipe",
     stderr: "pipe"
   });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
-  ]);
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
+  try {
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    return { exitCode, stdout, stderr };
+  } finally {
+    proc.kill();
+  }
 }
 
 class HiveError3 extends Error {
@@ -356756,9 +356932,9 @@ var hive_create3 = tool3({
   }
 });
 var hive_create_epic3 = tool3({
-  description: "Create epic with subtasks in one atomic operation",
+  description: "Create epic with subtasks atomically. REQUIRED: epic_title, subtasks (array with {title, files?}). Use after swarm_validate_decomposition confirms your decomposition is valid. Each subtask should list files it will modify to enable parallel work without conflicts.",
   args: {
-    epic_title: tool3.schema.string().describe("Epic title"),
+    epic_title: tool3.schema.string().describe("Epic title (e.g., 'Implement user auth')"),
     epic_description: tool3.schema.string().optional().describe("Epic description"),
     epic_id: tool3.schema.string().optional().describe("Custom ID for the epic (e.g., 'phase-0')"),
     subtasks: tool3.schema.array(tool3.schema.object({
@@ -356777,6 +356953,28 @@ var hive_create_epic3 = tool3({
     }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args5, ctx) {
+    const missing = [];
+    if (!args5.epic_title)
+      missing.push("epic_title");
+    if (!args5.subtasks || args5.subtasks.length === 0)
+      missing.push("subtasks (array of subtask objects)");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "hive_create_epic creates an epic with subtasks atomically.",
+        example: {
+          epic_title: "Implement user authentication",
+          epic_description: "Add login, logout, and session management",
+          subtasks: [
+            { title: "Create auth service", files: ["src/auth/service.ts"] },
+            { title: "Add login endpoint", files: ["src/api/login.ts"] },
+            { title: "Add session middleware", files: ["src/middleware/session.ts"] }
+          ]
+        },
+        tip: "Each subtask should have a title and optionally files it will modify. This helps with file reservation and parallel execution."
+      }, null, 2);
+    }
     const validated = EpicCreateArgsSchema3.parse(args5);
     const projectKey = getHiveWorkingDirectory3();
     const adapter6 = await getHiveAdapter3(projectKey);
@@ -357604,13 +357802,17 @@ var toolCheckers2 = {
         stderr: "pipe"
       });
       const timeout7 = setTimeout(() => proc.kill(), BUNX_TIMEOUT_MS2);
-      const exitCode = await proc.exited;
-      clearTimeout(timeout7);
-      return {
-        available: exitCode === 0,
-        checkedAt: new Date().toISOString(),
-        version: "bunx"
-      };
+      try {
+        const exitCode = await proc.exited;
+        return {
+          available: exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "bunx"
+        };
+      } finally {
+        clearTimeout(timeout7);
+        proc.kill();
+      }
     } catch (e) {
       return {
         available: false,
@@ -357683,13 +357885,17 @@ var toolCheckers2 = {
         stderr: "pipe"
       });
       const timeout7 = setTimeout(() => proc.kill(), BUNX_TIMEOUT_MS2);
-      const exitCode = await proc.exited;
-      clearTimeout(timeout7);
-      return {
-        available: exitCode === 0,
-        checkedAt: new Date().toISOString(),
-        version: "bunx-semantic-memory"
-      };
+      try {
+        const exitCode = await proc.exited;
+        return {
+          available: exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "bunx-semantic-memory"
+        };
+      } finally {
+        clearTimeout(timeout7);
+        proc.kill();
+      }
     } catch (e) {
       return {
         available: false,
@@ -358010,17 +358216,20 @@ class SqliteRateLimiter {
     const MAX_BATCHES = 10;
     const cutoff = Date.now() - 7200000;
     let totalDeleted = 0;
+    let batches = 0;
     for (let i = 0;i < MAX_BATCHES; i++) {
-      const result = this.db.run(`DELETE FROM rate_limits 
+      const result = this.db.run(`DELETE FROM rate_limits
          WHERE rowid IN (
-           SELECT rowid FROM rate_limits 
-           WHERE timestamp < ? 
+           SELECT rowid FROM rate_limits
+           WHERE timestamp < ?
            LIMIT ?
          )`, [cutoff, BATCH_SIZE]);
       totalDeleted += result.changes;
+      batches++;
       if (result.changes < BATCH_SIZE)
         break;
     }
+    return { totalDeleted, batches };
   }
   async recordRequest(agentName, endpoint) {
     const now4 = Date.now();
@@ -360161,14 +360370,27 @@ function formatCassHistoryForPrompt(history) {
 `);
 }
 var swarm_decompose = tool3({
-  description: "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
+  description: "Generate decomposition prompt for breaking task into parallelizable subtasks. REQUIRED: task (the work to decompose). Returns a prompt - use it to plan subtasks, then validate with swarm_validate_decomposition, then create with hive_create_epic.",
   args: {
-    task: tool3.schema.string().min(1).describe("Task description to decompose"),
+    task: tool3.schema.string().min(1).describe("Task description (e.g., 'Add user authentication with login/logout')"),
     context: tool3.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool3.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
     cass_limit: tool3.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)")
   },
   async execute(args5) {
+    if (!args5.task) {
+      return JSON.stringify({
+        success: false,
+        error: "Missing required parameter: task",
+        hint: "swarm_decompose generates a decomposition prompt for breaking a task into parallelizable subtasks.",
+        example: {
+          task: "Implement user authentication with login, logout, and session management",
+          context: "This is a Next.js app using Prisma for database access",
+          query_cass: true
+        },
+        tip: "Provide a clear task description. The tool will generate a prompt for decomposition and optionally query past similar tasks for patterns."
+      }, null, 2);
+    }
     const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition3 } = await Promise.resolve().then(() => (init_learning2(), exports_learning2));
     let cassContext = "";
     let cassResultInfo;
@@ -360221,9 +360443,9 @@ ${fullContext}` : `## Additional Context
   }
 });
 var swarm_validate_decomposition = tool3({
-  description: "Validate a decomposition response against CellTreeSchema and capture for eval",
+  description: "Validate decomposition JSON before creating epic. REQUIRED: response (JSON string with {epic: {title, description}, subtasks: [{title, files, dependencies}]}). Checks for file conflicts and valid dependencies. Call after planning, before hive_create_epic.",
   args: {
-    response: tool3.schema.string().describe("JSON response from agent (CellTree format)"),
+    response: tool3.schema.string().describe("JSON string with epic and subtasks (see example in error hint)"),
     project_path: tool3.schema.string().optional().describe("Project path for eval capture"),
     task: tool3.schema.string().optional().describe("Original task description for eval capture"),
     context: tool3.schema.string().optional().describe("Context provided for decomposition"),
@@ -360231,8 +360453,35 @@ var swarm_validate_decomposition = tool3({
     epic_id: tool3.schema.string().optional().describe("Epic ID for eval capture")
   },
   async execute(args5) {
+    if (!args5.response) {
+      return JSON.stringify({
+        success: false,
+        valid: false,
+        error: "Missing required parameter: response",
+        hint: "swarm_validate_decomposition validates a decomposition JSON. Pass the decomposition output as the 'response' parameter.",
+        example: {
+          response: JSON.stringify({
+            epic: { title: "Epic title", description: "Epic description" },
+            subtasks: [
+              { title: "Subtask 1", description: "...", files: ["src/file.ts"], dependencies: [] }
+            ]
+          }),
+          project_path: "/path/to/project",
+          task: "Original task description"
+        },
+        tip: "This tool validates the JSON output from your decomposition planning. The 'response' should be a JSON string matching CellTreeSchema."
+      }, null, 2);
+    }
     try {
-      const parsed = JSON.parse(args5.response);
+      let parsed;
+      if (typeof args5.response === "string") {
+        parsed = JSON.parse(args5.response);
+        if (typeof parsed === "string") {
+          parsed = JSON.parse(parsed);
+        }
+      } else {
+        parsed = args5.response;
+      }
       const validated = CellTreeSchema3.parse(parsed);
       const conflicts = detectFileConflicts(validated.subtasks);
       if (conflicts.length > 0) {
@@ -363303,17 +363552,41 @@ var swarm_status2 = tool3({
   }
 });
 var swarm_progress2 = tool3({
-  description: "Report progress on a subtask to coordinator",
+  description: "Report progress on a subtask to coordinator. REQUIRED: project_key, agent_name, bead_id, status. Call periodically (every 25% or when blocked) to keep coordinator informed. Use status='blocked' with message explaining the blocker if you're stuck.",
   args: {
-    project_key: tool3.schema.string().describe("Project path"),
-    agent_name: tool3.schema.string().describe("Your Agent Mail name"),
-    bead_id: tool3.schema.string().describe("Subtask bead ID"),
+    project_key: tool3.schema.string().describe("Project path (e.g., '/Users/name/project')"),
+    agent_name: tool3.schema.string().describe("Your agent name from swarmmail_init"),
+    bead_id: tool3.schema.string().describe("Task ID from your spawn prompt or hive cell"),
     status: tool3.schema.enum(["in_progress", "blocked", "completed", "failed"]).describe("Current status"),
     message: tool3.schema.string().optional().describe("Progress message or blockers"),
     progress_percent: tool3.schema.number().min(0).max(100).optional().describe("Completion percentage"),
     files_touched: tool3.schema.array(tool3.schema.string()).optional().describe("Files modified so far")
   },
   async execute(args5) {
+    const missing = [];
+    if (!args5.bead_id)
+      missing.push("bead_id");
+    if (!args5.project_key)
+      missing.push("project_key");
+    if (!args5.agent_name)
+      missing.push("agent_name");
+    if (!args5.status)
+      missing.push("status");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "swarm_progress reports task progress to the coordinator.",
+        example: {
+          project_key: "/path/to/project",
+          agent_name: "your-agent-name",
+          bead_id: "your-task-id from spawn",
+          status: "in_progress",
+          progress_percent: 50,
+          message: "Completed X, working on Y"
+        }
+      }, null, 2);
+    }
     const progress = {
       bead_id: args5.bead_id,
       agent_name: args5.agent_name,
@@ -363439,12 +363712,12 @@ ${args5.files_affected.map((f) => `- \`${f}\``).join(`
   }
 });
 var swarm_complete2 = tool3({
-  description: "Mark subtask complete with Verification Gate. Runs typecheck and tests before allowing completion.",
+  description: "Mark subtask complete with Verification Gate. REQUIRED: project_key, agent_name, bead_id (from your task assignment), summary, start_time (Date.now() from when you started). Before calling: 1) hivemind_store your learnings, 2) list files_touched for verification. Runs typecheck/tests before finalizing.",
   args: {
-    project_key: tool3.schema.string().describe("Project path"),
-    agent_name: tool3.schema.string().describe("Your Agent Mail name"),
-    bead_id: tool3.schema.string().describe("Subtask bead ID"),
-    summary: tool3.schema.string().describe("Brief summary of work done"),
+    project_key: tool3.schema.string().describe("Project path (e.g., '/Users/name/project')"),
+    agent_name: tool3.schema.string().describe("Your agent name from swarmmail_init"),
+    bead_id: tool3.schema.string().describe("Task ID from your spawn prompt or hive cell"),
+    summary: tool3.schema.string().describe("What you accomplished (1-3 sentences)"),
     evaluation: tool3.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
     files_touched: tool3.schema.array(tool3.schema.string()).optional().describe("Files modified - will be verified (typecheck, tests)"),
     skip_verification: tool3.schema.boolean().optional().describe("Skip ALL verification (typecheck, tests). Use sparingly! (default: false)"),
@@ -363455,6 +363728,33 @@ var swarm_complete2 = tool3({
     skip_review: tool3.schema.boolean().optional().describe("Skip review gate check (default: false). Use only for tasks that don't require coordinator review.")
   },
   async execute(args5, _ctx) {
+    const missing = [];
+    if (!args5.bead_id)
+      missing.push("bead_id");
+    if (!args5.project_key)
+      missing.push("project_key");
+    if (!args5.agent_name)
+      missing.push("agent_name");
+    if (!args5.summary)
+      missing.push("summary");
+    if (args5.start_time === undefined)
+      missing.push("start_time");
+    if (missing.length > 0) {
+      return JSON.stringify({
+        success: false,
+        error: `Missing required parameters: ${missing.join(", ")}`,
+        hint: "swarm_complete marks a subtask as done. All parameters are required.",
+        example: {
+          project_key: "/path/to/project",
+          agent_name: "your-agent-name",
+          bead_id: "epic-id.subtask-num OR cell-id from hive",
+          summary: "Brief description of what you completed",
+          start_time: Date.now(),
+          files_touched: ["src/file1.ts", "src/file2.ts"]
+        },
+        tip: "The bead_id comes from swarm_spawn_subtask or hive_create. Check your task assignment for the correct ID."
+      }, null, 2);
+    }
     const epicId = args5.bead_id.includes(".") ? args5.bead_id.split(".")[0] : args5.bead_id;
     if (!args5.skip_review) {
       const reviewStatusResult = getReviewStatus2(args5.bead_id);
@@ -364791,6 +365091,26 @@ Before writing code:
 Begin work on your subtask now.`;
 var SUBTASK_PROMPT_V22 = `You are a swarm agent working on: **{subtask_title}**
 
+╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                                                               ║
+║   \uD83D\uDED1  STOP - READ THIS FIRST - BEFORE ANY EDIT OR WRITE  \uD83D\uDED1                  ║
+║                                                                               ║
+║   You MUST do these 3 things BEFORE your first Edit/Write call:              ║
+║                                                                               ║
+║   1️⃣  hivemind_find(query="<your task keywords>", limit=5, expand=true)      ║
+║       → Check if past agents already solved this                              ║
+║       → Find gotchas, patterns, warnings                                      ║
+║                                                                               ║
+║   2️⃣  skills_list() then skills_use(name="<relevant>")                       ║
+║       → testing-patterns, swarm-coordination, system-design                   ║
+║                                                                               ║
+║   3️⃣  swarmmail_send(to=["coordinator"], ...) when blocked                   ║
+║       → Don't spin >5min - ASK FOR HELP                                       ║
+║                                                                               ║
+║   SKIPPING THESE = wasted time repeating solved problems                      ║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝
+
 ## [IDENTITY]
 Agent: (assigned at spawn)
 Cell: {bead_id}
@@ -370751,12 +371071,27 @@ async function claudeCommand() {
     case "user-prompt":
       await claudeUserPrompt();
       break;
+    case "pre-edit":
+      await claudePreEdit();
+      break;
+    case "pre-complete":
+      await claudePreComplete();
+      break;
+    case "post-complete":
+      await claudePostComplete();
+      break;
     case "pre-compact":
       await claudePreCompact();
       break;
     case "session-end":
       await claudeSessionEnd();
       break;
+    case "track-tool":
+      await claudeTrackTool(Bun.argv[4]);
+      break;
+    case "compliance":
+      await claudeCompliance();
+      break;
     default:
       console.error(`Unknown subcommand: ${subcommand}`);
       showClaudeHelp();
@@ -370774,6 +371109,9 @@ Commands:
   init                Create project-local .claude/ config
   session-start       Hook: session start context (JSON output)
   user-prompt         Hook: prompt submit context (JSON output)
+  pre-edit            Hook: pre-Edit/Write reminder (hivemind check)
+  pre-complete        Hook: pre-swarm_complete checklist
+  post-complete       Hook: post-swarm_complete learnings reminder
   pre-compact         Hook: pre-compaction handler
   session-end         Hook: session cleanup
 `);
@@ -371091,6 +371429,237 @@ async function claudeSessionEnd() {
     console.error(error56 instanceof Error ? error56.message : String(error56));
   }
 }
+async function claudePreEdit() {
+  try {
+    const input = await readHookInput();
+    const projectPath = resolveClaudeProjectPath(input);
+    const contextLines = [];
+    contextLines.push("\u26A0\uFE0F **Before this edit**: Did you run `hivemind_find` to check for existing solutions?");
+    contextLines.push("If you haven't queried hivemind yet, consider doing so to avoid re-solving problems.");
+    writeClaudeHookOutput("PreToolUse:Edit", contextLines.join(`
+`), { suppressOutput: true });
+  } catch (error56) {
+    console.error(error56 instanceof Error ? error56.message : String(error56));
+  }
+}
+async function claudePreComplete() {
+  try {
+    const input = await readHookInput();
+    const projectPath = resolveClaudeProjectPath(input);
+    const contextLines = [];
+    const trackingDir = join57(projectPath, ".claude", ".worker-tracking");
+    const sessionId = input.session_id || "";
+    const sessionDir = join57(trackingDir, sessionId.slice(0, 8));
+    const mandatoryTools = [
+      { name: "swarmmail_init", label: "Initialize coordination" },
+      { name: "hivemind_find", label: "Query past learnings" }
+    ];
+    const recommendedTools = [
+      { name: "skills_use", label: "Load relevant skills" },
+      { name: "hivemind_store", label: "Store new learnings" }
+    ];
+    const missing = [];
+    const skippedRecommended = [];
+    for (const tool5 of mandatoryTools) {
+      const markerPath = join57(sessionDir, `${tool5.name}.marker`);
+      if (!existsSync37(markerPath)) {
+        missing.push(tool5.label);
+      }
+    }
+    for (const tool5 of recommendedTools) {
+      const markerPath = join57(sessionDir, `${tool5.name}.marker`);
+      if (!existsSync37(markerPath)) {
+        skippedRecommended.push(tool5.label);
+      }
+    }
+    if (missing.length > 0) {
+      contextLines.push("\u26A0\uFE0F **MANDATORY STEPS SKIPPED:**");
+      for (const step5 of missing) {
+        contextLines.push(`  \u274C ${step5}`);
+      }
+      contextLines.push("");
+      contextLines.push("These steps are critical for swarm coordination.");
+      contextLines.push("Consider running `hivemind_find` before future completions.");
+    }
+    if (skippedRecommended.length > 0 && missing.length === 0) {
+      contextLines.push("\uD83D\uDCDD **Recommended steps not observed:**");
+      for (const step5 of skippedRecommended) {
+        contextLines.push(`  - ${step5}`);
+      }
+    }
+    if (missing.length === 0 && skippedRecommended.length === 0) {
+      contextLines.push("\u2705 **All mandatory and recommended steps completed!**");
+    }
+    try {
+      const swarmMail = await getSwarmMailLibSQL2(projectPath);
+      const db = await swarmMail.getDatabase(projectPath);
+      await db.execute({
+        sql: `INSERT INTO swarm_events (event_type, project_path, agent_name, epic_id, bead_id, payload, created_at)
+              VALUES (?, ?, ?, ?, ?, ?, datetime('now'))`,
+        args: [
+          "worker_compliance",
+          projectPath,
+          "worker",
+          "",
+          "",
+          JSON.stringify({
+            session_id: sessionId,
+            mandatory_skipped: missing.length,
+            recommended_skipped: skippedRecommended.length,
+            score: Math.round((mandatoryTools.length - missing.length) / mandatoryTools.length * 100)
+          })
+        ]
+      });
+    } catch {}
+    if (contextLines.length > 0) {
+      writeClaudeHookOutput("PreToolUse:swarm_complete", contextLines.join(`
+`), { suppressOutput: missing.length === 0 });
+    }
+  } catch (error56) {
+    console.error(error56 instanceof Error ? error56.message : String(error56));
+  }
+}
+async function claudePostComplete() {
+  try {
+    const input = await readHookInput();
+    const contextLines = [];
+    contextLines.push("\u2705 Task completed. If you discovered anything valuable during this work:");
+    contextLines.push("```");
+    contextLines.push("hivemind_store(");
+    contextLines.push('  information="<what you learned, WHY it matters>",');
+    contextLines.push('  tags="<domain, pattern-type>"');
+    contextLines.push(")");
+    contextLines.push("```");
+    contextLines.push("**The swarm's collective intelligence grows when agents share learnings.**");
+    writeClaudeHookOutput("PostToolUse:swarm_complete", contextLines.join(`
+`), { suppressOutput: true });
+  } catch (error56) {
+    console.error(error56 instanceof Error ? error56.message : String(error56));
+  }
+}
+async function claudeTrackTool(toolName) {
+  if (!toolName)
+    return;
+  try {
+    const input = await readHookInput();
+    const projectPath = resolveClaudeProjectPath(input);
+    const trackingDir = join57(projectPath, ".claude", ".worker-tracking");
+    const sessionId = input.session_id || `unknown-${Date.now()}`;
+    const sessionDir = join57(trackingDir, sessionId.slice(0, 8));
+    if (!existsSync37(sessionDir)) {
+      mkdirSync13(sessionDir, { recursive: true });
+    }
+    const markerPath = join57(sessionDir, `${toolName}.marker`);
+    writeFileSync9(markerPath, new Date().toISOString());
+    try {
+      const swarmMail = await getSwarmMailLibSQL2(projectPath);
+      const db = await swarmMail.getDatabase(projectPath);
+      await db.execute({
+        sql: `INSERT INTO swarm_events (event_type, project_path, agent_name, epic_id, bead_id, payload, created_at)
+              VALUES (?, ?, ?, ?, ?, ?, datetime('now'))`,
+        args: [
+          "worker_tool_call",
+          projectPath,
+          "worker",
+          "",
+          "",
+          JSON.stringify({ tool: toolName, session_id: sessionId })
+        ]
+      });
+    } catch {}
+  } catch (error56) {
+    console.error(`[track-tool] ${error56 instanceof Error ? error56.message : String(error56)}`);
+  }
+}
+async function claudeCompliance() {
+  try {
+    const input = await readHookInput();
+    const projectPath = resolveClaudeProjectPath(input);
+    const trackingDir = join57(projectPath, ".claude", ".worker-tracking");
+    const sessionId = input.session_id || "";
+    const sessionDir = join57(trackingDir, sessionId.slice(0, 8));
+    const mandatoryTools = ["swarmmail_init", "hivemind_find", "skills_use"];
+    const recommendedTools = ["hivemind_store"];
+    const compliance = {};
+    for (const tool5 of [...mandatoryTools, ...recommendedTools]) {
+      const markerPath = join57(sessionDir, `${tool5}.marker`);
+      compliance[tool5] = existsSync37(markerPath);
+    }
+    const mandatoryCount = mandatoryTools.filter((t) => compliance[t]).length;
+    const score = Math.round(mandatoryCount / mandatoryTools.length * 100);
+    console.log(JSON.stringify({
+      session_id: sessionId,
+      compliance,
+      mandatory_score: score,
+      mandatory_met: mandatoryCount,
+      mandatory_total: mandatoryTools.length,
+      stored_learnings: compliance.hivemind_store
+    }));
+  } catch (error56) {
+    console.error(error56 instanceof Error ? error56.message : String(error56));
+  }
+}
+async function showWorkerCompliance() {
+  const projectPath = process.cwd();
+  try {
+    const toolUsageSql = `SELECT
+      json_extract(payload, '$.tool') as tool,
+      COUNT(*) as count,
+      COUNT(DISTINCT json_extract(payload, '$.session_id')) as sessions
+    FROM swarm_events
+    WHERE event_type = 'worker_tool_call'
+      AND created_at > datetime('now', '-7 days')
+    GROUP BY tool
+    ORDER BY count DESC`;
+    const toolResult = await executeQueryCLI(projectPath, toolUsageSql);
+    const rows = toolResult.rows;
+    console.log(yellow3(BANNER));
+    console.log(cyan3(`
+\uD83D\uDCCA Worker Tool Usage (Last 7 Days)
+`));
+    if (rows.length === 0) {
+      console.log(dim4("No worker tool usage data found."));
+      console.log(dim4("Data is collected when workers run with the Claude Code plugin."));
+      return;
+    }
+    console.log(dim4("Tool                    Calls   Sessions"));
+    console.log(dim4("\u2500".repeat(45)));
+    for (const row of rows) {
+      const tool5 = String(row.tool).padEnd(22);
+      const count11 = String(row.count).padStart(6);
+      const sessions = String(row.sessions).padStart(8);
+      console.log(`${tool5} ${count11} ${sessions}`);
+    }
+    const hivemindFinds = rows.find((r) => r.tool === "hivemind_find");
+    const completesSql = `SELECT COUNT(*) as count FROM swarm_events
+      WHERE event_type = 'worker_completed'
+        AND created_at > datetime('now', '-7 days')`;
+    const completesResult = await executeQueryCLI(projectPath, completesSql);
+    const completes = Number(completesResult.rows[0]?.count || 0);
+    const finds = Number(hivemindFinds?.count || 0);
+    if (completes > 0) {
+      const rate = Math.round(Math.min(finds, completes) / completes * 100);
+      console.log(dim4(`
+\u2500`.repeat(45)));
+      console.log(`
+${green3("Hivemind compliance rate:")} ${rate}% (${finds} queries / ${completes} completions)`);
+    }
+  } catch (error56) {
+    const msg = error56 instanceof Error ? error56.message : String(error56);
+    if (msg.includes("no such table")) {
+      console.log(yellow3(BANNER));
+      console.log(cyan3(`
+\uD83D\uDCCA Worker Tool Usage
+`));
+      console.log(dim4("No tracking data yet."));
+      console.log(dim4("Compliance tracking starts when workers run with the Claude Code plugin hooks."));
+      console.log(dim4(`
+The swarm_events table will be created on first tracked tool call.`));
+    } else {
+      console.error("Error fetching compliance data:", msg);
+    }
+  }
+}
 async function init3() {
   p4.intro("swarm init v" + VERSION6);
   const projectPath = process.cwd();
@@ -371347,13 +371916,13 @@ async function query() {
   p4.intro("swarm query");
   const projectPath = process.cwd();
   try {
-    let rows;
+    let result;
     if (parsed.preset) {
       p4.log.step(`Executing preset: ${parsed.preset}`);
-      rows = await executePreset(projectPath, parsed.preset);
+      result = await executePreset(projectPath, parsed.preset);
     } else if (parsed.query) {
       p4.log.step("Executing custom SQL");
-      rows = await executeQuery(projectPath, parsed.query);
+      result = await executeQueryCLI(projectPath, parsed.query);
     } else {
       p4.log.error("No query specified. Use --sql or --preset");
       p4.outro("Aborted");
@@ -371362,20 +371931,20 @@ async function query() {
     let output;
     switch (parsed.format) {
       case "csv":
-        output = formatAsCSV(rows);
+        output = formatAsCSV(result);
         break;
       case "json":
-        output = formatAsJSON(rows);
+        output = formatAsJSON(result);
         break;
       case "table":
       default:
-        output = formatAsTable(rows);
+        output = formatAsTable(result);
         break;
     }
     console.log();
     console.log(output);
     console.log();
-    p4.outro(`Found ${rows.length} result(s)`);
+    p4.outro(`Found ${result.rowCount} result(s)`);
   } catch (error56) {
     p4.log.error("Query failed");
     p4.log.message(error56 instanceof Error ? error56.message : String(error56));
@@ -371652,6 +372221,7 @@ ${cyan3("Commands:")}
   swarm eval      Eval-driven development commands
   swarm query     SQL analytics with presets (--sql, --preset, --format)
   swarm dashboard Live terminal UI with worker status (--epic, --refresh)
+  swarm compliance Worker tool usage compliance stats (hivemind, skills, etc)
   swarm replay    Event replay with timing (--speed, --type, --agent, --since, --until)
   swarm export    Export events (--format otlp/csv/json, --epic, --output)
   swarm tree      Visualize cell hierarchy as ASCII tree (--status, --epic, --json)
@@ -371738,6 +372308,7 @@ ${cyan3("Observability Commands:")}
   swarm export --format csv            Export as CSV
   swarm export --epic <id>             Export specific epic only
   swarm export --output <file>         Write to file instead of stdout
+  swarm compliance                     Show worker tool usage compliance stats
   swarm tree                           Show all cells as tree
   swarm tree --status open             Show only open cells
   swarm tree --epic <id>               Show specific epic subtree
@@ -371762,6 +372333,11 @@ ${cyan3("Claude Code:")}
   swarm claude init                 Create project-local .claude config
   swarm claude session-start        Hook: session start context
   swarm claude user-prompt          Hook: prompt submit context
+  swarm claude pre-edit             Hook: pre-Edit/Write (hivemind reminder)
+  swarm claude pre-complete         Hook: pre-swarm_complete (compliance check)
+  swarm claude post-complete        Hook: post-swarm_complete (store learnings)
+  swarm claude track-tool <name>    Hook: track mandatory tool usage
+  swarm claude compliance           Hook: show session compliance data
   swarm claude pre-compact          Hook: pre-compaction handler
   swarm claude session-end          Hook: session cleanup
 
@@ -373648,6 +374224,9 @@ switch (command) {
   case "dashboard":
     await dashboard();
     break;
+  case "compliance":
+    await showWorkerCompliance();
+    break;
   case "replay":
     await replay();
     break;