opencode-swarm-plugin 0.34.0 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # opencode-swarm-plugin
 
+## 0.35.0
+
+### Minor Changes
+
+- [`084f888`](https://github.com/joelhooks/swarm-tools/commit/084f888fcac4912f594428b1ac7148c8a8aaa422) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 👁️ Watch Your Swarm in Real-Time
+
+  `swarm log` now has a `--watch` mode for continuous log monitoring. No more running the command repeatedly - just sit back and watch the bees work.
+
+  ```bash
+  # Watch all logs
+  swarm log --watch
+
+  # Watch with filters
+  swarm log compaction -w --level error
+
+  # Faster polling (500ms instead of default 1s)
+  swarm log --watch --interval 500
+  ```
+
+  **New flags:**
+
+  - `--watch`, `-w` - Enable continuous monitoring mode
+  - `--interval <ms>` - Poll interval in milliseconds (default: 1000, min: 100)
+
+  **How it works:**
+
+  - Shows initial logs (last N lines based on `--limit`)
+  - Polls log files for new entries at the specified interval
+  - Tracks file positions for efficient incremental reads
+  - Handles log rotation gracefully (detects file truncation)
+  - All existing filters work: `--level`, `--since`, module name
+  - Clean shutdown on Ctrl+C
+
+  _"The hive that watches itself, debugs itself."_
+
 ## 0.34.0
 
 ### Minor Changes

package/bin/swarm.test.ts

@@ -462,4 +462,74 @@ describe("Log command helpers", () => {
       expect(lines).toHaveLength(0);
     });
   });
+
+  describe("watchLogs", () => {
+    test("detects new log lines appended to file", async () => {
+      const logFile = join(testDir, "swarm.1log");
+      const collectedLines: string[] = [];
+      
+      // Create initial log file
+      writeFileSync(logFile, '{"level":30,"time":"2024-12-24T16:00:00.000Z","msg":"initial"}\n');
+      
+      // Import watch utilities
+      const { watch } = await import("fs");
+      const { appendFileSync } = await import("fs");
+      
+      // Track file position for incremental reads
+      let lastSize = 0;
+      
+      function readNewLines(filePath: string): string[] {
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.slice(lastSize);
+        lastSize = content.length;
+        return newContent.split("\n").filter((line) => line.trim());
+      }
+      
+      // Simulate watch behavior
+      const watcher = watch(testDir, (eventType, filename) => {
+        if (filename && /\.\d+log$/.test(filename)) {
+          const newLines = readNewLines(join(testDir, filename));
+          collectedLines.push(...newLines);
+        }
+      });
+      
+      // Wait for watcher to be ready
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      
+      // Append new log line
+      appendFileSync(logFile, '{"level":30,"time":"2024-12-24T16:00:01.000Z","msg":"appended"}\n');
+      
+      // Wait for event to fire
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      
+      watcher.close();
+      
+      // Should have detected the new line
+      expect(collectedLines.some((l) => l.includes("appended"))).toBe(true);
+    });
+
+    test("parseWatchArgs extracts --watch flag", () => {
+      function parseWatchArgs(args: string[]): { watch: boolean; interval: number } {
+        let watch = false;
+        let interval = 1000; // default 1 second
+        
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (arg === "--watch" || arg === "-w") {
+            watch = true;
+          } else if (arg === "--interval" && i + 1 < args.length) {
+            interval = parseInt(args[++i], 10);
+          }
+        }
+        
+        return { watch, interval };
+      }
+      
+      expect(parseWatchArgs(["--watch"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["-w"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["--watch", "--interval", "500"])).toEqual({ watch: true, interval: 500 });
+      expect(parseWatchArgs(["compaction", "--watch"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["--level", "error"])).toEqual({ watch: false, interval: 1000 });
+    });
+  });
 });

package/bin/swarm.ts

