opencode-swarm 6.33.5 → 6.33.7

package/dist/index.js

@@ -50891,17 +50891,10 @@ async function getEvidenceTaskId(session, directory) {
       }
     }
   } catch (err2) {
-    if (err2 instanceof Error) {
-      if (err2 instanceof SyntaxError) {
-        return null;
-      }
-      const code = err2.code;
-      if (code === "ENOENT" || code === "ENOTDIR") {
-        return null;
-      }
-      throw err2;
+    if (process.env.DEBUG_SWARM && err2 instanceof Error) {
+      console.warn(`[delegation-gate] getEvidenceTaskId error: ${err2.message} (code=${err2.code ?? "none"})`);
     }
-    throw err2;
+    return null;
   }
   return null;
 }
@@ -50995,10 +50988,10 @@ function createDelegationGateHook(config3, directory) {
         }
       }
       if (typeof subagentType === "string") {
-        const rawTaskId = directArgs?.task_id;
-        const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : await getEvidenceTaskId(session, directory);
-        if (evidenceTaskId) {
-          try {
+        try {
+          const rawTaskId = directArgs?.task_id;
+          const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : await getEvidenceTaskId(session, directory);
+          if (evidenceTaskId) {
             const turbo = hasActiveTurboMode();
             const gateAgents = [
               "reviewer",
@@ -51017,9 +51010,9 @@ function createDelegationGateHook(config3, directory) {
               const { recordAgentDispatch: recordAgentDispatch2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
               await recordAgentDispatch2(directory, evidenceTaskId, targetAgentForEvidence, turbo);
             }
-          } catch (err2) {
-            console.warn(`[delegation-gate] evidence write failed for task ${evidenceTaskId}: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
+        } catch (err2) {
+          console.warn(`[delegation-gate] evidence recording failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
       }
       if (storedArgs !== undefined) {
@@ -51114,24 +51107,22 @@ function createDelegationGateHook(config3, directory) {
             }
           }
         }
-        {
+        try {
           const rawTaskId = directArgs?.task_id;
           const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : await getEvidenceTaskId(session, directory);
           if (evidenceTaskId) {
-            try {
-              const turbo = hasActiveTurboMode();
-              if (hasReviewer) {
-                const { recordGateEvidence: recordGateEvidence2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
-                await recordGateEvidence2(directory, evidenceTaskId, "reviewer", input.sessionID, turbo);
-              }
-              if (hasTestEngineer) {
-                const { recordGateEvidence: recordGateEvidence2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
-                await recordGateEvidence2(directory, evidenceTaskId, "test_engineer", input.sessionID, turbo);
-              }
-            } catch (err2) {
-              console.warn(`[delegation-gate] evidence write failed for task ${evidenceTaskId}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+            const turbo = hasActiveTurboMode();
+            if (hasReviewer) {
+              const { recordGateEvidence: recordGateEvidence2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
+              await recordGateEvidence2(directory, evidenceTaskId, "reviewer", input.sessionID, turbo);
+            }
+            if (hasTestEngineer) {
+              const { recordGateEvidence: recordGateEvidence2 } = await Promise.resolve().then(() => (init_gate_evidence(), exports_gate_evidence));
+              await recordGateEvidence2(directory, evidenceTaskId, "test_engineer", input.sessionID, turbo);
             }
           }
+        } catch (err2) {
+          console.warn(`[delegation-gate] fallback evidence recording failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
       }
     }
@@ -55065,6 +55056,17 @@ async function rehydrateState(snapshot) {
           window2.warningReason = "";
         }
       }
+      session.revisionLimitHit = false;
+      session.coderRevisions = 0;
+      session.selfFixAttempted = false;
+      session.lastGateFailure = null;
+      session.architectWriteCount = 0;
+      session.selfCodingWarnedAtCount = 0;
+      session.pendingAdvisoryMessages = [];
+      session.model_fallback_index = 0;
+      session.modelFallbackExhausted = false;
+      session.scopeViolationDetected = false;
+      session.delegationActive = false;
       swarmState.agentSessions.set(sessionId, session);
     }
   }
@@ -65256,6 +65258,7 @@ var OpenCodeSwarm = async (ctx) => {
     },
     "experimental.chat.messages.transform": composeHandlers(...[
       (input, _output) => {
+        console.error(`[DIAG] messagesTransform START`);
         const p = input;
         if (p.sessionID) {
           const archAgent = swarmState.activeAgent.get(p.sessionID);
@@ -65279,16 +65282,24 @@ var OpenCodeSwarm = async (ctx) => {
         if (output.messages) {
           output.messages = consolidateSystemMessages(output.messages);
         }
+        console.error(`[DIAG] messagesTransform DONE`);
         return Promise.resolve();
       }
     ].filter((fn) => Boolean(fn))),
     "experimental.chat.system.transform": composeHandlers(...[
+      async (input, output) => {
+        console.error(`[DIAG] systemTransform START`);
+      },
       systemEnhancerHook["experimental.chat.system.transform"],
+      async (_input, _output) => {
+        console.error(`[DIAG] systemTransform enhancer DONE`);
+      },
       automationConfig.capabilities?.phase_preflight === true && preflightTriggerManager ? createPhaseMonitorHook(ctx.directory, preflightTriggerManager) : knowledgeConfig.enabled ? createPhaseMonitorHook(ctx.directory) : undefined
     ].filter(Boolean)),
     "experimental.session.compacting": compactionHook["experimental.session.compacting"],
     "command.execute.before": safeHook(commandHandler),
     "tool.execute.before": async (input, output) => {
+      console.error(`[DIAG] toolBefore tool=${input.tool?.replace?.(/^[^:]+[:.]/, "") ?? input.tool} session=${input.sessionID}`);
       if (!swarmState.activeAgent.has(input.sessionID)) {
         swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
       }
@@ -65297,7 +65308,7 @@ var OpenCodeSwarm = async (ctx) => {
       if (session && activeAgent && activeAgent !== ORCHESTRATOR_NAME) {
         const stripActive = stripKnownSwarmPrefix(activeAgent);
         if (stripActive !== ORCHESTRATOR_NAME) {
-          const staleDelegation = !session.delegationActive || Date.now() - session.lastAgentEventTime > 1e4;
+          const staleDelegation = !session.delegationActive && Date.now() - session.lastAgentEventTime > 1e4;
           if (staleDelegation) {
             swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
             ensureAgentSession(input.sessionID, ORCHESTRATOR_NAME);
@@ -65317,72 +65328,102 @@ var OpenCodeSwarm = async (ctx) => {
       await safeHook(activityHooks.toolBefore)(input, output);
     },
     "tool.execute.after": async (input, output) => {
-      if (process.env.DEBUG_SWARM) {
-        console.debug("[hook-chain] toolAfter start sessionID=%s agent=%s tool=%s", input.sessionID, input.agent, input.tool?.name);
-      }
-      await activityHooks.toolAfter(input, output);
-      await guardrailsHooks.toolAfter(input, output);
-      await safeHook(delegationLedgerHook.toolAfter)(input, output);
-      await safeHook(selfReviewHook.toolAfter)(input, output);
-      await safeHook(delegationGateHooks.toolAfter)(input, output);
-      if (knowledgeCuratorHook)
-        await safeHook(knowledgeCuratorHook)(input, output);
-      if (hivePromoterHook)
-        await safeHook(hivePromoterHook)(input, output);
-      await safeHook(steeringConsumedHook)(input, output);
-      await safeHook(coChangeSuggesterHook)(input, output);
-      await safeHook(darkMatterDetectorHook)(input, output);
-      await snapshotWriterHook(input, output);
-      await toolSummarizerHook?.(input, output);
-      const execMode = config3.execution_mode ?? "balanced";
-      if (execMode === "strict") {
-        if (slopDetectorHook)
-          await slopDetectorHook.toolAfter(input, output);
-        if (incrementalVerifyHook)
-          await incrementalVerifyHook.toolAfter(input, output);
-        if (compactionServiceHook)
-          await compactionServiceHook.toolAfter(input, output);
-      }
-      const toolOutputConfig = config3.tool_output;
-      if (toolOutputConfig && toolOutputConfig.truncation_enabled !== false && typeof output.output === "string") {
-        const defaultTruncatableTools = new Set([
-          "diff",
-          "symbols",
-          "bash",
-          "shell",
-          "test_runner",
-          "lint",
-          "pre_check_batch",
-          "complexity_hotspots",
-          "pkg_audit",
-          "sbom_generate",
-          "schema_drift"
-        ]);
-        const configuredTools = toolOutputConfig.truncation_tools;
-        const truncatableTools = configuredTools && configuredTools.length > 0 ? new Set(configuredTools) : defaultTruncatableTools;
-        const maxLines = toolOutputConfig.per_tool?.[input.tool] ?? toolOutputConfig.max_lines ?? 150;
-        if (truncatableTools.has(input.tool)) {
-          output.output = truncateToolOutput(output.output, maxLines, input.tool, 10);
-        }
-      }
+      const _toolName = input.tool?.replace?.(/^[^:]+[:.]/, "") ?? input.tool;
+      console.error(`[DIAG] toolAfter START tool=${_toolName} session=${input.sessionID}`);
       const normalizedTool = input.tool.replace(/^[^:]+[:.]/, "");
-      if (normalizedTool === "Task" || normalizedTool === "task") {
+      const isTaskTool = normalizedTool === "Task" || normalizedTool === "task";
+      if (isTaskTool) {
         const sessionId = input.sessionID;
         swarmState.activeAgent.set(sessionId, ORCHESTRATOR_NAME);
         ensureAgentSession(sessionId, ORCHESTRATOR_NAME);
-        const session = swarmState.agentSessions.get(sessionId);
-        if (session) {
-          session.delegationActive = false;
-          session.lastAgentEventTime = Date.now();
+        const taskSession = swarmState.agentSessions.get(sessionId);
+        if (taskSession) {
+          taskSession.delegationActive = false;
+          taskSession.lastAgentEventTime = Date.now();
+        }
+        console.error(`[DIAG] Task handoff DONE (early) session=${sessionId} activeAgent=${swarmState.activeAgent.get(sessionId)}`);
+      }
+      const HOOK_CHAIN_TIMEOUT_MS = 30000;
+      const hookChainStart = Date.now();
+      let hookChainTimedOut = false;
+      const hookChain = async () => {
+        await activityHooks.toolAfter(input, output);
+        console.error(`[DIAG] toolAfter activity done tool=${_toolName}`);
+        await guardrailsHooks.toolAfter(input, output);
+        console.error(`[DIAG] toolAfter guardrails done tool=${_toolName}`);
+        await safeHook(delegationLedgerHook.toolAfter)(input, output);
+        console.error(`[DIAG] toolAfter ledger done tool=${_toolName}`);
+        await safeHook(selfReviewHook.toolAfter)(input, output);
+        console.error(`[DIAG] toolAfter selfReview done tool=${_toolName}`);
+        await safeHook(delegationGateHooks.toolAfter)(input, output);
+        console.error(`[DIAG] toolAfter delegationGate done tool=${_toolName}`);
+        if (knowledgeCuratorHook)
+          await safeHook(knowledgeCuratorHook)(input, output);
+        if (hivePromoterHook)
+          await safeHook(hivePromoterHook)(input, output);
+        console.error(`[DIAG] toolAfter knowledge done tool=${_toolName}`);
+        await safeHook(steeringConsumedHook)(input, output);
+        await safeHook(coChangeSuggesterHook)(input, output);
+        await safeHook(darkMatterDetectorHook)(input, output);
+        console.error(`[DIAG] toolAfter intelligence done tool=${_toolName}`);
+        await snapshotWriterHook(input, output);
+        await toolSummarizerHook?.(input, output);
+        console.error(`[DIAG] toolAfter snapshot+summarizer done tool=${_toolName}`);
+        const execMode = config3.execution_mode ?? "balanced";
+        if (execMode === "strict") {
+          if (slopDetectorHook)
+            await slopDetectorHook.toolAfter(input, output);
+          if (incrementalVerifyHook)
+            await incrementalVerifyHook.toolAfter(input, output);
+          if (compactionServiceHook)
+            await compactionServiceHook.toolAfter(input, output);
+        }
+        const toolOutputConfig = config3.tool_output;
+        if (toolOutputConfig && toolOutputConfig.truncation_enabled !== false && typeof output.output === "string") {
+          const defaultTruncatableTools = new Set([
+            "diff",
+            "symbols",
+            "bash",
+            "shell",
+            "test_runner",
+            "lint",
+            "pre_check_batch",
+            "complexity_hotspots",
+            "pkg_audit",
+            "sbom_generate",
+            "schema_drift"
+          ]);
+          const configuredTools = toolOutputConfig.truncation_tools;
+          const truncatableTools = configuredTools && configuredTools.length > 0 ? new Set(configuredTools) : defaultTruncatableTools;
+          const maxLines = toolOutputConfig.per_tool?.[input.tool] ?? toolOutputConfig.max_lines ?? 150;
+          if (truncatableTools.has(input.tool)) {
+            output.output = truncateToolOutput(output.output, maxLines, input.tool, 10);
+          }
         }
+      };
+      const timeout = new Promise((resolve23) => {
+        setTimeout(() => {
+          hookChainTimedOut = true;
+          resolve23();
+        }, HOOK_CHAIN_TIMEOUT_MS);
+      });
+      await Promise.race([
+        hookChain().catch((err2) => {
+          console.error(`[DIAG] toolAfter hook chain error tool=${_toolName}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        }),
+        timeout
+      ]);
+      if (hookChainTimedOut) {
+        const elapsed = Date.now() - hookChainStart;
+        console.error(`[DIAG] toolAfter TIMEOUT after ${elapsed}ms tool=${_toolName} session=${input.sessionID} \u2014 hooks abandoned to prevent session freeze`);
       }
       deleteStoredInputArgs(input.callID);
+      console.error(`[DIAG] toolAfter COMPLETE tool=${_toolName}`);
     },
     "chat.message": safeHook(async (input, output) => {
-      if (process.env.DEBUG_SWARM) {
-        console.debug("[session] chat.message sessionID=%s agent=%s", input.sessionID, input.agent);
-      }
+      console.error(`[DIAG] chat.message agent=${input.agent ?? "none"} session=${input.sessionID}`);
       await delegationHandler(input, output);
+      console.error(`[DIAG] chat.message DONE agent=${input.agent ?? "none"}`);
     }),
     automation: automationManager
   };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.33.5",
+	"version": "6.33.7",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",