opencode-swarm-plugin 0.36.0 → 0.36.1

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # opencode-swarm-plugin
 
+## 0.36.1
+
+### Patch Changes
+
+- [`9c1f3f3`](https://github.com/joelhooks/swarm-tools/commit/9c1f3f3e7204f02c133c4a036fa34e83d8376a8c) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 Coordinator Discipline: Prohibition-First Enforcement
+
+  Coordinators kept "just doing it themselves" after compaction. Now they can't.
+
+  **The Problem:**
+  After context compaction, coordinators would ignore their own instructions to "spawn workers for remaining subtasks" and edit files directly. The compaction context was narrative ("do this") rather than prescriptive ("NEVER do that").
+
+  **The Fix:**
+
+  ### 1. Prohibition-First Compaction Context
+
+  The `SWARM_COMPACTION_CONTEXT` now leads with explicit anti-patterns:
+
+  ```markdown
+  ### ⛔ NEVER DO THESE (Coordinator Anti-Patterns)
+
+  - ❌ **NEVER** use `edit` or `write` tools - SPAWN A WORKER
+  - ❌ **NEVER** run tests with `bash` - SPAWN A WORKER
+  - ❌ **NEVER** implement features yourself - SPAWN A WORKER
+  - ❌ **NEVER** "just do it myself to save time" - NO. SPAWN A WORKER.
+  ```
+
+  ### 2. Runtime Violation Detection
+
+  `detectCoordinatorViolation()` is now wired up in `tool.execute.before`:
+
+  - Detects when coordinators call `edit`, `write`, or test commands
+  - Emits warnings to help coordinators self-correct
+  - Captures VIOLATION events for post-hoc analysis
+
+  ### 3. Coordinator Context Tracking
+
+  New functions track when we're in coordinator mode:
+
+  - `setCoordinatorContext()` - Activated when `hive_create_epic` or `swarm_decompose` is called
+  - `isInCoordinatorContext()` - Checks if we're currently coordinating
+  - `clearCoordinatorContext()` - Cleared when epic is closed
+
+  **Why This Matters:**
+
+  Coordinators that do implementation work burn context, create conflicts, and defeat the purpose of swarm coordination. This fix makes the anti-pattern visible and provides guardrails to prevent it.
+
+  **Validation:**
+
+  - Check `~/.config/swarm-tools/sessions/` for VIOLATION events
+  - Run `coordinator-behavior.eval.ts` to score coordinator discipline
+
+- [`4c23c7a`](https://github.com/joelhooks/swarm-tools/commit/4c23c7a31013bc6537d83a9294b51540056cde93) Thanks [@joelhooks](https://github.com/joelhooks)! - ## Fix Double Hook Registration
+
+  The compaction hook was firing twice per compaction event because OpenCode's plugin loader
+  calls ALL exports as plugin functions. We were exporting `SwarmPlugin` as both:
+
+  1. Named export: `export const SwarmPlugin`
+  2. Default export: `export default SwarmPlugin`
+
+  This caused the plugin to register twice, doubling all hook invocations.
+
+  **Fix:** Changed to default-only export pattern:
+
+  - `src/index.ts`: `const SwarmPlugin` (no export keyword)
+  - `src/plugin.ts`: `export default SwarmPlugin` (no named re-export)
+
+  **Impact:** Compaction hooks now fire once. LLM calls during compaction reduced by 50%.
+
+- Updated dependencies [[`e0c422d`](https://github.com/joelhooks/swarm-tools/commit/e0c422de3f5e15c117cc0cc655c0b03242245be4), [`43c8c93`](https://github.com/joelhooks/swarm-tools/commit/43c8c93ef90b2f04ce59317192334f69d7c4204e)]:
+  - swarm-mail@1.5.1
+
 ## 0.36.0
 
 ### Minor Changes

package/bin/swarm.ts

@@ -983,7 +983,7 @@ function getPluginWrapper(): string {
       `[swarm] Could not read plugin template from ${templatePath}, using minimal wrapper`,
     );
     return `// Minimal fallback - install opencode-swarm-plugin globally for full functionality
-import { SwarmPlugin } from "opencode-swarm-plugin"
+import SwarmPlugin from "opencode-swarm-plugin"
 export default SwarmPlugin
 `;
   }
@@ -1709,7 +1709,7 @@ async function doctor() {
   if (updateInfo) showUpdateNotification(updateInfo);
 }
 
-async function setup() {
+async function setup(forceReinstall = false, nonInteractive = false) {
   console.clear();
   console.log(yellow(BANNER));
   console.log(getDecoratedBee());
@@ -1783,7 +1783,7 @@ async function setup() {
     legacyWorkerPath,
   ].filter((f) => existsSync(f));
 
-  if (existingFiles.length > 0) {
+  if (existingFiles.length > 0 && !forceReinstall) {
     p.log.success("Swarm is already configured!");
     p.log.message(dim("  Found " + existingFiles.length + "/5 config files"));
 
@@ -1903,7 +1903,8 @@ async function setup() {
     p.log.step("Missing " + requiredMissing.length + " required dependencies");
 
     for (const { dep } of requiredMissing) {
-      const shouldInstall = await p.confirm({
+      // In non-interactive mode, auto-install required deps
+      const shouldInstall = nonInteractive ? true : await p.confirm({
         message: "Install " + dep.name + "? (" + dep.description + ")",
         initialValue: true,
       });
@@ -1931,8 +1932,8 @@ async function setup() {
     }
   }
 
-  // Only prompt for optional deps if there are missing ones
-  if (optionalMissing.length > 0) {
+  // Only prompt for optional deps if there are missing ones (skip in non-interactive mode)
+  if (optionalMissing.length > 0 && !nonInteractive) {
     const installable = optionalMissing.filter(
       (r) => r.dep.installType !== "manual",
     );
@@ -2099,135 +2100,157 @@ async function setup() {
     p.log.message(dim('  No OpenCode config found (skipping MCP check)'));
   }
 
-  // Model selection
-  p.log.step("Configuring swarm agents...");
-  p.log.message(dim("  Coordinator handles orchestration, worker executes tasks"));
+  // Model defaults: opus for coordinator, sonnet for worker, haiku for lite
+  const DEFAULT_COORDINATOR = "anthropic/claude-opus-4-5";
+  const DEFAULT_WORKER = "anthropic/claude-sonnet-4-5";
+  const DEFAULT_LITE = "anthropic/claude-haiku-4-5";
+
+  // Model selection (skip if non-interactive)
+  let coordinatorModel: string;
+  let workerModel: string;
+  let liteModel: string;
+
+  if (nonInteractive) {
+    coordinatorModel = DEFAULT_COORDINATOR;
+    workerModel = DEFAULT_WORKER;
+    liteModel = DEFAULT_LITE;
+    p.log.step("Using default models:");
+    p.log.message(dim(`  Coordinator: ${coordinatorModel}`));
+    p.log.message(dim(`  Worker: ${workerModel}`));
+    p.log.message(dim(`  Lite: ${liteModel}`));
+  } else {
+    p.log.step("Configuring swarm agents...");
+    p.log.message(dim("  Coordinator handles orchestration, worker executes tasks"));
 
-  const coordinatorModel = await p.select({
-    message: "Select coordinator model (for orchestration/planning):",
-    options: [
-      {
-        value: "anthropic/claude-sonnet-4-5",
-        label: "Claude Sonnet 4.5",
-        hint: "Best balance of speed and capability (recommended)",
-      },
-      {
-        value: "anthropic/claude-haiku-4-5",
-        label: "Claude Haiku 4.5",
-        hint: "Fast and cost-effective",
-      },
-      {
-        value: "anthropic/claude-opus-4-5",
-        label: "Claude Opus 4.5",
-        hint: "Most capable, slower",
-      },
-      {
-        value: "openai/gpt-4o",
-        label: "GPT-4o",
-        hint: "Fast, good for most tasks",
-      },
-      {
-        value: "openai/gpt-4-turbo",
-        label: "GPT-4 Turbo",
-        hint: "Powerful, more expensive",
-      },
-      {
-        value: "google/gemini-2.0-flash",
-        label: "Gemini 2.0 Flash",
-        hint: "Fast and capable",
-      },
-      {
-        value: "google/gemini-1.5-pro",
-        label: "Gemini 1.5 Pro",
-        hint: "More capable",
-      },
-    ],
-    initialValue: "anthropic/claude-sonnet-4-5",
-  });
+    const selectedCoordinator = await p.select({
+      message: "Select coordinator model (for orchestration/planning):",
+      options: [
+        {
+          value: "anthropic/claude-opus-4-5",
+          label: "Claude Opus 4.5",
+          hint: "Most capable, best for complex orchestration (recommended)",
+        },
+        {
+          value: "anthropic/claude-sonnet-4-5",
+          label: "Claude Sonnet 4.5",
+          hint: "Good balance of speed and capability",
+        },
+        {
+          value: "anthropic/claude-haiku-4-5",
+          label: "Claude Haiku 4.5",
+          hint: "Fast and cost-effective",
+        },
+        {
+          value: "openai/gpt-4o",
+          label: "GPT-4o",
+          hint: "Fast, good for most tasks",
+        },
+        {
+          value: "openai/gpt-4-turbo",
+          label: "GPT-4 Turbo",
+          hint: "Powerful, more expensive",
+        },
+        {
+          value: "google/gemini-2.0-flash",
+          label: "Gemini 2.0 Flash",
+          hint: "Fast and capable",
+        },
+        {
+          value: "google/gemini-1.5-pro",
+          label: "Gemini 1.5 Pro",
+          hint: "More capable",
+        },
+      ],
+      initialValue: DEFAULT_COORDINATOR,
+    });
 
-  if (p.isCancel(coordinatorModel)) {
-    p.cancel("Setup cancelled");
-    process.exit(0);
-  }
+    if (p.isCancel(selectedCoordinator)) {
+      p.cancel("Setup cancelled");
+      process.exit(0);
+    }
+    coordinatorModel = selectedCoordinator;
 
-  const workerModel = await p.select({
-    message: "Select worker model (for task execution):",
-    options: [
-      {
-        value: "anthropic/claude-haiku-4-5",
-        label: "Claude Haiku 4.5",
-        hint: "Fast and cost-effective (recommended)",
-      },
-      {
-        value: "anthropic/claude-sonnet-4-5",
-        label: "Claude Sonnet 4.5",
-        hint: "Best balance of speed and capability",
-      },
-      {
-        value: "anthropic/claude-opus-4-5",
-        label: "Claude Opus 4.5",
-        hint: "Most capable, slower",
-      },
-      {
-        value: "openai/gpt-4o",
-        label: "GPT-4o",
-        hint: "Fast, good for most tasks",
-      },
-      {
-        value: "openai/gpt-4-turbo",
-        label: "GPT-4 Turbo",
-        hint: "Powerful, more expensive",
-      },
-      {
-        value: "google/gemini-2.0-flash",
-        label: "Gemini 2.0 Flash",
-        hint: "Fast and capable",
-      },
-      {
-        value: "google/gemini-1.5-pro",
-        label: "Gemini 1.5 Pro",
-        hint: "More capable",
-      },
-    ],
-    initialValue: "anthropic/claude-haiku-4-5",
-  });
+    const selectedWorker = await p.select({
+      message: "Select worker model (for task execution):",
+      options: [
+        {
+          value: "anthropic/claude-sonnet-4-5",
+          label: "Claude Sonnet 4.5",
+          hint: "Best balance of speed and capability (recommended)",
+        },
+        {
+          value: "anthropic/claude-haiku-4-5",
+          label: "Claude Haiku 4.5",
+          hint: "Fast and cost-effective",
+        },
+        {
+          value: "anthropic/claude-opus-4-5",
+          label: "Claude Opus 4.5",
+          hint: "Most capable, slower",
+        },
+        {
+          value: "openai/gpt-4o",
+          label: "GPT-4o",
+          hint: "Fast, good for most tasks",
+        },
+        {
+          value: "openai/gpt-4-turbo",
+          label: "GPT-4 Turbo",
+          hint: "Powerful, more expensive",
+        },
+        {
+          value: "google/gemini-2.0-flash",
+          label: "Gemini 2.0 Flash",
+          hint: "Fast and capable",
+        },
+        {
+          value: "google/gemini-1.5-pro",
+          label: "Gemini 1.5 Pro",
+          hint: "More capable",
+        },
+      ],
+      initialValue: DEFAULT_WORKER,
+    });
 
-  if (p.isCancel(workerModel)) {
-    p.cancel("Setup cancelled");
-    process.exit(0);
-  }
+    if (p.isCancel(selectedWorker)) {
+      p.cancel("Setup cancelled");
+      process.exit(0);
+    }
+    workerModel = selectedWorker;
 
-  // Lite model selection for simple tasks (docs, tests)
-  const liteModel = await p.select({
-    message: "Select lite model (for docs, tests, simple edits):",
-    options: [
-      {
-        value: "anthropic/claude-haiku-4-5",
-        label: "Claude Haiku 4.5",
-        hint: "Fast and cost-effective (recommended)",
-      },
-      {
-        value: "anthropic/claude-sonnet-4-5",
-        label: "Claude Sonnet 4.5",
-        hint: "More capable, slower",
-      },
-      {
-        value: "openai/gpt-4o-mini",
-        label: "GPT-4o Mini",
-        hint: "Fast and cheap",
-      },
-      {
-        value: "google/gemini-2.0-flash",
-        label: "Gemini 2.0 Flash",
-        hint: "Fast and capable",
-      },
-    ],
-    initialValue: "anthropic/claude-haiku-4-5",
-  });
+    // Lite model selection for simple tasks (docs, tests)
+    const selectedLite = await p.select({
+      message: "Select lite model (for docs, tests, simple edits):",
+      options: [
+        {
+          value: "anthropic/claude-haiku-4-5",
+          label: "Claude Haiku 4.5",
+          hint: "Fast and cost-effective (recommended)",
+        },
+        {
+          value: "anthropic/claude-sonnet-4-5",
+          label: "Claude Sonnet 4.5",
+          hint: "More capable, slower",
+        },
+        {
+          value: "openai/gpt-4o-mini",
+          label: "GPT-4o Mini",
+          hint: "Fast and cheap",
+        },
+        {
+          value: "google/gemini-2.0-flash",
+          label: "Gemini 2.0 Flash",
+          hint: "Fast and capable",
+        },
+      ],
+      initialValue: DEFAULT_LITE,
+    });
 
-  if (p.isCancel(liteModel)) {
-    p.cancel("Setup cancelled");
-    process.exit(0);
+    if (p.isCancel(selectedLite)) {
+      p.cancel("Setup cancelled");
+      process.exit(0);
+    }
+    liteModel = selectedLite;
   }
 
   p.log.success("Selected models:");
@@ -2249,7 +2272,8 @@ async function setup() {
 
   // Write plugin and command files
   p.log.step("Writing configuration files...");
-  stats[writeFileWithStatus(pluginPath, getPluginWrapper(), "Plugin")]++;
+  const pluginContent = getPluginWrapper().replace(/__SWARM_LITE_MODEL__/g, liteModel);
+  stats[writeFileWithStatus(pluginPath, pluginContent, "Plugin")]++;
   stats[writeFileWithStatus(commandPath, SWARM_COMMAND, "Command")]++;
 
   // Write nested agent files (swarm/planner.md, swarm/worker.md, swarm/researcher.md)
@@ -2288,21 +2312,8 @@ async function setup() {
     );
 
     if (missingBundled.length > 0 || managedBundled.length > 0) {
-      const shouldSync = await p.confirm({
-        message:
-          "Sync bundled skills into your global skills directory? " +
-          (missingBundled.length > 0
-            ? `(${missingBundled.length} missing)`
-            : "(update managed skills)"),
-        initialValue: isReinstall || missingBundled.length > 0,
-      });
-
-      if (p.isCancel(shouldSync)) {
-        p.cancel("Setup cancelled");
-        process.exit(0);
-      }
-
-      if (shouldSync) {
+      // Always sync bundled skills - no prompt needed
+      {
         const syncSpinner = p.spinner();
         syncSpinner.start("Syncing bundled skills...");
         try {
@@ -2339,15 +2350,10 @@ async function setup() {
     }
   }
 
-  // Offer to update AGENTS.md with skill awareness
+  // Always update AGENTS.md with skill awareness - no prompt needed
   const agentsPath = join(configDir, "AGENTS.md");
   if (existsSync(agentsPath)) {
-    const updateAgents = await p.confirm({
-      message: "Update AGENTS.md with skill awareness?",
-      initialValue: true,
-    });
-
-    if (!p.isCancel(updateAgents) && updateAgents) {
+    {
       const s = p.spinner();
       s.start("Updating AGENTS.md...");
 
@@ -2708,8 +2714,10 @@ async function help() {
   console.log(magenta("  " + getRandomMessage()));
   console.log(`
 ${cyan("Commands:")}
-  swarm setup     Interactive installer - checks and installs dependencies
-  swarm doctor    Health check - shows status of all dependencies
+  swarm setup           Interactive installer - checks and installs dependencies
+    --reinstall, -r     Skip prompt, go straight to reinstall
+    --yes, -y           Non-interactive with defaults (opus/sonnet/haiku)
+  swarm doctor          Health check - shows status of all dependencies
   swarm init      Initialize beads in current project
   swarm config    Show paths to generated config files
   swarm agents    Update AGENTS.md with skill awareness
@@ -3101,17 +3109,43 @@ interface LogLine {
   time: string;
   module: string;
   msg: string;
+  data?: Record<string, unknown>; // Extra structured data
 }
 
-function parseLogLine(line: string): LogLine | null {
+function parseLogLine(line: string, sourceFile?: string): LogLine | null {
   try {
     const parsed = JSON.parse(line);
-    if (typeof parsed.level === "number" && parsed.time && parsed.msg) {
+    if (parsed.time && parsed.msg) {
+      // Handle both pino format (level: number) and plugin wrapper format (level: string)
+      let level: number;
+      if (typeof parsed.level === "number") {
+        level = parsed.level;
+      } else if (typeof parsed.level === "string") {
+        level = levelNameToNumber(parsed.level);
+      } else {
+        level = 30; // default to info
+      }
+      
+      // Derive module from: explicit field, or source filename (e.g., "compaction.log" -> "compaction")
+      let module = parsed.module;
+      if (!module && sourceFile) {
+        // Extract module from filename: "compaction.log" -> "compaction", "swarm.1log" -> "swarm"
+        const match = sourceFile.match(/([^/]+?)(?:\.\d+)?\.?log$/);
+        if (match) {
+          module = match[1];
+        }
+      }
+      
+      // Extract extra data (everything except core fields)
+      const { level: _l, time: _t, module: _m, msg: _msg, ...extraData } = parsed;
+      const hasExtraData = Object.keys(extraData).length > 0;
+      
       return {
-        level: parsed.level,
+        level,
         time: parsed.time,
-        module: parsed.module || "unknown",
+        module: module || "unknown",
         msg: parsed.msg,
+        data: hasExtraData ? extraData : undefined,
       };
     }
   } catch {
@@ -3164,36 +3198,51 @@ function parseDuration(duration: string): number | null {
   return value * multipliers[unit];
 }
 
-function formatLogLine(log: LogLine, useColor = true): string {
+function formatLogLine(log: LogLine, useColor = true, verbose = false): string {
   const timestamp = new Date(log.time).toLocaleTimeString();
   const levelName = levelToName(log.level);
   const module = log.module.padEnd(12);
   const levelStr = useColor ? levelToColor(log.level)(levelName) : levelName;
   
-  return `${timestamp} ${levelStr} ${module} ${log.msg}`;
+  let output = `${timestamp} ${levelStr} ${module} ${log.msg}`;
+  
+  // In verbose mode, pretty print the structured data
+  if (verbose && log.data) {
+    output += `\n${dim(JSON.stringify(log.data, null, 2))}`;
+  }
+  
+  return output;
+}
+
+interface LogEntry {
+  line: string;
+  file: string;
 }
 
-function readLogFiles(dir: string): string[] {
+function readLogFiles(dir: string): LogEntry[] {
   if (!existsSync(dir)) return [];
   
   const allFiles = readdirSync(dir);
+  // Match both pino-roll format (*.1log, *.2log) AND plain *.log files
   const logFiles = allFiles
-    .filter((f: string) => /\.\d+log$/.test(f))
+    .filter((f: string) => /\.\d+log$/.test(f) || /\.log$/.test(f))
     .sort()
     .map((f: string) => join(dir, f));
   
-  const lines: string[] = [];
+  const entries: LogEntry[] = [];
   for (const file of logFiles) {
     try {
       const content = readFileSync(file, "utf-8");
       const fileLines = content.split("\n").filter((line: string) => line.trim());
-      lines.push(...fileLines);
+      for (const line of fileLines) {
+        entries.push({ line, file });
+      }
     } catch {
       // Skip unreadable files
     }
   }
   
-  return lines;
+  return entries;
 }
 
 async function logs() {
@@ -3207,6 +3256,7 @@ async function logs() {
   let limit = 50;
   let watchMode = false;
   let pollInterval = 1000; // 1 second default
+  let verbose = false;
   
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -3231,6 +3281,8 @@ async function logs() {
       }
     } else if (arg === "--watch" || arg === "-w") {
       watchMode = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      verbose = true;
     } else if (arg === "--interval" && i + 1 < args.length) {
       pollInterval = parseInt(args[++i], 10);
       if (isNaN(pollInterval) || pollInterval < 100) {
@@ -3290,7 +3342,7 @@ async function logs() {
     // Initialize positions from current file sizes
     const initializePositions = () => {
       if (!existsSync(logsDir)) return;
-      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f) || /\.log$/.test(f));
       for (const file of files) {
         const filePath = join(logsDir, file);
         try {
@@ -3327,14 +3379,14 @@ async function logs() {
     };
     
     // Print initial logs (last N lines)
-    const rawLines = readLogFiles(logsDir);
-    let logs: LogLine[] = rawLines
-      .map(parseLogLine)
+    const rawEntries = readLogFiles(logsDir);
+    let logs: LogLine[] = rawEntries
+      .map(entry => parseLogLine(entry.line, entry.file))
       .filter((log): log is LogLine => log !== null);
     logs = filterLogs(logs).slice(-limit);
     
     for (const log of logs) {
-      console.log(formatLogLine(log));
+      console.log(formatLogLine(log, true, verbose));
     }
     
     // Initialize positions after printing initial logs
@@ -3344,18 +3396,18 @@ async function logs() {
     const pollForNewLogs = () => {
       if (!existsSync(logsDir)) return;
       
-      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f) || /\.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);
+          const parsed = parseLogLine(line, filePath);
           if (parsed) {
             const filtered = filterLogs([parsed]);
             if (filtered.length > 0) {
-              console.log(formatLogLine(filtered[0]));
+              console.log(formatLogLine(filtered[0], true, verbose));
             }
           }
         }
@@ -3381,11 +3433,11 @@ async function logs() {
   }
   
   // Non-watch mode - one-shot output
-  const rawLines = readLogFiles(logsDir);
+  const rawEntries = readLogFiles(logsDir);
   
   // Parse and filter
-  let logs: LogLine[] = rawLines
-    .map(parseLogLine)
+  let logs: LogLine[] = rawEntries
+    .map(entry => parseLogLine(entry.line, entry.file))
     .filter((log): log is LogLine => log !== null);
   
   logs = filterLogs(logs);
@@ -3410,7 +3462,7 @@ async function logs() {
     console.log();
     
     for (const log of logs) {
-      console.log(formatLogLine(log));
+      console.log(formatLogLine(log, true, verbose));
     }
     console.log();
   }
@@ -3522,9 +3574,12 @@ async function db() {
 const command = process.argv[2];
 
 switch (command) {
-  case "setup":
-    await setup();
+  case "setup": {
+    const reinstallFlag = process.argv.includes("--reinstall") || process.argv.includes("-r");
+    const yesFlag = process.argv.includes("--yes") || process.argv.includes("-y");
+    await setup(reinstallFlag || yesFlag, yesFlag);
     break;
+  }
   case "doctor":
     await doctor();
     break;