@@ -2732,6 +2732,8 @@ ${cyan("Log Viewing:")}
   swarm log --since <duration>         Time filter (30s, 5m, 2h, 1d)
   swarm log --json                     Raw JSON output for jq
   swarm log --limit <n>                Limit output to n lines (default: 50)
+  swarm log --watch, -w                Watch mode - continuously monitor for new logs
+  swarm log --interval <ms>            Poll interval in ms (default: 1000, min: 100)
 
 ${cyan("Usage in OpenCode:")}
   /swarm "Add user authentication with OAuth"
@@ -3203,6 +3205,8 @@ async function logs() {
   let sinceMs: number | null = null;
   let jsonOutput = false;
   let limit = 50;
+  let watchMode = false;
+  let pollInterval = 1000; // 1 second default
   
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -3225,7 +3229,15 @@ async function logs() {
         p.log.error(`Invalid limit: ${args[i]}`);
         process.exit(1);
       }
-    } else if (!arg.startsWith("--")) {
+    } else if (arg === "--watch" || arg === "-w") {
+      watchMode = true;
+    } else if (arg === "--interval" && i + 1 < args.length) {
+      pollInterval = parseInt(args[++i], 10);
+      if (isNaN(pollInterval) || pollInterval < 100) {
+        p.log.error(`Invalid interval: ${args[i]} (minimum 100ms)`);
+        process.exit(1);
+      }
+    } else if (!arg.startsWith("--") && !arg.startsWith("-")) {
       // Positional arg = module filter
       moduleFilter = arg;
     }
@@ -3244,6 +3256,131 @@ async function logs() {
     return;
   }
   
