opencode-swarm 6.29.5 → 6.29.6

package/dist/index.js

@@ -39369,6 +39369,7 @@ init_plan_schema();
 init_schema();
 import * as fs3 from "fs/promises";
 import * as path2 from "path";
+var _rehydrationCache = null;
 var swarmState = {
   activeToolCalls: new Map,
   toolAggregates: new Map,
@@ -39378,7 +39379,7 @@ var swarmState = {
   lastBudgetPct: 0,
   agentSessions: new Map
 };
-function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, directory) {
+function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, _directory) {
   const now = Date.now();
   const staleIds = [];
   for (const [id, session] of swarmState.agentSessions) {
@@ -39426,14 +39427,12 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
   };
   swarmState.agentSessions.set(sessionId, sessionState);
   swarmState.activeAgent.set(sessionId, agentName);
-  if (directory) {
-    rehydrateSessionFromDisk(directory, sessionState).catch(() => {});
-  }
+  applyRehydrationCache(sessionState);
 }
 function getAgentSession(sessionId) {
   return swarmState.agentSessions.get(sessionId);
 }
-function ensureAgentSession(sessionId, agentName, directory) {
+function ensureAgentSession(sessionId, agentName, _directory) {
   const now = Date.now();
   let session = swarmState.agentSessions.get(sessionId);
   if (session) {
@@ -39533,7 +39532,7 @@ function ensureAgentSession(sessionId, agentName, directory) {
     session.lastToolCallTime = now;
     return session;
   }
-  startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
+  startAgentSession(sessionId, agentName ?? "unknown", 7200000);
   session = swarmState.agentSessions.get(sessionId);
   if (!session) {
     throw new Error(`Failed to create guardrail session for ${sessionId}`);
@@ -39718,43 +39717,47 @@ async function readEvidenceFromDisk(directory) {
   } catch {}
   return evidenceMap;
 }
-async function rehydrateSessionFromDisk(directory, session) {
-  if (!session.taskWorkflowStates) {
-    session.taskWorkflowStates = new Map;
-  }
-  const plan = await readPlanFromDisk(directory);
-  if (!plan) {
-    return;
-  }
+async function buildRehydrationCache(directory) {
   const planTaskStates = new Map;
-  for (const phase of plan.phases ?? []) {
-    for (const task of phase.tasks ?? []) {
-      const taskState = planStatusToWorkflowState(task.status);
-      planTaskStates.set(task.id, taskState);
+  const plan = await readPlanFromDisk(directory);
+  if (plan) {
+    for (const phase of plan.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        planTaskStates.set(task.id, planStatusToWorkflowState(task.status));
+      }
     }
   }
   const evidenceMap = await readEvidenceFromDisk(directory);
+  _rehydrationCache = { planTaskStates, evidenceMap };
+}
+function applyRehydrationCache(session) {
+  if (!_rehydrationCache) {
+    return;
+  }
+  if (!session.taskWorkflowStates) {
+    session.taskWorkflowStates = new Map;
+  }
+  const { planTaskStates, evidenceMap } = _rehydrationCache;
+  const STATE_ORDER = [
+    "idle",
+    "coder_delegated",
+    "pre_check_passed",
+    "reviewer_run",
+    "tests_run",
+    "complete"
+  ];
   for (const [taskId, planState] of planTaskStates) {
     const existingState = session.taskWorkflowStates.get(taskId);
     const evidence = evidenceMap.get(taskId);
-    let derivedState;
     if (evidence) {
-      derivedState = evidenceToWorkflowState(evidence);
-    } else {
-      derivedState = planState;
-    }
-    const STATE_ORDER = [
-      "idle",
-      "coder_delegated",
-      "pre_check_passed",
-      "reviewer_run",
-      "tests_run",
-      "complete"
-    ];
-    const existingIndex = existingState ? STATE_ORDER.indexOf(existingState) : -1;
-    const derivedIndex = STATE_ORDER.indexOf(derivedState);
-    if (derivedIndex > existingIndex) {
+      const derivedState = evidenceToWorkflowState(evidence);
       session.taskWorkflowStates.set(taskId, derivedState);
+    } else {
+      const existingIndex = existingState ? STATE_ORDER.indexOf(existingState) : -1;
+      const derivedIndex = STATE_ORDER.indexOf(planState);
+      if (derivedIndex > existingIndex) {
+        session.taskWorkflowStates.set(taskId, planState);
+      }
     }
   }
 }
@@ -54021,9 +54024,13 @@ async function reconcileTaskStatesFromPlan(directory) {
 }
 async function loadSnapshot(directory) {
   try {
+    await buildRehydrationCache(directory);
     const snapshot = await readSnapshot(directory);
     if (snapshot !== null) {
       rehydrateState(snapshot);
+      for (const session of swarmState.agentSessions.values()) {
+        applyRehydrationCache(session);
+      }
       await reconcileTaskStatesFromPlan(directory);
     }
   } catch {}

package/dist/state.d.ts

@@ -194,7 +194,7 @@ export declare function resetSwarmState(): void;
  * @param staleDurationMs - Age threshold for stale session eviction (default: 120 min)
  * @param directory - Optional project directory for rehydrating workflow state from disk
  */
-export declare function startAgentSession(sessionId: string, agentName: string, staleDurationMs?: number, directory?: string): void;
+export declare function startAgentSession(sessionId: string, agentName: string, staleDurationMs?: number, _directory?: string): void;
 /**
  * End an agent session by removing it from the state.
  * NOTE: Currently unused in production — no session lifecycle teardown is wired up.
@@ -216,10 +216,9 @@ export declare function getAgentSession(sessionId: string): AgentSessionState |
  * Always updates lastToolCallTime.
  * @param sessionId - The session identifier
  * @param agentName - Optional agent name (if known)
- * @param directory - Optional project directory for rehydrating workflow state from disk
  * @returns The AgentSessionState
  */
-export declare function ensureAgentSession(sessionId: string, agentName?: string, directory?: string): AgentSessionState;
+export declare function ensureAgentSession(sessionId: string, agentName?: string, _directory?: string): AgentSessionState;
 /**
  * Update only the agent event timestamp (for stale detection).
  * Does NOT change agent name or reset guardrail state.
@@ -301,6 +300,25 @@ export declare function getTaskState(session: AgentSessionState, taskId: string)
  * @param directory - Project root containing .swarm/ subdirectory
  * @param session - Target AgentSessionState to merge rehydrated state into
  */
+/**
+ * Reads plan.json + evidence/*.json from the project directory and populates the
+ * module-level _rehydrationCache.  Called once at plugin init by loadSnapshot().
+ * Non-fatal: missing/malformed files leave an empty cache.
+ */
+export declare function buildRehydrationCache(directory: string): Promise<void>;
+/**
+ * Synchronously applies the cached plan+evidence data to a session.
+ * Merge rules:
+ *   - evidence-derived state: always applied (replaces snapshot state, even if lower)
+ *   - plan-only derived state: only applied if it advances past existing state
+ * No-op when the cache has not been built yet.
+ */
+export declare function applyRehydrationCache(session: AgentSessionState): void;
+/**
+ * Rehydrates session workflow state from durable swarm files.
+ * Builds (or refreshes) the rehydration cache from disk, then applies it
+ * to the target session.
+ */
 export declare function rehydrateSessionFromDisk(directory: string, session: AgentSessionState): Promise<void>;
 /**
  * Check if ANY active session has Turbo Mode enabled.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.29.5",
+	"version": "6.29.6",
 	"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",