opencode-swarm-plugin 0.35.0 → 0.36.1

package/src/index.ts

@@ -57,7 +57,13 @@ import {
 import {
   analyzeTodoWrite,
   shouldAnalyzeTool,
+  detectCoordinatorViolation,
+  isInCoordinatorContext,
+  getCoordinatorContext,
+  setCoordinatorContext,
+  clearCoordinatorContext,
 } from "./planning-guardrails";
+import { createCompactionHook } from "./compaction-hook";
 
 /**
  * OpenCode Swarm Plugin
@@ -77,10 +83,10 @@ import {
  * @param input - Plugin context from OpenCode
  * @returns Plugin hooks including tools, events, and tool execution hooks
  */
-export const SwarmPlugin: Plugin = async (
+const SwarmPlugin: Plugin = async (
   input: PluginInput,
 ): Promise<Hooks> => {
-  const { $, directory } = input;
+  const { $, directory, client } = input;
 
   // Set the working directory for hive commands
   // This ensures hive operations run in the project directory, not ~/.config/opencode
@@ -189,6 +195,8 @@ export const SwarmPlugin: Plugin = async (
      *
      * Warns when agents are about to make planning mistakes:
      * - Using todowrite for multi-file implementation (should use swarm)
+     * - Coordinator editing files directly (should spawn workers)
+     * - Coordinator running tests (workers should run tests)
      */
     "tool.execute.before": async (input, output) => {
       const toolName = input.tool;
@@ -200,6 +208,36 @@ export const SwarmPlugin: Plugin = async (
           console.warn(`[swarm-plugin] ${analysis.warning}`);
         }
       }
+
+      // Check for coordinator violations when in coordinator context
+      if (isInCoordinatorContext()) {
+        const ctx = getCoordinatorContext();
+        const violation = detectCoordinatorViolation({
+          sessionId: ctx.sessionId || "unknown",
+          epicId: ctx.epicId || "unknown",
+          toolName,
+          toolArgs: output.args as Record<string, unknown>,
+          agentContext: "coordinator",
+        });
+
+        if (violation.isViolation) {
+          console.warn(`[swarm-plugin] ${violation.message}`);
+        }
+      }
+
+      // Activate coordinator context when swarm tools are used
+      if (toolName === "hive_create_epic" || toolName === "swarm_decompose") {
+        setCoordinatorContext({
+          isCoordinator: true,
+          sessionId: input.sessionID,
+        });
+      }
+
+      // Capture epic ID when epic is created
+      if (toolName === "hive_create_epic" && output.args) {
+        const args = output.args as { epic_title?: string };
+        // Epic ID will be set after execution in tool.execute.after
+      }
     },
 
     /**
@@ -257,10 +295,59 @@ export const SwarmPlugin: Plugin = async (
         await releaseReservations();
       }
 
+      // Capture epic ID when epic is created (for coordinator context)
+      if (toolName === "hive_create_epic" && output.output) {
+        try {
+          const result = JSON.parse(output.output);
+          if (result.epic?.id) {
+            setCoordinatorContext({
+              isCoordinator: true,
+              epicId: result.epic.id,
+              sessionId: input.sessionID,
+            });
+          }
+        } catch {
+          // Parsing failed - ignore
+        }
+      }
+
+      // Clear coordinator context when epic is closed
+      if (toolName === "hive_close" && output.output && isInCoordinatorContext()) {
+        const ctx = getCoordinatorContext();
+        try {
+          // Check if the closed cell is the active epic
+          const result = JSON.parse(output.output);
+          if (result.id === ctx.epicId) {
+            clearCoordinatorContext();
+          }
+        } catch {
+          // Parsing failed - ignore
+        }
+      }
+
       // Note: hive_sync should be called explicitly at session end
       // Auto-sync was removed because bd CLI is deprecated
       // The hive_sync tool handles flushing to JSONL and git commit/push
     },
+
+    /**
+     * Compaction hook for swarm context preservation
+     *
+     * When OpenCode compacts session context, this hook injects swarm state
+     * to ensure coordinators can resume orchestration seamlessly.
+     *
+     * Uses SDK client to scan actual session messages for precise swarm state
+     * (epic IDs, subtask status, agent names) rather than relying solely on
+     * heuristic detection from hive/swarm-mail.
+     *
+     * Note: This hook is experimental and may not be in the published Hooks type yet.
+     */
+    "experimental.session.compacting": createCompactionHook(client),
+  } as Hooks & {
+    "experimental.session.compacting"?: (
+      input: { sessionID: string },
+      output: { context: string[] },
+    ) => Promise<void>;
   };
 };
 

package/src/learning.integration.test.ts

@@ -976,7 +976,6 @@ describe("Swarm Tool Integrations", () => {
       const result = await swarm_decompose.execute(
         {
           task: "Add user authentication",
-          max_subtasks: 3,
           query_cass: true,
         },
         mockContext,
@@ -992,7 +991,6 @@ describe("Swarm Tool Integrations", () => {
       const result = await swarm_decompose.execute(
         {
           task: "Add user authentication",
-          max_subtasks: 3,
           query_cass: false,
         },
         mockContext,

package/src/planning-guardrails.test.ts

@@ -1,5 +1,17 @@
-import { describe, it, expect } from "bun:test";
-import { analyzeTodoWrite, shouldAnalyzeTool } from "./planning-guardrails";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import {
+  analyzeTodoWrite,
+  shouldAnalyzeTool,
+  detectCoordinatorViolation,
+  setCoordinatorContext,
+  getCoordinatorContext,
+  clearCoordinatorContext,
+  isInCoordinatorContext,
+  type ViolationDetectionResult,
+} from "./planning-guardrails";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "os";
 
 describe("planning-guardrails", () => {
   describe("shouldAnalyzeTool", () => {
@@ -103,4 +115,377 @@ describe("planning-guardrails", () => {
       expect(result.totalCount).toBe(6);
     });
   });
+
+  describe("detectCoordinatorViolation", () => {
+    const sessionId = "test-session-123";
+    const epicId = "test-epic-456";
+
+    // Clean up session files after tests
+    afterEach(() => {
+      const sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+      const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+      if (fs.existsSync(sessionPath)) {
+        fs.unlinkSync(sessionPath);
+      }
+    });
+
+    describe("coordinator_edited_file violation", () => {
+      it("detects Edit tool call from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "edit",
+          toolArgs: { filePath: "/path/to/file.ts", oldString: "old", newString: "new" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_edited_file");
+        expect(result.message).toContain("Coordinators should spawn workers");
+        expect(result.payload.tool).toBe("edit");
+        expect(result.payload.file).toBe("/path/to/file.ts");
+      });
+
+      it("detects Write tool call from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "write",
+          toolArgs: { filePath: "/path/to/new-file.ts", content: "export const foo = 1;" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_edited_file");
+        expect(result.message).toContain("Coordinators should spawn workers");
+        expect(result.payload.tool).toBe("write");
+        expect(result.payload.file).toBe("/path/to/new-file.ts");
+      });
+
+      it("does not detect edit from worker agent", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "edit",
+          toolArgs: { filePath: "/path/to/file.ts", oldString: "old", newString: "new" },
+          agentContext: "worker",
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+
+      it("does not detect Read tool (read-only)", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "read",
+          toolArgs: { filePath: "/path/to/file.ts" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+    });
+
+    describe("coordinator_ran_tests violation", () => {
+      it("detects bash test execution from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "bash",
+          toolArgs: { command: "bun test src/module.test.ts" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_ran_tests");
+        expect(result.message).toContain("Workers run tests");
+        expect(result.payload.command).toContain("bun test");
+      });
+
+      it("detects npm test from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "bash",
+          toolArgs: { command: "npm run test:unit" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_ran_tests");
+      });
+
+      it("detects jest from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "bash",
+          toolArgs: { command: "jest --coverage" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_ran_tests");
+      });
+
+      it("does not detect non-test bash commands", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "bash",
+          toolArgs: { command: "git status" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+
+      it("does not detect test execution from worker", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "bash",
+          toolArgs: { command: "bun test" },
+          agentContext: "worker",
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+    });
+
+    describe("coordinator_reserved_files violation", () => {
+      it("detects swarmmail_reserve from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "swarmmail_reserve",
+          toolArgs: { paths: ["src/auth/**"], reason: "Working on auth" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_reserved_files");
+        expect(result.message).toContain("Workers reserve files");
+        expect(result.payload.paths).toEqual(["src/auth/**"]);
+      });
+
+      it("detects agentmail_reserve from coordinator", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "agentmail_reserve",
+          toolArgs: { paths: ["src/lib/**"], reason: "Refactoring" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("coordinator_reserved_files");
+      });
+
+      it("does not detect reserve from worker", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "swarmmail_reserve",
+          toolArgs: { paths: ["src/auth/**"], reason: "Working on auth" },
+          agentContext: "worker",
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+    });
+
+    describe("no_worker_spawned violation", () => {
+      it("detects no spawn after decomposition", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "hive_create_epic",
+          toolArgs: {
+            epic_title: "Add feature",
+            subtasks: [
+              { title: "Task 1", files: ["a.ts"] },
+              { title: "Task 2", files: ["b.ts"] },
+            ],
+          },
+          agentContext: "coordinator",
+          checkNoSpawn: true,
+        });
+
+        expect(result.isViolation).toBe(true);
+        expect(result.violationType).toBe("no_worker_spawned");
+        expect(result.message).toContain("decomposition without spawning");
+        expect(result.payload.epic_title).toBe("Add feature");
+        expect(result.payload.subtask_count).toBe(2);
+      });
+
+      it("does not flag if workers were spawned", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "hive_create_epic",
+          toolArgs: {
+            epic_title: "Add feature",
+            subtasks: [
+              { title: "Task 1", files: ["a.ts"] },
+              { title: "Task 2", files: ["b.ts"] },
+            ],
+          },
+          agentContext: "coordinator",
+          checkNoSpawn: false, // Workers were spawned
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+
+      it("does not flag from worker agent", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "hive_create_epic",
+          toolArgs: {
+            epic_title: "Add feature",
+            subtasks: [{ title: "Task 1", files: ["a.ts"] }],
+          },
+          agentContext: "worker",
+          checkNoSpawn: true,
+        });
+
+        expect(result.isViolation).toBe(false);
+      });
+    });
+
+    describe("event capture integration", () => {
+      it("captures violation event to session file when violation detected", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "edit",
+          toolArgs: { filePath: "/test.ts", oldString: "a", newString: "b" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(true);
+
+        // Verify event was written to session file
+        const sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+        const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+        expect(fs.existsSync(sessionPath)).toBe(true);
+
+        const content = fs.readFileSync(sessionPath, "utf-8");
+        const lines = content.trim().split("\n");
+        expect(lines.length).toBe(1);
+
+        const event = JSON.parse(lines[0]);
+        expect(event.event_type).toBe("VIOLATION");
+        expect(event.violation_type).toBe("coordinator_edited_file");
+        expect(event.session_id).toBe(sessionId);
+        expect(event.epic_id).toBe(epicId);
+        expect(event.payload.tool).toBe("edit");
+      });
+
+      it("does not capture event when no violation", () => {
+        const result = detectCoordinatorViolation({
+          sessionId,
+          epicId,
+          toolName: "read",
+          toolArgs: { filePath: "/test.ts" },
+          agentContext: "coordinator",
+        });
+
+        expect(result.isViolation).toBe(false);
+
+        // Verify no session file created
+        const sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+        const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+        expect(fs.existsSync(sessionPath)).toBe(false);
+      });
+    });
+  });
+
+  describe("coordinator context", () => {
+    beforeEach(() => {
+      clearCoordinatorContext();
+    });
+
+    afterEach(() => {
+      clearCoordinatorContext();
+    });
+
+    describe("setCoordinatorContext", () => {
+      it("sets coordinator context", () => {
+        setCoordinatorContext({
+          isCoordinator: true,
+          epicId: "test-epic-123",
+          sessionId: "test-session-456",
+        });
+
+        const ctx = getCoordinatorContext();
+        expect(ctx.isCoordinator).toBe(true);
+        expect(ctx.epicId).toBe("test-epic-123");
+        expect(ctx.sessionId).toBe("test-session-456");
+        expect(ctx.activatedAt).toBeDefined();
+      });
+
+      it("merges with existing context", () => {
+        setCoordinatorContext({
+          isCoordinator: true,
+          sessionId: "session-1",
+        });
+
+        setCoordinatorContext({
+          epicId: "epic-1",
+        });
+
+        const ctx = getCoordinatorContext();
+        expect(ctx.isCoordinator).toBe(true);
+        expect(ctx.sessionId).toBe("session-1");
+        expect(ctx.epicId).toBe("epic-1");
+      });
+    });
+
+    describe("isInCoordinatorContext", () => {
+      it("returns false when not in coordinator context", () => {
+        expect(isInCoordinatorContext()).toBe(false);
+      });
+
+      it("returns true when in coordinator context", () => {
+        setCoordinatorContext({
+          isCoordinator: true,
+          epicId: "test-epic",
+        });
+
+        expect(isInCoordinatorContext()).toBe(true);
+      });
+
+      it("returns false after context is cleared", () => {
+        setCoordinatorContext({
+          isCoordinator: true,
+          epicId: "test-epic",
+        });
+
+        clearCoordinatorContext();
+
+        expect(isInCoordinatorContext()).toBe(false);
+      });
+    });
+
+    describe("clearCoordinatorContext", () => {
+      it("clears all context", () => {
+        setCoordinatorContext({
+          isCoordinator: true,
+          epicId: "test-epic",
+          sessionId: "test-session",
+        });
+
+        clearCoordinatorContext();
+
+        const ctx = getCoordinatorContext();
+        expect(ctx.isCoordinator).toBe(false);
+        expect(ctx.epicId).toBeUndefined();
+        expect(ctx.sessionId).toBeUndefined();
+      });
+    });
+  });
 });