+  // Helper to filter logs
+  const filterLogs = (rawLogs: LogLine[]): LogLine[] => {
+    let filtered = rawLogs;
+    
+    if (moduleFilter) {
+      filtered = filtered.filter((log) => log.module === moduleFilter);
+    }
+    
+    if (levelFilter !== null) {
+      filtered = filtered.filter((log) => log.level >= levelFilter);
+    }
+    
+    if (sinceMs !== null) {
+      const cutoffTime = Date.now() - sinceMs;
+      filtered = filtered.filter((log) => new Date(log.time).getTime() >= cutoffTime);
+    }
+    
+    return filtered;
+  };
+  
+  // Watch mode - continuous monitoring
+  if (watchMode) {
+    console.log(yellow(BANNER));
+    console.log(dim(`  Watching logs... (Ctrl+C to stop)`));
+    if (moduleFilter) console.log(dim(`  Module: ${moduleFilter}`));
+    if (levelFilter !== null) console.log(dim(`  Level: >=${levelToName(levelFilter)}`));
+    console.log();
+    
+    // Track file positions for incremental reads
+    const filePositions: Map<string, number> = new Map();
+    
+    // Initialize positions from current file sizes
+    const initializePositions = () => {
+      if (!existsSync(logsDir)) return;
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      for (const file of files) {
+        const filePath = join(logsDir, file);
+        try {
+          const stats = statSync(filePath);
+          filePositions.set(filePath, stats.size);
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    };
+    
+    // Read new lines from a file since last position
+    const readNewLines = (filePath: string): string[] => {
+      try {
+        const stats = statSync(filePath);
+        const lastPos = filePositions.get(filePath) || 0;
+        
+        if (stats.size <= lastPos) {
+          // File was truncated or no new content
+          if (stats.size < lastPos) {
+            filePositions.set(filePath, stats.size);
+          }
+          return [];
+        }
+        
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.slice(lastPos);
+        filePositions.set(filePath, stats.size);
+        
+        return newContent.split("\n").filter((line: string) => line.trim());
+      } catch {
+        return [];
+      }
+    };
+    
+    // Print initial logs (last N lines)
+    const rawLines = readLogFiles(logsDir);
+    let logs: LogLine[] = rawLines
+      .map(parseLogLine)
+      .filter((log): log is LogLine => log !== null);
+    logs = filterLogs(logs).slice(-limit);
+    
+    for (const log of logs) {
+      console.log(formatLogLine(log));
+    }
+    
+    // Initialize positions after printing initial logs
+    initializePositions();
+    
+    // Poll for new logs
+    const pollForNewLogs = () => {
+      if (!existsSync(logsDir)) return;
+      
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      
+      for (const file of files) {
+        const filePath = join(logsDir, file);
+        const newLines = readNewLines(filePath);
+        
+        for (const line of newLines) {
+          const parsed = parseLogLine(line);
+          if (parsed) {
+            const filtered = filterLogs([parsed]);
+            if (filtered.length > 0) {
+              console.log(formatLogLine(filtered[0]));
+            }
+          }
+        }
+      }
+    };
+    
+    // Set up polling interval
+    const intervalId = setInterval(pollForNewLogs, pollInterval);
+    
+    // Handle graceful shutdown
+    const cleanup = () => {
+      clearInterval(intervalId);
+      console.log(dim("\n  Stopped watching."));
+      process.exit(0);
+    };
+    
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    
+    // Keep process alive
+    await new Promise(() => {});
+    return;
+  }
+  
+  // Non-watch mode - one-shot output
   const rawLines = readLogFiles(logsDir);
   
   // Parse and filter
@@ -3251,19 +3388,7 @@ async function logs() {
     .map(parseLogLine)
     .filter((log): log is LogLine => log !== null);
   
-  // Apply filters
-  if (moduleFilter) {
-    logs = logs.filter((log) => log.module === moduleFilter);
-  }
-  
-  if (levelFilter !== null) {
-    logs = logs.filter((log) => log.level >= levelFilter);
-  }
-  
-  if (sinceMs !== null) {
-    const cutoffTime = Date.now() - sinceMs;
-    logs = logs.filter((log) => new Date(log.time).getTime() >= cutoffTime);
-  }
+  logs = filterLogs(logs);
   
   // Apply limit (keep most recent)
   logs = logs.slice(-limit);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

package/src/compaction-hook.test.ts

@@ -330,254 +330,276 @@ describe("Compaction Hook", () => {
     });
   });
 
-  describe("scanSessionMessages (SDK client integration)", () => {
-    /**
-     * These tests verify that we can extract swarm state from session messages
-     * using the OpenCode SDK client.
-     * 
-     * Key types from @opencode-ai/sdk:
-     * - ToolPart: { type: "tool", tool: string, state: ToolState, ... }
-     * - ToolStateCompleted: { status: "completed", input: Record<string, unknown>, output: string, ... }
-     * - Part: union type including ToolPart
-     * - Message: { id, sessionID, role, ... }
-     * 
-     * SDK API:
-     * - client.session.messages({ sessionID, limit }) → { info: Message, parts: Part[] }[]
-     */
-
-    // Mock SDK client factory
-    const createMockClient = (messages: Array<{ info: any; parts: any[] }>) => ({
-      session: {
-        messages: async ({ sessionID, limit }: { sessionID: string; limit?: number }) => ({
-          data: messages,
-          error: undefined,
-        }),
-      },
+  describe("scanSessionMessages", () => {
+    it("returns empty state when client is undefined", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const result = await scanSessionMessages(undefined, "session-123");
+      
+      expect(result.epicId).toBeUndefined();
+      expect(result.epicTitle).toBeUndefined();
+      expect(result.projectPath).toBeUndefined();
+      expect(result.agentName).toBeUndefined();
+      expect(result.subtasks.size).toBe(0);
+      expect(result.lastAction).toBeUndefined();
     });
 
-    it("extracts epic ID from swarm_spawn_subtask tool calls", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
-            {
-              id: "part-1",
-              type: "tool",
-              tool: "swarm_spawn_subtask",
-              state: {
-                status: "completed",
-                input: {
-                  epic_id: "bd-epic-auth-123",
-                  subtask_title: "Implement auth service",
-                  files: ["src/auth/service.ts"],
-                },
-                output: JSON.stringify({ success: true, agent_name: "BlueLake" }),
-                title: "Spawned subtask",
-                metadata: {},
-                time: { start: 1000, end: 2000 },
+    it("extracts epic data from hive_create_epic tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      // Mock SDK client
+      const mockClient = {
+        session: {
+          messages: async ({ sessionID, limit }: { sessionID: string; limit?: number }) => {
+            return [
+              {
+                info: { id: "msg-1", sessionID: "session-123" },
+                parts: [
+                  {
+                    id: "part-1",
+                    sessionID: "session-123",
+                    messageID: "msg-1",
+                    type: "tool" as const,
+                    callID: "call-1",
+                    tool: "hive_create_epic",
+                    state: {
+                      status: "completed" as const,
+                      input: {
+                        epic_title: "Add authentication system",
+                        epic_description: "Implement OAuth flow",
+                      },
+                      output: JSON.stringify({
+                        success: true,
+                        epic: { id: "bd-epic-123" },
+                      }),
+                      title: "Create Epic",
+                      metadata: {},
+                      time: { start: Date.now(), end: Date.now() },
+                    },
+                  },
+                ],
               },
-            },
-          ],
+            ];
+          },
         },
-      ];
-
-      const client = createMockClient(mockMessages);
+      } as any;
       
-      // This function doesn't exist yet - TDD Red phase
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      expect(result.epicId).toBe("bd-epic-auth-123");
-      expect(result.subtasks.size).toBeGreaterThan(0);
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.epicId).toBe("bd-epic-123");
+      expect(result.epicTitle).toBe("Add authentication system");
     });
 
-    it("extracts agent name from swarmmail_init tool calls", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
+    it("extracts agent name from swarmmail_init tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
             {
-              id: "part-1",
-              type: "tool",
-              tool: "swarmmail_init",
-              state: {
-                status: "completed",
-                input: {
-                  project_path: "/Users/joel/project",
-                  task_description: "Working on auth",
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarmmail_init",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      project_path: "/test/project",
+                      task_description: "Working on auth",
+                    },
+                    output: JSON.stringify({
+                      agent_name: "BlueLake",
+                      project_key: "/test/project",
+                    }),
+                    title: "Init Swarm Mail",
+                    metadata: {},
+                    time: { start: Date.now(), end: Date.now() },
+                  },
                 },
-                output: JSON.stringify({ 
-                  agent_name: "DarkWind",
-                  project_key: "/Users/joel/project",
-                }),
-                title: "Initialized swarm mail",
-                metadata: {},
-                time: { start: 1000, end: 2000 },
-              },
+              ],
             },
           ],
         },
-      ];
-
-      const client = createMockClient(mockMessages);
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      expect(result.agentName).toBe("DarkWind");
-      expect(result.projectPath).toBe("/Users/joel/project");
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.agentName).toBe("BlueLake");
+      expect(result.projectPath).toBe("/test/project");
     });
 
