opencode-swarm 7.78.4 → 7.78.5

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.78.4",
+    version: "7.78.5",
     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",

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.78.4",
+    version: "7.78.5",
     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",
@@ -64383,7 +64383,7 @@ async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
           return true;
         return false;
       });
-      const violations = skillUsage.filter((e) => e.complianceVerdict === "violation").length;
+      const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
       let allArchived = false;
       try {
@@ -65044,7 +65044,7 @@ ${phaseDigest.summary}`,
         });
         if (skillUsage.length === 0)
           continue;
-        const violations = skillUsage.filter((e) => e.complianceVerdict === "violation").length;
+        const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
         const violationRate = violations / skillUsage.length;
         if (violationRate > REVISION_VIOLATION_THRESHOLD && violationRate <= 0.3) {
           const content = await _internals28.readFileAsync(active.path, "utf-8");
@@ -65052,7 +65052,7 @@ ${phaseDigest.summary}`,
           if (fm && fm.skillOrigin === "promoted_external")
             continue;
           const currentVersion = fm?.version ?? 1;
-          const violationContexts = skillUsage.filter((e) => e.complianceVerdict === "violation").slice(-10).map((e) => ({
+          const violationContexts = skillUsage.filter((e) => e.complianceVerdict === "violated").slice(-10).map((e) => ({
             taskId: e.taskID,
             agent: e.agentName,
             verdict: e.complianceVerdict,
@@ -103812,7 +103812,7 @@ var init_curator_drift = __esm(() => {
 var exports_design_doc_drift = {};
 __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
-  _internals: () => _internals94
+  _internals: () => _internals95
 });
 import * as fs110 from "node:fs";
 import * as path165 from "node:path";
@@ -103945,7 +103945,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     return null;
   }
 }
-var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals94;
+var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals95;
 var init_design_doc_drift = __esm(() => {
   init_event_bus();
   init_effective_spec();
@@ -103960,7 +103960,7 @@ var init_design_doc_drift = __esm(() => {
     "idiom-notes": path165.join("reference", "idiom-notes.md")
   };
   TRACEABILITY_REL = path165.join("reference", "traceability.json");
-  _internals94 = {
+  _internals95 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
     DESIGN_DOC_FILES
@@ -103971,7 +103971,7 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals107,
+  _internals: () => _internals108,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs134 from "node:fs";
@@ -104055,7 +104055,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals107.pickBackend(directory);
+  const backend = await _internals108.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -104094,17 +104094,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals107.pickedProfiles(directory);
+  const profiles = _internals108.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals107;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals108;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals107 = {
+  _internals108 = {
     pickBackend,
     pickedProfiles
   };
@@ -130481,6 +130481,65 @@ function getMergeStrategy2(config3) {
 // src/turbo/lean/runner.ts
 init_state3();
 
+// src/turbo/lean/state-lock.ts
+init_file_locks();
+var _internals89 = { tryAcquireLock };
+
+class TurboStateLockTimeoutError extends Error {
+  directory;
+  sessionID;
+  constructor(directory, sessionID, timeoutMs) {
+    super(`Turbo state lock timeout after ${timeoutMs}ms for session ${sessionID}`);
+    this.name = "TurboStateLockTimeoutError";
+    this.directory = directory;
+    this.sessionID = sessionID;
+  }
+}
+var BACKOFF_START_MS2 = 50;
+var BACKOFF_MAX_MS2 = 2000;
+var BACKOFF_JITTER_RATIO2 = 0.25;
+function backoffMs2(attempt) {
+  const base = Math.min(BACKOFF_START_MS2 * 2 ** attempt, BACKOFF_MAX_MS2);
+  const jitter = base * BACKOFF_JITTER_RATIO2 * (Math.random() * 2 - 1);
+  return Math.max(1, Math.round(base + jitter));
+}
+async function withTurboStateLock(directory, sessionID, fn2, timeoutMs = 30000) {
+  const lockPath = ".swarm/turbo-state.json";
+  const agent = "lean-turbo-runner";
+  const deadline = Date.now() + timeoutMs;
+  let attempt = 0;
+  while (true) {
+    let result;
+    try {
+      result = await _internals89.tryAcquireLock(directory, lockPath, agent, sessionID);
+    } catch (acquireErr) {
+      console.warn(`[lean-turbo] state lock acquisition error for ${sessionID} (${lockPath}), will retry: ${acquireErr instanceof Error ? acquireErr.message : String(acquireErr)}`);
+    }
+    if (result && result.acquired) {
+      const lock = result.lock;
+      try {
+        return await fn2();
+      } finally {
+        if (lock._release) {
+          try {
+            await lock._release();
+          } catch (releaseErr) {
+            console.warn(`[lean-turbo] state lock release failed for ${sessionID} (${lockPath}): ${releaseErr instanceof Error ? releaseErr.message : String(releaseErr)}`);
+          }
+        }
+      }
+    }
+    if (Date.now() >= deadline) {
+      throw new TurboStateLockTimeoutError(directory, sessionID, timeoutMs);
+    }
+    const delay2 = Math.min(backoffMs2(attempt), deadline - Date.now());
+    if (delay2 > 0) {
+      await new Promise((resolve60) => setTimeout(resolve60, delay2));
+    }
+    attempt++;
+  }
+}
+
 // src/turbo/lean/worktree.ts
 init_core3();
 async function provisionWorktree2(directory, laneId, sessionId, config3) {
@@ -131062,21 +131121,47 @@ class LeanTurboRunner {
     return agent;
   }
   async _writeLaneEvidenceSafely(lane, status, extras) {
-    try {
-      const evidence = {
-        laneId: lane.laneId,
-        taskIds: lane.taskIds,
-        files: lane.files,
-        status,
-        startedAt: lane.startedAt,
-        ...extras
-      };
-      const runState = LeanTurboRunner._internals.loadLeanTurboRunState(this._directory, this._sessionID);
-      const phase = runState?.phase;
-      if (phase !== undefined) {
+    const maxAttempts = 3;
+    const baseDelayMs = 100;
+    for (let attempt = 0;attempt < maxAttempts; attempt++) {
+      try {
+        const evidence = {
+          laneId: lane.laneId,
+          taskIds: lane.taskIds,
+          files: lane.files,
+          status,
+          startedAt: lane.startedAt,
+          ...extras
+        };
+        const runState = LeanTurboRunner._internals.loadLeanTurboRunState(this._directory, this._sessionID);
+        const phase = runState?.phase;
+        if (phase === undefined) {
+          console.warn(`[lean-turbo] evidence write skipped for lane ${lane.laneId}: phase not set in run state`);
+          return;
+        }
         await LeanTurboRunner._internals.writeLaneEvidence(this._directory, phase, evidence);
+        return;
+      } catch (error93) {
+        const errCode = error93 instanceof Error ? error93.code ?? "" : "";
+        const isTransient = errCode.length > 0 && [
+          "ENOENT",
+          "EBUSY",
+          "EPERM",
+          "EIO",
+          "EAGAIN",
+          "ETIMEDOUT",
+          "ENOSPC"
+        ].includes(errCode);
+        if (attempt < maxAttempts - 1 && isTransient) {
+          const delayMs = baseDelayMs * 2 ** attempt;
+          await new Promise((resolve60) => setTimeout(resolve60, delayMs));
+          continue;
+        }
+        const msg = error93 instanceof Error ? error93.message : String(error93);
+        console.warn(`[lean-turbo] evidence write failed for lane ${lane.laneId}: ${msg}`);
+        return;
       }
-    } catch {}
+    }
   }
   _buildLanePrompt(lane) {
     const taskList = lane.taskIds.map((id) => `  - ${id}`).join(`
@@ -131095,23 +131180,9 @@ ${fileList}
 ` + `When all tasks are complete, signal completion.`;
   }
   async _withStateLock(fn2) {
-    const timeoutMs = 1e4;
-    let timeoutId;
-    const withTimeout3 = new Promise((_resolve, reject) => {
-      timeoutId = setTimeout(() => {
-        reject(new Error(`_withStateLock timed out after ${timeoutMs}ms — state update will not block subsequent operations`));
-      }, timeoutMs);
-    });
-    const chain = this._stateLock.then(fn2).finally(() => {
-      if (timeoutId)
-        clearTimeout(timeoutId);
-    });
-    const promise3 = Promise.race([chain, withTimeout3]).finally(() => {
-      if (timeoutId)
-        clearTimeout(timeoutId);
-    });
-    this._stateLock = promise3.catch(() => {});
-    return promise3;
+    const chain = this._stateLock.then(() => withTurboStateLock(this._directory, this._sessionID, fn2, 1e4));
+    this._stateLock = chain.catch(() => {});
+    return chain;
   }
   async _updateDurableState(lanePlan) {
     try {
@@ -131186,7 +131257,7 @@ ${fileList}
 
 // src/tools/lean-turbo-run-phase.ts
 init_create_tool();
-var _internals89 = {
+var _internals90 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -131196,9 +131267,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals89.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals90.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals89.LeanTurboRunner({
+    runner = new _internals90.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -131534,7 +131605,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals90 = {
+var _internals91 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -131574,7 +131645,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals90.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals91.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err2) {
       results.push({
@@ -131634,7 +131705,7 @@ function validateTestCommand(testCommand) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals91 = {
+var _internals92 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -131666,7 +131737,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals91.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals92.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -131697,7 +131768,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
     try {
       const safeTestFiles = testFiles.filter((f) => !f.startsWith("-"));
       const testArgs = safeTestFiles.length > 0 ? [...testCommand.slice(1), ...safeTestFiles] : testCommand.slice(1);
-      const spawnResult = _internals91.spawnSync(testCommand[0], testArgs, {
+      const spawnResult = _internals92.spawnSync(testCommand[0], testArgs, {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -131730,7 +131801,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals91.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals92.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -131927,7 +131998,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals92 = {
+var _internals93 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -131948,8 +132019,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals92.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals92.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals93.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals93.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -132466,7 +132537,7 @@ function listLaneEvidenceSync(directory, phase) {
   }
   return laneIds;
 }
-var _internals93 = {
+var _internals94 = {
   listActiveLocks,
   readPersisted: readPersisted2,
   readPlanJson: defaultReadPlanJson,
@@ -132527,7 +132598,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       reason: "Lean Turbo state unreadable or missing"
     };
   }
-  const persisted = _internals93.readPersisted(directory);
+  const persisted = _internals94.readPersisted(directory);
   if (!persisted) {
     return {
       ok: false,
@@ -132591,7 +132662,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (runState.lanes.length > 0) {
-    const evidenceLaneIds = new Set(_internals93.listLaneEvidenceSync(directory, phase));
+    const evidenceLaneIds = new Set(_internals94.listLaneEvidenceSync(directory, phase));
     for (const lane of runState.lanes) {
       if ((lane.status === "completed" || lane.status === "failed") && !evidenceLaneIds.has(lane.laneId)) {
         return {
@@ -132601,7 +132672,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       }
     }
   }
-  const activeLocks = _internals93.listActiveLocks(directory);
+  const activeLocks = _internals94.listActiveLocks(directory);
   const phaseLaneIds = new Set(laneIds);
   for (const lock of activeLocks) {
     if (lock.laneId && phaseLaneIds.has(lock.laneId)) {
@@ -132621,7 +132692,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serialDegradedTasks = runState.degradedTasks.filter((dt) => !laneTaskIds.has(dt.taskId));
   if (serialDegradedTasks.length > 0) {
-    const plan = _internals93.readPlanJson(directory);
+    const plan = _internals94.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -132665,7 +132736,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serializedTasks = runState.serializedTasks;
   if (Array.isArray(serializedTasks) && serializedTasks.length > 0) {
-    const plan = _internals93.readPlanJson(directory);
+    const plan = _internals94.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -132724,7 +132795,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let reviewerVerdict = runState.lastReviewerVerdict;
   if (!reviewerVerdict) {
-    const evidence = _internals93.readReviewerEvidence(directory, phase);
+    const evidence = _internals94.readReviewerEvidence(directory, phase);
     reviewerVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_reviewer) {
@@ -132737,7 +132808,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let criticVerdict = runState.lastCriticVerdict;
   if (!criticVerdict) {
-    const evidence = _internals93.readCriticEvidence(directory, phase);
+    const evidence = _internals94.readCriticEvidence(directory, phase);
     criticVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_critic) {
@@ -133920,7 +133991,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       phase_critic: leanConfig.phase_critic,
       integrated_diff_required: leanConfig.integrated_diff_required
     } : undefined;
-    const leanCheck = _internals93.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
+    const leanCheck = _internals94.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
     if (!leanCheck.ok) {
       return JSON.stringify({
         success: false,
@@ -136272,11 +136343,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals95.qualityBudget(args2, directory);
+    const result = await _internals96.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals95 = {
+var _internals96 = {
   qualityBudget
 };
 
@@ -137001,7 +137072,7 @@ var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
 var MAX_OUTPUT_BYTES8 = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals96 = {
+var _internals97 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -137027,7 +137098,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals96.isSemgrepAvailable();
+  return _internals97.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -137184,12 +137255,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS4;
   if (files.length === 0) {
     return {
-      available: _internals96.isSemgrepAvailable(),
+      available: _internals97.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals96.isSemgrepAvailable()) {
+  if (!_internals97.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -137356,7 +137427,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals97.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals98.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -137425,7 +137496,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals97.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals98.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -137565,7 +137636,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals97 = {
+var _internals98 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -137975,11 +138046,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals98.sastScan(input, directory);
+    const result = await _internals99.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals98 = {
+var _internals99 = {
   sastScan,
   sast_scan
 };
@@ -143014,7 +143085,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals99.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals100.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -143030,7 +143101,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals99.createMemoryGateway({
+    const gateway = _internals100.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -143055,7 +143126,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals99 = {
+var _internals100 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -143093,7 +143164,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals100.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals101.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -143109,7 +143180,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent4(ctx);
-    const gateway = _internals100.createMemoryGateway({
+    const gateway = _internals101.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -143142,7 +143213,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals100 = {
+var _internals101 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -143668,7 +143739,7 @@ import * as path185 from "node:path";
 init_bun_compat();
 import * as fs126 from "node:fs";
 import * as path184 from "node:path";
-var _internals101 = { bunSpawn };
+var _internals102 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -143701,7 +143772,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals101.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals102.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -143711,7 +143782,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals101.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals102.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -143721,7 +143792,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals101.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals102.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -143760,7 +143831,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals101.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals102.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -143785,7 +143856,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals102 = { bunSpawn };
+var _internals103 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path185.join(directory, ".swarm", "plan.json");
@@ -143820,7 +143891,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles2(directory) {
   try {
-    const proc = _internals102.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals103.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -143837,7 +143908,7 @@ async function getChangedFiles2(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals102.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals103.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -143895,7 +143966,7 @@ init_telemetry();
 init_file_locks();
 import * as fs128 from "node:fs";
 import * as path186 from "node:path";
-var _internals103 = {
+var _internals104 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -144037,7 +144108,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals103.listActiveLocks(directory);
+  const activeLocks = _internals104.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -144104,7 +144175,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-var _internals104 = {
+var _internals105 = {
   tryAcquireLock,
   updateTaskStatus,
   resolveWorkingDirectory
@@ -144201,7 +144272,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     let resolvedDir;
     if (fallbackDir) {
-      const resolveResult = _internals104.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      const resolveResult = _internals105.resolveWorkingDirectory(workingDirectory, fallbackDir);
       if (resolveResult.success) {
         resolvedDir = resolveResult.directory;
       } else {
@@ -144548,7 +144619,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
   }
   let directory;
-  const resolveResult = _internals104.resolveWorkingDirectory(args2.working_directory, fallbackDir);
+  const resolveResult = _internals105.resolveWorkingDirectory(args2.working_directory, fallbackDir);
   if (!resolveResult.success) {
     return {
       success: false,
@@ -144641,7 +144712,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   let lockResult;
   try {
-    lockResult = await _internals104.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+    lockResult = await _internals105.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
   } catch (error93) {
     return {
       success: false,
@@ -144660,7 +144731,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   try {
-    const updatedPlan = await _internals104.updateTaskStatus(directory, args2.task_id, args2.status);
+    const updatedPlan = await _internals105.updateTaskStatus(directory, args2.task_id, args2.status);
     if (args2.status === "completed") {
       for (const [_sessionId, session] of swarmState.agentSessions) {
         if (!(session.taskWorkflowStates instanceof Map)) {
@@ -145315,7 +145386,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const config3 = _internals105.loadPluginConfig(dirResult.directory);
+    const config3 = _internals106.loadPluginConfig(dirResult.directory);
     const generalConfig = config3.council?.general;
     if (!generalConfig || generalConfig.enabled !== true) {
       const fail = {
@@ -145325,7 +145396,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const validated = await validateFetchUrl(parsed.data.url, _internals105.dnsLookup);
+    const validated = await validateFetchUrl(parsed.data.url, _internals106.dnsLookup);
     if (!validated.ok) {
       const fail = {
         success: false,
@@ -145336,7 +145407,7 @@ var web_fetch = createSwarmTool({
     }
     const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
     const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS5;
-    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals105);
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals106);
     if (!result.ok) {
       const fail = {
         success: false,
@@ -145371,7 +145442,7 @@ var web_fetch = createSwarmTool({
 });
 async function captureFetchEvidence(directory, url3, title, text) {
   try {
-    const written = await _internals105.writeEvidenceDocuments(directory, [
+    const written = await _internals106.writeEvidenceDocuments(directory, [
       {
         sourceType: "crawl",
         url: url3,
@@ -145392,7 +145463,7 @@ async function captureFetchEvidence(directory, url3, title, text) {
     };
   }
 }
-var _internals105 = {
+var _internals106 = {
   httpRequest: performHttpRequest,
   dnsLookup: lookup,
   loadPluginConfig,
@@ -145706,7 +145777,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals106.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals107.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -145734,7 +145805,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals106 = {
+var _internals107 = {
   writeEvidenceDocuments
 };
 

package/dist/turbo/lean/runner.d.ts

@@ -122,6 +122,19 @@ export interface LaneResult {
 }
 /**
  * Result of a full phase run.
+ *
+ * ## Serial Tasks Contract
+ *
+ * `serializedTasks` contains task IDs excluded from parallel lanes due to lock conflicts
+ * (Issue #1 - Serial Task Orphan Risk).
+ *
+ * **Caller Responsibility**: The orchestrator MUST complete these tasks via standard
+ * serial flow (normal task dispatch). The runner does NOT dispatch serializedTasks.
+ *
+ * **Verification**: phase-ready (step 6b) verifies serializedTasks by checking that
+ * each task ID has status: completed in plan.json. If serializedTasks contain task IDs
+ * but those tasks are not marked completed in plan.json, phase-ready returns ok: false,
+ * blocking phase advancement.
  */
 export interface LeanTurboPhaseResult {
     /** Whether the phase ran (at least one lane attempted) */
@@ -132,7 +145,11 @@ export interface LeanTurboPhaseResult {
     lanes: LaneResult[];
     /** Task IDs that were degraded (risk conditions) */
     degradedTasks: string[];
-    /** Task IDs excluded from parallel lanes, must complete via standard serial flow */
+    /**
+     * Task IDs excluded from parallel lanes due to lock conflicts.
+     * Caller must complete these via standard serial flow before phase can advance.
+     * (Issue #1: Serial Task Orphan Risk - Fixed with integration test)
+     */
     serializedTasks: string[];
     /** Lanes whose coder completed but merge-back to primary branch failed */
     mergeBackFailures?: MergeBackFailureInfo[];
@@ -326,8 +343,11 @@ export declare class LeanTurboRunner {
      */
     private _selectNextAgent;
     /**
-     * Safely write lane evidence, catching errors to prevent evidence write
-     * failure from blocking lane processing.
+     * Write lane evidence with retry logic for transient disk errors.
+     *
+     * Evidence is required by phase-ready (step 4b) to verify lane completion.
+     * Transient I/O errors are retried with exponential backoff; permanent errors
+     * are logged and dropped (evidence failure is non-fatal for runner operation).
      */
     private _writeLaneEvidenceSafely;
     /**
@@ -335,11 +355,20 @@ export declare class LeanTurboRunner {
      */
     private _buildLanePrompt;
     /**
-     * Serializes access to durable state via a promise chain.
-     * Prevents concurrent lane updates from racing on turbo-state.json writes.
+     * Serializes access to durable state via a promise chain AND file-based lock.
+     *
+     * - Promise chain: serializes writes within a single runner instance
+     * - File-based lock: coordinates between multiple runners with the same sessionID
+     *
+     * Timeout budget starts when this call reaches the front of the queue (execution
+     * time), not when it is enqueued. withTurboStateLock computes its deadline
+     * internally on entry, so each caller gets a full 10-second window regardless
+     * of how long it waited behind prior entries.
      *
-     * Includes a 10-second timeout: if state persistence hangs, the lock is
-     * released so subsequent updates are not blocked indefinitely.
+     * Timeout coverage: withTurboStateLock is tested directly in state-lock.test.ts
+     * (test: "throws TurboStateLockTimeoutError when lock is held by another caller").
+     * This wrapper delegates to it in a single line with no additional timeout logic,
+     * so a separate wrapper-level timeout test would duplicate that coverage.
      */
     private _withStateLock;
     /**

package/dist/turbo/lean/state-lock.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Durable Lean Turbo state write-lock helper.
+ *
+ * ## Issue #2: Cross-Runner Durable State Race
+ *
+ * Multiple LeanTurboRunner instances with the same sessionID share turbo-state.json.
+ * Each runner has its own in-process _stateLock promise chain, but without file-level
+ * coordination, concurrent runners can race:
+ *
+ * - Runner A: load state → modify → write
+ * - Runner B: load state (gets A's version) → modify → write (overwrites A's changes)
+ *
+ * This module adds file-based locking using proper-lockfile to coordinate read-modify-write
+ * cycles across processes, preventing inter-runner write races.
+ *
+ * ## Pattern
+ *
+ * Mirrors the evidence-lock pattern (src/evidence/lock.ts) with:
+ * - Exponential backoff (50ms start, 2000ms max) with jitter
+ * - Timeout protection (default 30 seconds for state, 60 seconds for evidence)
+ * - Best-effort lock release in finally block
+ * - Non-fatal lock release failures (proper-lockfile TTL cleanup)
+ *
+ * ## Telemetry
+ *
+ * Events emitted (when integrated into runners):
+ * - turbo_state_lock_acquired
+ * - turbo_state_lock_contended
+ * - turbo_state_lock_timeout (thrown as error)
+ */
+import { tryAcquireLock } from '../../parallel/file-locks';
+/** Test-only seam — allows injecting a mock tryAcquireLock without mock.module. */
+export declare const _internals: {
+    tryAcquireLock: typeof tryAcquireLock;
+};
+export declare class TurboStateLockTimeoutError extends Error {
+    readonly directory: string;
+    readonly sessionID: string;
+    constructor(directory: string, sessionID: string, timeoutMs: number);
+}
+/**
+ * Acquire an exclusive turbo-state lock, execute `fn`, then release the lock.
+ *
+ * Retries with exponential backoff until `timeoutMs` elapses,
+ * then throws `TurboStateLockTimeoutError`. Always releases the lock in a
+ * `finally` block even if `fn` throws.
+ *
+ * **Timeout scope**: `timeoutMs` governs lock _acquisition_ only. Once the lock
+ * is held, `fn()` runs to completion with no separate execution deadline.
+ * Callers must ensure `fn` is bounded (e.g., synchronous disk writes). This
+ * matches the behaviour of the previous `Promise.race` implementation, which
+ * also could not cancel an in-flight `fn()`.
+ *
+ * @param directory    Project root directory
+ * @param sessionID    Session identifier (for lock metadata and diagnostics)
+ * @param fn           Callback that performs the read-modify-write on turbo state
+ * @param timeoutMs    Maximum wait time for lock acquisition (default 30 000ms)
+ */
+export declare function withTurboStateLock<T>(directory: string, sessionID: string, fn: () => Promise<T>, timeoutMs?: number): Promise<T>;

package/package.json

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