opencode-swarm 7.144.7 → 7.145.0

package/dist/cli/index-4evasm2b.js

@@ -0,0 +1,514 @@
+// @bun
+import {
+  invalidateCachedArtifact
+} from "./index-ed5ykebp.js";
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var UUID_RE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var SWARM_TEMP_GRAMMARS = [
+  {
+    id: "canonical-v1",
+    era: "canonical",
+    match: /^(.+)\.[0-9a-f]{32}\.tmp$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/utils/atomic-write.ts:atomicWriteSwarmFile",
+      "src/utils/atomic-write.ts:atomicWriteFileAnyRoot"
+    ]
+  },
+  {
+    id: "target-suffix-tmp-uuid",
+    era: "current",
+    match: new RegExp(`^(.+)\\.tmp\\.${UUID_RE}$`),
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/commands/handoff.ts:48 (pre-#2035)",
+      "src/commands/handoff.ts:79 (pre-#2035)",
+      "src/memory/local-jsonl-provider.ts:1171",
+      "src/config/bundled-skills.ts:241"
+    ]
+  },
+  {
+    id: "target-suffix-tmp-pid-uuid",
+    era: "current",
+    match: new RegExp(`^(.+)\\.tmp\\.\\d+\\.${UUID_RE}$`),
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/hooks/pr-workflow-gate.ts:11950"],
+    note: "pre/post-rename file-identity verification (assertOpened/ClosedSwarmFileIdentity, pr-workflow-gate.ts:11844-11889) is writer-specific and load-bearing"
+  },
+  {
+    id: "target-suffix-tmp-num-num-json",
+    era: "current",
+    match: /^(.+)\.tmp\.\d+\.\d+\.json$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/hooks/issue-trace-state.ts:315"],
+    note: "the .json terminator keeps this shape distinct from the bare two-token family \u2014 declared before it so first-match wins"
+  },
+  {
+    id: "target-suffix-tmp-num-alnum",
+    era: "current",
+    match: /^(.+)\.tmp\.\d+\.[0-9a-z]+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/evidence/task-file.ts:67 (pre-#2035)",
+      "src/scope/scope-persistence.ts:2304 (pre-#2035)",
+      "src/scope/scope-persistence.ts:2318 (pre-#2035)",
+      "src/plan/manager.ts:628",
+      "src/plan/manager.ts:1775",
+      "src/plan/manager.ts:1820",
+      "src/review/evidence.ts:125",
+      "src/turbo/lean/evidence.ts:182",
+      "src/summaries/manager.ts:122",
+      "src/evidence/manager.ts:288",
+      "src/evidence/manager.ts:456",
+      "src/tools/sast-baseline.ts:106",
+      "src/tools/repo-graph/storage.ts:397",
+      "src/memory/reflection-service.ts:547 (pre-#2035)",
+      "src/hooks/review-receipt.ts:608",
+      "src/hooks/review-receipt.ts:674",
+      "src/hooks/review-receipt.ts:812",
+      "src/knowledge/identity.ts:209",
+      "src/evidence/phase-participation.ts:303 (pre-#2035)",
+      "src/turbo/lean/integration.ts:426",
+      "src/turbo/lean/reviewer.ts:403",
+      "src/plan/ledger.ts:713",
+      "src/services/synonym-map.ts:389",
+      "src/services/skill-optimizer/store.ts:340",
+      "src/services/skill-optimizer/store.ts:503",
+      "src/turbo/epic/state.ts:177",
+      "src/turbo/epic/calibration.ts:197",
+      "src/commands/archive-sqlite.ts:318",
+      "src/memory/jsonl-migration.ts:157"
+    ],
+    note: "fsync-discipline / lock-scoped fd writers whose temp naming is pinned by their own durability test suites (plan-durability invariant 5, #2034 crash matrix); grammars registered here so their residue stays discoverable"
+  },
+  {
+    id: "target-suffix-tmp-token",
+    era: "current",
+    match: /^(.+)\.tmp\.[0-9a-z-]{6,}$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/turbo/lean/state.ts:246",
+      "src/turbo/lean/recovery.ts:175",
+      "src/hooks/delegation-gate/worktree-merge-status.ts:110"
+    ]
+  },
+  {
+    id: "target-suffix-tmp-dash",
+    era: "current",
+    match: /^(.+)\.tmp-\d+-[0-9a-z-]+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/services/skill-evaluator.ts:492 (pre-#2035)",
+      "src/services/skill-improver.ts:154 (pre-#2035)",
+      "src/services/skill-consolidation.ts:72 (pre-#2035)",
+      "src/services/skill-generator.ts:601 (pre-#2035)",
+      "src/tools/spec-write.ts:98",
+      "src/sdd/effective-spec.ts:1149",
+      "src/background/lane-output-store.ts:353",
+      "src/background/pending-delegations.ts:905",
+      "src/background/delegation-health.ts:300",
+      "src/hooks/delegation-gate/worktree-provisioning-owner.ts:100",
+      "src/tools/submit-phase-council-verdicts.ts:437",
+      "src/summaries/store.ts:46 (pre-#2035)"
+    ],
+    note: "background lane/delegation stores keep bounded-retry rename semantics wired into their callers (#2034/#2276 delivery contracts); migration candidates for a follow-up but grammars registered"
+  },
+  {
+    id: "target-suffix-tmp-dash-num",
+    era: "current",
+    match: /^(.+)\.tmp-\d+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/services/skill-improver-quota.ts:114"]
+  },
+  {
+    id: "target-dot-pid-uuid-tmp",
+    era: "current",
+    match: new RegExp(`^(.+)\\.\\d+\\.${UUID_RE}\\.tmp$`),
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/hooks/knowledge-receipt-ledger-storage.ts:546"],
+    note: "pre/post-rename file-identity verification (existingFileIdentity checks, knowledge-receipt-ledger-storage.ts:544-591) is writer-specific and load-bearing"
+  },
+  {
+    id: "dot-numeric-instance-tmp",
+    era: "current",
+    match: /^\..+(?:\.\d+){2,4}\.[0-9a-z]+\.tmp$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: false,
+    producers: [
+      "src/utils/bun-compat.ts:138",
+      "src/tools/repo-graph/freshness.ts:171"
+    ],
+    note: "bunWrite Node-fallback internal temp and the repo-graph fingerprint temp (2-4 numeric token groups); leading-dot temps are standalone, target not parsed"
+  },
+  {
+    id: "dot-uuid-instance-tmp",
+    era: "current",
+    match: new RegExp(`^\\..+\\.${UUID_RE}\\.tmp$`),
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: [
+      "src/tools/write-pr-review-artifact.ts:107",
+      "src/tools/write-pr-review-trigger-eval.ts:574"
+    ],
+    note: "bundled-skills writes outside .swarm (project skill roots) and keeps its own contained-directory logic (invariant 4 bundled-skill ownership)"
+  },
+  {
+    id: "tmp-prefix-named",
+    era: "legacy",
+    match: /^\.tmp-.+-\d+-\d+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: false,
+    producers: ["src/commands/issue.ts:167 (pre-#2035)"],
+    note: "prefix form embeds the filename; target not reliably parseable (dashes), so eligibility relies on the age/tracked/symlink/lock gates"
+  },
+  {
+    id: "target-rebuild-close",
+    era: "current",
+    match: /^(.+)\.(?:rebuild|close)\.\d+\.[0-9a-z]+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/plan/manager.ts:1960", "src/plan/manager.ts:2149"],
+    note: "plan-durability (invariant 5) fd-write paths; grammars registered, writers unchanged in this PR"
+  },
+  {
+    id: "target-migration-pid",
+    era: "current",
+    match: /^(.+)\.migration-\d+$/,
+    token: "instance",
+    quarantineEligible: true,
+    parsesTarget: true,
+    producers: ["src/scope/scope-persistence.ts:633 (pre-#2035)"]
+  },
+  {
+    id: "dot-tmp-prefix-legacy",
+    era: "legacy",
+    match: /^\.tmp\..+$/,
+    token: "constant",
+    quarantineEligible: true,
+    parsesTarget: false,
+    producers: [
+      "pre-7.x writers (historical); matched by the pre-#2035 close sweep"
+    ],
+    note: "legacy prefix grammar: issue #2035 req 7 preserves its handling \u2014 stale instances are quarantined (formerly unlinked) under the same eligibility gates"
+  },
+  {
+    id: "dot-constant-tmp",
+    era: "current",
+    match: /^\..+\.tmp$/,
+    token: "constant",
+    quarantineEligible: false,
+    parsesTarget: false,
+    producers: [
+      "src/tools/write-drift-evidence.ts:275",
+      "src/tools/write-mutation-evidence.ts:169",
+      "src/tools/write-hallucination-evidence.ts:121",
+      "src/tools/record-implementation-review.ts:87",
+      "src/tools/record-recurrence-sweep.ts:125",
+      "src/tools/record-issue-reproduction.ts:85",
+      "src/tools/record-issue-publication.ts:74",
+      "src/tools/write-final-council-evidence.ts:311"
+    ],
+    note: "constant-name temps: no per-invocation token \u2014 reported when stale, never auto-quarantined (may be an in-flight writer of any process)"
+  },
+  {
+    id: "target-constant-tmp",
+    era: "current",
+    match: /^(.+)\.tmp$/,
+    token: "constant",
+    quarantineEligible: false,
+    parsesTarget: false,
+    producers: [
+      "src/tools/checkpoint.ts:194",
+      "src/full-auto/state.ts:448",
+      "src/context-map/persistence.ts:119",
+      "src/context-map/capsule-persistence.ts:107",
+      "src/test-impact/history-store.ts:225",
+      "src/test-impact/history-store.ts:353",
+      "src/hooks/promotion-evidence-store.ts:102",
+      "src/hooks/skill-usage-log.ts:554",
+      "src/hooks/skill-usage-log.ts:608",
+      "src/parallel/file-locks.ts:113",
+      "src/plan/ledger.ts:1302",
+      "src/plan/ledger.ts:1303"
+    ],
+    note: "constant-name temps: reported when stale, never auto-quarantined. file-locks meta sidecars live under the scanner-skipped .swarm/locks/ subtree; the ledger reconcile temp embeds instance tokens but its .tmp-suffix shape maps here (conservatively report-only)"
+  }
+];
+function matchTempGrammar(basename) {
+  return SWARM_TEMP_GRAMMARS.find((g) => g.match.test(basename));
+}
+function parseTargetBasename(basename) {
+  for (const g of SWARM_TEMP_GRAMMARS) {
+    if (!g.parsesTarget)
+      continue;
+    const m = g.match.exec(basename);
+    if (m?.[1])
+      return m[1];
+  }
+  return null;
+}
+var WRITER_CLASSIFICATION = Object.freeze({
+  "src/commands/close.ts": "migrated",
+  "src/commands/handoff.ts": "migrated",
+  "src/commands/simulate.ts": "migrated",
+  "src/commands/coupling.ts": "migrated",
+  "src/commands/issue.ts": "migrated",
+  "src/evidence/task-file.ts": "migrated",
+  "src/evidence/phase-participation.ts": "migrated",
+  "src/memory/reflection-service.ts": "migrated",
+  "src/scope/scope-persistence.ts": "migrated",
+  "src/services/skill-consolidation.ts": "migrated",
+  "src/services/skill-evaluator.ts": "migrated",
+  "src/services/skill-generator.ts": "migrated",
+  "src/services/skill-improver.ts": "migrated",
+  "src/summaries/store.ts": "migrated",
+  "src/background/delegation-health.ts": "registered-bespoke",
+  "src/background/lane-output-store.ts": "registered-bespoke",
+  "src/background/pending-delegations.ts": "registered-bespoke",
+  "src/commands/archive-sqlite.ts": "registered-bespoke",
+  "src/context-map/capsule-persistence.ts": "registered-bespoke",
+  "src/context-map/persistence.ts": "registered-bespoke",
+  "src/evidence/documents-retention.ts": "registered-bespoke",
+  "src/evidence/manager.ts": "registered-bespoke",
+  "src/full-auto/state.ts": "registered-bespoke",
+  "src/hooks/delegation-gate/worktree-merge-status.ts": "registered-bespoke",
+  "src/hooks/delegation-gate/worktree-provisioning-owner.ts": "registered-bespoke",
+  "src/hooks/issue-trace-state.ts": "registered-bespoke",
+  "src/hooks/knowledge-receipt-ledger-storage.ts": "registered-bespoke",
+  "src/hooks/pr-workflow-gate.ts": "registered-bespoke",
+  "src/hooks/promotion-evidence-store.ts": "registered-bespoke",
+  "src/hooks/review-receipt.ts": "registered-bespoke",
+  "src/hooks/skill-usage-log.ts": "registered-bespoke",
+  "src/knowledge/identity.ts": "registered-bespoke",
+  "src/memory/jsonl-migration.ts": "external",
+  "src/memory/local-jsonl-provider.ts": "registered-bespoke",
+  "src/plan/ledger.ts": "registered-bespoke",
+  "src/plan/manager.ts": "registered-bespoke",
+  "src/review/evidence.ts": "registered-bespoke",
+  "src/sdd/effective-spec.ts": "registered-bespoke",
+  "src/services/skill-improver-quota.ts": "registered-bespoke",
+  "src/services/skill-optimizer/activation.ts": "external",
+  "src/services/skill-optimizer/store.ts": "registered-bespoke",
+  "src/services/skill-reviser.ts": "external",
+  "src/services/synonym-map.ts": "registered-bespoke",
+  "src/session/snapshot-writer.ts": "registered-bespoke",
+  "src/summaries/manager.ts": "registered-bespoke",
+  "src/test-impact/history-store.ts": "registered-bespoke",
+  "src/turbo/epic/calibration.ts": "registered-bespoke",
+  "src/turbo/epic/state.ts": "registered-bespoke",
+  "src/turbo/lean/evidence.ts": "registered-bespoke",
+  "src/turbo/lean/integration.ts": "registered-bespoke",
+  "src/turbo/lean/recovery.ts": "registered-bespoke",
+  "src/turbo/lean/reviewer.ts": "registered-bespoke",
+  "src/turbo/lean/state.ts": "registered-bespoke",
+  "src/tools/apply-patch.ts": "external",
+  "src/tools/checkpoint.ts": "registered-bespoke",
+  "src/tools/record-implementation-review.ts": "registered-bespoke",
+  "src/tools/record-issue-publication.ts": "registered-bespoke",
+  "src/tools/record-issue-reproduction.ts": "registered-bespoke",
+  "src/tools/record-recurrence-sweep.ts": "registered-bespoke",
+  "src/tools/repo-graph/freshness.ts": "registered-bespoke",
+  "src/tools/repo-graph/storage.ts": "registered-bespoke",
+  "src/tools/sast-baseline.ts": "registered-bespoke",
+  "src/tools/spec-write.ts": "registered-bespoke",
+  "src/tools/submit-phase-council-verdicts.ts": "registered-bespoke",
+  "src/tools/write-drift-evidence.ts": "registered-bespoke",
+  "src/tools/write-final-council-evidence.ts": "registered-bespoke",
+  "src/tools/write-hallucination-evidence.ts": "registered-bespoke",
+  "src/tools/write-mutation-evidence.ts": "registered-bespoke",
+  "src/tools/write-pr-review-artifact.ts": "registered-bespoke",
+  "src/tools/write-pr-review-trigger-eval.ts": "registered-bespoke",
+  "src/config/bundled-skills.ts": "external",
+  "src/services/config-doctor.ts": "external",
+  "src/parallel/file-locks.ts": "registered-bespoke",
+  "src/utils/bun-compat.ts": "registered-bespoke",
+  "src/background/plan-sync-worker.ts": "reader-only",
+  "src/config/lane-permissions.ts": "reader-only",
+  "src/environment/profile.ts": "reader-only",
+  "src/worktree/core.ts": "reader-only"
+});
+function assertWellFormedTargetPath(targetPath) {
+  if (!path.isAbsolute(targetPath)) {
+    throw new Error(`atomic-write target must be absolute: ${targetPath}`);
+  }
+  if (/[\0-\x1f\x7f]/.test(targetPath)) {
+    throw new Error("atomic-write target contains control characters");
+  }
+  if (/[*?]/.test(targetPath) || /(^|[/\\])\{[^}]*\}([/\\]|$)/.test(targetPath)) {
+    throw new Error(`atomic-write target contains glob metacharacters: ${targetPath}`);
+  }
+  if (/(^|[/\\])~([/\\]|$)/.test(targetPath)) {
+    throw new Error("atomic-write target contains unresolved home-dir marker (~)");
+  }
+  if (/\$\{?[A-Za-z_][A-Za-z0-9_]*\}?/.test(targetPath) || /%[^/\\%]+%/.test(targetPath)) {
+    throw new Error("atomic-write target contains unresolved environment-variable form");
+  }
+}
+function lstatNotSymlink(p, what) {
+  const st = fs.lstatSync(p);
+  if (st.isSymbolicLink()) {
+    throw new Error(`${what} is a symlink/reparse point: ${p}`);
+  }
+}
+function assertSwarmContainedTarget(targetPath) {
+  assertWellFormedTargetPath(targetPath);
+  const resolved = path.normalize(path.resolve(targetPath));
+  const segments = resolved.split(path.sep);
+  let swarmIdx = -1;
+  for (let i = segments.length - 2;i >= 1; i--) {
+    if (segments[i] === ".swarm") {
+      swarmIdx = i;
+      break;
+    }
+  }
+  if (swarmIdx === -1) {
+    throw new Error(`atomic-write target is not under a project .swarm root: ${targetPath}`);
+  }
+  const swarmRoot = segments.slice(0, swarmIdx + 1).join(path.sep);
+  try {
+    const st = fs.lstatSync(swarmRoot);
+    if (!st.isDirectory() || st.isSymbolicLink()) {
+      throw new Error(`.swarm root is not a real directory (symlink/reparse or non-dir): ${swarmRoot}`);
+    }
+  } catch (err) {
+    if (err?.code !== "ENOENT")
+      throw err;
+  }
+  const rel = path.relative(swarmRoot, resolved);
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(`atomic-write target escapes .swarm root: ${targetPath}`);
+  }
+  let probe = swarmRoot;
+  for (const seg of rel.split(path.sep)) {
+    probe = path.join(probe, seg);
+    if (!fs.existsSync(probe))
+      break;
+    lstatNotSymlink(probe, "path segment under .swarm");
+  }
+  return { projectRoot: path.dirname(swarmRoot), swarmRoot };
+}
+var MAX_ATOMIC_WRITE_BYTES = 256 * 1024 * 1024;
+var RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200];
+var RETRYABLE_RENAME_CODES = new Set(["EPERM", "EBUSY", "EACCES", "EEXIST"]);
+var _internals = {
+  randomSuffix: () => randomBytes(16).toString("hex"),
+  writeSync: (fd, buffer, offset, length) => fs.writeSync(fd, buffer, offset, length),
+  renameSync: (from, to) => fs.renameSync(from, to),
+  unlinkSync: (p) => fs.unlinkSync(p),
+  fsyncSync: (fd) => fs.fsyncSync(fd)
+};
+function toBuffer(content) {
+  if (typeof content === "string")
+    return Buffer.from(content, "utf-8");
+  return content;
+}
+function syncSleep(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const start = Date.now();
+    while (Date.now() - start < ms) {}
+  }
+}
+function renameWithRetry(tempPath, targetPath) {
+  let lastError;
+  for (let attempt = 0;attempt <= RENAME_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      _internals.renameSync(tempPath, targetPath);
+      return;
+    } catch (err) {
+      lastError = err;
+      const code = err?.code;
+      if (!code || !RETRYABLE_RENAME_CODES.has(code))
+        throw err;
+      if (attempt < RENAME_RETRY_DELAYS_MS.length) {
+        syncSleep(RENAME_RETRY_DELAYS_MS[attempt]);
+      }
+    }
+  }
+  throw lastError;
+}
+function writeAtomicSync(targetPath, content, options) {
+  if (options?.contained !== false) {
+    assertSwarmContainedTarget(targetPath);
+  } else {
+    assertWellFormedTargetPath(targetPath);
+  }
+  const resolvedTarget = path.resolve(targetPath);
+  const buffer = toBuffer(content);
+  const maxBytes = options?.maxBytes ?? MAX_ATOMIC_WRITE_BYTES;
+  if (buffer.byteLength > maxBytes) {
+    throw new Error(`atomic write exceeds ${maxBytes} byte bound: ${buffer.byteLength}`);
+  }
+  const tempPath = `${resolvedTarget}.${_internals.randomSuffix()}.tmp`;
+  fs.mkdirSync(path.dirname(tempPath), { recursive: true });
+  try {
+    const fd = fs.openSync(tempPath, "wx");
+    try {
+      let written = 0;
+      while (written < buffer.byteLength) {
+        written += _internals.writeSync(fd, buffer, written, buffer.byteLength - written);
+      }
+      if (options?.skipFsync !== true) {
+        try {
+          _internals.fsyncSync(fd);
+        } catch {}
+      }
+    } finally {
+      fs.closeSync(fd);
+    }
+    renameWithRetry(tempPath, resolvedTarget);
+  } finally {
+    try {
+      _internals.unlinkSync(tempPath);
+    } catch {}
+  }
+  try {
+    const dirFd = fs.openSync(path.dirname(resolvedTarget), "r");
+    try {
+      fs.fsyncSync(dirFd);
+    } finally {
+      fs.closeSync(dirFd);
+    }
+  } catch {}
+  invalidateCachedArtifact(resolvedTarget);
+}
+async function atomicWriteSwarmFile(targetPath, content, options) {
+  await new Promise((resolve2) => setImmediate(resolve2));
+  writeAtomicSync(targetPath, content, options);
+}
+function atomicWriteSwarmFileSync(targetPath, content, options) {
+  writeAtomicSync(targetPath, content, options);
+}
+async function atomicWriteFileAnyRoot(targetPath, content, options) {
+  await new Promise((resolve2) => setImmediate(resolve2));
+  writeAtomicSync(targetPath, content, { ...options, contained: false });
+}
+
+export { matchTempGrammar, parseTargetBasename, atomicWriteSwarmFile, atomicWriteSwarmFileSync, atomicWriteFileAnyRoot };