-    it("extracts epic title from hive_create_epic tool calls", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
+    it("extracts subtask data from swarm_spawn_subtask tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
             {
-              id: "part-1",
-              type: "tool",
-              tool: "hive_create_epic",
-              state: {
-                status: "completed",
-                input: {
-                  epic_title: "Add OAuth authentication",
-                  epic_description: "Implement OAuth2 flow",
-                  subtasks: [
-                    { title: "Schema", files: ["src/schema.ts"] },
-                    { title: "Service", files: ["src/service.ts"] },
-                  ],
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_spawn_subtask",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      epic_id: "bd-epic-123",
+                      subtask_title: "Implement OAuth service",
+                      files: ["src/auth/oauth.ts"],
+                    },
+                    output: JSON.stringify({
+                      worker: "RedMountain",
+                      bead_id: "bd-task-1",
+                    }),
+                    title: "Spawn Subtask",
+                    metadata: {},
+                    time: { start: Date.now(), end: Date.now() },
+                  },
                 },
-                output: JSON.stringify({ 
-                  epic_id: "bd-epic-oauth-456",
-                  subtask_ids: ["bd-epic-oauth-456.1", "bd-epic-oauth-456.2"],
-                }),
-                title: "Created epic",
-                metadata: {},
-                time: { start: 1000, end: 2000 },
-              },
+              ],
             },
           ],
         },
