opencode-swarm 7.152.1 → 7.153.1

package/dist/cli/{index-txbd25bc.js → index-891g7hbf.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   emit
-} from "./index-aw492hpn.js";
+} from "./index-x8vw6ap1.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";

package/dist/cli/{index-02ajc6d1.js → index-8v9sj4aq.js}

@@ -2,14 +2,14 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-0tfgn5x0.js";
+} from "./index-k10qtq71.js";
 import {
   init_git_executable,
   resolveGitExecutableAsync
 } from "./index-9e6fdz2h.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-79g6edht.js";
+} from "./index-x3y6zhgj.js";
 import {
   init_knowledge_types,
   isActiveStatus

package/dist/cli/{index-z9fyd0d6.js → index-9v8d3c0k.js}

@@ -2,7 +2,7 @@
 import {
   autoCommitDirty,
   cleanUntrackedFiles
-} from "./index-qqrdmaxq.js";
+} from "./index-4g0g3dqz.js";
 import {
   isPathWithinDeclaredScope,
   unsafePathTextReason
@@ -26,13 +26,13 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-mken64yj.js";
+} from "./index-zppxpc3y.js";
 import {
   assertProjectRoot
-} from "./index-txbd25bc.js";
+} from "./index-891g7hbf.js";
 import {
   telemetry
-} from "./index-aw492hpn.js";
+} from "./index-x8vw6ap1.js";
 import {
   exports_external,
   init_zod
@@ -44,7 +44,7 @@ import {
 // src/gate-evidence.ts
 init_zod();
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/evidence/task-gate-requirements.ts
 init_zod();
@@ -299,12 +299,14 @@ function sanitizeTaskId(taskId) {
 }
 
 // src/workflow/workflow-wal-file.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import { mkdir, open } from "fs/promises";
 import { dirname } from "path";
 
 // src/worktree/merge.ts
 init_warning_buffer();
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/turbo/lean/recovery.ts
 import * as fs2 from "fs";
@@ -398,9 +400,10 @@ init_git_executable();
 var _internals = {
   bunSpawn,
   platform: process.platform,
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+  sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
   cleanupOrphanedBranches,
   startupOrphanRecovery,
+  captureMergeOverlapSnapshot,
   extractSessionId,
   resolveGitExecutable
 };
@@ -471,6 +474,285 @@ function parseConflictFiles(output) {
   return files;
 }
 var GIT_OBJECT_ID_PATTERN = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
+function abortArgsForStrategy(strategy) {
+  return strategy === "rebase" ? ["rebase", "--abort"] : strategy === "cherry-pick" ? ["cherry-pick", "--abort"] : ["merge", "--abort"];
+}
+async function finalizeMergeStrategyResult(primaryDir, strategy, result, metadata) {
+  if (result.exitCode === 0) {
+    return { merged: true, strategy, ...metadata };
+  }
+  const combinedOutput = `${result.stderr}
+${result.stdout}`;
+  const hasConflict = /CONFLICT/i.test(combinedOutput);
+  const operationState = await detectInProgressOperation(primaryDir);
+  if (hasConflict || operationState.inProgress) {
+    const abortResult = await runGit(abortArgsForStrategy(strategy), primaryDir);
+    if (abortResult.exitCode !== 0) {
+      return {
+        error: `${strategy} abort failed after a non-zero merge result: ${abortResult.stderr.trim() || abortResult.stdout.trim() || "unknown abort failure"}`,
+        ...metadata
+      };
+    }
+    return {
+      conflict: true,
+      files: parseConflictFiles(combinedOutput),
+      message: result.stderr.trim() || result.stdout.trim() || (operationState.inProgress ? `${strategy} left an in-progress operation; it was aborted` : `${strategy} reported a conflict`),
+      ...metadata
+    };
+  }
+  return {
+    error: result.stderr.trim() || result.stdout.trim(),
+    ...metadata
+  };
+}
+async function detectInProgressOperation(primaryDir) {
+  for (const marker of [
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "rebase-merge",
+    "rebase-apply",
+    "sequencer"
+  ]) {
+    const result = await runGit(["rev-parse", "--git-path", marker], primaryDir);
+    if (result.exitCode !== 0)
+      continue;
+    const rawPath = result.stdout.trim();
+    if (!rawPath)
+      continue;
+    const markerPath = path3.isAbsolute(rawPath) ? rawPath : path3.resolve(primaryDir, rawPath);
+    if (fs3.existsSync(markerPath))
+      return { inProgress: true };
+  }
+  return { inProgress: false };
+}
+function currentPathCasePolicy() {
+  return _internals.platform === "win32" ? "insensitive" : "sensitive";
+}
+function normalizeGitPath(rawPath, casePolicy) {
+  if (rawPath.includes("\x00")) {
+    return null;
+  }
+  const slashNormalized = rawPath.replaceAll("\\", "/");
+  const segments = slashNormalized.split("/");
+  const normalizedSegments = [];
+  const displaySegments = [];
+  for (const segment of segments) {
+    if (segment.length === 0 || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      return null;
+    }
+    displaySegments.push(segment);
+    normalizedSegments.push(casePolicy === "insensitive" ? segment.toLowerCase() : segment);
+  }
+  if (displaySegments.length === 0) {
+    return null;
+  }
+  return {
+    normalized: normalizedSegments.join("/"),
+    display: displaySegments.join("/")
+  };
+}
+function collapseOverlapPaths(paths) {
+  return Array.from(new Set(paths)).sort((a, b) => a.localeCompare(b));
+}
+function extractRecordPath(record, spacesToSkip) {
+  let cursor = 0;
+  for (let index = 0;index < spacesToSkip; index++) {
+    const next = record.indexOf(" ", cursor);
+    if (next === -1) {
+      return null;
+    }
+    cursor = next + 1;
+  }
+  return record.slice(cursor);
+}
+function parsePrimaryDirtyPaths(rawStatus, casePolicy) {
+  const paths = new Map;
+  const records = rawStatus.split("\x00");
+  for (let index = 0;index < records.length; index++) {
+    const record = records[index];
+    if (!record) {
+      continue;
+    }
+    switch (record[0]) {
+      case "1": {
+        const path4 = extractRecordPath(record, 8);
+        const normalized = path4 ? normalizeGitPath(path4, casePolicy) : null;
+        if (!normalized) {
+          return { error: `Malformed porcelain v2 entry: ${record}` };
+        }
+        paths.set(normalized.normalized, normalized.display);
+        break;
+      }
+      case "2": {
+        const path4 = extractRecordPath(record, 9);
+        const previousPath = records[++index];
+        const normalizedPath = path4 ? normalizeGitPath(path4, casePolicy) : null;
+        const normalizedPrevious = previousPath ? normalizeGitPath(previousPath, casePolicy) : null;
+        if (!normalizedPath || !normalizedPrevious) {
+          return {
+            error: `Malformed porcelain v2 rename/copy entry: ${record}`
+          };
+        }
+        paths.set(normalizedPath.normalized, normalizedPath.display);
+        paths.set(normalizedPrevious.normalized, normalizedPrevious.display);
+        break;
+      }
+      case "u": {
+        const path4 = extractRecordPath(record, 10);
+        const normalized = path4 ? normalizeGitPath(path4, casePolicy) : null;
+        if (!normalized) {
+          return { error: `Malformed porcelain v2 unmerged entry: ${record}` };
+        }
+        paths.set(normalized.normalized, normalized.display);
+        break;
+      }
+      case "?": {
+        const normalized = normalizeGitPath(record.slice(2), casePolicy);
+        if (!normalized) {
+          return { error: `Malformed porcelain v2 untracked entry: ${record}` };
+        }
+        paths.set(normalized.normalized, normalized.display);
+        break;
+      }
+      case "!":
+        break;
+      default:
+        return { error: `Malformed porcelain v2 record kind: ${record}` };
+    }
+  }
+  return { paths };
+}
+function parseIncomingPaths(rawDiff, casePolicy) {
+  const paths = new Map;
+  const records = rawDiff.split("\x00");
+  for (let index = 0;index < records.length; ) {
+    const status = records[index++];
+    if (!status) {
+      continue;
+    }
+    if (status.startsWith("R") || status.startsWith("C")) {
+      const fromPath = records[index++];
+      const toPath = records[index++];
+      const normalizedFrom = fromPath ? normalizeGitPath(fromPath, casePolicy) : null;
+      const normalizedTo = toPath ? normalizeGitPath(toPath, casePolicy) : null;
+      if (!normalizedFrom || !normalizedTo) {
+        return { error: `Malformed diff rename/copy entry: ${status}` };
+      }
+      paths.set(normalizedFrom.normalized, normalizedFrom.display);
+      paths.set(normalizedTo.normalized, normalizedTo.display);
+      continue;
+    }
+    const path4 = records[index++];
+    const normalized = path4 ? normalizeGitPath(path4, casePolicy) : null;
+    if (!normalized) {
+      return { error: `Malformed diff entry: ${status}` };
+    }
+    paths.set(normalized.normalized, normalized.display);
+  }
+  return { paths };
+}
+function pathsOverlap(left, right) {
+  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function buildOverlapPaths(dirtyPaths, incomingPaths) {
+  const collisions = new Set;
+  for (const dirtyNormalized of dirtyPaths.keys()) {
+    for (const incomingNormalized of incomingPaths.keys()) {
+      if (!pathsOverlap(dirtyNormalized, incomingNormalized)) {
+        continue;
+      }
+      collisions.add(dirtyNormalized);
+      collisions.add(incomingNormalized);
+    }
+  }
+  return collapseOverlapPaths(collisions);
+}
+async function readVerifiedGitObjectId(cwd, ref, description) {
+  const result = await runGit(["rev-parse", "--verify", `${ref}^0`], cwd);
+  const oid = result.stdout.trim();
+  if (result.exitCode !== 0 || !GIT_OBJECT_ID_PATTERN.test(oid)) {
+    return {
+      error: `Unable to verify ${description} for overlap preflight`
+    };
+  }
+  return { oid };
+}
+async function captureMergeOverlapSnapshot(primaryDir, branchName) {
+  const casePolicy = currentPathCasePolicy();
+  const targetHead = await readVerifiedGitObjectId(primaryDir, "HEAD", "primary HEAD");
+  if ("error" in targetHead) {
+    return targetHead;
+  }
+  const laneHead = await readVerifiedGitObjectId(primaryDir, branchName, "lane HEAD");
+  if ("error" in laneHead) {
+    return laneHead;
+  }
+  const mergeBaseResult = await runGit(["merge-base", targetHead.oid, laneHead.oid], primaryDir);
+  const mergeBase = mergeBaseResult.stdout.trim();
+  if (mergeBaseResult.exitCode !== 0 || !GIT_OBJECT_ID_PATTERN.test(mergeBase)) {
+    return {
+      error: "Unable to determine incoming lane changes for overlap preflight"
+    };
+  }
+  const statusResult = await runGit(["status", "--porcelain=v2", "-z", "--untracked-files=all"], primaryDir);
+  if (statusResult.exitCode !== 0) {
+    return {
+      error: "Unable to inspect primary dirty state for overlap preflight"
+    };
+  }
+  const parsedStatus = parsePrimaryDirtyPaths(statusResult.stdout, casePolicy);
+  if ("error" in parsedStatus) {
+    return { error: parsedStatus.error };
+  }
+  const indexResult = await runGit(["ls-files", "--stage", "-z"], primaryDir);
+  if (indexResult.exitCode !== 0) {
+    return { error: "Unable to inspect primary index for overlap preflight" };
+  }
+  const incomingResult = await runGit([
+    "diff",
+    "--name-status",
+    "-z",
+    "--find-renames",
+    `${mergeBase}..${laneHead.oid}`
+  ], primaryDir);
+  if (incomingResult.exitCode !== 0) {
+    return {
+      error: "Unable to inspect incoming lane paths for overlap preflight"
+    };
+  }
+  const parsedIncoming = parseIncomingPaths(incomingResult.stdout, casePolicy);
+  if ("error" in parsedIncoming) {
+    return { error: parsedIncoming.error };
+  }
+  return {
+    snapshot: {
+      targetHead: targetHead.oid,
+      laneHead: laneHead.oid,
+      mergeBase,
+      indexDigest: indexResult.stdout,
+      statusDigest: statusResult.stdout,
+      incomingDigest: incomingResult.stdout,
+      overlapPaths: buildOverlapPaths(parsedStatus.paths, parsedIncoming.paths)
+    }
+  };
+}
+async function captureImmutableMergeOverlapSnapshot(primaryDir, coordinates) {
+  const snapshot = await captureMergeOverlapSnapshot(primaryDir, coordinates.sourceHeadOid);
+  if ("error" in snapshot)
+    return snapshot;
+  if (snapshot.snapshot.laneHead !== coordinates.sourceHeadOid || snapshot.snapshot.mergeBase !== coordinates.sourceBaseOid) {
+    return {
+      error: "Immutable recovery coordinates changed during overlap preflight; refusing merge-back"
+    };
+  }
+  return snapshot;
+}
+function sameOverlapSnapshot(left, right) {
+  return left.targetHead === right.targetHead && left.laneHead === right.laneHead && left.mergeBase === right.mergeBase && left.indexDigest === right.indexDigest && left.statusDigest === right.statusDigest && left.incomingDigest === right.incomingDigest;
+}
 function getMergeStrategy(config) {
   return config.mergeStrategy ?? config.merge_strategy ?? "merge";
 }
@@ -495,24 +777,123 @@ async function mergeLaneBranch(primaryDir, branchName, strategy) {
       break;
     }
   }
-  if (result.exitCode === 0) {
-    return { merged: true, strategy };
+  return finalizeMergeStrategyResult(primaryDir, strategy, result, {});
+}
+async function requireAncestorRelation(primaryDir, ancestor, descendant, description) {
+  const relation = await runGit(["merge-base", "--is-ancestor", ancestor, descendant], primaryDir);
+  if (relation.exitCode === 0) {
+    return { ok: true };
   }
-  const combinedOutput = `${result.stderr}
-${result.stdout}`;
-  const hasConflict = /CONFLICT/i.test(combinedOutput) || /conflict/i.test(combinedOutput);
-  if (hasConflict) {
-    const files = parseConflictFiles(combinedOutput);
-    const abortArgs = strategy === "rebase" ? ["rebase", "--abort"] : strategy === "cherry-pick" ? ["cherry-pick", "--abort"] : ["merge", "--abort"];
-    await runGit(abortArgs, primaryDir);
+  if (relation.exitCode === 1) {
+    return { ok: false, error: description };
+  }
+  return {
+    ok: false,
+    error: relation.stderr.trim() || relation.stdout.trim() || `git merge-base exited ${relation.exitCode}`
+  };
+}
+async function readOrderedCommitRange(primaryDir, fromExclusive, toInclusive, description) {
+  const revList = await runGit([
+    "rev-list",
+    "--reverse",
+    "--topo-order",
+    `${fromExclusive}..${toInclusive}`
+  ], primaryDir);
+  if (revList.exitCode !== 0) {
     return {
-      conflict: true,
-      files,
-      message: result.stderr.trim()
+      error: revList.stderr.trim() || revList.stdout.trim() || `${description}: git rev-list exited ${revList.exitCode}`
+    };
+  }
+  const commits = revList.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (!commits.every((commit) => GIT_OBJECT_ID_PATTERN.test(commit))) {
+    return {
+      error: `${description}: git rev-list returned a malformed object id`
+    };
+  }
+  return { commits };
+}
+async function recoverMergeBackFromImmutableCoordinates(primaryDir, coordinates) {
+  if (!GIT_OBJECT_ID_PATTERN.test(coordinates.sourceBaseOid) || !GIT_OBJECT_ID_PATTERN.test(coordinates.sourceHeadOid) || !GIT_OBJECT_ID_PATTERN.test(coordinates.targetHeadOid)) {
+    return {
+      error: "Malformed preserved lane recovery coordinates"
+    };
+  }
+  const laneAncestry = await requireAncestorRelation(primaryDir, coordinates.sourceBaseOid, coordinates.sourceHeadOid, "Preserved lane recovery base does not reach the preserved lane head");
+  if (!laneAncestry.ok) {
+    return { error: laneAncestry.error };
+  }
+  const targetBaseRelation = await requireAncestorRelation(primaryDir, coordinates.sourceBaseOid, coordinates.targetHeadOid, "Preserved lane recovery base does not reach the captured target head");
+  if (!targetBaseRelation.ok) {
+    return { error: targetBaseRelation.error };
+  }
+  const currentTargetRelation = await requireAncestorRelation(primaryDir, coordinates.targetHeadOid, "HEAD", "Current primary HEAD no longer descends from the captured recovery target");
+  if (!currentTargetRelation.ok) {
+    return { error: currentTargetRelation.error };
+  }
+  const initialOverlapSnapshot = await captureImmutableMergeOverlapSnapshot(primaryDir, coordinates);
+  if ("error" in initialOverlapSnapshot) {
+    return { error: initialOverlapSnapshot.error };
+  }
+  if (initialOverlapSnapshot.snapshot.overlapPaths.length > 0) {
+    return {
+      error: `Primary checkout has overlapping dirty paths with incoming preserved lane changes: ${initialOverlapSnapshot.snapshot.overlapPaths.join(", ")}`
+    };
+  }
+  const finalOverlapSnapshot = await captureImmutableMergeOverlapSnapshot(primaryDir, coordinates);
+  if ("error" in finalOverlapSnapshot) {
+    return { error: finalOverlapSnapshot.error };
+  }
+  if (!sameOverlapSnapshot(initialOverlapSnapshot.snapshot, finalOverlapSnapshot.snapshot)) {
+    return {
+      error: "Primary or preserved lane state changed during overlap preflight; refusing merge-back"
+    };
+  }
+  if (coordinates.strategy === "merge") {
+    return finalizeMergeStrategyResult(primaryDir, "merge", await runGit(["merge", "--no-edit", coordinates.sourceHeadOid], primaryDir), {});
+  }
+  if (coordinates.strategy === "rebase") {
+    return finalizeMergeStrategyResult(primaryDir, "rebase", await runGit([
+      "rebase",
+      "--onto",
+      coordinates.sourceHeadOid,
+      coordinates.sourceBaseOid
+    ], primaryDir), {});
+  }
+  const sourceCommitOrder = await readOrderedCommitRange(primaryDir, coordinates.sourceBaseOid, coordinates.sourceHeadOid, "Malformed preserved lane recovery coordinates: exact cherry-pick order could not be reconstructed");
+  if ("error" in sourceCommitOrder) {
+    return { error: sourceCommitOrder.error };
+  }
+  if (sourceCommitOrder.commits.length === 0) {
+    return {
+      merged: true,
+      strategy: "cherry-pick",
+      sourceCommitOrder: []
+    };
+  }
+  const headBefore = await readVerifiedGitObjectId(primaryDir, "HEAD", "current primary HEAD before preserved cherry-pick recovery");
+  if ("error" in headBefore) {
+    return { error: headBefore.error };
+  }
+  const cherryPickResult = await finalizeMergeStrategyResult(primaryDir, "cherry-pick", await runGit(["cherry-pick", ...sourceCommitOrder.commits, "-x"], primaryDir), { sourceCommitOrder: sourceCommitOrder.commits });
+  if (!("merged" in cherryPickResult) || !cherryPickResult.merged) {
+    return cherryPickResult;
+  }
+  const rewrittenCommitOrder = await readOrderedCommitRange(primaryDir, headBefore.oid, "HEAD", "Unable to reconstruct rewritten preserved cherry-pick order");
+  if ("error" in rewrittenCommitOrder) {
+    return {
+      error: rewrittenCommitOrder.error,
+      sourceCommitOrder: sourceCommitOrder.commits
+    };
+  }
+  if (rewrittenCommitOrder.commits.length !== sourceCommitOrder.commits.length) {
+    return {
+      error: "Unable to reconstruct rewritten preserved cherry-pick order: rewritten commit count did not match the captured lane range",
+      sourceCommitOrder: sourceCommitOrder.commits
     };
   }
   return {
-    error: result.stderr.trim() || result.stdout.trim()
+    ...cherryPickResult,
+    rewrittenCommitOrder: rewrittenCommitOrder.commits
   };
 }
 async function reconcileLandedMerge(primaryDir, provenance) {
@@ -703,6 +1084,15 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       };
     }
   }
+  const initialOverlapSnapshot = await _internals.captureMergeOverlapSnapshot(primaryDir, branchName);
+  if ("error" in initialOverlapSnapshot) {
+    return {
+      failed: true,
+      stage: "pre-merge",
+      message: initialOverlapSnapshot.error,
+      ...provenance ? { provenance } : {}
+    };
+  }
   if (!provenance && (options.operationId || options.onBeforeMerge)) {
     if (!options.operationId) {
       return {
@@ -711,26 +1101,10 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         message: "A pre-merge callback requires a stable operationId"
       };
     }
-    const source = await captureLaneSourceHead(worktreePath, branchName, primaryDir, sourceWorktreeMissing);
-    if (source.sourceWorktreeMissing && !sourceWorktreeMissing) {
-      const unrecoverable = await handleSourceWorktreeGone(source.result, worktreePath, branchName, primaryDir, provenance);
-      if (unrecoverable)
-        return unrecoverable;
-      sourceWorktreeMissing = true;
-    }
-    const sourceHead = source.result;
-    const targetHead = await runGit(["rev-parse", "HEAD"], primaryDir);
-    if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || !sourceHead.stdout.trim() || !targetHead.stdout.trim()) {
-      return {
-        failed: true,
-        stage: "pre-merge",
-        message: "Unable to capture source and target HEAD before merge-back"
-      };
-    }
     provenance = {
       operationId: options.operationId,
-      sourceHead: sourceHead.stdout.trim(),
-      targetHeadBefore: targetHead.stdout.trim(),
+      sourceHead: initialOverlapSnapshot.snapshot.laneHead,
+      targetHeadBefore: initialOverlapSnapshot.snapshot.targetHead,
       branchName,
       strategy
     };
@@ -747,6 +1121,34 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       }
     }
   }