package/dist/cli/{index-jszgrk71.js → index-4zwjc9sb.js}

@@ -2,22 +2,23 @@
 import {
   computePlanStructureHash,
   derivePlanId
-} from "./index-7bvd5nh2.js";
+} from "./index-apjdytwx.js";
 import {
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   PlanSchema
-} from "./index-zq9gs0yk.js";
+} from "./index-0pcq32y2.js";
+import {
+  atomicWriteSwarmFile,
+  atomicWriteSwarmFileSync
+} from "./index-4evasm2b.js";
 import {
   assertProjectRoot
-} from "./index-f9vvg5xb.js";
+} from "./index-pa86tpgt.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
-import {
-  bunWrite
-} from "./index-zj6t9zgx.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";
@@ -562,11 +563,7 @@ function migrateLegacyBindingsSync(directory, scanCapacity = bindingFileScanCapa
       if (valid && binding) {
         const exactPath = getBindingFilePath(directory, binding);
         if (!fs2.existsSync(exactPath)) {
-          const temp = `${exactPath}.migration-${process.pid}`;
-          fs2.writeFileSync(temp, JSON.stringify(binding, null, 2), {
-            flag: "wx"
-          });
-          fs2.renameSync(temp, exactPath);
+          atomicWriteSwarmFileSync(exactPath, JSON.stringify(binding, null, 2));
         } else {
           const existingRaw = readBoundedFile(exactPath);
           const existing = existingRaw ? validateScopeBindingPayload(directory, JSON.parse(existingRaw)) : null;
@@ -1596,26 +1593,10 @@ function resolveAuthorizedPrFeedbackScopeBindingFromDisk(input) {
   return admission.ok ? matches[0] : null;
 }
 async function atomicWrite(targetPath, content) {
-  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  try {
-    await bunWrite(tempPath, content);
-    fs2.renameSync(tempPath, targetPath);
-  } finally {
-    try {
-      fs2.unlinkSync(tempPath);
-    } catch {}
-  }
+  await atomicWriteSwarmFile(targetPath, content);
 }
 function atomicWriteSync(targetPath, content) {
-  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  try {
-    fs2.writeFileSync(tempPath, content, { flag: "wx" });
-    fs2.renameSync(tempPath, targetPath);
-  } finally {
-    try {
-      fs2.unlinkSync(tempPath);
-    } catch {}
-  }
+  atomicWriteSwarmFileSync(targetPath, content);
 }
 var _scopePersistenceInternals = {
   get liveBindingCapacity() {