-      ];
-
-      const client = createMockClient(mockMessages);
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      expect(result.epicId).toBe("bd-epic-oauth-456");
-      expect(result.epicTitle).toBe("Add OAuth authentication");
-      expect(result.subtasks.size).toBe(2);
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.subtasks.size).toBe(1);
+      expect(result.subtasks.get("bd-task-1")).toEqual({
+        title: "Implement OAuth service",
+        status: "spawned",
+        worker: "RedMountain",
+        files: ["src/auth/oauth.ts"],
+      });
     });
 
-    it("tracks last action with timestamp", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
+    it("marks subtask as completed from swarm_complete tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
             {
-              id: "part-1",
-              type: "tool",
-              tool: "swarm_status",
-              state: {
-                status: "completed",
-                input: { epic_id: "bd-epic-123", project_key: "/path" },
-                output: JSON.stringify({ status: "in_progress" }),
-                title: "Checked status",
-                metadata: {},
-                time: { start: 5000, end: 6000 },
-              },
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_spawn_subtask",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      epic_id: "bd-epic-123",
+                      subtask_title: "Fix bug",
+                      files: [],
+                    },
+                    output: "{}",
+                    title: "Spawn",
+                    metadata: {},
+                    time: { start: 100, end: 200 },
+                  },
+                },
+                {
+                  id: "part-2",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-2",
+                  tool: "swarm_complete",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      summary: "Fixed the bug",
+                    },
+                    output: JSON.stringify({ success: true, closed: true }),
+                    title: "Complete",
+                    metadata: {},
+                    time: { start: 300, end: 400 },
+                  },
+                },
+              ],
             },
           ],
         },
-      ];
-
-      const client = createMockClient(mockMessages);
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      expect(result.lastAction).toBeDefined();
-      expect(result.lastAction?.tool).toBe("swarm_status");
-      expect(result.lastAction?.timestamp).toBe(6000);
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.subtasks.get("bd-task-1")?.status).toBe("completed");
     });
 
-    it("ignores non-tool parts", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
-            { id: "part-1", type: "text", text: "Hello" },
-            { id: "part-2", type: "reasoning", text: "Thinking..." },
-          ],
-        },
-      ];
-
-      const client = createMockClient(mockMessages);
+    it("captures last action timestamp", async () => {
       const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      expect(result.epicId).toBeUndefined();
-      expect(result.subtasks.size).toBe(0);
-    });
-
-    it("ignores pending/running tool states", async () => {
-      const mockMessages = [
-        {
-          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
-          parts: [
-            {
-              id: "part-1",
-              type: "tool",
-              tool: "swarm_spawn_subtask",
-              state: {
-                status: "pending",
-                input: { epic_id: "bd-epic-123" },
-                raw: "{}",
-              },
-            },
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
             {
-              id: "part-2",
-              type: "tool",
-              tool: "swarm_status",
-              state: {
-                status: "running",
-                input: { epic_id: "bd-epic-456" },
-                time: { start: 1000 },
-              },
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_status",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      epic_id: "bd-epic-123",
+                      project_key: "/test",
+                    },
+                    output: "{}",
+                    title: "Check Status",
+                    metadata: {},
+                    time: { start: 1000, end: 2000 },
+                  },
+                },
+              ],
             },
           ],
         },
-      ];
-
-      const client = createMockClient(mockMessages);
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(client as any, "sess-1");
-
-      // Should not extract from pending/running states
-      expect(result.epicId).toBeUndefined();
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.lastAction).toBeDefined();
+      expect(result.lastAction?.tool).toBe("swarm_status");
+      expect(result.lastAction?.timestamp).toBe(2000);
     });
 