+  const finalOverlapSnapshot = await _internals.captureMergeOverlapSnapshot(primaryDir, branchName);
+  if ("error" in finalOverlapSnapshot) {
+    return {
+      failed: true,
+      stage: "pre-merge",
+      message: finalOverlapSnapshot.error,
+      ...provenance ? { provenance } : {}
+    };
+  }
+  if (finalOverlapSnapshot.snapshot.overlapPaths.length > 0) {
+    return {
+      partial: true,
+      stage: "pre-merge-overlap",
+      autoCommitted,
+      cleaned,
+      message: `Primary checkout has overlapping dirty paths with incoming lane changes: ${finalOverlapSnapshot.snapshot.overlapPaths.join(", ")}`,
+      conflictFiles: finalOverlapSnapshot.snapshot.overlapPaths,
+      ...provenance ? { provenance } : {}
+    };
+  }
+  if (!sameOverlapSnapshot(initialOverlapSnapshot.snapshot, finalOverlapSnapshot.snapshot)) {
+    return {
+      failed: true,
+      stage: "pre-merge",
+      message: "Primary or lane state changed during overlap preflight; refusing merge-back",
+      ...provenance ? { provenance } : {}
+    };
+  }
   const mergeResult = await mergeLaneBranch(primaryDir, branchName, strategy);
   if ("merged" in mergeResult && mergeResult.merged) {
     return {
@@ -972,9 +1374,9 @@ var SMALL_WORKFLOW_WAL_MAX_BYTES = 1024 * 1024;
 var CHUNK_BYTES = 64 * 1024;
 var _internals2 = {
   openFile: open,
-  openFileSync: fs3.openSync,
-  readFileSync: fs3.readSync,
-  closeFileSync: fs3.closeSync
+  openFileSync: fs4.openSync,
+  readFileSync: fs4.readSync,
+  closeFileSync: fs4.closeSync
 };
 function maxBytesFor(kind) {
   return kind === "coder-settlement" ? CODER_SETTLEMENT_MAX_BYTES : SMALL_WORKFLOW_WAL_MAX_BYTES;
@@ -1474,18 +1876,18 @@ function reduceTaskWorkflowSnapshot(current, event, context) {
   }
 }
 function getEvidenceDir(directory) {
-  const swarmDir = path3.resolve(directory, ".swarm");
-  const evidenceDir = path3.join(swarmDir, "evidence");
+  const swarmDir = path4.resolve(directory, ".swarm");
+  const evidenceDir = path4.join(swarmDir, "evidence");
   mkdirSync3(evidenceDir, { recursive: true });
   let resolvedSwarmDir;
   let resolvedEvidenceDir;
   try {
-    resolvedSwarmDir = path3.normalize(realpathSync2(swarmDir));
-    resolvedEvidenceDir = path3.normalize(realpathSync2(evidenceDir));
+    resolvedSwarmDir = path4.normalize(realpathSync2(swarmDir));
+    resolvedEvidenceDir = path4.normalize(realpathSync2(evidenceDir));
   } catch (error) {
     throw new Error(`Unable to resolve evidence directory: ${error.message}`);
   }
-  const swarmPrefix = `${resolvedSwarmDir}${path3.sep}`;
+  const swarmPrefix = `${resolvedSwarmDir}${path4.sep}`;
   const withinSwarmBoundary = process.platform === "win32" ? resolvedEvidenceDir.toLowerCase().startsWith(swarmPrefix.toLowerCase()) : resolvedEvidenceDir.startsWith(swarmPrefix);
   if (!withinSwarmBoundary) {
     throw new Error(`Evidence path escapes .swarm boundary: ${resolvedEvidenceDir}`);
@@ -1614,7 +2016,7 @@ async function withTaskEvidenceTransaction(directory, taskId, agent, callback) {
   assertValidTaskId(taskId);
   return withTaskEvidenceLock(directory, taskId, agent, async () => {
     const resolvedEvidenceDir = getEvidenceDir(directory);
-    const evidencePath = path3.join(resolvedEvidenceDir, `${taskId}.json`);
+    const evidencePath = path4.join(resolvedEvidenceDir, `${taskId}.json`);
     let current = null;
     try {
       current = readExisting(evidencePath, taskId);
@@ -1719,4 +2121,4 @@ function compareTaskWorkflowStateRank(left, right) {
   return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
 }
 
-export { isStrictTaskId, sanitizeTaskId, listRecoveryRecords, GitBinaryMissingError, GitSpawnCwdError, isGitBinaryMissing, isSpawnCwdMissing, isSpawnCwdUnreadable, _internals, SOURCE_WORKTREE_GONE_STAGE, SOURCE_WORKTREE_UNCERTAIN_STAGE, getMergeStrategy, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };
+export { isStrictTaskId, sanitizeTaskId, listRecoveryRecords, GitBinaryMissingError, GitSpawnCwdError, isGitBinaryMissing, isSpawnCwdMissing, isSpawnCwdUnreadable, _internals, SOURCE_WORKTREE_GONE_STAGE, SOURCE_WORKTREE_UNCERTAIN_STAGE, getMergeStrategy, recoverMergeBackFromImmutableCoordinates, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };