opencode-swarm 7.22.1 → 7.23.1

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.22.1",
+    version: "7.23.1",
     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",
@@ -43447,7 +43447,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { mkdirSync as mkdirSync10, renameSync as renameSync6 } from "fs";
+import { closeSync as closeSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync10, openSync as openSync3, renameSync as renameSync6 } from "fs";
 import * as path27 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -43464,6 +43464,12 @@ function serializeAgentSession(s) {
   const catastrophicPhaseWarnings = Array.from(s.catastrophicPhaseWarnings ?? new Set);
   const phaseAgentsDispatched = Array.from(s.phaseAgentsDispatched ?? new Set);
   const lastCompletedPhaseAgentsDispatched = Array.from(s.lastCompletedPhaseAgentsDispatched ?? new Set);
+  const stageBCompletion = {};
+  if (s.stageBCompletion) {
+    for (const [taskId, agents] of s.stageBCompletion) {
+      stageBCompletion[taskId] = Array.from(agents);
+    }
+  }
   const windows = {};
   const rawWindows = s.windows ?? {};
   for (const [key, win] of Object.entries(rawWindows)) {
@@ -43520,7 +43526,8 @@ function serializeAgentSession(s) {
     fullAutoInteractionCount: s.fullAutoInteractionCount ?? 0,
     fullAutoDeadlockCount: s.fullAutoDeadlockCount ?? 0,
     fullAutoLastQuestionHash: s.fullAutoLastQuestionHash ?? null,
-    sessionRehydratedAt: s.sessionRehydratedAt ?? 0
+    sessionRehydratedAt: s.sessionRehydratedAt ?? 0,
+    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion }
   };
 }
 async function writeSnapshot(directory, state) {
@@ -43542,6 +43549,14 @@ async function writeSnapshot(directory, state) {
     mkdirSync10(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
+    try {
+      const fd = openSync3(tempPath, "r+");
+      try {
+        fsyncSync2(fd);
+      } finally {
+        closeSync3(fd);
+      }
+    } catch {}
     renameSync6(tempPath, resolvedPath);
   } catch (error93) {
     log("[snapshot-writer] write failed", {

package/dist/hooks/skill-propagation-gate.d.ts

@@ -18,7 +18,7 @@
  */
 import * as fs from 'node:fs';
 import type { MessageWithParts } from './knowledge-types.js';
-import { computeSkillRelevanceScore } from './skill-scoring.js';
+import { computeSkillRelevanceScore, formatSkillIndexWithContext } from './skill-scoring.js';
 import { appendSkillUsageEntry, readSkillUsageEntries, readSkillUsageEntriesTail } from './skill-usage-log.js';
 /** Agents that should receive skill context in delegations. */
 export declare const SKILL_CAPABLE_AGENTS: Set<string>;
@@ -37,6 +37,8 @@ export interface SkillGateInput {
 }
 export interface SkillPropagationConfig {
     enabled: boolean;
+    /** When true, blocks delegations missing SKILLS field instead of warning. */
+    enforce?: boolean;
 }
 export declare const _internals: {
     readdirSync: typeof fs.readdirSync;
@@ -44,6 +46,8 @@ export declare const _internals: {
     statSync: typeof fs.statSync;
     mkdirSync: typeof fs.mkdirSync;
     appendFileSync: typeof fs.appendFileSync;
+    readFileSync: typeof fs.readFileSync;
+    writeFileSync: typeof fs.writeFileSync;
     skillPropagationGateBefore: typeof skillPropagationGateBefore;
     skillPropagationTransformScan: typeof skillPropagationTransformScan;
     SKILL_CAPABLE_AGENTS: Set<string>;
@@ -57,6 +61,7 @@ export declare const _internals: {
     parseSkillPaths: typeof parseSkillPaths;
     extractTaskIdFromPrompt: typeof extractTaskIdFromPrompt;
     computeSkillRelevanceScore: typeof computeSkillRelevanceScore;
+    formatSkillIndexWithContext: typeof formatSkillIndexWithContext;
 };
 /**
  * Scans project for available skill SKILL.md files.
@@ -94,13 +99,22 @@ export declare function extractTaskIdFromPrompt(prompt: string): string;
 /**
  * Pre-tool gate. When the architect delegates via Task tool to a skill-capable
  * agent and the SKILLS field is missing or 'none' while skills exist in the
- * project, logs a warning event to events.jsonl. NEVER blocks execution.
+ * project, logs a warning event to events.jsonl and returns a warning string
+ * for visible injection into the architect prompt. When config.enforce is true,
+ * blocks the delegation entirely instead of merely warning.
  *
  * Also records skill delegation entries to `.swarm/skill-usage.jsonl` when
  * the architect delegates to a skill-capable agent with a non-empty, non-"none"
  * SKILLS field.
+ *
+ * @returns { blocked: false, reason: null } when no action needed.
+ *          { blocked: false, reason: "warning message" } when warning only (enforce=false).
+ *          { blocked: true, reason: "blocked: ..." } when blocking (enforce=true).
  */
-export declare function skillPropagationGateBefore(directory: string, input: SkillGateInput, config: SkillPropagationConfig): Promise<void>;
+export declare function skillPropagationGateBefore(directory: string, input: SkillGateInput, config: SkillPropagationConfig): Promise<{
+    blocked: boolean;
+    reason: string | null;
+}>;
 /**
  * Chat messages transform hook. Scans reviewer output for SKILL_COMPLIANCE
  * verdicts and records compliance outcomes to `.swarm/skill-usage.jsonl`.

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.22.1",
+    version: "7.23.1",
     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",
@@ -52386,7 +52386,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { mkdirSync as mkdirSync13, renameSync as renameSync9 } from "node:fs";
+import { closeSync as closeSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync13, openSync as openSync3, renameSync as renameSync9 } from "node:fs";
 import * as path33 from "node:path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -52403,6 +52403,12 @@ function serializeAgentSession(s) {
   const catastrophicPhaseWarnings = Array.from(s.catastrophicPhaseWarnings ?? new Set);
   const phaseAgentsDispatched = Array.from(s.phaseAgentsDispatched ?? new Set);
   const lastCompletedPhaseAgentsDispatched = Array.from(s.lastCompletedPhaseAgentsDispatched ?? new Set);
+  const stageBCompletion = {};
+  if (s.stageBCompletion) {
+    for (const [taskId, agents] of s.stageBCompletion) {
+      stageBCompletion[taskId] = Array.from(agents);
+    }
+  }
   const windows = {};
   const rawWindows = s.windows ?? {};
   for (const [key, win] of Object.entries(rawWindows)) {
@@ -52459,7 +52465,8 @@ function serializeAgentSession(s) {
     fullAutoInteractionCount: s.fullAutoInteractionCount ?? 0,
     fullAutoDeadlockCount: s.fullAutoDeadlockCount ?? 0,
     fullAutoLastQuestionHash: s.fullAutoLastQuestionHash ?? null,
-    sessionRehydratedAt: s.sessionRehydratedAt ?? 0
+    sessionRehydratedAt: s.sessionRehydratedAt ?? 0,
+    ...Object.keys(stageBCompletion).length > 0 && { stageBCompletion }
   };
 }
 async function writeSnapshot(directory, state) {
@@ -52481,6 +52488,14 @@ async function writeSnapshot(directory, state) {
     mkdirSync13(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
+    try {
+      const fd = openSync3(tempPath, "r+");
+      try {
+        fsyncSync2(fd);
+      } finally {
+        closeSync3(fd);
+      }
+    } catch {}
     renameSync9(tempPath, resolvedPath);
   } catch (error93) {
     log("[snapshot-writer] write failed", {
@@ -83382,6 +83397,8 @@ var _internals42 = {
   statSync: fs62.statSync.bind(fs62),
   mkdirSync: fs62.mkdirSync.bind(fs62),
   appendFileSync: fs62.appendFileSync.bind(fs62),
+  readFileSync: fs62.readFileSync.bind(fs62),
+  writeFileSync: fs62.writeFileSync.bind(fs62),
   skillPropagationGateBefore: null,
   skillPropagationTransformScan: null,
   SKILL_CAPABLE_AGENTS,
@@ -83394,7 +83411,8 @@ var _internals42 = {
   readSkillUsageEntriesTail,
   parseSkillPaths: null,
   extractTaskIdFromPrompt: null,
-  computeSkillRelevanceScore
+  computeSkillRelevanceScore,
+  formatSkillIndexWithContext
 };
 function discoverAvailableSkills(directory) {
   const results = [];
@@ -83494,22 +83512,22 @@ function extractTaskIdFromPrompt(prompt) {
 }
 async function skillPropagationGateBefore(directory, input, config3) {
   if (!config3.enabled)
-    return;
+    return { blocked: false, reason: null };
   const toolName = typeof input.tool === "string" ? input.tool : "";
   if (toolName !== "task" && toolName !== "Task")
-    return;
+    return { blocked: false, reason: null };
   const agentRaw = typeof input.agent === "string" ? input.agent : "";
   if (!agentRaw)
-    return;
+    return { blocked: false, reason: null };
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
-    return;
+    return { blocked: false, reason: null };
   const parsed = _internals42.parseDelegationArgs(input.args);
   if (!parsed)
-    return;
+    return { blocked: false, reason: null };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
   if (!_internals42.SKILL_CAPABLE_AGENTS.has(targetBase))
-    return;
+    return { blocked: false, reason: null };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
   const availableSkills = _internals42.discoverAvailableSkills(directory);
   const skillsValue = parsed.skillsField.trim();
@@ -83545,16 +83563,19 @@ async function skillPropagationGateBefore(directory, input, config3) {
       }
     }
   }
+  let scoringSkipped = false;
+  let scored = [];
   if (skillsValue && skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
       const sessionEntries = _internals42.readSkillUsageEntriesTail(directory, {
         sessionID
       });
       if (sessionEntries.length > _internals42.MAX_SCORING_SESSION_ENTRIES) {
+        scoringSkipped = true;
         warn(`[skill-propagation-gate] skipping scoring — session has ${sessionEntries.length} entries (limit: ${_internals42.MAX_SCORING_SESSION_ENTRIES})`);
       } else {
         const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-        const scored = availableSkills.map((skillPath) => {
+        scored = availableSkills.map((skillPath) => {
           const skillEntries = sessionEntries.filter((e) => e.skillPath === skillPath);
           const score = _internals42.computeSkillRelevanceScore(skillPath, prompt, skillEntries);
           return { skillPath, score, usageCount: skillEntries.length };
@@ -83569,11 +83590,77 @@ async function skillPropagationGateBefore(directory, input, config3) {
       warn(`[skill-propagation-gate] skill scoring failed (non-blocking): ${err2 instanceof Error ? err2.message : String(err2)}`);
     }
   }
+  if (availableSkills.length > 0) {
+    try {
+      let skillsForIndex = availableSkills;
+      if (scoringSkipped) {
+        skillsForIndex = [...availableSkills].sort((a, b) => {
+          const nameA = path89.basename(path89.dirname(a));
+          const nameB = path89.basename(path89.dirname(b));
+          return nameA.localeCompare(nameB);
+        });
+      } else if (typeof scored !== "undefined" && scored.length > 0) {
+        skillsForIndex = scored.map((r) => r.skillPath);
+      }
+      const formattedIndex = _internals42.formatSkillIndexWithContext(skillsForIndex, directory);
+      if (formattedIndex.length > 0) {
+        const contextPath = path89.join(directory, ".swarm", "context.md");
+        let existingContent = "";
+        if (_internals42.existsSync(contextPath)) {
+          existingContent = _internals42.readFileSync(contextPath, "utf-8");
+        }
+        const sectionHeader = "## Available Skills";
+        const newSection = `${sectionHeader}
+${formattedIndex}
+`;
+        let updatedContent;
+        if (existingContent.includes(sectionHeader)) {
+          const sectionStart = existingContent.indexOf(sectionHeader);
+          const sectionEnd = existingContent.indexOf(`
+## `, sectionStart + sectionHeader.length);
+          if (sectionEnd !== -1) {
+            updatedContent = existingContent.slice(0, sectionStart) + newSection + existingContent.slice(sectionEnd + 1);
+          } else {
+            updatedContent = existingContent.slice(0, sectionStart) + newSection;
+          }
+        } else {
+          if (existingContent.length > 0 && !existingContent.endsWith(`
+`)) {
+            updatedContent = existingContent + `
+` + newSection;
+          } else {
+            updatedContent = existingContent + newSection;
+          }
+        }
+        const swarmDir = path89.dirname(contextPath);
+        if (!_internals42.existsSync(swarmDir)) {
+          _internals42.mkdirSync(swarmDir, { recursive: true });
+        }
+        _internals42.writeFileSync(contextPath, updatedContent, "utf-8");
+      }
+    } catch (err2) {
+      warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+  }
+  if (targetBase === "reviewer") {
+    const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
+    const hasSkillsUsedByCoder = /SKILLS_USED_BY_CODER\s*:/i.test(prompt);
+    const coderHadSkills = skillsValue.length > 0 && skillsValue.toLowerCase() !== "none";
+    if (!hasSkillsUsedByCoder && coderHadSkills) {
+      const message = `SKILLS_USED_BY_CODER warning: Delegating to reviewer without SKILLS_USED_BY_CODER field. ` + `Add SKILLS_USED_BY_CODER with the skills the coder received for this task.`;
+      return { blocked: false, reason: message };
+    }
+  }
   if (availableSkills.length === 0)
-    return;
+    return { blocked: false, reason: null };
   const skillsLower = skillsValue.toLowerCase();
   if (skillsValue && skillsLower !== "none")
-    return;
+    return { blocked: false, reason: null };
+  const skillNames = availableSkills.map((p) => {
+    const parts2 = p.split("/");
+    return parts2[parts2.length - 2] ?? p;
+  });
+  const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
     _internals42.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
@@ -83586,6 +83673,11 @@ async function skillPropagationGateBefore(directory, input, config3) {
       available_skills: availableSkills
     });
   } catch {}
+  if (config3.enforce) {
+    const blockedMsg = `Blocked by skill propagation gate: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}. ` + `Add a SKILLS: field or set enforce: false in config.`;
+    return { blocked: true, reason: blockedMsg };
+  }
+  return { blocked: false, reason: warningMsg };
 }
 var COMPLIANCE_PATTERN = /SKILL_COMPLIANCE\s*:\s*(COMPLIANT|PARTIAL|VIOLATED)(?:\s*(?:—|-)\s*(.*))?\s*$/i;
 var CODER_SKILLS_PATTERN = /SKILLS_USED_BY_CODER\s*:\s*(.+)/i;
@@ -83599,10 +83691,13 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals42.readSkillUsageEntries(directory, {
+    existingEntries = _internals42.readSkillUsageEntriesTail(directory, {
       sessionID
     });
-    dedupKeys = new Set(existingEntries.map((e) => `${e.skillPath}|${e.agentName}|${e.taskID}`));
+    dedupKeys = new Set(existingEntries.map((e, i2) => {
+      const taskKey = e.taskID === "unknown" ? `unknown-${i2}` : e.taskID;
+      return `${e.skillPath}|${e.agentName}|${taskKey}`;
+    }));
   } catch (err2) {
     warn(`[skill-propagation-gate] dedup preload failed, continuing without dedup: ${err2 instanceof Error ? err2.message : String(err2)}`);
   }
@@ -83738,6 +83833,7 @@ _internals42.discoverAvailableSkills = discoverAvailableSkills;
 _internals42.parseDelegationArgs = parseDelegationArgs;
 _internals42.parseSkillPaths = parseSkillPaths;
 _internals42.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+_internals42.formatSkillIndexWithContext = formatSkillIndexWithContext;
 
 // src/hooks/slop-detector.ts
 import * as fs63 from "node:fs";
@@ -85115,6 +85211,12 @@ function deserializeAgentSession(s) {
   const catastrophicPhaseWarnings = new Set(s.catastrophicPhaseWarnings ?? []);
   const phaseAgentsDispatched = new Set(s.phaseAgentsDispatched ?? []);
   const lastCompletedPhaseAgentsDispatched = new Set(s.lastCompletedPhaseAgentsDispatched ?? []);
+  const stageBCompletion = new Map;
+  if (s.stageBCompletion) {
+    for (const [taskId, agents] of Object.entries(s.stageBCompletion)) {
+      stageBCompletion.set(taskId, new Set(agents));
+    }
+  }
   const windows = {};
   for (const [key, win] of Object.entries(s.windows ?? {})) {
     windows[key] = {
@@ -85169,7 +85271,8 @@ function deserializeAgentSession(s) {
     prmLastPatternDetected: null,
     prmTrajectoryStep: 0,
     prmHardStopPending: false,
-    sessionRehydratedAt: s.sessionRehydratedAt ?? 0
+    sessionRehydratedAt: s.sessionRehydratedAt ?? 0,
+    stageBCompletion
   };
 }
 async function readSnapshot(directory) {
@@ -86379,7 +86482,7 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename13 = path97.basename(filePath);
+  const basename14 = path97.basename(filePath);
   const _ext = path97.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
@@ -86395,7 +86498,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename13.includes(pattern)) {
+    if (basename14.includes(pattern)) {
       return true;
     }
   }
@@ -87009,8 +87112,8 @@ import {
   appendFileSync as appendFileSync11,
   existsSync as existsSync53,
   mkdirSync as mkdirSync24,
-  readFileSync as readFileSync43,
-  writeFileSync as writeFileSync16
+  readFileSync as readFileSync44,
+  writeFileSync as writeFileSync17
 } from "node:fs";
 import { join as join83 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -87052,7 +87155,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
   const existingRoot = Object.create(null);
   if (existsSync53(filePath)) {
     try {
-      const parsed = JSON.parse(readFileSync43(filePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync44(filePath, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         safeAssignOwnProps(existingRoot, parsed);
       }
@@ -87080,7 +87183,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
     updated.taskId = synthesis.taskId;
   if (!Array.isArray(updated.required_gates))
     updated.required_gates = [];
-  writeFileSync16(filePath, JSON.stringify(updated, null, 2));
+  writeFileSync17(filePath, JSON.stringify(updated, null, 2));
   try {
     const councilDir = join83(workingDir, ".swarm", "council");
     mkdirSync24(councilDir, { recursive: true });
@@ -87412,7 +87515,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 }
 
 // src/council/criteria-store.ts
-import { existsSync as existsSync54, mkdirSync as mkdirSync25, readFileSync as readFileSync44, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync25, readFileSync as readFileSync45, writeFileSync as writeFileSync18 } from "node:fs";
 import { join as join84 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
@@ -87423,14 +87526,14 @@ function writeCriteria(workingDir, taskId, criteria) {
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync17(join84(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync18(join84(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
   const filePath = join84(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
   if (!existsSync54(filePath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync44(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync45(filePath, "utf-8"));
     if (parsed && typeof parsed === "object" && typeof parsed.taskId === "string" && Array.isArray(parsed.criteria)) {
       return parsed;
     }
@@ -99766,10 +99869,10 @@ init_loader();
 import {
   existsSync as existsSync72,
   mkdirSync as mkdirSync31,
-  readFileSync as readFileSync62,
+  readFileSync as readFileSync63,
   renameSync as renameSync20,
   unlinkSync as unlinkSync15,
-  writeFileSync as writeFileSync24
+  writeFileSync as writeFileSync25
 } from "node:fs";
 import path124 from "node:path";
 init_create_tool();
@@ -99903,7 +100006,7 @@ var submit_phase_council_verdicts = createSwarmTool({
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   const mutationGatePath = path124.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
-    const raw = readFileSync62(mutationGatePath, "utf-8");
+    const raw = readFileSync63(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
     const gateEntry = (parsed.entries ?? []).find((entry) => entry?.type === "mutation-gate");
     if (!gateEntry) {
@@ -99998,7 +100101,7 @@ function writePhaseCouncilEvidence(workingDir, synthesis) {
   };
   const tempFile = `${evidenceFile}.tmp-${Date.now()}`;
   try {
-    writeFileSync24(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    writeFileSync25(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
     renameSync20(tempFile, evidenceFile);
   } finally {
     if (existsSync72(tempFile)) {
@@ -102209,7 +102312,7 @@ import * as path131 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { unlinkSync as unlinkSync16, writeFileSync as writeFileSync25 } from "node:fs";
+import { unlinkSync as unlinkSync16, writeFileSync as writeFileSync26 } from "node:fs";
 import * as path130 from "node:path";
 
 // src/mutation/equivalence.ts
@@ -102352,7 +102455,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
     patchFile = path130.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
-      writeFileSync25(patchFile, patch.patch);
+      writeFileSync26(patchFile, patch.patch);
     } catch (writeErr) {
       error93 = `Failed to write patch file: ${writeErr}`;
       outcome = "error";
@@ -103865,7 +103968,27 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
       }
     }
     const currentStateStr = stateEntries.length > 0 ? stateEntries.join(", ") : "no active sessions";
-    const finalReason = evidenceIncompleteReason ?? `Task ${taskId} has not passed QA gates. Current state by session: [${currentStateStr}]. Missing required state: tests_run or complete in at least one valid session. Do not write directly to plan files — use update_task_status after running the reviewer and test_engineer agents.`;
+    const chainEntries = [];
+    for (const [sessionId, chain] of swarmState.delegationChains) {
+      const session = swarmState.agentSessions.get(sessionId);
+      if (session && (session.currentTaskId === taskId || session.lastCoderDelegationTaskId === taskId)) {
+        const targets = chain.map((d) => stripKnownSwarmPrefix(d.to));
+        chainEntries.push(`${sessionId}: [${targets.join(", ")}]`);
+      }
+    }
+    const chainSummary = chainEntries.length > 0 ? chainEntries.join("; ") : "no chains for this task";
+    const rehydratedSessionCount = [
+      ...swarmState.agentSessions.values()
+    ].filter((s) => s.sessionRehydratedAt > 0).length;
+    const finalReason = [
+      `Task ${taskId} has not passed QA gates.`,
+      `  Session states: [${currentStateStr}].`,
+      `  Delegation chains: [${chainSummary}].`,
+      `  Evidence: [${evidenceIncompleteReason ?? "no evidence file found"}].`,
+      `  Rehydrated sessions: ${rehydratedSessionCount}.`,
+      `  Missing required state: tests_run or complete.`
+    ].join(`
+`);
     telemetry.gateFailed("", "qa_gate", taskId, evidenceIncompleteReason ? `Missing gates: evidence incomplete` : `Missing state: tests_run or complete`);
     return {
       blocked: true,
@@ -103887,7 +104010,7 @@ async function checkReviewerGateWithScope(taskId, workingDirectory, sessionID) {
 ${scopeWarning}` : scopeWarning
   };
 }
-function recoverTaskStateFromDelegations(taskId) {
+function recoverTaskStateFromDelegations(taskId, directory) {
   let hasReviewer = false;
   let hasTestEngineer = false;
   for (const [sessionId, chain] of swarmState.delegationChains) {
@@ -103902,8 +104025,24 @@ function recoverTaskStateFromDelegations(taskId) {
       }
     }
   }
+  if ((!hasReviewer || !hasTestEngineer) && directory) {
+    try {
+      const evidence = readTaskEvidenceRaw(directory, taskId);
+      if (evidence && evidence.gates && Array.isArray(evidence.required_gates)) {
+        if (evidence.gates["reviewer"] != null)
+          hasReviewer = true;
+        if (evidence.gates["test_engineer"] != null)
+          hasTestEngineer = true;
+      }
+    } catch {}
+  }
   if (!hasReviewer && !hasTestEngineer)
     return;
+  if (swarmState.agentSessions.size === 0) {
+    try {
+      startAgentSession("recovery-session", "architect");
+    } catch {}
+  }
   for (const [, session] of swarmState.agentSessions) {
     if (!(session.taskWorkflowStates instanceof Map))
       continue;
@@ -104047,7 +104186,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     } catch {}
   }
   if (args2.status === "completed") {
-    recoverTaskStateFromDelegations(args2.task_id);
+    recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
       const planPath = path137.join(directory, ".swarm", "plan.json");
@@ -105762,12 +105901,20 @@ async function initializeOpenCodeSwarm(ctx) {
         agent: input.agent,
         sessionID: input.sessionID
       }, KnowledgeApplicationConfigSchema.parse(config3.knowledge_application ?? {}));
-      await skillPropagationGateBefore(ctx.directory, {
+      const skillResult = await skillPropagationGateBefore(ctx.directory, {
         tool: input.tool,
         agent: input.agent,
         sessionID: input.sessionID,
         args: input.args
       }, { enabled: true });
+      if (skillResult.blocked) {
+        throw new Error(skillResult.reason ?? "Blocked by skill propagation gate");
+      }
+      if (skillResult.reason) {
+        const skillSession = ensureAgentSession(input.sessionID, swarmState.activeAgent.get(input.sessionID) ?? ORCHESTRATOR_NAME);
+        skillSession.pendingAdvisoryMessages ??= [];
+        skillSession.pendingAdvisoryMessages.push(skillResult.reason);
+      }
       if (swarmState.lastBudgetPct >= 50) {
         const pressureSession = ensureAgentSession(input.sessionID, swarmState.activeAgent.get(input.sessionID) ?? ORCHESTRATOR_NAME);
         if (!pressureSession.contextPressureWarningSent) {

package/dist/session/snapshot-writer.d.ts

@@ -59,6 +59,8 @@ export interface SerializedAgentSession {
     fullAutoLastQuestionHash?: string | null;
     /** Timestamp when session was rehydrated from snapshot (0 if never rehydrated) */
     sessionRehydratedAt?: number;
+    /** Stage B completion tracking: per-task set of completed Stage B agents. Optional for backward compat with old snapshots. */
+    stageBCompletion?: Record<string, string[]>;
 }
 /**
  * Minimal interface for serialized InvocationWindow

package/dist/tools/update-task-status.d.ts

@@ -71,9 +71,14 @@ export declare function checkReviewerGateWithScope(taskId: string, workingDirect
  * missing), this function advances the task state so that checkReviewerGate can
  * make an accurate decision without attributing unrelated delegation activity.
  *
+ * Falls back to reading durable evidence files when delegation chains are empty
+ * (e.g., after a crash or session restart without snapshot). This ensures
+ * recovery works even when no in-memory delegation history exists.
+ *
  * @param taskId - The task ID to recover state for
+ * @param directory - Optional project directory for evidence file fallback
  */
-export declare function recoverTaskStateFromDelegations(taskId: string): void;
+export declare function recoverTaskStateFromDelegations(taskId: string, directory?: string): void;
 /**
  * Result of the council-gate check used when transitioning to 'completed'.
  *

package/package.json

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