-    it("handles SDK client errors gracefully", async () => {
-      const errorClient = {
+    it("respects limit parameter", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      let capturedLimit: number | undefined;
+      const mockClient = {
         session: {
-          messages: async () => ({
-            data: undefined,
-            error: { message: "Network error" },
-          }),
+          messages: async ({ limit }: { limit?: number }) => {
+            capturedLimit = limit;
+            return [];
+          },
         },
-      };
-
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(errorClient as any, "sess-1");
-
-      // Should return empty state, not throw
-      expect(result.subtasks.size).toBe(0);
-      expect(result.epicId).toBeUndefined();
-    });
-
-    it("returns empty state when client is undefined", async () => {
-      const { scanSessionMessages } = await import("./compaction-hook");
-      const result = await scanSessionMessages(undefined as any, "sess-1");
-
-      expect(result.subtasks.size).toBe(0);
+      } as any;
+      
+      await scanSessionMessages(mockClient, "session-123", 50);
+      
+      expect(capturedLimit).toBe(50);
     });
   });
 

package/src/compaction-hook.ts

@@ -216,6 +216,203 @@ function buildDynamicSwarmState(state: SwarmState): string {
   return parts.join("\n");
 }
 
+// ============================================================================
+// SDK Message Scanning
+// ============================================================================
+
+/**
+ * Tool part with completed state containing input/output
+ */
+interface ToolPart {
+  id: string;
+  sessionID: string;
+  messageID: string;
+  type: "tool";
+  callID: string;
+  tool: string;
+  state: ToolState;
+}
+
+/**
+ * Tool state (completed tools have input/output we need)
+ */
+type ToolState = {
+  status: "completed";
+  input: { [key: string]: unknown };
+  output: string;
+  title: string;
+  metadata: { [key: string]: unknown };
+  time: { start: number; end: number };
+} | {
+  status: string;
+  [key: string]: unknown;
+};
+
+/**
+ * SDK Client type (minimal interface for scanSessionMessages)
+ */
+interface OpencodeClient {
+  session: {
+    messages: (opts: { sessionID: string; limit?: number }) => Promise<{
+      info: { id: string; sessionID: string };
+      parts: ToolPart[];
+    }[]>;
+  };
+}
+
+/**
+ * Scanned swarm state extracted from session messages
+ */
+export interface ScannedSwarmState {
+  epicId?: string;
+  epicTitle?: string;
+  projectPath?: string;
+  agentName?: string;
+  subtasks: Map<string, { title: string; status: string; worker?: string; files?: string[] }>;
+  lastAction?: { tool: string; args: unknown; timestamp: number };
+}
+
+/**
+ * Scan session messages for swarm state using SDK client
+ * 
+ * Extracts swarm coordination state from actual tool calls:
+ * - swarm_spawn_subtask → subtask tracking
+ * - swarmmail_init → agent name, project path
+ * - hive_create_epic → epic ID and title
+ * - swarm_status → epic reference
+ * - swarm_complete → subtask completion
+ * 
+ * @param client - OpenCode SDK client (undefined if not available)
+ * @param sessionID - Session to scan
+ * @param limit - Max messages to fetch (default 100)
+ * @returns Extracted swarm state
+ */
+export async function scanSessionMessages(
+  client: OpencodeClient | undefined,
+  sessionID: string,
+  limit: number = 100
+): Promise<ScannedSwarmState> {
+  const state: ScannedSwarmState = {
+    subtasks: new Map(),
+  };
+
+  if (!client) {
+    return state;
+  }
+
+  try {
+    const messages = await client.session.messages({ sessionID, limit });
+
+    for (const message of messages) {
+      for (const part of message.parts) {
+        if (part.type !== "tool" || part.state.status !== "completed") {
+          continue;
+        }
+
+        const { tool, state: toolState } = part;
+        const { input, output, time } = toolState as Extract<ToolState, { status: "completed" }>;
+
+        // Track last action
+        state.lastAction = {
+          tool,
+          args: input,
+          timestamp: time.end,
+        };
+
+        // Extract swarm state based on tool type
+        switch (tool) {
+          case "hive_create_epic": {
+            try {
+              const parsed = JSON.parse(output);
+              if (parsed.epic?.id) {
+                state.epicId = parsed.epic.id;
+              }
+              if (input.epic_title && typeof input.epic_title === "string") {
+                state.epicTitle = input.epic_title;
+              }
+            } catch {
+              // Invalid JSON, skip
+            }
+            break;
+          }
+
+          case "swarmmail_init": {
+            try {
+              const parsed = JSON.parse(output);
+              if (parsed.agent_name) {
+                state.agentName = parsed.agent_name;
+              }
+              if (parsed.project_key) {
+                state.projectPath = parsed.project_key;
+              }
+            } catch {
+              // Invalid JSON, skip
+            }
+            break;
+          }
+
+          case "swarm_spawn_subtask": {
+            const beadId = input.bead_id as string | undefined;
+            const epicId = input.epic_id as string | undefined;
+            const title = input.subtask_title as string | undefined;
+            const files = input.files as string[] | undefined;
+
+            if (beadId && title) {
+              let worker: string | undefined;
+              try {
+                const parsed = JSON.parse(output);
+                worker = parsed.worker;
+              } catch {
+                // No worker in output
+              }
+
+              state.subtasks.set(beadId, {
+                title,
+                status: "spawned",
+                worker,
+                files,
+              });
+
+              if (epicId && !state.epicId) {
+                state.epicId = epicId;
+              }
+            }
+            break;
+          }
+
+          case "swarm_complete": {
+            const beadId = input.bead_id as string | undefined;
+            if (beadId && state.subtasks.has(beadId)) {
+              const existing = state.subtasks.get(beadId)!;
+              state.subtasks.set(beadId, {
+                ...existing,
+                status: "completed",
+              });
+            }
+            break;
+          }
+
+          case "swarm_status": {
+            const epicId = input.epic_id as string | undefined;
+            if (epicId && !state.epicId) {
+              state.epicId = epicId;
+            }
+            const projectKey = input.project_key as string | undefined;
+            if (projectKey && !state.projectPath) {
+              state.projectPath = projectKey;
+            }
+            break;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    // SDK not available or error fetching messages - return what we have
+  }
+
+  return state;
+}
+
 // ============================================================================
 // Swarm Detection
 // ============================================================================

package/src/swarm-decompose.ts

@@ -434,12 +434,6 @@ export const swarm_decompose = tool({
     "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
-    max_subtasks: tool.schema
-      .number()
-      .int()
-      .min(1)
-      .optional()
-      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema
       .string()
       .optional()
@@ -503,7 +497,6 @@ export const swarm_decompose = tool({
       : "## Additional Context\n(none provided)";
 
     const prompt = DECOMPOSITION_PROMPT.replace("{task}", args.task)
-      .replace("{max_subtasks}", (args.max_subtasks ?? 5).toString())
       .replace("{context_section}", contextSection);
 
     // Return the prompt and schema info for the caller

package/src/swarm-prompts.ts

@@ -1393,12 +1393,6 @@ export const swarm_plan_prompt = tool({
       .enum(["file-based", "feature-based", "risk-based", "auto"])
       .optional()
       .describe("Decomposition strategy (default: auto-detect)"),
-    max_subtasks: tool.schema
-      .number()
-      .int()
-      .min(1)
-      .optional()
-      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema
       .string()
       .optional()
@@ -1482,8 +1476,7 @@ export const swarm_plan_prompt = tool({
       .replace("{strategy_guidelines}", strategyGuidelines)
       .replace("{context_section}", contextSection)
       .replace("{cass_history}", "") // Empty for now
-      .replace("{skills_context}", skillsContext || "")
-      .replace("{max_subtasks}", (args.max_subtasks ?? 5).toString());
+      .replace("{skills_context}", skillsContext || "");
 
     return JSON.stringify(
       {