opencode-swarm-plugin 0.45.1 → 0.45.3

package/dist/swarm-prompts.js

@@ -17242,6 +17242,34 @@ import {
   sep as sep2
 } from "path";
 import { fileURLToPath } from "url";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL2, createEvent as createEvent2 } from "swarm-mail";
+async function emitSkillLoadedEvent(data) {
+  try {
+    const projectPath = skillsProjectDirectory;
+    const swarmMail = await getSwarmMailLibSQL2(projectPath);
+    const event = createEvent2("skill_loaded", {
+      project_key: projectPath,
+      skill_name: data.skill_name,
+      skill_source: data.skill_source,
+      context_provided: data.context_provided,
+      content_length: data.content_length
+    });
+    await swarmMail.appendEvent(event);
+  } catch {}
+}
+async function emitSkillCreatedEvent(data) {
+  try {
+    const projectPath = skillsProjectDirectory;
+    const swarmMail = await getSwarmMailLibSQL2(projectPath);
+    const event = createEvent2("skill_created", {
+      project_key: projectPath,
+      skill_name: data.skill_name,
+      skill_scope: data.skill_scope,
+      description: data.description
+    });
+    await swarmMail.appendEvent(event);
+  } catch {}
+}
 function setSkillsProjectDirectory(dir) {
   skillsProjectDirectory = dir;
   skillsCache = null;
@@ -17677,6 +17705,18 @@ If the skill has scripts, you can run them with skills_execute.`,
         const names = available.map((s) => s.name).join(", ");
         return `Skill '${args.name}' not found. Available skills: ${names || "none"}`;
       }
+      let skillSource = "project";
+      if (skill.path.includes(".config/opencode/skills") || skill.path.includes(".claude/skills")) {
+        skillSource = "global";
+      } else if (skill.path.includes("global-skills")) {
+        skillSource = "bundled";
+      }
+      await emitSkillLoadedEvent({
+        skill_name: skill.metadata.name,
+        skill_source: skillSource,
+        context_provided: true,
+        content_length: skill.body.length
+      });
       const includeScripts = args.include_scripts !== false;
       let output = `# Skill: ${skill.metadata.name}
 
@@ -17845,6 +17885,12 @@ Good skills have:
         const content = generateSkillContent(args.name, args.description, args.body, { tags: args.tags, tools: args.tools });
         await writeFile(skillPath, content, "utf-8");
         invalidateSkillsCache();
+        const skillScope = args.directory === "global" || args.directory === "global-claude" ? "global" : "project";
+        await emitSkillCreatedEvent({
+          skill_name: args.name,
+          skill_scope: skillScope,
+          description: args.description
+        });
         const response = {
           success: true,
           skill: args.name,
@@ -18080,6 +18126,12 @@ echo "Project directory: $1"
           createdFiles.push("references/guide.md");
         }
         invalidateSkillsCache();
+        const skillScope = args.directory === "global" ? "global" : "project";
+        await emitSkillCreatedEvent({
+          skill_name: args.name,
+          skill_scope: skillScope,
+          description: args.description || "[TODO: Complete description]"
+        });
         return JSON.stringify({
           success: true,
           skill: args.name,
@@ -20679,9 +20731,9 @@ import {
   releaseSwarmFiles,
   sendSwarmMessage as sendSwarmMessage2,
   getAgent,
-  createEvent as createEvent2,
+  createEvent as createEvent3,
   appendEvent as appendEvent2,
-  getSwarmMailLibSQL as getSwarmMailLibSQL2
+  getSwarmMailLibSQL as getSwarmMailLibSQL3
 } from "swarm-mail";
 
 // src/tool-availability.ts
@@ -21092,6 +21144,20 @@ var hive_create = tool({
         parent_id: validated.parent_id
       });
       await adapter.markDirty(projectKey, cell.id);
+      try {
+        const event = createEvent("cell_created", {
+          project_key: projectKey,
+          cell_id: cell.id,
+          title: validated.title,
+          description: validated.description,
+          issue_type: validated.type || "task",
+          priority: validated.priority ?? 2,
+          parent_id: validated.parent_id
+        });
+        await appendEvent(event, projectKey);
+      } catch (error45) {
+        console.warn("[hive_create] Failed to emit cell_created event:", error45);
+      }
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
@@ -21151,6 +21217,19 @@ var hive_create_epic = tool({
         subtasks: created.slice(1).map((c) => formatCellForOutput(c))
       };
       const effectiveProjectKey = args.project_key || projectKey;
+      try {
+        const epicCreatedEvent = createEvent("epic_created", {
+          project_key: effectiveProjectKey,
+          epic_id: epic.id,
+          title: validated.epic_title,
+          description: validated.epic_description,
+          subtask_count: validated.subtasks.length,
+          subtask_ids: created.slice(1).map((c) => c.id)
+        });
+        await appendEvent(epicCreatedEvent, effectiveProjectKey);
+      } catch (error45) {
+        console.warn("[hive_create_epic] Failed to emit epic_created event:", error45);
+      }
       try {
         const event = createEvent("decomposition_generated", {
           project_key: effectiveProjectKey,
@@ -21315,6 +21394,23 @@ var hive_update = tool({
         cell = existingCell;
       }
       await adapter.markDirty(projectKey, cellId);
+      try {
+        const fieldsChanged = [];
+        if (validated.status)
+          fieldsChanged.push("status");
+        if (validated.description !== undefined)
+          fieldsChanged.push("description");
+        if (validated.priority !== undefined)
+          fieldsChanged.push("priority");
+        const event = createEvent("cell_updated", {
+          project_key: projectKey,
+          cell_id: cellId,
+          fields_changed: fieldsChanged
+        });
+        await appendEvent(event, projectKey);
+      } catch (error45) {
+        console.warn("[hive_update] Failed to emit cell_updated event:", error45);
+      }
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
@@ -21431,6 +21527,16 @@ var hive_close = tool({
           console.warn("[hive_close] Failed to emit SwarmCompletedEvent:", error45);
         }
       }
+      try {
+        const event = createEvent("cell_closed", {
+          project_key: projectKey,
+          cell_id: cellId,
+          reason: validated.reason
+        });
+        await appendEvent(event, projectKey);
+      } catch (error45) {
+        console.warn("[hive_close] Failed to emit cell_closed event:", error45);
+      }
       return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
@@ -21456,6 +21562,17 @@ var hive_start = tool({
       const cellId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
       const cell = await adapter.changeCellStatus(projectKey, cellId, "in_progress");
       await adapter.markDirty(projectKey, cellId);
+      try {
+        const event = createEvent("cell_status_changed", {
+          project_key: projectKey,
+          cell_id: cellId,
+          old_status: "open",
+          new_status: "in_progress"
+        });
+        await appendEvent(event, projectKey);
+      } catch (error45) {
+        console.warn("[hive_start] Failed to emit cell_status_changed event:", error45);
+      }
       return `Started: ${cell.id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
@@ -21644,11 +21761,25 @@ var hive_sync = tool({
     }
     const remoteCheckResult = await runGitCommand(["remote"]);
     const hasRemote = remoteCheckResult.stdout.trim() !== "";
+    let pushSuccess = false;
     if (hasRemote) {
       const pushResult = await withTimeout(runGitCommand(["push"]), TIMEOUT_MS, "git push");
       if (pushResult.exitCode !== 0) {
         throw new HiveError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
       }
+      pushSuccess = true;
+    }
+    try {
+      const event = createEvent("hive_synced", {
+        project_key: projectKey,
+        cells_synced: flushResult.cellsExported,
+        push_success: pushSuccess
+      });
+      await appendEvent(event, projectKey);
+    } catch (error45) {
+      console.warn("[hive_sync] Failed to emit hive_synced event:", error45);
+    }
+    if (hasRemote) {
       return "Hive synced and pushed successfully";
     } else {
       return "Hive synced successfully (no remote configured)";
@@ -22340,9 +22471,9 @@ var swarm_review = tool({
       downstream_tasks: downstreamTasks.length > 0 ? downstreamTasks : undefined
     });
     try {
-      const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
+      const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
       const attempt = getReviewStatus(args.task_id).attempt_count || 1;
-      const reviewStartedEvent = createEvent2("review_started", {
+      const reviewStartedEvent = createEvent3("review_started", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: args.task_id,
@@ -22431,9 +22562,9 @@ var swarm_review_feedback = tool({
         console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
       }
       try {
-        const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
+        const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
         const attempt = getReviewStatus(args.task_id).attempt_count || 1;
-        const reviewCompletedEvent = createEvent2("review_completed", {
+        const reviewCompletedEvent = createEvent3("review_completed", {
           project_key: args.project_key,
           epic_id: epicId,
           bead_id: args.task_id,
@@ -22502,9 +22633,9 @@ You may now complete the task with \`swarm_complete\`.`,
       console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
     }
     try {
-      const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
+      const { createEvent: createEvent3, appendEvent: appendEvent2 } = await import("swarm-mail");
       const status = remaining <= 0 ? "blocked" : "needs_changes";
-      const reviewCompletedEvent = createEvent2("review_completed", {
+      const reviewCompletedEvent = createEvent3("review_completed", {
         project_key: args.project_key,
         epic_id: epicId,
         bead_id: args.task_id,
@@ -23056,7 +23187,7 @@ var swarm_progress = tool({
             }
           };
           const checkpointData = JSON.stringify(checkpoint);
-          const checkpointEvent = createEvent2("swarm_checkpointed", {
+          const checkpointEvent = createEvent3("swarm_checkpointed", {
             project_key: args.project_key,
             ...checkpoint,
             checkpoint_size_bytes: Buffer.byteLength(checkpointData, "utf8"),
@@ -23064,7 +23195,7 @@ var swarm_progress = tool({
           });
           await appendEvent2(checkpointEvent, args.project_key);
           const checkpointId = `ckpt-${Date.now()}-${args.bead_id}`;
-          const createdEvent = createEvent2("checkpoint_created", {
+          const createdEvent = createEvent3("checkpoint_created", {
             project_key: args.project_key,
             epic_id: epicId,
             bead_id: args.bead_id,
@@ -23317,7 +23448,7 @@ This will be recorded as a negative learning signal.`;
       let deferredResolved = false;
       let deferredError;
       try {
-        const swarmMail = await getSwarmMailLibSQL2(args.project_key);
+        const swarmMail = await getSwarmMailLibSQL3(args.project_key);
         const db = await swarmMail.getDatabase();
         const deferredUrl = `deferred:${args.bead_id}`;
         const checkResult = await db.query(`SELECT url, resolved FROM deferred WHERE url = ? AND resolved = 0`, [deferredUrl]);
@@ -23346,16 +23477,16 @@ This will be recorded as a negative learning signal.`;
         syncError = error45 instanceof Error ? error45.message : String(error45);
         console.warn(`[swarm_complete] Auto-sync failed (non-fatal): ${syncError}`);
       }
+      const completionDurationMs = args.start_time ? Date.now() - args.start_time : 0;
+      const eventEpicId = cell.parent_id || (args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id);
       try {
-        const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
-        const eventEpicId = cell.parent_id || (args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id);
-        const event = createEvent2("subtask_outcome", {
+        const event = createEvent3("subtask_outcome", {
           project_key: args.project_key,
           epic_id: eventEpicId,
           bead_id: args.bead_id,
           planned_files: args.planned_files || [],
           actual_files: args.files_touched || [],
-          duration_ms: durationMs2,
+          duration_ms: completionDurationMs,
           error_count: args.error_count || 0,
           retry_count: args.retry_count || 0,
           success: true,
@@ -23366,8 +23497,21 @@ This will be recorded as a negative learning signal.`;
       } catch (error45) {
         console.warn("[swarm_complete] Failed to emit SubtaskOutcomeEvent:", error45);
       }
+      try {
+        const workerCompletedEvent = createEvent3("worker_completed", {
+          project_key: args.project_key,
+          epic_id: eventEpicId,
+          bead_id: args.bead_id,
+          worker_agent: args.agent_name,
+          success: true,
+          duration_ms: completionDurationMs,
+          files_touched: args.files_touched || []
+        });
+        await appendEvent2(workerCompletedEvent, args.project_key);
+      } catch (error45) {
+        console.warn("[swarm_complete] Failed to emit worker_completed event:", error45);
+      }
       let capturedStrategy;
-      const durationMs = args.start_time ? Date.now() - args.start_time : 0;
       const memoryInfo = formatMemoryStoreOnSuccess(args.bead_id, args.summary, args.files_touched || [], capturedStrategy);
       let memoryStored = false;
       let memoryError;
@@ -23484,7 +23628,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
       };
       try {
         const { captureSubtaskOutcome: captureSubtaskOutcome2 } = await Promise.resolve().then(() => (init_eval_capture(), exports_eval_capture));
-        const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
         const evalEpicId = cell.parent_id || epicId2;
         captureSubtaskOutcome2({
           epicId: evalEpicId,
@@ -23493,7 +23637,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
           title: cell.title,
           plannedFiles: args.planned_files || [],
           actualFiles: args.files_touched || [],
-          durationMs: durationMs2,
+          durationMs,
           errorCount: args.error_count || 0,
           retryCount: args.retry_count || 0,
           success: true
@@ -23502,7 +23646,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
         console.warn("[swarm_complete] Failed to capture subtask outcome:", error45);
       }
       try {
-        const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
         captureCoordinatorEvent({
           session_id: _ctx.sessionID || "unknown",
           epic_id: epicId2,
@@ -23511,7 +23655,7 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
           outcome_type: "subtask_success",
           payload: {
             bead_id: args.bead_id,
-            duration_ms: durationMs2,
+            duration_ms: durationMs,
             files_touched: args.files_touched || [],
             verification_passed: verificationResult?.passed ?? false,
             verification_skipped: args.skip_verification ?? false
@@ -23985,7 +24129,7 @@ var swarm_checkpoint = tool({
         }
       };
       const checkpointData = JSON.stringify(checkpoint);
-      const event = createEvent2("swarm_checkpointed", {
+      const event = createEvent3("swarm_checkpointed", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: args.bead_id,
@@ -24027,8 +24171,8 @@ var swarm_recover = tool({
   },
   async execute(args) {
     try {
-      const { getSwarmMailLibSQL: getSwarmMailLibSQL3 } = await import("swarm-mail");
-      const swarmMail = await getSwarmMailLibSQL3(args.project_key);
+      const { getSwarmMailLibSQL: getSwarmMailLibSQL4 } = await import("swarm-mail");
+      const swarmMail = await getSwarmMailLibSQL4(args.project_key);
       const db = await swarmMail.getDatabase();
       const result = await db.query(`SELECT * FROM swarm_contexts 
          WHERE epic_id = $1 
@@ -24055,7 +24199,7 @@ var swarm_recover = tool({
         created_at: row.created_at,
         updated_at: row.updated_at
       };
-      const event = createEvent2("swarm_recovered", {
+      const event = createEvent3("swarm_recovered", {
         project_key: args.project_key,
         epic_id: args.epic_id,
         bead_id: context.bead_id,
@@ -24214,7 +24358,7 @@ init_eval_capture();
 
 // src/memory-tools.ts
 init_dist();
-import { getSwarmMailLibSQL as getSwarmMailLibSQL3 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL4, createEvent as createEvent4, appendEvent as appendEvent3 } from "swarm-mail";
 
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -37831,7 +37975,7 @@ async function getMemoryAdapter(projectPath) {
   if (cachedAdapter && cachedProjectPath === path3) {
     return cachedAdapter;
   }
-  const swarmMail = await getSwarmMailLibSQL3(path3);
+  const swarmMail = await getSwarmMailLibSQL4(path3);
   const dbAdapter = await swarmMail.getDatabase();
   cachedAdapter = await createMemoryAdapter(dbAdapter);
   cachedProjectPath = path3;
@@ -37852,6 +37996,21 @@ var semantic_memory_store = tool({
   async execute(args2, ctx) {
     const adapter = await getMemoryAdapter();
     const result = await adapter.store(args2);
+    try {
+      const projectKey = cachedProjectPath || process.cwd();
+      const tags = args2.tags ? args2.tags.split(",").map((t) => t.trim()) : [];
+      const event = createEvent4("memory_stored", {
+        project_key: projectKey,
+        memory_id: result.id,
+        content_preview: args2.information.slice(0, 100),
+        tags,
+        auto_tagged: args2.autoTag,
+        collection: args2.collection
+      });
+      await appendEvent3(event, projectKey);
+    } catch (error45) {
+      console.warn("[semantic_memory_store] Failed to emit memory_stored event:", error45);
+    }
     return JSON.stringify(result, null, 2);
   }
 });
@@ -37865,8 +38024,25 @@ var semantic_memory_find = tool({
     fts: tool.schema.boolean().optional().describe("Use full-text search instead of vector search (default: false)")
   },
   async execute(args2, ctx) {
+    const startTime = Date.now();
     const adapter = await getMemoryAdapter();
     const result = await adapter.find(args2);
+    const duration3 = Date.now() - startTime;
+    try {
+      const projectKey = cachedProjectPath || process.cwd();
+      const topScore = result.results.length > 0 ? result.results[0].score : undefined;
+      const event = createEvent4("memory_found", {
+        project_key: projectKey,
+        query: args2.query,
+        result_count: result.results.length,
+        top_score: topScore,
+        search_duration_ms: duration3,
+        used_fts: args2.fts
+      });
+      await appendEvent3(event, projectKey);
+    } catch (error45) {
+      console.warn("[semantic_memory_find] Failed to emit memory_found event:", error45);
+    }
     return JSON.stringify(result, null, 2);
   }
 });
@@ -37889,6 +38065,18 @@ var semantic_memory_remove = tool({
   async execute(args2, ctx) {
     const adapter = await getMemoryAdapter();
     const result = await adapter.remove(args2);
+    if (result.success) {
+      try {
+        const projectKey = cachedProjectPath || process.cwd();
+        const event = createEvent4("memory_deleted", {
+          project_key: projectKey,
+          memory_id: args2.id
+        });
+        await appendEvent3(event, projectKey);
+      } catch (error45) {
+        console.warn("[semantic_memory_remove] Failed to emit memory_deleted event:", error45);
+      }
+    }
     return JSON.stringify(result, null, 2);
   }
 });
@@ -37900,6 +38088,19 @@ var semantic_memory_validate = tool({
   async execute(args2, ctx) {
     const adapter = await getMemoryAdapter();
     const result = await adapter.validate(args2);
+    if (result.success) {
+      try {
+        const projectKey = cachedProjectPath || process.cwd();
+        const event = createEvent4("memory_validated", {
+          project_key: projectKey,
+          memory_id: args2.id,
+          decay_reset: true
+        });
+        await appendEvent3(event, projectKey);
+      } catch (error45) {
+        console.warn("[semantic_memory_validate] Failed to emit memory_validated event:", error45);
+      }
+    }
     return JSON.stringify(result, null, 2);
   }
 });
@@ -37947,6 +38148,18 @@ var semantic_memory_upsert = tool({
   async execute(args2, ctx) {
     const adapter = await getMemoryAdapter();
     const result = await adapter.upsert(args2);
+    try {
+      const projectKey = cachedProjectPath || process.cwd();
+      const event = createEvent4("memory_updated", {
+        project_key: projectKey,
+        memory_id: result.memoryId || "unknown",
+        operation: result.operation,
+        reason: result.reason
+      });
+      await appendEvent3(event, projectKey);
+    } catch (error45) {
+      console.warn("[semantic_memory_upsert] Failed to emit memory_updated event:", error45);
+    }
     return JSON.stringify(result, null, 2);
   }
 });
@@ -39281,9 +39494,9 @@ var swarm_spawn_subtask = tool({
     }
     if (args2.project_path) {
       try {
-        const { createEvent: createEvent3, appendEvent: appendEvent3 } = await import("swarm-mail");
+        const { createEvent: createEvent5, appendEvent: appendEvent4 } = await import("swarm-mail");
         const spawnOrder = 0;
-        const workerSpawnedEvent = createEvent3("worker_spawned", {
+        const workerSpawnedEvent = createEvent5("worker_spawned", {
           project_key: args2.project_path,
           epic_id: args2.epic_id,
           bead_id: args2.bead_id,
@@ -39293,7 +39506,7 @@ var swarm_spawn_subtask = tool({
           spawn_order: spawnOrder,
           is_parallel: false
         });
-        await appendEvent3(workerSpawnedEvent, args2.project_path);
+        await appendEvent4(workerSpawnedEvent, args2.project_path);
       } catch (error45) {
         console.warn("[swarm_spawn_subtask] Failed to emit WorkerSpawnedEvent:", error45);
       }

package/examples/plugin-wrapper-template.ts

@@ -2344,6 +2344,97 @@ Extract from session context:
 **You are not waiting for instructions. You are the coordinator. Coordinate.**
 `;
 
+/**
+ * Build dynamic swarm state section from snapshot
+ * 
+ * This creates a concrete state summary with actual IDs and status
+ * to prepend to the static compaction context.
+ */
+function buildDynamicStateFromSnapshot(snapshot: SwarmStateSnapshot): string {
+  if (!snapshot.epic) {
+    return "";
+  }
+
+  const parts: string[] = [];
+  
+  // Header with epic info
+  parts.push(`## 🐝 Current Swarm State\n`);
+  parts.push(`**Epic:** ${snapshot.epic.id} - ${snapshot.epic.title}`);
+  parts.push(`**Status:** ${snapshot.epic.status}`);
+  parts.push(`**Project:** ${projectDirectory}\n`);
+  
+  // Subtask breakdown
+  const subtasks = snapshot.epic.subtasks || [];
+  const completed = subtasks.filter(s => s.status === "closed");
+  const inProgress = subtasks.filter(s => s.status === "in_progress");
+  const blocked = subtasks.filter(s => s.status === "blocked");
+  const pending = subtasks.filter(s => s.status === "open");
+  
+  parts.push(`**Progress:** ${completed.length}/${subtasks.length} subtasks complete\n`);
+  
+  // Immediate actions with real IDs
+  parts.push(`## 1️⃣ IMMEDIATE ACTIONS (Do These FIRST)\n`);
+  parts.push(`1. \`swarm_status(epic_id="${snapshot.epic.id}", project_key="${projectDirectory}")\` - Get current state`);
+  parts.push(`2. \`swarmmail_inbox(limit=5)\` - Check for worker messages`);
+  
+  if (inProgress.length > 0) {
+    parts.push(`3. Review in-progress work when workers complete`);
+  }
+  if (pending.length > 0) {
+    const next = pending[0];
+    parts.push(`4. Spawn next subtask: \`swarm_spawn_subtask(bead_id="${next.id}", ...)\``);
+  }
+  if (blocked.length > 0) {
+    parts.push(`5. Unblock: ${blocked.map(s => s.id).join(", ")}`);
+  }
+  parts.push("");
+  
+  // Detailed subtask status
+  if (inProgress.length > 0) {
+    parts.push(`### 🚧 In Progress (${inProgress.length})`);
+    for (const s of inProgress) {
+      const files = s.files?.length ? ` (${s.files.slice(0, 3).join(", ")}${s.files.length > 3 ? "..." : ""})` : "";
+      parts.push(`- ${s.id}: ${s.title}${files}`);
+    }
+    parts.push("");
+  }
+  
+  if (blocked.length > 0) {
+    parts.push(`### 🚫 Blocked (${blocked.length})`);
+    for (const s of blocked) {
+      parts.push(`- ${s.id}: ${s.title}`);
+    }
+    parts.push("");
+  }
+  
+  if (pending.length > 0) {
+    parts.push(`### ⏳ Ready to Spawn (${pending.length})`);
+    for (const s of pending.slice(0, 5)) { // Show first 5
+      const files = s.files?.length ? ` (${s.files.slice(0, 2).join(", ")}${s.files.length > 2 ? "..." : ""})` : "";
+      parts.push(`- ${s.id}: ${s.title}${files}`);
+    }
+    if (pending.length > 5) {
+      parts.push(`- ... and ${pending.length - 5} more`);
+    }
+    parts.push("");
+  }
+  
+  if (completed.length > 0) {
+    parts.push(`### ✅ Completed (${completed.length})`);
+    for (const s of completed.slice(-3)) { // Show last 3
+      parts.push(`- ${s.id}: ${s.title} ✓`);
+    }
+    if (completed.length > 3) {
+      parts.push(`- ... and ${completed.length - 3} more`);
+    }
+    parts.push("");
+  }
+  
+  parts.push("---\n");
+  
+  return parts.join("\n");
+}
+
 /**
  * Fallback detection prompt - tells the compactor what to look for
  * 
@@ -2610,6 +2701,9 @@ const SwarmPlugin: Plugin = async (
           has_projection: !!sessionScan.projection?.isSwarm,
         });
 
+        // Hoist snapshot outside try block so it's available in fallback path
+        let snapshot: SwarmStateSnapshot | undefined;
+        
         try {
           // =======================================================================
           // PREFER PROJECTION (ground truth from events) OVER HIVE QUERY
@@ -2617,8 +2711,6 @@ const SwarmPlugin: Plugin = async (
           // The projection is derived from session events - it's the source of truth.
           // Hive query may show all cells closed even if swarm was active.
           
-          let snapshot: SwarmStateSnapshot;
-          
           if (sessionScan.projection?.isSwarm) {
             // Use projection as primary source - convert to snapshot format
             const proj = sessionScan.projection;
@@ -2801,9 +2893,12 @@ const SwarmPlugin: Plugin = async (
           });
         }
 
-        // Level 3: Fall back to static context
+        // Level 3: Fall back to static context WITH dynamic state from snapshot
         const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
-        const staticContent = header + SWARM_COMPACTION_CONTEXT;
+        
+        // Build dynamic state section if we have snapshot data
+        const dynamicState = snapshot ? buildDynamicStateFromSnapshot(snapshot) : "";
+        const staticContent = header + dynamicState + SWARM_COMPACTION_CONTEXT;
         output.context.push(staticContent);
 
         // =======================================================================
@@ -2811,13 +2906,16 @@ const SwarmPlugin: Plugin = async (
         // =======================================================================
         await captureCompaction(
           input.sessionID,
-          "unknown", // No snapshot available in this path
+          snapshot?.epic?.id || "unknown",
           "context_injected",
           {
             full_content: staticContent,
             content_length: staticContent.length,
             injection_method: "output.context.push",
-            context_type: "static_swarm_context",
+            context_type: "static_with_dynamic_state",
+            has_dynamic_state: !!dynamicState,
+            epic_id: snapshot?.epic?.id,
+            subtask_count: snapshot?.epic?.subtasks?.length ?? 0,
           },
         );
 
@@ -2826,9 +2924,12 @@ const SwarmPlugin: Plugin = async (
           session_id: input.sessionID,
           total_duration_ms: totalDuration,
           confidence: detection.confidence,
-          context_type: "static_swarm_context",
+          context_type: dynamicState ? "static_with_dynamic_state" : "static_swarm_context",
           content_length: staticContent.length,
           context_count_after: output.context.length,
+          has_dynamic_state: !!dynamicState,
+          epic_id: snapshot?.epic?.id,
+          subtask_count: snapshot?.epic?.subtasks?.length ?? 0,
         });
       } else if (detection.confidence === "low") {
         // Level 4: Possible swarm - inject fallback detection prompt