opencode-swarm 7.200.8 → 7.200.10

package/dist/cli/{index-z1e9b5qk.js → index-vqknke9n.js}

@@ -1,26 +1,35 @@
 // @bun
+import {
+  ensureTaskGateRequirementsReceiptForSettledTransition,
+  getTaskWorkflowSnapshot,
+  withTaskEvidenceTransaction
+} from "./index-xkavxqf2.js";
 import {
   captureWorkspaceSnapshotAsync,
   changedFilesSinceSnapshotAsync
-} from "./index-bk8r4m9j.js";
+} from "./index-rpvp88js.js";
 import {
   removeWorktreeProvisioningOwner
-} from "./index-7h22y3ew.js";
+} from "./index-w0afnznk.js";
+import {
+  appendCoreEventSync
+} from "./index-rjsqf4hv.js";
 import {
   SOURCE_WORKTREE_GONE_STAGE,
-  ensureTaskGateRequirementsReceiptForSettledTransition,
-  getTaskWorkflowSnapshot,
+  preserveSettlementSource,
+  probeSettlementSource,
   readWorkflowWalFile,
   reconcileLandedMerge,
-  withTaskEvidenceTransaction,
+  releaseSettlementSource,
+  validateSettlementLane,
   writeWorkflowWalFile
-} from "./index-x8cac18k.js";
+} from "./index-r3wyt8za.js";
 import {
-  validateSwarmPath
-} from "./index-4krkevgc.js";
+  withSettlementArtifactLifecycle
+} from "./index-vm3j8fvn.js";
 import {
-  appendCoreEventSync
-} from "./index-vtpt8yns.js";
+  validateSwarmPath
+} from "./index-001tkp0j.js";
 import {
   init_path_identity,
   isPathWithinDeclaredScope
@@ -288,31 +297,44 @@ async function beginCoderSettlement(options) {
         return;
       }
     }
-    await transaction.transition({
-      type: "dispatch_attempted",
-      agentType: "coder",
-      expectedGeneration: options.expectedGeneration,
-      transitionId: options.transitionId
-    });
-    await writeWal(filePath, {
-      version: 1,
-      state: "DISPATCHED",
-      taskId: options.taskId,
-      transitionId: options.transitionId,
-      actor: options.actor,
-      processId: process.pid,
-      runtimeId,
-      expectedGeneration: options.expectedGeneration,
-      context: options.context,
-      ...options.worktree ? { worktree: options.worktree } : {},
-      recordedAt: new Date().toISOString()
-    });
-    ownsActiveDispatch = true;
-    await appendSettlementEvent(options.directory, "dispatched", {
-      taskId: options.taskId,
-      transitionId: options.transitionId,
-      actor: options.actor
-    });
+    const publish = async () => {
+      if (options.worktree) {
+        if (canonicalRootKeyFresh(options.context.baseline.directory) !== canonicalRootKeyFresh(options.worktree.worktreePath) || options.context.baseline.gitHead === null) {
+          throw new Error("CODER_SETTLEMENT_DISPATCH_ARTIFACT_CHANGED");
+        }
+        await _internals.validateSettlementLane(options.worktree.worktreePath, options.worktree.branchName, options.context.baseline.gitHead);
+      }
+      await transaction.transition({
+        type: "dispatch_attempted",
+        agentType: "coder",
+        expectedGeneration: options.expectedGeneration,
+        transitionId: options.transitionId
+      });
+      await writeWal(filePath, {
+        version: 1,
+        state: "DISPATCHED",
+        taskId: options.taskId,
+        transitionId: options.transitionId,
+        actor: options.actor,
+        processId: process.pid,
+        runtimeId,
+        expectedGeneration: options.expectedGeneration,
+        context: options.context,
+        ...options.worktree ? { worktree: options.worktree } : {},
+        recordedAt: new Date().toISOString()
+      });
+      ownsActiveDispatch = true;
+      await appendSettlementEvent(options.directory, "dispatched", {
+        taskId: options.taskId,
+        transitionId: options.transitionId,
+        actor: options.actor
+      });
+    };
+    if (options.worktree) {
+      await _internals.withSettlementArtifactLifecycle(options.directory, publish);
+    } else {
+      await publish();
+    }
   }));
   if (ownsActiveDispatch) {
     const key = dispatchKey(options.directory, options.taskId, options.transitionId);
@@ -512,7 +534,7 @@ async function cleanupRecoveredWorktree(directory, descriptor, options) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-9evd232c.js");
+  } = await import("./worktree-isolation-tjvxcsr9.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -540,6 +562,41 @@ async function cleanupRecoveredWorktree(directory, descriptor, options) {
     throw new Error("CODER_SETTLEMENT_OWNER_CLEANUP_FAILED");
   }
 }
+var HISTORICAL_ORPHAN_ADVISORY_COOLDOWN_MS = 600000;
+var MAX_HISTORICAL_ORPHAN_ADVISORIES = 256;
+var historicalOrphanAdvisoryAt = new Map;
+function shouldEmitHistoricalOrphanAdvisory(key) {
+  const now = Date.now();
+  const last = historicalOrphanAdvisoryAt.get(key);
+  if (last !== undefined && now - last >= 0 && now - last < HISTORICAL_ORPHAN_ADVISORY_COOLDOWN_MS)
+    return false;
+  historicalOrphanAdvisoryAt.delete(key);
+  historicalOrphanAdvisoryAt.set(key, now);
+  while (historicalOrphanAdvisoryAt.size > MAX_HISTORICAL_ORPHAN_ADVISORIES) {
+    const oldest = historicalOrphanAdvisoryAt.keys().next().value;
+    if (oldest === undefined)
+      break;
+    historicalOrphanAdvisoryAt.delete(oldest);
+  }
+  return true;
+}
+async function preserveHistoricalSelfHealedSource(directory, wal) {
+  if (wal.state !== "ABORTED" || !wal.abortReason?.startsWith("CODER_SETTLEMENT_SELF_HEALED_MISSING_WORKTREE") || !wal.mergeProvenance || await probeSettlementSource(directory, wal.mergeProvenance.sourceHead) !== "present")
+    return "none";
+  const source = wal.mergeProvenance.sourceHead;
+  const backup = await preserveSettlementSource(directory, source);
+  const landed = await reconcileLandedMerge(directory, wal.mergeProvenance);
+  if (landed.landed && landed.method !== "worktree-match") {
+    await releaseSettlementSource(directory, source);
+    return "none";
+  }
+  if (shouldEmitHistoricalOrphanAdvisory(`${canonicalRootKeyFresh(directory)}\x00${wal.taskId}\x00${source}`)) {
+    const message = `RECOVERABLE_ORPHAN_COMMIT: historical aborted task ${wal.taskId} source ${source} is retained at ${backup}; apply it explicitly after reviewing the current task generation. The settlement remains ABORTED. This report is advisory: task status, dispatch and close are not blocked by it.`;
+    criticalWarn(message);
+    advisoryWarn(message);
+  }
+  return "orphan";
+}
 async function completeCoderSettlementCleanup(directory, taskId, transitionId) {
   await withSettlementLock(directory, taskId, "coder-cleanup", async () => {
     const filePath = walPath(directory, taskId);
@@ -552,6 +609,8 @@ async function completeCoderSettlementCleanup(directory, taskId, transitionId) {
     if (wal.state !== "COMMITTED" && wal.state !== "ABORTED") {
       throw new Error("CODER_SETTLEMENT_NOT_COMMITTED");
     }
+    if (await preserveHistoricalSelfHealedSource(directory, wal) === "orphan")
+      return;
     if (!wal.worktree || wal.cleanupComplete === true)
       return;
     await cleanupRecoveredWorktree(directory, wal.worktree);
@@ -563,6 +622,14 @@ async function selfHealMissingLaneWorktree(directory, filePath, taskId, transiti
     return false;
   if (_internals.branchExists(directory, descriptor.branchName))
     return false;
+  const currentWal = await readWal(filePath, taskId);
+  if (currentWal?.mergeProvenance) {
+    const source = currentWal.mergeProvenance.sourceHead;
+    if (await probeSettlementSource(directory, source) === "present") {
+      const backup = await preserveSettlementSource(directory, source);
+      throw new Error(`RECOVERABLE_ORPHAN_COMMIT: task ${taskId} source ${source} is retained at ${backup}; settlement remains pending.`);
+    }
+  }
   const reason = `CODER_SETTLEMENT_SELF_HEALED_MISSING_WORKTREE: ${detail}`;
   const aborted = await abortDispatchedWalUnderLock(directory, taskId, transitionId, reason);
   if (aborted.outcome === "not-dispatched")
@@ -588,8 +655,10 @@ async function recoverCoderSettlement(directory, taskId) {
     if (existingWal === null)
       return null;
     let wal = existingWal;
-    if (wal.state === "ABORTED")
+    if (wal.state === "ABORTED") {
+      await preserveHistoricalSelfHealedSource(directory, wal);
       return null;
+    }
     if (wal.state === "COMMITTED") {
       if (wal.worktree && wal.cleanupComplete !== true) {
         await cleanupRecoveredWorktree(directory, wal.worktree);
@@ -604,6 +673,9 @@ async function recoverCoderSettlement(directory, taskId) {
     if (wal.state === "DISPATCHED") {
       if (wal.worktree) {
         const worktree = wal.worktree;
+        const sourceState = wal.mergeProvenance ? await probeSettlementSource(directory, wal.mergeProvenance.sourceHead) : undefined;
+        if (sourceState === "absent" && await selfHealMissingLaneWorktree(directory, filePath, taskId, wal.transitionId, worktree, "the recorded source object, lane branch and checkout are absent"))
+          return null;
         const observed2 = wal.observedFiles ?? await scopedObservedFiles(worktree.worktreePath, wal.context);
         if (observed2 === null) {
           throw new Error(`CODER_SETTLEMENT_RECOVERY_UNCERTAIN: transition ${wal.transitionId} for isolated task ${taskId} could not attribute worktree changes to the declared scope (${filePath}, state ${wal.state}). Run /swarm recover ${taskId} (or /swarm reset-session), then retry; do not remove the WAL by hand.`);
@@ -611,10 +683,15 @@ async function recoverCoderSettlement(directory, taskId) {
         const unattributedEmptyScopeMutation2 = hasUnattributedEmptyScopeMutation(wal.context.declaredFiles, observed2);
         const accepted = observed2.length > 0 || unattributedEmptyScopeMutation2;
         const settlementFailed = wal.settlementFailed === true || unattributedEmptyScopeMutation2;
-        if (wal.mergeProvenance) {
+        if (wal.mergeProvenance && sourceState !== "absent") {
           const landed = await reconcileLandedMerge(directory, wal.mergeProvenance);
           if (landed.landed) {
             const landedUnstaged = landed.method === "worktree-match";
+            if (landedUnstaged) {
+              await preserveSettlementSource(directory, wal.mergeProvenance.sourceHead);
+            } else {
+              await releaseSettlementSource(directory, wal.mergeProvenance.sourceHead);
+            }
             wal = {
               ...wal,
               state: "PREPARED",
@@ -640,6 +717,7 @@ async function recoverCoderSettlement(directory, taskId) {
             });
             return committed2;
           }
+          await preserveSettlementSource(directory, wal.mergeProvenance.sourceHead);
           if (landed.error) {
             throw new Error(`CODER_SETTLEMENT_RECOVERY_UNCERTAIN: transition ${wal.transitionId} for task ${taskId} could not reconcile the landed merge (${filePath}, state ${wal.state}): ${landed.error}. Run /swarm recover ${taskId} (or /swarm reset-session), then retry; do not remove the WAL by hand.`);
           }
@@ -648,7 +726,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-9evd232c.js");
+        } = await import("./worktree-isolation-tjvxcsr9.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -927,9 +1005,12 @@ async function recoverStaleCoderSettlements(directory, options) {
 }
 var _internals = {
   liveDispatches,
+  withSettlementArtifactLifecycle,
+  validateSettlementLane,
   removeWorktreeProvisioningOwner,
   branchExists: probeBranchExists,
-  recoverCoderSettlement
+  recoverCoderSettlement,
+  historicalOrphanAdvisoryAt
 };
 
 export { hasUnattributedEmptyScopeMutation, beginCoderSettlement, settleCoderDispatch, abortCoderSettlement, transferCoderSettlementToBackground, abortCoderSettlementIfDoomed, recordCoderMergeProvenance, completeCoderSettlementCleanup, recoverCoderSettlement, releaseCoderDispatchOwnership, assertNoUnsettledCoderDispatch, listCoderSettlementWalStates, recoverStaleCoderSettlements, _internals };

package/dist/cli/{index-4ph7ad0b.js → index-vx1j2t5p.js}

@@ -9,10 +9,10 @@ import {
 } from "./index-txdagbh7.js";
 import {
   atomicWriteFile
-} from "./index-yyrnkc3a.js";
+} from "./index-6m551cng.js";
 import {
   withEvidenceLock
-} from "./index-q8vfw61p.js";
+} from "./index-pjrx4jkq.js";
 import {
   assertProjectRoot
 } from "./index-t7hmqgjy.js";

package/dist/cli/{index-7h22y3ew.js → index-w0afnznk.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-4krkevgc.js";
+} from "./index-001tkp0j.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-mn75z39t.js";
+} from "./index-9qy3tzt5.js";
 
 // src/hooks/delegation-gate/worktree-provisioning-owner.ts
 import { createHash } from "crypto";

package/dist/cli/{index-76xnddca.js → index-ww5ne0g6.js}

@@ -1,10 +1,4 @@
 // @bun
-import {
-  GIT_BINARY_ENV_VAR,
-  advisoryWarn,
-  init_git_executable,
-  init_warning_buffer
-} from "./index-sp2cxpaq.js";
 import {
   CONSERVATIVE_PRESET_BASE,
   ExternalSkillsConfigSchema,
@@ -16,7 +10,13 @@ import {
   init_schema,
   resolveExternalSkillsConfig,
   retiredEpicKeyReplacement
-} from "./index-k5h4mmwd.js";
+} from "./index-06sj5bjh.js";
+import {
+  GIT_BINARY_ENV_VAR,
+  advisoryWarn,
+  init_git_executable,
+  init_warning_buffer
+} from "./index-sp2cxpaq.js";
 import {
   DangerousMergeKeyError,
   MAX_MERGE_DEPTH,