@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/worktree.js

@@ -2,9 +2,12 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { resolveAuthorityDecision } from "../../policy/authority.js";
+import { PROJECT_SUBAGENTS_RELATIVE_DIR } from "../../shared/artifacts.js";
+import { getAgentDir } from "../../shared/utils.js";
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 function runGit(cwd, args) {
-  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
   return {
     stdout: result.stdout ?? "",
     stderr: result.stderr ?? "",
@@ -23,7 +26,7 @@ function runGitChecked(cwd, args) {
 function resolveRepoState(cwd) {
   const cwdRelative = resolveRepoCwdRelative(cwd);
   const toplevel = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim();
-  const status = runGitChecked(toplevel, ["status", "--porcelain"]);
+  const status = runGitChecked(toplevel, ["status", "--porcelain", "--", `:!${PROJECT_SUBAGENTS_RELATIVE_DIR}`]);
   if (status.trim().length > 0) {
     throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
   }
@@ -32,10 +35,18 @@ function resolveRepoState(cwd) {
 }
 function normalizeComparableCwd(cwd) {
   const resolved = path.resolve(cwd);
-  try {
-    return fs.realpathSync(resolved);
-  } catch {
-    return resolved;
+  let existing = resolved;
+  const missingSegments = [];
+  while (true) {
+    try {
+      return path.join(fs.realpathSync(existing), ...missingSegments.reverse());
+    } catch {
+      const parent = path.dirname(existing);
+      if (parent === existing)
+        return resolved;
+      missingSegments.push(path.basename(existing));
+      existing = parent;
+    }
   }
 }
 export function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
@@ -69,6 +80,11 @@ function resolveWorktreeBaseDir(configuredBaseDir, repoRoot) {
     throw new Error("worktree base directory cannot be empty");
   const expanded = trimmed.startsWith("~/") ? path.join(os.homedir(), trimmed.slice(2)) : trimmed;
   const resolved = path.isAbsolute(expanded) ? expanded : path.resolve(repoRoot, expanded);
+  const extensionsDir = normalizeComparableCwd(path.join(getAgentDir(), "extensions"));
+  const relativeToExtensions = path.relative(extensionsDir, normalizeComparableCwd(resolved));
+  if (!relativeToExtensions || !relativeToExtensions.startsWith(`..${path.sep}`) && relativeToExtensions !== ".." && !path.isAbsolute(relativeToExtensions)) {
+    throw new Error(`worktree base directory cannot be inside DM extensions directory: ${extensionsDir}. Choose a directory outside it.`);
+  }
   try {
     fs.mkdirSync(resolved, { recursive: true });
   } catch (error) {
@@ -181,6 +197,7 @@ function parseWorktreeSetupHookOutput(rawStdout) {
 }
 function runWorktreeSetupHook(hook, input) {
   const result = spawnSync(hook.hookPath, [], {
+    windowsHide: true,
     cwd: input.worktreePath,
     encoding: "utf-8",
     input: JSON.stringify(input),
@@ -297,7 +314,7 @@ function removeSyntheticPathsBeforeDiff(worktree) {
     removeSyntheticPath(worktree, syntheticPath);
   }
 }
-function emptyDiff(index, agent, branch, patchPath) {
+function emptyDiff(index, agent, branch, patchPath, error) {
   return {
     index,
     agent,
@@ -306,7 +323,8 @@ function emptyDiff(index, agent, branch, patchPath) {
     filesChanged: 0,
     insertions: 0,
     deletions: 0,
-    patchPath
+    patchPath,
+    ...error ? { error } : {}
   };
 }
 function parseNumstat(numstat) {
@@ -354,13 +372,113 @@ function writeEmptyPatch(patchPath) {
     fs.writeFileSync(patchPath, "", "utf-8");
   } catch {}
 }
-function cleanupSingleWorktree(repoCwd, worktree) {
+function handoffRecordsPatch(manifestPath, patchPath) {
+  if (!manifestPath || !fs.existsSync(manifestPath))
+    return false;
   try {
-    runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
-  } catch {}
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    if (manifest.version !== 1 || !Array.isArray(manifest.groups))
+      return false;
+    const resolvedPatchPath = path.resolve(patchPath);
+    return manifest.groups.some((group) => Array.isArray(group.children) && group.children.some((child) => child.patch?.error === undefined && typeof child.patch?.path === "string" && path.resolve(child.patch.path) === resolvedPatchPath));
+  } catch {
+    return false;
+  }
+}
+function cleanupSingleWorktree(setup, worktree, intent) {
+  const errors = [];
+  let worktreeRemoved = false;
+  let branchRemoved = false;
+  if (intent.kind === "preserve" && intent.cleanupBlocker) {
+    return {
+      index: worktree.index,
+      path: worktree.path,
+      branch: worktree.branch,
+      worktreeRemoved: false,
+      branchRemoved: false,
+      preserved: true,
+      reason: intent.cleanupBlocker
+    };
+  }
+  if (intent.kind !== "setup-rollback") {
+    try {
+      removeSyntheticPathsBeforeDiff(worktree);
+    } catch (error) {
+      errors.push(`synthetic path cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const status = runGit(worktree.path, ["status", "--porcelain"]);
+    const baseDiff = runGit(worktree.path, ["diff", "--quiet", setup.baseCommit, "--"]);
+    if (status.status !== 0 || baseDiff.status !== 0 && baseDiff.status !== 1) {
+      const reason = status.status !== 0 ? status.stderr.trim() || status.stdout.trim() || "git status failed" : baseDiff.stderr.trim() || baseDiff.stdout.trim() || "git diff check failed";
+      return {
+        index: worktree.index,
+        path: worktree.path,
+        branch: worktree.branch,
+        worktreeRemoved: false,
+        branchRemoved: false,
+        preserved: true,
+        reason: "cleanup safety check failed",
+        errors: [...errors, `cleanup refused: ${reason}`]
+      };
+    }
+    const hasWork = status.stdout.trim().length > 0 || baseDiff.status === 1;
+    if (hasWork && intent.kind === "preserve") {
+      const captured = (intent.capturedDiffs ?? setup.capturedDiffs)?.find((diff) => diff.index === worktree.index);
+      const patchCaptured = captured !== undefined && captured.error === undefined && fs.existsSync(captured.patchPath) && fs.statSync(captured.patchPath).size > 0 && handoffRecordsPatch(intent.handoffManifestPath, captured.patchPath);
+      if (!patchCaptured) {
+        const reason = "worktree contains changes that are not represented by a captured handoff patch";
+        return {
+          index: worktree.index,
+          path: worktree.path,
+          branch: worktree.branch,
+          worktreeRemoved: false,
+          branchRemoved: false,
+          preserved: true,
+          reason,
+          errors: [...errors, `cleanup refused: ${reason}; preserved ${worktree.path}`]
+        };
+      }
+    }
+    if (hasWork && intent.kind === "discard") {
+      const decision = resolveAuthorityDecision({ action: "discardWorktree", policy: intent.authorization.policy });
+      const authorized = decision === "auto" || decision === "confirm" && intent.authorization.kind === "confirmed";
+      if (!authorized) {
+        const reason = decision === "forbid" ? "authority policy forbids worktree discard" : "worktree discard requires explicit user confirmation";
+        return {
+          index: worktree.index,
+          path: worktree.path,
+          branch: worktree.branch,
+          worktreeRemoved: false,
+          branchRemoved: false,
+          preserved: true,
+          reason,
+          errors: [...errors, `cleanup refused: ${reason}; preserved ${worktree.path}`]
+        };
+      }
+    }
+  }
   try {
-    runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
-  } catch {}
+    runGitChecked(setup.cwd, ["worktree", "remove", "--force", worktree.path]);
+    worktreeRemoved = true;
+  } catch (error) {
+    errors.push(`worktree removal failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (worktreeRemoved) {
+    try {
+      runGitChecked(setup.cwd, ["branch", "-D", worktree.branch]);
+      branchRemoved = true;
+    } catch (error) {
+      errors.push(`branch removal failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return {
+    index: worktree.index,
+    path: worktree.path,
+    branch: worktree.branch,
+    worktreeRemoved,
+    branchRemoved,
+    ...errors.length ? { errors } : {}
+  };
 }
 function hasWorktreeChanges(diff) {
   return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
@@ -369,6 +487,22 @@ export function createWorktrees(cwd, runId, count, options) {
   const repo = resolveRepoState(cwd);
   const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
   const baseDir = resolveWorktreeBaseDir(options?.baseDir, repo.toplevel);
+  const plannedSetup = {
+    cwd: repo.toplevel,
+    baseCommit: repo.baseCommit,
+    worktrees: Array.from({ length: count }, (_, index) => {
+      const worktreePath = buildWorktreePath(baseDir, runId, index);
+      return {
+        path: worktreePath,
+        agentCwd: repo.cwdRelative ? path.join(worktreePath, repo.cwdRelative) : worktreePath,
+        branch: buildWorktreeBranch(runId, index),
+        index,
+        nodeModulesLinked: false,
+        syntheticPaths: []
+      };
+    })
+  };
+  options?.beforeCreate?.(plannedSetup);
   const worktrees = [];
   try {
     for (let index = 0;index < count; index++) {
@@ -379,7 +513,7 @@ export function createWorktrees(cwd, runId, count, options) {
       cwd: repo.toplevel,
       worktrees,
       baseCommit: repo.baseCommit
-    });
+    }, { kind: "setup-rollback" });
     throw error;
   }
   return {
@@ -401,20 +535,35 @@ export function diffWorktrees(setup, agents, diffsDir) {
     const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
     try {
       diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
-    } catch {
+    } catch (error) {
       writeEmptyPatch(patchPath);
-      diffs.push(emptyDiff(index, agent, worktree.branch, patchPath));
+      diffs.push(emptyDiff(index, agent, worktree.branch, patchPath, error instanceof Error ? error.message : String(error)));
     }
   }
+  setup.capturedDiffs = diffs;
   return diffs;
 }
-export function cleanupWorktrees(setup) {
+export function cleanupWorktrees(setup, intent = { kind: "preserve", ...setup.capturedDiffs ? { capturedDiffs: setup.capturedDiffs } : {} }) {
+  const tasks = [];
   for (let index = setup.worktrees.length - 1;index >= 0; index--) {
-    cleanupSingleWorktree(setup.cwd, setup.worktrees[index]);
+    tasks.push(cleanupSingleWorktree(setup, setup.worktrees[index], intent));
   }
+  tasks.sort((left, right) => left.index - right.index);
+  const errors = [];
+  let pruned = false;
   try {
     runGitChecked(setup.cwd, ["worktree", "prune"]);
-  } catch {}
+    pruned = true;
+  } catch (error) {
+    errors.push(`worktree prune failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const state = tasks.every((task) => task.worktreeRemoved && task.branchRemoved) && pruned ? "complete" : "partial";
+  return {
+    state,
+    tasks,
+    pruned,
+    ...errors.length ? { errors } : {}
+  };
 }
 export function formatWorktreeDiffSummary(diffs) {
   const changed = diffs.filter(hasWorktreeChanges);

package/extensions/dm-subagents/src/shared/accessible-dir.js

@@ -0,0 +1,35 @@
+import * as fs from "node:fs";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.js";
+export function ensureAccessibleDir(dirPath, options = {}) {
+  const fsImpl = options.fs ?? fs;
+  const pid = options.pid ?? process.pid;
+  const retryDirectoryErrors = options.retryDirectoryErrors ?? process.platform === "win32";
+  const retryDelaysMs = retryDirectoryErrors ? options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];
+  const wait = options.wait ?? waitForFileSystemRetry;
+  const mkdirWithRetry = (target) => {
+    runFileSystemOperationWithRetry(() => {
+      fsImpl.mkdirSync(target, { recursive: true });
+    }, { retryDelaysMs, wait });
+  };
+  const accessWithRetry = (target) => {
+    runFileSystemOperationWithRetry(() => {
+      fsImpl.accessSync(target, fs.constants.R_OK | fs.constants.W_OK);
+    }, { retryDelaysMs, wait });
+  };
+  const fallbackPath = () => {
+    const fallback = `${dirPath}-${pid}`;
+    mkdirWithRetry(fallback);
+    accessWithRetry(fallback);
+    return fallback;
+  };
+  try {
+    mkdirWithRetry(dirPath);
+    accessWithRetry(dirPath);
+    return dirPath;
+  } catch (error) {
+    const code = error?.code;
+    if (code !== "EPERM" && code !== "EACCES")
+      throw error;
+    return fallbackPath();
+  }
+}

package/extensions/dm-subagents/src/shared/agent-stream-options.js

@@ -0,0 +1,3 @@
+export function agentStreamOptions(streamFn) {
+  return { streamFunction: streamFn, streamFn };
+}

package/extensions/dm-subagents/src/shared/artifacts.js

@@ -1,11 +1,133 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { TEMP_ARTIFACTS_DIR } from "./types.js";
+import { CHAIN_RUNS_DIR, TEMP_ARTIFACTS_DIR } from "./types.js";
 import { getAgentDir } from "./utils.js";
 const CLEANUP_MARKER_FILE = ".last-cleanup";
-const PROJECT_ARTIFACT_ROOT = ".dm-subagents";
+export const PROJECT_SUBAGENTS_RELATIVE_DIR = ".dm/subagents";
+const PROJECT_ARTIFACT_PATHS = [
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_input.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker.jsonl`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_transcript.jsonl`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_meta.json`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/progress/run/progress.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/run/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/chain-runs/run.json`
+];
+function globMatchesPath(pattern, filePath) {
+  let expression = "^";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const character = pattern[index];
+    if (character === undefined)
+      break;
+    if (character === "*" && pattern[index + 1] === "*") {
+      index += 1;
+      if (pattern[index + 1] === "/") {
+        index += 1;
+        expression += "(?:.*/)?";
+      } else {
+        expression += ".*";
+      }
+    } else if (character === "*") {
+      expression += "[^/]*";
+    } else if (character === "?") {
+      expression += "[^/]";
+    } else if (character === "[") {
+      const end = pattern.indexOf("]", index + 1);
+      if (end === -1)
+        expression += "\\[";
+      else {
+        expression += pattern.slice(index, end + 1);
+        index = end;
+      }
+    } else {
+      expression += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  try {
+    return new RegExp(`${expression}$`).test(filePath);
+  } catch {
+    return false;
+  }
+}
+function normalizePattern(pattern) {
+  return pattern.replace(/^\.\//, "").replace(/^\//, "").replace(/\/+$/, "");
+}
+function patternMatchesArtifactPath(pattern, artifactPath) {
+  const normalized = normalizePattern(pattern);
+  return normalized === PROJECT_SUBAGENTS_RELATIVE_DIR || normalized === "*" || artifactPath.startsWith(`${normalized}/`) || globMatchesPath(normalized, artifactPath);
+}
+function ignoreFileExcludesProjectArtifacts(filePath) {
+  if (!fs.existsSync(filePath))
+    return false;
+  try {
+    const excluded = new Set;
+    for (const rawLine of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#"))
+        continue;
+      const negated = line.startsWith("!");
+      const pattern = negated ? line.slice(1) : line;
+      for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+        if (!patternMatchesArtifactPath(pattern, artifactPath))
+          continue;
+        if (negated)
+          excluded.delete(artifactPath);
+        else
+          excluded.add(artifactPath);
+      }
+    }
+    return excluded.size === PROJECT_ARTIFACT_PATHS.length;
+  } catch {
+    return false;
+  }
+}
+function filesIncludeProjectArtifacts(files) {
+  if (!Array.isArray(files))
+    return;
+  const included = new Set;
+  for (const entry of files) {
+    if (typeof entry !== "string")
+      continue;
+    const negated = entry.startsWith("!");
+    const pattern = negated ? entry.slice(1) : entry;
+    for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+      if (!patternMatchesArtifactPath(pattern, artifactPath))
+        continue;
+      if (negated)
+        included.delete(artifactPath);
+      else
+        included.add(artifactPath);
+    }
+  }
+  return included.size > 0;
+}
+export function getProjectArtifactPackagingWarning(cwd) {
+  const packagePath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packagePath))
+    return;
+  let packageJson;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    packageJson = parsed;
+  } catch {
+    return;
+  }
+  const filesIncludeArtifacts = filesIncludeProjectArtifacts(packageJson.files);
+  if (filesIncludeArtifacts === false)
+    return;
+  const npmIgnorePath = path.join(cwd, ".npmignore");
+  const ignorePath = fs.existsSync(npmIgnorePath) ? npmIgnorePath : path.join(cwd, ".gitignore");
+  if (filesIncludeArtifacts === undefined && ignoreFileExcludesProjectArtifacts(ignorePath))
+    return;
+  return "Project-scoped subagent artifacts can be included when this package is published. Add '.dm/subagents/' to .npmignore, restrict package.json files, or set artifactDir to 'session' or 'temp'.";
+}
 export function getProjectSubagentsDir(cwd) {
-  return path.join(cwd, PROJECT_ARTIFACT_ROOT);
+  return path.join(cwd, PROJECT_SUBAGENTS_RELATIVE_DIR);
 }
 export function getProjectArtifactsDir(cwd) {
   return path.join(getProjectSubagentsDir(cwd), "artifacts");
@@ -13,14 +135,38 @@ export function getProjectArtifactsDir(cwd) {
 export function getProjectChainRunsDir(cwd) {
   return path.join(getProjectSubagentsDir(cwd), "chain-runs");
 }
-export function getArtifactsDir(sessionFile, projectCwd) {
-  if (projectCwd)
-    return getProjectArtifactsDir(projectCwd);
-  if (sessionFile) {
-    const sessionDir = path.dirname(sessionFile);
-    return path.join(sessionDir, "subagent-artifacts");
+export function getChainRunsDir(projectCwd, dirPreference = "session") {
+  switch (dirPreference) {
+    case "project":
+      return getProjectChainRunsDir(projectCwd);
+    case "session":
+    case "temp":
+      return CHAIN_RUNS_DIR;
+    default:
+      throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
+  }
+}
+export function getArtifactsDir(sessionFile, projectCwd, dirPreference = "session") {
+  switch (dirPreference) {
+    case "session":
+      if (sessionFile) {
+        const sessionDir = path.dirname(sessionFile);
+        return path.join(sessionDir, "subagent-artifacts");
+      }
+      return TEMP_ARTIFACTS_DIR;
+    case "temp":
+      return TEMP_ARTIFACTS_DIR;
+    case "project":
+      if (projectCwd)
+        return getProjectArtifactsDir(projectCwd);
+      if (sessionFile) {
+        const sessionDir = path.dirname(sessionFile);
+        return path.join(sessionDir, "subagent-artifacts");
+      }
+      return TEMP_ARTIFACTS_DIR;
+    default:
+      throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
   }
-  return TEMP_ARTIFACTS_DIR;
 }
 export function getArtifactPaths(artifactsDir, runId, agent, index) {
   const suffix = index !== undefined ? `_${index}` : "";
@@ -38,9 +184,22 @@ export function ensureArtifactsDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 export function writeArtifact(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, "utf-8");
 }
+export function formatOutputArtifactContent(input) {
+  if (input.output.trim() || !input.error)
+    return input.output;
+  const lines = ["Subagent run failed before producing output.", "", "Error:", input.error];
+  if (input.transcriptPath)
+    lines.push("", `Transcript: ${input.transcriptPath}`);
+  if (input.metadataPath)
+    lines.push(`Metadata: ${input.metadataPath}`);
+  return lines.join(`
+`);
+}
 export function writeMetadata(filePath, metadata) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 export function appendJsonl(filePath, line) {
@@ -48,7 +207,7 @@ export function appendJsonl(filePath, line) {
 `);
 }
 export function cleanupOldArtifacts(dir, maxAgeDays) {
-  if (!fs.existsSync(dir))
+  if (maxAgeDays <= 0 || !fs.existsSync(dir))
     return;
   const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
   const now = Date.now();

package/extensions/dm-subagents/src/shared/atomic-json.js

@@ -1,55 +1,53 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000];
-const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
-const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
-const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
-function waitSync(delayMs) {
-  if (delayMs <= 0)
-    return;
-  if (WAIT_VIEW) {
-    try {
-      Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
-      return;
-    } catch {}
-  }
-  const end = Date.now() + delayMs;
-  while (Date.now() < end) {}
-}
-function isRetryableRenameError(error) {
-  const code = error?.code;
-  return typeof code === "string" && RETRYABLE_RENAME_ERROR_CODES.has(code);
-}
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.js";
+const MAX_PATH_COMPONENT_BYTES = 255;
 function renameWithRetry(fsImpl, sourcePath, targetPath, retryDelaysMs, wait) {
-  for (let attempt = 0;; attempt++) {
-    try {
-      fsImpl.renameSync(sourcePath, targetPath);
-      return;
-    } catch (error) {
-      const delayMs = retryDelaysMs[attempt];
-      if (delayMs === undefined || !isRetryableRenameError(error))
-        throw error;
-      wait(delayMs);
-    }
-  }
+  runFileSystemOperationWithRetry(() => {
+    fsImpl.renameSync(sourcePath, targetPath);
+  }, { retryDelaysMs, wait });
+}
+function tempBaseName(filePath, pid, nowMs, randomId) {
+  const suffix = `.${pid}.${nowMs}.${randomId}.tmp`;
+  const preferred = `.${path.basename(filePath)}${suffix}`;
+  if (Buffer.byteLength(preferred, "utf-8") <= MAX_PATH_COMPONENT_BYTES)
+    return preferred;
+  return `.${createHash("sha256").update(path.basename(filePath)).digest("hex")}${suffix}`;
 }
 export function createAtomicJsonWriter(options = {}) {
   const fsImpl = options.fs ?? fs;
   const now = options.now ?? Date.now;
   const pid = options.pid ?? process.pid;
   const random = options.random ?? Math.random;
+  const mode = options.mode;
   const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
-  const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
-  const wait = options.wait ?? waitSync;
+  const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+  const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
+  const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
+  const wait = options.wait ?? waitForFileSystemRetry;
   return (filePath, payload) => {
-    fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`);
+    runFileSystemOperationWithRetry(() => {
+      fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+    }, { retryDelaysMs: directoryRetryDelaysMs, wait });
+    const tempPath = path.join(path.dirname(filePath), tempBaseName(filePath, pid, now(), random().toString(36).slice(2)));
+    let writeError;
     try {
-      fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-      renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
+      fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
+      renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
+    } catch (error) {
+      writeError = error;
+      throw error;
     } finally {
-      fsImpl.rmSync(tempPath, { force: true });
+      try {
+        fsImpl.rmSync(tempPath, { force: true });
+      } catch (cleanupError) {
+        if (writeError === undefined)
+          throw cleanupError;
+      }
     }
   };
 }
 export const writeAtomicJson = createAtomicJsonWriter();
+export const writePrivateAtomicJson = createAtomicJsonWriter({ mode: 384 });