opencode-swarm-plugin 0.35.0 → 0.36.1

package/examples/plugin-wrapper-template.ts

@@ -14,15 +14,65 @@
  * - SWARM_PROJECT_DIR: Project directory (critical for database path)
  */
 import type { Plugin, PluginInput, Hooks } from "@opencode-ai/plugin";
+import type { ToolPart } from "@opencode-ai/sdk";
 import { tool } from "@opencode-ai/plugin";
 import { spawn } from "child_process";
+import { appendFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 
 const SWARM_CLI = "swarm";
 
+// =============================================================================
+// File-based Logging (writes to ~/.config/swarm-tools/logs/)
+// =============================================================================
+
+const LOG_DIR = join(homedir(), ".config", "swarm-tools", "logs");
+const COMPACTION_LOG = join(LOG_DIR, "compaction.log");
+
+/**
+ * Ensure log directory exists
+ */
+function ensureLogDir(): void {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Log a compaction event to file (JSON lines format, compatible with `swarm log`)
+ * 
+ * @param level - Log level (info, debug, warn, error)
+ * @param msg - Log message
+ * @param data - Additional structured data
+ */
+function logCompaction(
+  level: "info" | "debug" | "warn" | "error",
+  msg: string,
+  data?: Record<string, unknown>,
+): void {
+  try {
+    ensureLogDir();
+    const entry = JSON.stringify({
+      time: new Date().toISOString(),
+      level,
+      msg,
+      ...data,
+    });
+    appendFileSync(COMPACTION_LOG, entry + "\n");
+  } catch {
+    // Silently fail - logging should never break the plugin
+  }
+}
+
 // Module-level project directory - set during plugin initialization
 // This is CRITICAL: without it, the CLI uses process.cwd() which may be wrong
 let projectDirectory: string = process.cwd();
 
+// Module-level SDK client - set during plugin initialization
+// Used for scanning session messages during compaction
+let sdkClient: any = null;
+
 // =============================================================================
 // CLI Execution Helper
 // =============================================================================
@@ -952,26 +1002,71 @@ interface SwarmStateSnapshot {
  * Shells out to swarm CLI to get real data.
  */
 async function querySwarmState(sessionID: string): Promise<SwarmStateSnapshot> {
+  const startTime = Date.now();
+  
+  logCompaction("debug", "query_swarm_state_start", {
+    session_id: sessionID,
+    project_directory: projectDirectory,
+  });
+
   try {
     // Query cells via swarm CLI
-    const cellsResult = await new Promise<{ exitCode: number; stdout: string }>(
+    const cliStart = Date.now();
+    const cellsResult = await new Promise<{ exitCode: number; stdout: string; stderr: string }>(
       (resolve) => {
         const proc = spawn(SWARM_CLI, ["tool", "hive_query"], {
           cwd: projectDirectory,
           stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
+        let stderr = "";
         proc.stdout.on("data", (d) => {
           stdout += d;
         });
+        proc.stderr.on("data", (d) => {
+          stderr += d;
+        });
         proc.on("close", (exitCode) =>
-          resolve({ exitCode: exitCode ?? 1, stdout }),
+          resolve({ exitCode: exitCode ?? 1, stdout, stderr }),
         );
       },
     );
+    const cliDuration = Date.now() - cliStart;
+
+    logCompaction("debug", "query_swarm_state_cli_complete", {
+      session_id: sessionID,
+      duration_ms: cliDuration,
+      exit_code: cellsResult.exitCode,
+      stdout_length: cellsResult.stdout.length,
+      stderr_length: cellsResult.stderr.length,
+    });
 
-    const cells =
-      cellsResult.exitCode === 0 ? JSON.parse(cellsResult.stdout) : [];
+    let cells: any[] = [];
+    if (cellsResult.exitCode === 0) {
+      try {
+        const parsed = JSON.parse(cellsResult.stdout);
+        // Handle wrapped response: { success: true, data: [...] }
+        cells = Array.isArray(parsed) ? parsed : (parsed?.data ?? []);
+      } catch (parseErr) {
+        logCompaction("error", "query_swarm_state_parse_failed", {
+          session_id: sessionID,
+          error: parseErr instanceof Error ? parseErr.message : String(parseErr),
+          stdout_preview: cellsResult.stdout.substring(0, 500),
+        });
+      }
+    }
+
+    logCompaction("debug", "query_swarm_state_cells_parsed", {
+      session_id: sessionID,
+      cell_count: cells.length,
+      cells: cells.map((c: any) => ({
+        id: c.id,
+        title: c.title,
+        type: c.type,
+        status: c.status,
+        parent_id: c.parent_id,
+      })),
+    });
 
     // Find active epic (first unclosed epic with subtasks)
     const openEpics = cells.filter(
@@ -980,6 +1075,12 @@ async function querySwarmState(sessionID: string): Promise<SwarmStateSnapshot> {
     );
     const epic = openEpics[0];
 
+    logCompaction("debug", "query_swarm_state_epics", {
+      session_id: sessionID,
+      open_epic_count: openEpics.length,
+      selected_epic: epic ? { id: epic.id, title: epic.title, status: epic.status } : null,
+    });
+
     // Get subtasks if we have an epic
     const subtasks =
       epic && epic.id
@@ -988,15 +1089,26 @@ async function querySwarmState(sessionID: string): Promise<SwarmStateSnapshot> {
           )
         : [];
 
+    logCompaction("debug", "query_swarm_state_subtasks", {
+      session_id: sessionID,
+      subtask_count: subtasks.length,
+      subtasks: subtasks.map((s: any) => ({
+        id: s.id,
+        title: s.title,
+        status: s.status,
+        files: s.files,
+      })),
+    });
+
     // TODO: Query swarm mail for messages and reservations
     // For MVP, use empty arrays - the fallback chain handles this
     const messages: SwarmStateSnapshot["messages"] = [];
     const reservations: SwarmStateSnapshot["reservations"] = [];
 
-    // Run detection for confidence
+    // Run detection for confidence (already logged internally)
     const detection = await detectSwarm();
 
-    return {
+    const snapshot: SwarmStateSnapshot = {
       sessionID,
       detection: {
         confidence: detection.confidence,
@@ -1023,7 +1135,27 @@ async function querySwarmState(sessionID: string): Promise<SwarmStateSnapshot> {
       messages,
       reservations,
     };
+
+    const totalDuration = Date.now() - startTime;
+    logCompaction("debug", "query_swarm_state_complete", {
+      session_id: sessionID,
+      duration_ms: totalDuration,
+      has_epic: !!snapshot.epic,
+      epic_id: snapshot.epic?.id,
+      subtask_count: snapshot.epic?.subtasks?.length ?? 0,
+      message_count: snapshot.messages.length,
+      reservation_count: snapshot.reservations.length,
+    });
+
+    return snapshot;
   } catch (err) {
+    logCompaction("error", "query_swarm_state_exception", {
+      session_id: sessionID,
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : undefined,
+      duration_ms: Date.now() - startTime,
+    });
+
     // If query fails, return minimal snapshot
     const detection = await detectSwarm();
     return {
@@ -1049,10 +1181,19 @@ async function querySwarmState(sessionID: string): Promise<SwarmStateSnapshot> {
 async function generateCompactionPrompt(
   snapshot: SwarmStateSnapshot,
 ): Promise<string | null> {
-  try {
-    const liteModel =
-      process.env.OPENCODE_LITE_MODEL || "claude-3-5-haiku-20241022";
+  const startTime = Date.now();
+  const liteModel = process.env.OPENCODE_LITE_MODEL || "__SWARM_LITE_MODEL__";
+
+  logCompaction("debug", "generate_compaction_prompt_start", {
+    session_id: snapshot.sessionID,
+    lite_model: liteModel,
+    has_epic: !!snapshot.epic,
+    epic_id: snapshot.epic?.id,
+    subtask_count: snapshot.epic?.subtasks?.length ?? 0,
+    snapshot_size: JSON.stringify(snapshot).length,
+  });
 
+  try {
     const promptText = `You are generating a continuation prompt for a compacted swarm coordination session.
 
 Analyze this swarm state and generate a structured markdown prompt that will be given to the resumed session:
@@ -1100,6 +1241,14 @@ You are resuming coordination of an active swarm that was interrupted by context
 
 Keep the prompt concise but actionable. Use actual data from the snapshot, not placeholders.`;
 
+    logCompaction("debug", "generate_compaction_prompt_calling_llm", {
+      session_id: snapshot.sessionID,
+      prompt_length: promptText.length,
+      model: liteModel,
+      command: `opencode run -m ${liteModel} -- <prompt>`,
+    });
+
+    const llmStart = Date.now();
     const result = await new Promise<{ exitCode: number; stdout: string; stderr: string }>(
       (resolve, reject) => {
         const proc = spawn("opencode", ["run", "-m", liteModel, "--", promptText], {
@@ -1133,24 +1282,275 @@ Keep the prompt concise but actionable. Use actual data from the snapshot, not p
         }, 30000);
       },
     );
+    const llmDuration = Date.now() - llmStart;
+
+    logCompaction("debug", "generate_compaction_prompt_llm_complete", {
+      session_id: snapshot.sessionID,
+      duration_ms: llmDuration,
+      exit_code: result.exitCode,
+      stdout_length: result.stdout.length,
+      stderr_length: result.stderr.length,
+      stderr_preview: result.stderr.substring(0, 500),
+      stdout_preview: result.stdout.substring(0, 500),
+    });
 
     if (result.exitCode !== 0) {
-      console.error(
-        "[Swarm Compaction] opencode run failed:",
-        result.stderr,
-      );
+      logCompaction("error", "generate_compaction_prompt_llm_failed", {
+        session_id: snapshot.sessionID,
+        exit_code: result.exitCode,
+        stderr: result.stderr,
+        stdout: result.stdout,
+        duration_ms: llmDuration,
+      });
       return null;
     }
 
     // Extract the prompt from stdout (LLM may wrap in markdown)
     const prompt = result.stdout.trim();
+    
+    const totalDuration = Date.now() - startTime;
+    logCompaction("debug", "generate_compaction_prompt_success", {
+      session_id: snapshot.sessionID,
+      total_duration_ms: totalDuration,
+      llm_duration_ms: llmDuration,
+      prompt_length: prompt.length,
+      prompt_preview: prompt.substring(0, 500),
+      prompt_has_content: prompt.length > 0,
+    });
+
     return prompt.length > 0 ? prompt : null;
   } catch (err) {
-    console.error("[Swarm Compaction] LLM generation failed:", err);
+    const totalDuration = Date.now() - startTime;
+    logCompaction("error", "generate_compaction_prompt_exception", {
+      session_id: snapshot.sessionID,
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : undefined,
+      duration_ms: totalDuration,
+    });
     return null;
   }
 }
 
+/**
+ * Session message scan result
+ */
+interface SessionScanResult {
+  messageCount: number;
+  toolCalls: Array<{
+    toolName: string;
+    args: Record<string, unknown>;
+    output?: string;
+  }>;
+  swarmDetected: boolean;
+  reasons: string[];
+}
+
+/**
+ * Scan session messages for swarm tool calls
+ * 
+ * Uses SDK client to fetch messages and look for swarm activity.
+ * This can detect swarm work even if no cells exist yet.
+ */
+async function scanSessionMessages(sessionID: string): Promise<SessionScanResult> {
+  const startTime = Date.now();
+  const result: SessionScanResult = {
+    messageCount: 0,
+    toolCalls: [],
+    swarmDetected: false,
+    reasons: [],
+  };
+
+  logCompaction("debug", "session_scan_start", {
+    session_id: sessionID,
+    has_sdk_client: !!sdkClient,
+  });
+
+  if (!sdkClient) {
+    logCompaction("warn", "session_scan_no_sdk_client", {
+      session_id: sessionID,
+    });
+    return result;
+  }
+
+  try {
+    // Fetch session messages
+    const messagesStart = Date.now();
+    const rawResponse = await sdkClient.session.messages({ path: { id: sessionID } });
+    const messagesDuration = Date.now() - messagesStart;
+
+    // Log the RAW response to understand its shape
+    logCompaction("debug", "session_scan_raw_response", {
+      session_id: sessionID,
+      response_type: typeof rawResponse,
+      is_array: Array.isArray(rawResponse),
+      is_null: rawResponse === null,
+      is_undefined: rawResponse === undefined,
+      keys: rawResponse && typeof rawResponse === 'object' ? Object.keys(rawResponse) : [],
+      raw_preview: JSON.stringify(rawResponse)?.slice(0, 500),
+    });
+
+    // The response might be wrapped - check common patterns
+    const messages = Array.isArray(rawResponse) 
+      ? rawResponse 
+      : rawResponse?.data 
+      ? rawResponse.data 
+      : rawResponse?.messages 
+      ? rawResponse.messages 
+      : rawResponse?.items
+      ? rawResponse.items
+      : [];
+
+    result.messageCount = messages?.length ?? 0;
+
+    logCompaction("debug", "session_scan_messages_fetched", {
+      session_id: sessionID,
+      duration_ms: messagesDuration,
+      message_count: result.messageCount,
+      extraction_method: Array.isArray(rawResponse) ? 'direct_array' : rawResponse?.data ? 'data_field' : rawResponse?.messages ? 'messages_field' : rawResponse?.items ? 'items_field' : 'fallback_empty',
+    });
+
+    if (!Array.isArray(messages) || messages.length === 0) {
+      logCompaction("debug", "session_scan_no_messages", {
+        session_id: sessionID,
+      });
+      return result;
+    }
+
+    // Swarm-related tool patterns
+    const swarmTools = [
+      // High confidence - active swarm coordination
+      "hive_create_epic",
+      "swarm_decompose",
+      "swarm_spawn_subtask",
+      "swarm_complete",
+      "swarmmail_init",
+      "swarmmail_reserve",
+      // Medium confidence - swarm activity
+      "hive_start",
+      "hive_close",
+      "swarm_status",
+      "swarm_progress",
+      "swarmmail_send",
+      // Low confidence - possible swarm
+      "hive_create",
+      "hive_query",
+    ];
+
+    const highConfidenceTools = new Set([
+      "hive_create_epic",
+      "swarm_decompose",
+      "swarm_spawn_subtask",
+      "swarmmail_init",
+      "swarmmail_reserve",
+    ]);
+
+    // Scan messages for tool calls
+    let swarmToolCount = 0;
+    let highConfidenceCount = 0;
+    
+    // Debug: collect part types to understand message structure
+    const partTypeCounts: Record<string, number> = {};
+    let messagesWithParts = 0;
+    let messagesWithoutParts = 0;
+    let samplePartTypes: string[] = [];
+
+    for (const message of messages) {
+      if (!message.parts || !Array.isArray(message.parts)) {
+        messagesWithoutParts++;
+        continue;
+      }
+      messagesWithParts++;
+
+      for (const part of message.parts) {
+        const partType = part.type || "unknown";
+        partTypeCounts[partType] = (partTypeCounts[partType] || 0) + 1;
+        
+        // Collect first 10 unique part types for debugging
+        if (samplePartTypes.length < 10 && !samplePartTypes.includes(partType)) {
+          samplePartTypes.push(partType);
+        }
+        
+        // Check if this is a tool call part
+        // OpenCode SDK: ToolPart has type="tool", tool=<string name>, state={...}
+        if (part.type === "tool") {
+          const toolPart = part as ToolPart;
+          const toolName = toolPart.tool; // tool name is a string directly
+          
+          if (toolName && swarmTools.includes(toolName)) {
+            swarmToolCount++;
+            
+            if (highConfidenceTools.has(toolName)) {
+              highConfidenceCount++;
+            }
+
+            // Extract args/output from state if available
+            const state = toolPart.state;
+            const args = state && "input" in state ? state.input : {};
+            const output = state && "output" in state ? state.output : undefined;
+
+            result.toolCalls.push({
+              toolName,
+              args,
+              output,
+            });
+
+            logCompaction("debug", "session_scan_tool_found", {
+              session_id: sessionID,
+              tool_name: toolName,
+              is_high_confidence: highConfidenceTools.has(toolName),
+            });
+          }
+        }
+      }
+    }
+
+    // Determine if swarm detected based on tool calls
+    if (highConfidenceCount > 0) {
+      result.swarmDetected = true;
+      result.reasons.push(`${highConfidenceCount} high-confidence swarm tools (${Array.from(new Set(result.toolCalls.filter(tc => highConfidenceTools.has(tc.toolName)).map(tc => tc.toolName))).join(", ")})`);
+    }
+    
+    if (swarmToolCount > 0 && !result.swarmDetected) {
+      result.swarmDetected = true;
+      result.reasons.push(`${swarmToolCount} swarm-related tools used`);
+    }
+
+    const totalDuration = Date.now() - startTime;
+    
+    // Debug: log part type distribution to understand message structure
+    logCompaction("debug", "session_scan_part_types", {
+      session_id: sessionID,
+      messages_with_parts: messagesWithParts,
+      messages_without_parts: messagesWithoutParts,
+      part_type_counts: partTypeCounts,
+      sample_part_types: samplePartTypes,
+    });
+    
+    logCompaction("info", "session_scan_complete", {
+      session_id: sessionID,
+      duration_ms: totalDuration,
+      message_count: result.messageCount,
+      tool_call_count: result.toolCalls.length,
+      swarm_tool_count: swarmToolCount,
+      high_confidence_count: highConfidenceCount,
+      swarm_detected: result.swarmDetected,
+      reasons: result.reasons,
+      unique_tools: Array.from(new Set(result.toolCalls.map(tc => tc.toolName))),
+    });
+
+    return result;
+  } catch (err) {
+    const totalDuration = Date.now() - startTime;
+    logCompaction("error", "session_scan_exception", {
+      session_id: sessionID,
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : undefined,
+      duration_ms: totalDuration,
+    });
+    return result;
+  }
+}
+
 /**
  * Check for swarm sign - evidence a swarm passed through
  *
@@ -1164,37 +1564,90 @@ Keep the prompt concise but actionable. Use actual data from the snapshot, not p
  * False negative = lost swarm (high cost)
  */
 async function detectSwarm(): Promise<SwarmDetection> {
+  const startTime = Date.now();
   const reasons: string[] = [];
   let highConfidence = false;
   let mediumConfidence = false;
   let lowConfidence = false;
 
+  logCompaction("debug", "detect_swarm_start", {
+    project_directory: projectDirectory,
+    cwd: process.cwd(),
+  });
+
   try {
-    const result = await new Promise<{ exitCode: number; stdout: string }>(
+    const cliStart = Date.now();
+    const result = await new Promise<{ exitCode: number; stdout: string; stderr: string }>(
       (resolve) => {
         // Use swarm tool to query beads
         const proc = spawn(SWARM_CLI, ["tool", "hive_query"], {
+          cwd: projectDirectory,
           stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
+        let stderr = "";
         proc.stdout.on("data", (d) => {
           stdout += d;
         });
+        proc.stderr.on("data", (d) => {
+          stderr += d;
+        });
         proc.on("close", (exitCode) =>
-          resolve({ exitCode: exitCode ?? 1, stdout }),
+          resolve({ exitCode: exitCode ?? 1, stdout, stderr }),
         );
       },
     );
+    const cliDuration = Date.now() - cliStart;
+
+    logCompaction("debug", "detect_swarm_cli_complete", {
+      duration_ms: cliDuration,
+      exit_code: result.exitCode,
+      stdout_length: result.stdout.length,
+      stderr_length: result.stderr.length,
+      stderr_preview: result.stderr.substring(0, 200),
+    });
 
     if (result.exitCode !== 0) {
+      logCompaction("warn", "detect_swarm_cli_failed", {
+        exit_code: result.exitCode,
+        stderr: result.stderr,
+      });
       return { detected: false, confidence: "none", reasons: ["hive_query failed"] };
     }
 
-    const cells = JSON.parse(result.stdout);
+    let cells: any[];
+    try {
+      cells = JSON.parse(result.stdout);
+    } catch (parseErr) {
+      logCompaction("error", "detect_swarm_parse_failed", {
+        error: parseErr instanceof Error ? parseErr.message : String(parseErr),
+        stdout_preview: result.stdout.substring(0, 500),
+      });
+      return { detected: false, confidence: "none", reasons: ["hive_query parse failed"] };
+    }
+
     if (!Array.isArray(cells) || cells.length === 0) {
+      logCompaction("debug", "detect_swarm_no_cells", {
+        is_array: Array.isArray(cells),
+        length: cells?.length ?? 0,
+      });
       return { detected: false, confidence: "none", reasons: ["no cells found"] };
     }
 
+    // Log ALL cells for debugging
+    logCompaction("debug", "detect_swarm_cells_found", {
+      total_cells: cells.length,
+      cells: cells.map((c: any) => ({
+        id: c.id,
+        title: c.title,
+        type: c.type,
+        status: c.status,
+        parent_id: c.parent_id,
+        updated_at: c.updated_at,
+        created_at: c.created_at,
+      })),
+    });
+
     // HIGH: Any in_progress cells
     const inProgress = cells.filter(
       (c: { status: string }) => c.status === "in_progress"
@@ -1202,6 +1655,10 @@ async function detectSwarm(): Promise<SwarmDetection> {
     if (inProgress.length > 0) {
       highConfidence = true;
       reasons.push(`${inProgress.length} cells in_progress`);
+      logCompaction("debug", "detect_swarm_in_progress", {
+        count: inProgress.length,
+        cells: inProgress.map((c: any) => ({ id: c.id, title: c.title })),
+      });
     }
 
     // MEDIUM: Open subtasks (cells with parent_id)
@@ -1212,6 +1669,10 @@ async function detectSwarm(): Promise<SwarmDetection> {
     if (subtasks.length > 0) {
       mediumConfidence = true;
       reasons.push(`${subtasks.length} open subtasks`);
+      logCompaction("debug", "detect_swarm_open_subtasks", {
+        count: subtasks.length,
+        cells: subtasks.map((c: any) => ({ id: c.id, title: c.title, parent_id: c.parent_id })),
+      });
     }
 
     // MEDIUM: Unclosed epics
@@ -1222,6 +1683,10 @@ async function detectSwarm(): Promise<SwarmDetection> {
     if (openEpics.length > 0) {
       mediumConfidence = true;
       reasons.push(`${openEpics.length} unclosed epics`);
+      logCompaction("debug", "detect_swarm_open_epics", {
+        count: openEpics.length,
+        cells: openEpics.map((c: any) => ({ id: c.id, title: c.title, status: c.status })),
+      });
     }
 
     // MEDIUM: Recently updated cells (last hour)
@@ -1232,6 +1697,16 @@ async function detectSwarm(): Promise<SwarmDetection> {
     if (recentCells.length > 0) {
       mediumConfidence = true;
       reasons.push(`${recentCells.length} cells updated in last hour`);
+      logCompaction("debug", "detect_swarm_recent_cells", {
+        count: recentCells.length,
+        one_hour_ago: oneHourAgo,
+        cells: recentCells.map((c: any) => ({ 
+          id: c.id, 
+          title: c.title, 
+          updated_at: c.updated_at,
+          age_minutes: Math.round((Date.now() - c.updated_at) / 60000),
+        })),
+      });
     }
 
     // LOW: Any cells exist at all
@@ -1239,10 +1714,14 @@ async function detectSwarm(): Promise<SwarmDetection> {
       lowConfidence = true;
       reasons.push(`${cells.length} total cells in hive`);
     }
-  } catch {
+  } catch (err) {
     // Detection failed, use fallback
     lowConfidence = true;
     reasons.push("Detection error, using fallback");
+    logCompaction("error", "detect_swarm_exception", {
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : undefined,
+    });
   }
 
   // Determine overall confidence
@@ -1257,6 +1736,18 @@ async function detectSwarm(): Promise<SwarmDetection> {
     confidence = "none";
   }
 
+  const totalDuration = Date.now() - startTime;
+  logCompaction("debug", "detect_swarm_complete", {
+    duration_ms: totalDuration,
+    confidence,
+    detected: confidence !== "none",
+    reason_count: reasons.length,
+    reasons,
+    high_confidence: highConfidence,
+    medium_confidence: mediumConfidence,
+    low_confidence: lowConfidence,
+  });
+
   return {
     detected: confidence !== "none",
     confidence,
@@ -1383,13 +1874,18 @@ type ExtendedHooks = Hooks & {
   ) => Promise<void>;
 };
 
-export const SwarmPlugin: Plugin = async (
+// NOTE: Only default export - named exports cause double registration!
+// OpenCode's plugin loader calls ALL exports as functions.
+const SwarmPlugin: Plugin = async (
   input: PluginInput,
 ): Promise<ExtendedHooks> => {
   // CRITICAL: Set project directory from OpenCode input
   // Without this, CLI uses wrong database path
   projectDirectory = input.directory;
   
+  // Store SDK client for session message scanning during compaction
+  sdkClient = input.client;
+  
   return {
     tool: {
       // Beads
@@ -1458,55 +1954,272 @@ export const SwarmPlugin: Plugin = async (
       input: { sessionID: string },
       output: CompactionOutput,
     ) => {
+      const startTime = Date.now();
+      
+      // =======================================================================
+      // LOG: Compaction hook invoked - capture EVERYTHING we receive
+      // =======================================================================
+      logCompaction("info", "compaction_hook_invoked", {
+        session_id: input.sessionID,
+        project_directory: projectDirectory,
+        input_keys: Object.keys(input),
+        input_full: JSON.parse(JSON.stringify(input)), // Deep clone for logging
+        output_keys: Object.keys(output),
+        output_context_count: output.context?.length ?? 0,
+        output_has_prompt_field: "prompt" in output,
+        output_initial_state: {
+          context: output.context,
+          prompt: (output as any).prompt,
+        },
+        env: {
+          OPENCODE_SESSION_ID: process.env.OPENCODE_SESSION_ID,
+          OPENCODE_MESSAGE_ID: process.env.OPENCODE_MESSAGE_ID,
+          OPENCODE_AGENT: process.env.OPENCODE_AGENT,
+          OPENCODE_LITE_MODEL: process.env.OPENCODE_LITE_MODEL,
+          SWARM_PROJECT_DIR: process.env.SWARM_PROJECT_DIR,
+        },
+        cwd: process.cwd(),
+        timestamp: new Date().toISOString(),
+      });
+
+      // =======================================================================
+      // STEP 1: Scan session messages for swarm tool calls
+      // =======================================================================
+      const sessionScanStart = Date.now();
+      const sessionScan = await scanSessionMessages(input.sessionID);
+      const sessionScanDuration = Date.now() - sessionScanStart;
+
+      logCompaction("info", "session_scan_results", {
+        session_id: input.sessionID,
+        duration_ms: sessionScanDuration,
+        message_count: sessionScan.messageCount,
+        tool_call_count: sessionScan.toolCalls.length,
+        swarm_detected_from_messages: sessionScan.swarmDetected,
+        reasons: sessionScan.reasons,
+      });
+
+      // =======================================================================
+      // STEP 2: Detect swarm state from hive cells
+      // =======================================================================
+      const detectionStart = Date.now();
       const detection = await detectSwarm();
+      const detectionDuration = Date.now() - detectionStart;
+
+      logCompaction("info", "swarm_detection_complete", {
+        session_id: input.sessionID,
+        duration_ms: detectionDuration,
+        detected: detection.detected,
+        confidence: detection.confidence,
+        reasons: detection.reasons,
+        reason_count: detection.reasons.length,
+      });
+
+      // =======================================================================
+      // STEP 3: Merge session scan with hive detection for final confidence
+      // =======================================================================
+      // If session messages show high-confidence swarm tools, boost confidence
+      if (sessionScan.swarmDetected && sessionScan.reasons.some(r => r.includes("high-confidence"))) {
+        if (detection.confidence === "none" || detection.confidence === "low") {
+          detection.confidence = "high";
+          detection.detected = true;
+          detection.reasons.push(...sessionScan.reasons);
+          
+          logCompaction("info", "confidence_boost_from_session_scan", {
+            session_id: input.sessionID,
+            original_confidence: detection.confidence,
+            boosted_to: "high",
+            session_reasons: sessionScan.reasons,
+          });
+        }
+      } else if (sessionScan.swarmDetected) {
+        // Medium boost for any swarm tools found
+        if (detection.confidence === "none") {
+          detection.confidence = "medium";
+          detection.detected = true;
+          detection.reasons.push(...sessionScan.reasons);
+
+          logCompaction("info", "confidence_boost_from_session_scan", {
+            session_id: input.sessionID,
+            original_confidence: "none",
+            boosted_to: "medium",
+            session_reasons: sessionScan.reasons,
+          });
+        } else if (detection.confidence === "low") {
+          detection.confidence = "medium";
+          detection.reasons.push(...sessionScan.reasons);
+
+          logCompaction("info", "confidence_boost_from_session_scan", {
+            session_id: input.sessionID,
+            original_confidence: "low",
+            boosted_to: "medium",
+            session_reasons: sessionScan.reasons,
+          });
+        }
+      }
+
+      logCompaction("info", "final_swarm_detection", {
+        session_id: input.sessionID,
+        confidence: detection.confidence,
+        detected: detection.detected,
+        combined_reasons: detection.reasons,
+        message_scan_contributed: sessionScan.swarmDetected,
+      });
 
       if (detection.confidence === "high" || detection.confidence === "medium") {
         // Definite or probable swarm - try LLM-powered compaction
+        logCompaction("info", "swarm_detected_attempting_llm", {
+          session_id: input.sessionID,
+          confidence: detection.confidence,
+          reasons: detection.reasons,
+        });
+
         try {
           // Level 1: Query actual state
+          const queryStart = Date.now();
           const snapshot = await querySwarmState(input.sessionID);
+          const queryDuration = Date.now() - queryStart;
+
+          logCompaction("info", "swarm_state_queried", {
+            session_id: input.sessionID,
+            duration_ms: queryDuration,
+            has_epic: !!snapshot.epic,
+            epic_id: snapshot.epic?.id,
+            epic_title: snapshot.epic?.title,
+            epic_status: snapshot.epic?.status,
+            subtask_count: snapshot.epic?.subtasks?.length ?? 0,
+            subtasks: snapshot.epic?.subtasks?.map(s => ({
+              id: s.id,
+              title: s.title,
+              status: s.status,
+              file_count: s.files?.length ?? 0,
+            })),
+            message_count: snapshot.messages?.length ?? 0,
+            reservation_count: snapshot.reservations?.length ?? 0,
+            detection_confidence: snapshot.detection.confidence,
+            detection_reasons: snapshot.detection.reasons,
+            full_snapshot: snapshot, // Log the entire snapshot
+          });
 
           // Level 2: Generate prompt with LLM
+          const llmStart = Date.now();
           const llmPrompt = await generateCompactionPrompt(snapshot);
+          const llmDuration = Date.now() - llmStart;
+
+          logCompaction("info", "llm_generation_complete", {
+            session_id: input.sessionID,
+            duration_ms: llmDuration,
+            success: !!llmPrompt,
+            prompt_length: llmPrompt?.length ?? 0,
+            prompt_preview: llmPrompt?.substring(0, 500),
+          });
 
           if (llmPrompt) {
             // SUCCESS: Use LLM-generated prompt
             const header = `[Swarm compaction: LLM-generated, ${detection.reasons.join(", ")}]\n\n`;
+            const fullContent = header + llmPrompt;
 
             // Progressive enhancement: use new API if available
             if ("prompt" in output) {
-              output.prompt = header + llmPrompt;
+              output.prompt = fullContent;
+              logCompaction("info", "context_injected_via_prompt_api", {
+                session_id: input.sessionID,
+                content_length: fullContent.length,
+                method: "output.prompt",
+              });
             } else {
-              output.context.push(header + llmPrompt);
+              output.context.push(fullContent);
+              logCompaction("info", "context_injected_via_context_array", {
+                session_id: input.sessionID,
+                content_length: fullContent.length,
+                method: "output.context.push",
+                context_count_after: output.context.length,
+              });
             }
 
-            console.log(
-              "[Swarm Compaction] Using LLM-generated continuation prompt",
-            );
+            const totalDuration = Date.now() - startTime;
+            logCompaction("info", "compaction_complete_llm_success", {
+              session_id: input.sessionID,
+              total_duration_ms: totalDuration,
+              detection_duration_ms: detectionDuration,
+              query_duration_ms: queryDuration,
+              llm_duration_ms: llmDuration,
+              confidence: detection.confidence,
+              context_type: "llm_generated",
+              content_length: fullContent.length,
+            });
             return;
           }
 
           // LLM failed, fall through to static prompt
-          console.log(
-            "[Swarm Compaction] LLM generation returned null, using static prompt",
-          );
+          logCompaction("warn", "llm_generation_returned_null", {
+            session_id: input.sessionID,
+            llm_duration_ms: llmDuration,
+            falling_back_to: "static_prompt",
+          });
         } catch (err) {
           // LLM failed, fall through to static prompt
-          console.error(
-            "[Swarm Compaction] LLM generation failed, using static prompt:",
-            err,
-          );
+          logCompaction("error", "llm_generation_failed", {
+            session_id: input.sessionID,
+            error: err instanceof Error ? err.message : String(err),
+            error_stack: err instanceof Error ? err.stack : undefined,
+            falling_back_to: "static_prompt",
+          });
         }
 
         // Level 3: Fall back to static context
         const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
-        output.context.push(header + SWARM_COMPACTION_CONTEXT);
+        const staticContent = header + SWARM_COMPACTION_CONTEXT;
+        output.context.push(staticContent);
+
+        const totalDuration = Date.now() - startTime;
+        logCompaction("info", "compaction_complete_static_fallback", {
+          session_id: input.sessionID,
+          total_duration_ms: totalDuration,
+          confidence: detection.confidence,
+          context_type: "static_swarm_context",
+          content_length: staticContent.length,
+          context_count_after: output.context.length,
+        });
       } else if (detection.confidence === "low") {
         // Level 4: Possible swarm - inject fallback detection prompt
         const header = `[Possible swarm: ${detection.reasons.join(", ")}]\n\n`;
-        output.context.push(header + SWARM_DETECTION_FALLBACK);
+        const fallbackContent = header + SWARM_DETECTION_FALLBACK;
+        output.context.push(fallbackContent);
+
+        const totalDuration = Date.now() - startTime;
+        logCompaction("info", "compaction_complete_detection_fallback", {
+          session_id: input.sessionID,
+          total_duration_ms: totalDuration,
+          confidence: detection.confidence,
+          context_type: "detection_fallback",
+          content_length: fallbackContent.length,
+          context_count_after: output.context.length,
+          reasons: detection.reasons,
+        });
+      } else {
+        // Level 5: confidence === "none" - no injection, probably not a swarm
+        const totalDuration = Date.now() - startTime;
+        logCompaction("info", "compaction_complete_no_swarm", {
+          session_id: input.sessionID,
+          total_duration_ms: totalDuration,
+          confidence: detection.confidence,
+          context_type: "none",
+          reasons: detection.reasons,
+          context_count_unchanged: output.context.length,
+        });
       }
-      // Level 5: confidence === "none" - no injection, probably not a swarm
+
+      // =======================================================================
+      // LOG: Final output state
+      // =======================================================================
+      logCompaction("debug", "compaction_hook_complete_final_state", {
+        session_id: input.sessionID,
+        output_context_count: output.context?.length ?? 0,
+        output_context_lengths: output.context?.map(c => c.length) ?? [],
+        output_has_prompt: !!(output as any).prompt,
+        output_prompt_length: (output as any).prompt?.length ?? 0,
+        total_duration_ms: Date.now() - startTime,
+      });
     },
   };
 };