opencode-swarm-plugin 0.28.2 → 0.30.0

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 $ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
-Bundled 200 modules in 35ms
+Bundled 200 modules in 34ms
 
   index.js  1.20 MB  (entry point)
 
-Bundled 201 modules in 32ms
+Bundled 201 modules in 44ms
 
   plugin.js  1.16 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,114 @@
 # opencode-swarm-plugin
 
+## 0.30.0
+
+### Minor Changes
+
+- [`f3917ad`](https://github.com/joelhooks/swarm-tools/commit/f3917ad911d3c716a2470a01c66bce3500f644f4) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 The Great bd CLI Purge
+
+  The `bd` CLI is officially dead. Long live HiveAdapter!
+
+  **What changed:**
+
+  ### `swarm init` Command Rewritten
+
+  - No longer shells out to `bd init` or `bd create`
+  - Uses `ensureHiveDirectory()` and `getHiveAdapter()` directly
+  - Supports `.beads` → `.hive` migration with user prompts
+  - Creates cells via HiveAdapter, not CLI
+
+  ### Auto-sync Removed from `index.ts`
+
+  - Removed `void $\`bd sync\`.quiet().nothrow()`after`hive_close`
+  - Users should call `hive_sync` explicitly at session end
+  - This was a fire-and-forget that could race with other operations
+
+  ### Plugin Template Updated
+
+  - `detectSwarm()` now has confidence levels (HIGH/MEDIUM/LOW/NONE)
+  - Added `SWARM_DETECTION_FALLBACK` for uncertain cases
+  - Compaction hook injects context based on confidence:
+    - HIGH/MEDIUM → Full swarm context
+    - LOW → Fallback detection prompt
+    - NONE → No injection
+
+  ### Error Handling Fixed
+
+  - `execTool()` now handles both string and object error formats
+  - Fixes "Tool execution failed" generic error from `swarm_complete`
+  - Actual error messages now propagate to the agent
+
+  **Why it matters:**
+
+  - No external CLI dependency for core functionality
+  - HiveAdapter is type-safe and testable
+  - Plugin works in environments without `bd` installed
+  - Better error messages for debugging
+
+  **Migration:** Run `swarm setup` to update your deployed plugin.
+
+## 0.29.0
+
+### Minor Changes
+
+- [`a2ff1f4`](https://github.com/joelhooks/swarm-tools/commit/a2ff1f4257a2e9857f63abe4e9b941a573f44380) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 Cell IDs Now Wear Their Project Colors
+
+  > _"We may fantasize about being International Men of Mystery, but our code needs to be mundane and clear. One of the most important parts of clear code is good names."_
+  > — Martin Fowler, _Refactoring_
+
+  Cell IDs finally know where they came from. Instead of anonymous `bd-xxx` prefixes,
+  new cells proudly display their project name: `swarm-mail-lf2p4u-abc123`.
+
+  ### What Changed
+
+  **swarm-mail:**
+
+  - `generateBeadId()` now reads `package.json` name field from project directory
+  - Added `slugifyProjectName()` for safe ID generation (lowercase, special chars → dashes)
+  - Falls back to `cell-` prefix if no package.json or no name field
+
+  **opencode-swarm-plugin:**
+
+  - Removed all `bd` CLI usage from `swarm-orchestrate.ts` - now uses HiveAdapter
+  - Improved compaction hook swarm detection with confidence levels (high/medium/low)
+  - Added fallback detection prompt for uncertain swarm states
+
+  ### Examples
+
+  | Before                  | After                           |
+  | ----------------------- | ------------------------------- |
+  | `bd-lf2p4u-mjbneh7mqah` | `swarm-mail-lf2p4u-mjbneh7mqah` |
+  | `bd-abc123-xyz`         | `my-cool-app-abc123-xyz`        |
+  | (no package.json)       | `cell-abc123-xyz`               |
+
+  ### Why It Matters
+
+  - **Identifiable at a glance** - Know which project a cell belongs to without looking it up
+  - **Multi-project workspaces** - Filter/search cells by project prefix
+  - **Terminology cleanup** - Removes legacy "bead" (`bd-`) from user-facing IDs
+
+  ### Backward Compatible
+
+  Existing `bd-*` IDs still work fine. No migration needed - only NEW cells get project prefixes.
+
+  ### Compaction: Keeping the Swarm Alive
+
+  > _"Intelligent and structured group dynamics that emerge not from a leader, but from the local interactions of the elements themselves."_
+  > — Daniel Shiffman, _The Nature of Code_
+
+  The compaction hook now uses multi-signal detection to keep swarms cooking through context compression:
+
+  - **HIGH confidence:** Active reservations, in_progress cells → full swarm context
+  - **MEDIUM confidence:** Open subtasks, unclosed epics → full swarm context
+  - **LOW confidence:** Any cells exist → fallback detection prompt
+
+  Philosophy: Err on the side of continuation. A false positive costs context space. A false negative loses the swarm.
+
+### Patch Changes
+
+- Updated dependencies [[`a2ff1f4`](https://github.com/joelhooks/swarm-tools/commit/a2ff1f4257a2e9857f63abe4e9b941a573f44380)]:
+  - swarm-mail@0.4.0
+
 ## 0.28.2
 
 ### Patch Changes

package/bin/swarm.test.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+/**
+ * Tests for swarm CLI file operation helpers
+ * 
+ * These tests verify the verbose output helpers used in `swarm setup`:
+ * - writeFileWithStatus: logs created/updated/unchanged status
+ * - mkdirWithStatus: logs directory creation
+ * - rmWithStatus: logs file removal
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+/**
+ * Mock logger for testing (matches @clack/prompts API)
+ */
+class MockLogger {
+  logs: Array<{ type: string; message: string }> = [];
+
+  success(msg: string) {
+    this.logs.push({ type: "success", message: msg });
+  }
+
+  message(msg: string) {
+    this.logs.push({ type: "message", message: msg });
+  }
+
+  reset() {
+    this.logs = [];
+  }
+}
+
+describe("File operation helpers", () => {
+  let testDir: string;
+  let logger: MockLogger;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `swarm-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    logger = new MockLogger();
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("writeFileWithStatus", () => {
+    // Helper that mimics the implementation
+    function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+      const exists = existsSync(path);
+      
+      if (exists) {
+        const current = readFileSync(path, "utf-8");
+        if (current === content) {
+          logger.message(`  ${label}: ${path} (unchanged)`);
+          return "unchanged";
+        }
+      }
+      
+      writeFileSync(path, content);
+      const status: FileStatus = exists ? "updated" : "created";
+      logger.success(`${label}: ${path} (${status})`);
+      return status;
+    }
+
+    test("returns 'created' for new file", () => {
+      const filePath = join(testDir, "new.txt");
+      const result = writeFileWithStatus(filePath, "content", "Test");
+      
+      expect(result).toBe("created");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(created)");
+      expect(existsSync(filePath)).toBe(true);
+    });
+
+    test("returns 'unchanged' if content is same", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "same content");
+      
+      const result = writeFileWithStatus(filePath, "same content", "Test");
+      
+      expect(result).toBe("unchanged");
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("(unchanged)");
+    });
+
+    test("returns 'updated' if content differs", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "old content");
+      
+      const result = writeFileWithStatus(filePath, "new content", "Test");
+      
+      expect(result).toBe("updated");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(updated)");
+      expect(readFileSync(filePath, "utf-8")).toBe("new content");
+    });
+  });
+
+  describe("mkdirWithStatus", () => {
+    function mkdirWithStatus(path: string): boolean {
+      if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+        logger.message(`  Created directory: ${path}`);
+        return true;
+      }
+      return false;
+    }
+
+    test("creates directory and logs when it doesn't exist", () => {
+      const dirPath = join(testDir, "newdir");
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(true);
+      expect(existsSync(dirPath)).toBe(true);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Created directory");
+    });
+
+    test("returns false when directory already exists", () => {
+      const dirPath = join(testDir, "existing");
+      mkdirSync(dirPath);
+      
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(false);
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+
+  describe("rmWithStatus", () => {
+    function rmWithStatus(path: string, label: string): void {
+      if (existsSync(path)) {
+        rmSync(path);
+        logger.message(`  Removed ${label}: ${path}`);
+      }
+    }
+
+    test("removes file and logs when it exists", () => {
+      const filePath = join(testDir, "todelete.txt");
+      writeFileSync(filePath, "content");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(existsSync(filePath)).toBe(false);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Removed test file");
+    });
+
+    test("does nothing when file doesn't exist", () => {
+      const filePath = join(testDir, "nonexistent.txt");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+});

package/bin/swarm.ts

@@ -32,6 +32,8 @@ import {
   migrateBeadsToHive,
   mergeHistoricBeads,
   importJsonlToPGLite,
+  ensureHiveDirectory,
+  getHiveAdapter,
 } from "../src/hive";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -71,6 +73,68 @@ const magenta = (s: string) => `\x1b[35m${s}\x1b[0m`;
 
 const PACKAGE_NAME = "opencode-swarm-plugin";
 
+// ============================================================================
+// File Operation Helpers
+// ============================================================================
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+interface FileStats {
+  created: number;
+  updated: number;
+  unchanged: number;
+}
+
+/**
+ * Write a file with status logging (created/updated/unchanged)
+ * @param path - File path to write
+ * @param content - Content to write
+ * @param label - Label for logging (e.g., "Plugin", "Command")
+ * @returns Status of the operation
+ */
+function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+  const exists = existsSync(path);
+  
+  if (exists) {
+    const current = readFileSync(path, "utf-8");
+    if (current === content) {
+      p.log.message(dim(`  ${label}: ${path} (unchanged)`));
+      return "unchanged";
+    }
+  }
+  
+  writeFileSync(path, content);
+  const status: FileStatus = exists ? "updated" : "created";
+  p.log.success(`${label}: ${path} (${status})`);
+  return status;
+}
+
+/**
+ * Create a directory with logging
+ * @param path - Directory path to create
+ * @returns true if created, false if already exists
+ */
+function mkdirWithStatus(path: string): boolean {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+    p.log.message(dim(`  Created directory: ${path}`));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Remove a file with logging
+ * @param path - File path to remove
+ * @param label - Label for logging
+ */
+function rmWithStatus(path: string, label: string): void {
+  if (existsSync(path)) {
+    rmSync(path);
+    p.log.message(dim(`  Removed ${label}: ${path}`));
+  }
+}
+
 // ============================================================================
 // Seasonal Messages (inspired by Astro's Houston)
 // ============================================================================
@@ -1707,39 +1771,29 @@ async function setup() {
 
   p.log.step("Setting up OpenCode integration...");
 
+  // Track file operation statistics
+  const stats: FileStats = { created: 0, updated: 0, unchanged: 0 };
+
   // Create directories if needed
   const skillsDir = join(configDir, "skills");
   for (const dir of [pluginDir, commandDir, agentDir, swarmAgentDir, skillsDir]) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
+    mkdirWithStatus(dir);
   }
 
-  writeFileSync(pluginPath, getPluginWrapper());
-  p.log.success("Plugin: " + pluginPath);
-
-  writeFileSync(commandPath, SWARM_COMMAND);
-  p.log.success("Command: " + commandPath);
+  // Write plugin and command files
+  stats[writeFileWithStatus(pluginPath, getPluginWrapper(), "Plugin")]++;
+  stats[writeFileWithStatus(commandPath, SWARM_COMMAND, "Command")]++;
 
   // Write nested agent files (swarm/planner.md, swarm/worker.md)
   // This is the format used by Task(subagent_type="swarm/worker")
-  writeFileSync(plannerAgentPath, getPlannerAgent(coordinatorModel as string));
-  p.log.success("Planner agent: " + plannerAgentPath);
-
-  writeFileSync(workerAgentPath, getWorkerAgent(workerModel as string));
-  p.log.success("Worker agent: " + workerAgentPath);
+  stats[writeFileWithStatus(plannerAgentPath, getPlannerAgent(coordinatorModel as string), "Planner agent")]++;
+  stats[writeFileWithStatus(workerAgentPath, getWorkerAgent(workerModel as string), "Worker agent")]++;
 
   // Clean up legacy flat agent files if they exist
-  if (existsSync(legacyPlannerPath)) {
-    rmSync(legacyPlannerPath);
-    p.log.message(dim("  Removed legacy: " + legacyPlannerPath));
-  }
-  if (existsSync(legacyWorkerPath)) {
-    rmSync(legacyWorkerPath);
-    p.log.message(dim("  Removed legacy: " + legacyWorkerPath));
-  }
+  rmWithStatus(legacyPlannerPath, "legacy planner");
+  rmWithStatus(legacyWorkerPath, "legacy worker");
 
-  p.log.success("Skills directory: " + skillsDir);
+  p.log.message(dim(`  Skills directory: ${skillsDir}`));
 
   // Show bundled skills info (and optionally sync to global skills dir)
   const bundledSkillsPath = join(__dirname, "..", "global-skills");
@@ -1850,17 +1904,29 @@ async function setup() {
     }
   }
 
+  // Show setup summary
+  const totalFiles = stats.created + stats.updated + stats.unchanged;
+  const summaryParts: string[] = [];
+  if (stats.created > 0) summaryParts.push(`${stats.created} created`);
+  if (stats.updated > 0) summaryParts.push(`${stats.updated} updated`);
+  if (stats.unchanged > 0) summaryParts.push(`${stats.unchanged} unchanged`);
+  
+  p.log.message("");
+  p.log.success(`Setup complete: ${totalFiles} files (${summaryParts.join(", ")})`);
+
   p.note(
-    'cd your-project\nbd init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
+    'cd your-project\nswarm init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
     "Next steps",
   );
 
-  p.outro("Setup complete! Run 'swarm doctor' to verify.");
+  p.outro("Run 'swarm doctor' to verify installation.");
 }
 
 async function init() {
   p.intro("swarm init v" + VERSION);
 
+  const projectPath = process.cwd();
+
   const gitDir = existsSync(".git");
   if (!gitDir) {
     p.log.error("Not in a git repository");
@@ -1869,12 +1935,15 @@ async function init() {
     process.exit(1);
   }
 
+  // Check for existing .hive or .beads directories
+  const hiveDir = existsSync(".hive");
   const beadsDir = existsSync(".beads");
-  if (beadsDir) {
-    p.log.warn("Beads already initialized in this project");
+  
+  if (hiveDir) {
+    p.log.warn("Hive already initialized in this project (.hive/ exists)");
 
     const reinit = await p.confirm({
-      message: "Re-initialize beads?",
+      message: "Continue anyway?",
       initialValue: false,
     });
 
@@ -1882,25 +1951,54 @@ async function init() {
       p.outro("Aborted");
       process.exit(0);
     }
+  } else if (beadsDir) {
+    // Offer migration from .beads to .hive
+    p.log.warn("Found legacy .beads/ directory");
+    
+    const migrate = await p.confirm({
+      message: "Migrate .beads/ to .hive/?",
+      initialValue: true,
+    });
+
+    if (!p.isCancel(migrate) && migrate) {
+      const s = p.spinner();
+      s.start("Migrating .beads/ to .hive/...");
+      
+      const result = await migrateBeadsToHive(projectPath);
+      
+      if (result.migrated) {
+        s.stop("Migration complete");
+        p.log.success("Renamed .beads/ to .hive/");
+        
+        // Merge historic beads if beads.base.jsonl exists
+        const mergeResult = await mergeHistoricBeads(projectPath);
+        if (mergeResult.merged > 0) {
+          p.log.success(`Merged ${mergeResult.merged} historic cells`);
+        }
+      } else {
+        s.stop("Migration skipped: " + result.reason);
+      }
+    }
   }
 
   const s = p.spinner();
-  s.start("Initializing beads...");
-
-  const success = await runInstall("bd init");
+  s.start("Initializing hive...");
 
-  if (success) {
-    s.stop("Beads initialized");
-    p.log.success("Created .beads/ directory");
+  try {
+    // Create .hive directory using our function (no bd CLI needed)
+    ensureHiveDirectory(projectPath);
+    
+    s.stop("Hive initialized");
+    p.log.success("Created .hive/ directory");
 
-    const createBead = await p.confirm({
-      message: "Create your first bead?",
+    const createCell = await p.confirm({
+      message: "Create your first cell?",
       initialValue: true,
     });
 
-    if (!p.isCancel(createBead) && createBead) {
+    if (!p.isCancel(createCell) && createCell) {
       const title = await p.text({
-        message: "Bead title:",
+        message: "Cell title:",
         placeholder: "Implement user authentication",
         validate: (v) => (v.length === 0 ? "Title required" : undefined),
       });
@@ -1917,17 +2015,22 @@ async function init() {
         });
 
         if (!p.isCancel(typeResult)) {
-          const beadSpinner = p.spinner();
-          beadSpinner.start("Creating bead...");
-
-          const createSuccess = await runInstall(
-            'bd create --title "' + title + '" --type ' + typeResult,
-          );
-
-          if (createSuccess) {
-            beadSpinner.stop("Bead created");
-          } else {
-            beadSpinner.stop("Failed to create bead");
+          const cellSpinner = p.spinner();
+          cellSpinner.start("Creating cell...");
+
+          try {
+            // Use HiveAdapter to create the cell (no bd CLI needed)
+            const adapter = await getHiveAdapter(projectPath);
+            const cell = await adapter.createCell(projectPath, {
+              title: title as string,
+              type: typeResult as "feature" | "bug" | "task" | "chore",
+              priority: 2,
+            });
+            
+            cellSpinner.stop("Cell created: " + cell.id);
+          } catch (error) {
+            cellSpinner.stop("Failed to create cell");
+            p.log.error(error instanceof Error ? error.message : String(error));
           }
         }
       }
@@ -1953,9 +2056,9 @@ async function init() {
     }
 
     p.outro("Project initialized! Use '/swarm' in OpenCode to get started.");
-  } else {
-    s.stop("Failed to initialize beads");
-    p.log.error("Make sure 'bd' is installed: swarm doctor");
+  } catch (error) {
+    s.stop("Failed to initialize hive");
+    p.log.error(error instanceof Error ? error.message : String(error));
     p.outro("Aborted");
     process.exit(1);
   }

package/dist/compaction-hook.d.ts

@@ -5,6 +5,12 @@
  * When context is compacted, this hook injects instructions for the summarizer
  * to preserve swarm coordination state and enable seamless resumption.
  *
+ * ## Philosophy: Err on the Side of Continuation
+ *
+ * It's better to inject swarm context unnecessarily than to lose an active swarm.
+ * The cost of a false positive (extra context) is low.
+ * The cost of a false negative (lost swarm) is high - wasted work, confused agents.
+ *
  * Hook signature (from @opencode-ai/plugin):
  * ```typescript
  * "experimental.session.compacting"?: (
@@ -33,11 +39,23 @@
  * autonomously after context compression.
  */
 export declare const SWARM_COMPACTION_CONTEXT = "## \uD83D\uDC1D SWARM ACTIVE - Keep Cooking\n\nYou are the **COORDINATOR** of an active swarm. Context was compacted but the swarm is still running.\n\n**YOUR JOB:** Keep orchestrating. Spawn agents. Monitor progress. Unblock work. Ship it.\n\n### Preserve in Summary\n\nExtract from session context:\n\n1. **Epic & Subtasks** - IDs, titles, status, file assignments\n2. **What's Running** - Which agents are active, what they're working on  \n3. **What's Blocked** - Blockers and what's needed to unblock\n4. **What's Done** - Completed work and any follow-ups needed\n5. **What's Next** - Pending subtasks ready to spawn\n\n### Summary Format\n\n```\n## \uD83D\uDC1D Swarm State\n\n**Epic:** <bd-xxx> - <title>\n**Project:** <path>\n**Progress:** X/Y subtasks complete\n\n**Active:**\n- <bd-xxx>: <title> [in_progress] \u2192 <agent> working on <files>\n\n**Blocked:**\n- <bd-xxx>: <title> - BLOCKED: <reason>\n\n**Completed:**\n- <bd-xxx>: <title> \u2713\n\n**Ready to Spawn:**\n- <bd-xxx>: <title> (files: <...>)\n```\n\n### On Resume - IMMEDIATELY\n\n1. `swarm_status(epic_id=\"<epic>\", project_key=\"<path>\")` - Get current state\n2. `swarmmail_inbox(limit=5)` - Check for agent messages\n3. **Spawn ready subtasks** - Don't wait, fire them off\n4. **Unblock blocked work** - Resolve dependencies, reassign if needed\n5. **Collect completed work** - Close done subtasks, verify quality\n\n### Keep the Swarm Cooking\n\n- **Spawn aggressively** - If a subtask is ready and unblocked, spawn an agent\n- **Monitor actively** - Check status, read messages, respond to blockers\n- **Close the loop** - When all subtasks done, verify and close the epic\n- **Don't stop** - The swarm runs until the epic is closed\n\n**You are not waiting for instructions. You are the coordinator. Coordinate.**\n";
+/**
+ * Fallback detection prompt - tells the compactor what to look for
+ *
+ * Used when we can't definitively detect a swarm but want to be safe.
+ * The compactor can check the conversation context for these patterns.
+ */
+export declare const SWARM_DETECTION_FALLBACK = "## \uD83D\uDC1D Swarm Detection - Check Your Context\n\n**IMPORTANT:** Before summarizing, check if this session involves an active swarm.\n\nLook for ANY of these patterns in the conversation:\n\n### Tool Calls (definite swarm sign)\n- `swarm_decompose`, `swarm_spawn_subtask`, `swarm_status`, `swarm_complete`\n- `swarmmail_init`, `swarmmail_reserve`, `swarmmail_send`\n- `hive_create_epic`, `hive_start`, `hive_close`\n\n### IDs and Names\n- Cell IDs: `bd-xxx`, `bd-xxx.N` (subtask format)\n- Agent names: BlueLake, RedMountain, GreenValley, etc.\n- Epic references: \"epic\", \"subtask\", \"parent\"\n\n### Coordination Language\n- \"spawn\", \"worker\", \"coordinator\"\n- \"reserve\", \"reservation\", \"files\"\n- \"blocked\", \"unblock\", \"dependency\"\n- \"progress\", \"complete\", \"in_progress\"\n\n### If You Find Swarm Evidence\n\nInclude this in your summary:\n1. Epic ID and title\n2. Project path\n3. Subtask status (running/blocked/done/pending)\n4. Any blockers or issues\n5. What should happen next\n\n**Then tell the resumed session:**\n\"This is an active swarm. Check swarm_status and swarmmail_inbox immediately.\"\n";
 /**
  * Create the compaction hook for use in plugin registration
  *
- * Only injects swarm context if there's an active swarm (in-progress beads).
- * This keeps the coordinator cooking after compaction.
+ * Injects swarm context based on detection confidence:
+ * - HIGH/MEDIUM: Full swarm context (definitely/probably a swarm)
+ * - LOW: Fallback detection prompt (let compactor check context)
+ * - NONE: No injection (probably not a swarm)
+ *
+ * Philosophy: Err on the side of continuation. A false positive costs
+ * a bit of context space. A false negative loses the swarm.
  *
  * @example
  * ```typescript

package/dist/compaction-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compaction-hook.d.ts","sourceRoot":"","sources":["../src/compaction-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,2wDAsDpC,CAAC;AAyCF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,KAEhC,QAAQ;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,KAC5B,OAAO,CAAC,IAAI,CAAC,CAMjB"}
+{"version":3,"file":"compaction-hook.d.ts","sourceRoot":"","sources":["../src/compaction-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AASH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,2wDAsDpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,0nCAiCpC,CAAC;AAoIF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,KAEhC,QAAQ;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,KAC5B,OAAO,CAAC,IAAI,CAAC,CAcjB"}

package/dist/index.d.ts.map

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