@duckmind/dm-windows-x64 0.60.6 → 0.60.9

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

@@ -1,3 +1,435 @@
-import{spawnSync as T}from"node:child_process";import*as F from"node:fs";import*as W from"node:os";import*as Z from"node:path";var M=30000;function O(j,Q){let J=T("git",["-C",j,...Q],{encoding:"utf-8"});return{stdout:J.stdout??"",stderr:J.stderr??"",status:J.status}}function A(j,Q){let J=O(j,Q);if(J.status!==0){let X=`git -C ${j} ${Q.join(" ")}`,V=J.stderr.trim()||J.stdout.trim()||`${X} failed`;throw Error(V)}return J.stdout}function G(j){let Q=S(j),J=A(j,["rev-parse","--show-toplevel"]).trim();if(A(J,["status","--porcelain"]).trim().length>0)throw Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");let V=A(J,["rev-parse","HEAD"]).trim();return{toplevel:J,cwdRelative:Q,baseCommit:V}}function _(j){let Q=Z.resolve(j);try{return F.realpathSync(Q)}catch{return Q}}function i(j,Q){let J=_(Q);for(let X=0;X<j.length;X++){let V=j[X];if(!V.cwd)continue;let Y=Z.isAbsolute(V.cwd)?V.cwd:Z.resolve(Q,V.cwd);if(_(Y)===J)continue;return{index:X,agent:V.agent,cwd:V.cwd}}return}function d(j,Q){return`worktree isolation uses the shared cwd (${Q}); task ${j.index+1} (${j.agent}) sets cwd to ${j.cwd}. Remove task-level cwd overrides or disable worktree.`}function R(j){return j.replace(/[^\w.-]/g,"_")}function I(j,Q){return`dm-parallel-${j}-${Q}`}function z(j,Q){let J=j??process.env.DM_SUBAGENTS_WORKTREE_DIR;if(J===void 0)return W.tmpdir();let X=J.trim();if(!X)throw Error("worktree base directory cannot be empty");let V=X.startsWith("~/")?Z.join(W.homedir(),X.slice(2)):X,Y=Z.isAbsolute(V)?V:Z.resolve(Q,V);try{F.mkdirSync(Y,{recursive:!0})}catch($){let q=$ instanceof Error?$.message:String($);throw Error(`failed to create worktree base directory ${Y}: ${q}`)}return Y}function H(j,Q,J){return Z.join(j,`dm-worktree-${Q}-${J}`)}function S(j){let Q=O(j,["rev-parse","--is-inside-work-tree"]);if(Q.status!==0||Q.stdout.trim()!=="true")throw Error("worktree isolation requires a git repository");let J=A(j,["rev-parse","--show-prefix"]).trim(),X=J?Z.normalize(J.replace(/[\\/]+$/,"")):"";return X==="."?"":X}function a(j,Q,J,X){let V=S(j),Y=A(j,["rev-parse","--show-toplevel"]).trim(),$=H(z(X,Y),Q,J);return V?Z.join($,V):$}function D(j,Q){let J=Z.join(j,"node_modules"),X=Z.join(Q,"node_modules");if(!F.existsSync(J)||F.existsSync(X))return!1;try{return F.symlinkSync(J,X),!0}catch{return!1}}function C(j){if(j===void 0)return M;if(!Number.isInteger(j)||j<=0)throw Error("worktree setup hook timeout must be an integer greater than 0");return j}function g(j,Q){if(!Q)return;let J=Q.hookPath.trim();if(!J)throw Error("worktree setup hook path cannot be empty");let X=J.startsWith("~/")?Z.join(W.homedir(),J.slice(2)):J,V;if(Z.isAbsolute(X))V=X;else if(X.includes("/")||X.includes("\\"))V=Z.resolve(j,X);else throw Error("worktree setup hook must be an absolute path or a repo-relative path");if(!F.existsSync(V))throw Error(`worktree setup hook not found: ${V}`);if(F.statSync(V).isDirectory())throw Error(`worktree setup hook must be a file, got directory: ${V}`);return{hookPath:V,timeoutMs:C(Q.timeoutMs)}}function x(j,Q){let J=Q.trim();if(!J)throw Error("synthetic path cannot be empty");if(Z.isAbsolute(J))throw Error(`synthetic path must be relative: ${Q}`);let X=Z.resolve(j,J),V=Z.relative(j,X);if(!V||V===".")throw Error(`synthetic path cannot target the worktree root: ${Q}`);if(V===".."||V.startsWith(`..${Z.sep}`)||Z.isAbsolute(V))throw Error(`synthetic path escapes the worktree root: ${Q}`);return Z.normalize(V)}function m(j,Q){let J=O(j,["ls-files","--",Q]);return J.status===0&&J.stdout.trim().length>0}function v(j){let Q=j.trim();if(!Q)throw Error("worktree setup hook returned empty stdout; expected JSON object");let J;try{J=JSON.parse(Q)}catch(X){let V=X instanceof Error?X.message:String(X);throw Error(`worktree setup hook returned invalid JSON: ${V}`)}if(!J||typeof J!=="object"||Array.isArray(J))throw Error("worktree setup hook stdout must be a JSON object");return J}function f(j,Q){let J=T(j.hookPath,[],{cwd:Q.worktreePath,encoding:"utf-8",input:JSON.stringify(Q),timeout:j.timeoutMs,shell:!1});if(J.error){if(("code"in J.error?J.error.code:void 0)==="ETIMEDOUT")throw Error(`worktree setup hook timed out after ${j.timeoutMs}ms`);throw Error(`worktree setup hook failed: ${J.error.message}`)}if(J.status!==0){let Y=J.stderr.trim()||J.stdout.trim()||"no output";throw Error(`worktree setup hook failed with exit code ${J.status}: ${Y}`)}let X=v(J.stdout);if(X.syntheticPaths===void 0)return[];if(!Array.isArray(X.syntheticPaths))throw Error("worktree setup hook output field 'syntheticPaths' must be an array of relative paths");let V=new Set;for(let Y of X.syntheticPaths){if(typeof Y!=="string")throw Error("worktree setup hook output field 'syntheticPaths' must contain only strings");let $=x(Q.worktreePath,Y);if(m(Q.worktreePath,$))throw Error(`worktree setup hook cannot mark tracked paths as synthetic: ${$}`);V.add($)}return[...V]}function P(j,Q,J,X,V,Y,$,q){let K=I(J,X),N=H(q,J,X),B=O(j,["worktree","add",N,"-b",K,"HEAD"]);if(B.status!==0){let U=B.stderr.trim()||B.stdout.trim()||`failed to create worktree ${N}`;throw Error(U)}let E=Q?Z.join(N,Q):N;try{let U=D(j,N),L=U?["node_modules"]:[];if(Y){let b=f(Y,{version:1,repoRoot:j,worktreePath:N,agentCwd:E,branch:K,index:X,runId:J,baseCommit:V,agent:$});L.push(...b)}return{path:N,agentCwd:E,branch:K,index:X,nodeModulesLinked:U,syntheticPaths:L}}catch(U){try{A(j,["worktree","remove","--force",N])}catch{}try{A(j,["branch","-D",K])}catch{}throw U}}function c(j,Q){let J=Z.resolve(j.path,Q),X=Z.relative(j.path,J);if(!X||X==="."||X===".."||X.startsWith(`..${Z.sep}`)||Z.isAbsolute(X))return;let V;try{V=F.lstatSync(J)}catch(Y){if((Y&&typeof Y==="object"&&"code"in Y?Y.code:void 0)==="ENOENT")return;throw Y}if(V.isSymbolicLink()){F.unlinkSync(J);return}if(V.isDirectory()){F.rmSync(J,{recursive:!0,force:!0});return}F.rmSync(J,{force:!0})}function k(j){if(j.syntheticPaths.length===0)return;let Q=new Set;for(let J of j.syntheticPaths){if(Q.has(J))continue;Q.add(J),c(j,J)}}function y(j,Q,J,X){return{index:j,agent:Q,branch:J,diffStat:"",filesChanged:0,insertions:0,deletions:0,patchPath:X}}function p(j){let Q=j.split(`
-`).map((Y)=>Y.trim()).filter(Boolean),J=0,X=0,V=0;for(let Y of Q){let[$,q]=Y.split("\t");if($===void 0||q===void 0)continue;if(J++,/^\d+$/.test($))X+=parseInt($,10);if(/^\d+$/.test(q))V+=parseInt(q,10)}return{filesChanged:J,insertions:X,deletions:V}}function u(j,Q,J,X){k(Q),A(Q.path,["add","-A"]);let V=A(Q.path,["diff","--cached","--stat",j.baseCommit]).trim(),Y=A(Q.path,["diff","--cached",j.baseCommit]),$=A(Q.path,["diff","--cached","--numstat",j.baseCommit]);if(F.writeFileSync(X,Y,"utf-8"),!Y.trim())return y(Q.index,J,Q.branch,X);let q=p($);return{index:Q.index,agent:J,branch:Q.branch,diffStat:V,filesChanged:q.filesChanged,insertions:q.insertions,deletions:q.deletions,patchPath:X}}function w(j){try{F.writeFileSync(j,"","utf-8")}catch{}}function l(j,Q){try{A(j,["worktree","remove","--force",Q.path])}catch{}try{A(j,["branch","-D",Q.branch])}catch{}}function h(j){return j.filesChanged>0||j.insertions>0||j.deletions>0||j.diffStat.trim().length>0}function o(j,Q,J,X){let V=G(j),Y=g(V.toplevel,X?.setupHook),$=z(X?.baseDir,V.toplevel),q=[];try{for(let K=0;K<J;K++)q.push(P(V.toplevel,V.cwdRelative,Q,K,V.baseCommit,Y,X?.agents?.[K],$))}catch(K){throw n({cwd:V.toplevel,worktrees:q,baseCommit:V.baseCommit}),K}return{cwd:V.toplevel,worktrees:q,baseCommit:V.baseCommit}}function r(j,Q,J){try{F.mkdirSync(J,{recursive:!0})}catch{return[]}let X=[];for(let V=0;V<j.worktrees.length;V++){let Y=j.worktrees[V],$=Q[V]??`task-${V+1}`,q=Z.join(J,`task-${V}-${R($)}.patch`);try{X.push(u(j,Y,$,q))}catch{w(q),X.push(y(V,$,Y.branch,q))}}return X}function n(j){for(let Q=j.worktrees.length-1;Q>=0;Q--)l(j.cwd,j.worktrees[Q]);try{A(j.cwd,["worktree","prune"])}catch{}}function t(j){let Q=j.filter(h);if(Q.length===0)return"";let J=["=== Worktree Changes ===",""];for(let V of Q){if(J.push(`--- Task ${V.index+1} (${V.agent}): ${V.filesChanged} files changed, +${V.insertions} -${V.deletions} ---`),V.diffStat.trim().length>0)J.push(V.diffStat);J.push("")}let X=Z.dirname(Q[0].patchPath);return J.push(`Full patches: ${X}`),J.join(`
-`).trimEnd()}export{a as resolveExpectedWorktreeAgentCwd,d as formatWorktreeTaskCwdConflict,t as formatWorktreeDiffSummary,i as findWorktreeTaskCwdConflict,r as diffWorktrees,o as createWorktrees,n as cleanupWorktrees};
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
+function runGit(cwd, args) {
+  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status
+  };
+}
+function runGitChecked(cwd, args) {
+  const result = runGit(cwd, args);
+  if (result.status !== 0) {
+    const command = `git -C ${cwd} ${args.join(" ")}`;
+    const message = result.stderr.trim() || result.stdout.trim() || `${command} failed`;
+    throw new Error(message);
+  }
+  return result.stdout;
+}
+function resolveRepoState(cwd) {
+  const cwdRelative = resolveRepoCwdRelative(cwd);
+  const toplevel = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  const status = runGitChecked(toplevel, ["status", "--porcelain"]);
+  if (status.trim().length > 0) {
+    throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
+  }
+  const baseCommit = runGitChecked(toplevel, ["rev-parse", "HEAD"]).trim();
+  return { toplevel, cwdRelative, baseCommit };
+}
+function normalizeComparableCwd(cwd) {
+  const resolved = path.resolve(cwd);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+export function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
+  const normalizedSharedCwd = normalizeComparableCwd(sharedCwd);
+  for (let index = 0;index < tasks.length; index++) {
+    const task = tasks[index];
+    if (!task.cwd)
+      continue;
+    const taskCwd = path.isAbsolute(task.cwd) ? task.cwd : path.resolve(sharedCwd, task.cwd);
+    if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd)
+      continue;
+    return { index, agent: task.agent, cwd: task.cwd };
+  }
+  return;
+}
+export function formatWorktreeTaskCwdConflict(conflict, sharedCwd) {
+  return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
+}
+function safePatchAgentName(agent) {
+  return agent.replace(/[^\w.-]/g, "_");
+}
+function buildWorktreeBranch(runId, index) {
+  return `dm-parallel-${runId}-${index}`;
+}
+function resolveWorktreeBaseDir(configuredBaseDir, repoRoot) {
+  const rawBaseDir = configuredBaseDir ?? process.env.DM_SUBAGENTS_WORKTREE_DIR;
+  if (rawBaseDir === undefined)
+    return os.tmpdir();
+  const trimmed = rawBaseDir.trim();
+  if (!trimmed)
+    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);
+  try {
+    fs.mkdirSync(resolved, { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to create worktree base directory ${resolved}: ${message}`);
+  }
+  return resolved;
+}
+function buildWorktreePath(baseDir, runId, index) {
+  return path.join(baseDir, `dm-worktree-${runId}-${index}`);
+}
+function resolveRepoCwdRelative(cwd) {
+  const repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
+    throw new Error("worktree isolation requires a git repository");
+  }
+  const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
+  const normalizedPrefix = rawPrefix ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
+  return normalizedPrefix === "." ? "" : normalizedPrefix;
+}
+export function resolveExpectedWorktreeAgentCwd(cwd, runId, index, baseDir) {
+  const cwdRelative = resolveRepoCwdRelative(cwd);
+  const repoRoot = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  const worktreePath = buildWorktreePath(resolveWorktreeBaseDir(baseDir, repoRoot), runId, index);
+  return cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath;
+}
+function linkNodeModulesIfPresent(toplevel, worktreePath) {
+  const nodeModulesPath = path.join(toplevel, "node_modules");
+  const nodeModulesLinkPath = path.join(worktreePath, "node_modules");
+  if (!fs.existsSync(nodeModulesPath) || fs.existsSync(nodeModulesLinkPath))
+    return false;
+  try {
+    fs.symlinkSync(nodeModulesPath, nodeModulesLinkPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseHookTimeout(timeoutMs) {
+  if (timeoutMs === undefined)
+    return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("worktree setup hook timeout must be an integer greater than 0");
+  }
+  return timeoutMs;
+}
+function resolveWorktreeSetupHook(repoRoot, config) {
+  if (!config)
+    return;
+  const hookPath = config.hookPath.trim();
+  if (!hookPath) {
+    throw new Error("worktree setup hook path cannot be empty");
+  }
+  const expandedHookPath = hookPath.startsWith("~/") ? path.join(os.homedir(), hookPath.slice(2)) : hookPath;
+  let resolvedPath;
+  if (path.isAbsolute(expandedHookPath)) {
+    resolvedPath = expandedHookPath;
+  } else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
+    resolvedPath = path.resolve(repoRoot, expandedHookPath);
+  } else {
+    throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
+  }
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`worktree setup hook not found: ${resolvedPath}`);
+  }
+  if (fs.statSync(resolvedPath).isDirectory()) {
+    throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
+  }
+  return {
+    hookPath: resolvedPath,
+    timeoutMs: parseHookTimeout(config.timeoutMs)
+  };
+}
+function normalizeSyntheticPath(worktreePath, rawPath) {
+  const trimmed = rawPath.trim();
+  if (!trimmed)
+    throw new Error("synthetic path cannot be empty");
+  if (path.isAbsolute(trimmed))
+    throw new Error(`synthetic path must be relative: ${rawPath}`);
+  const resolved = path.resolve(worktreePath, trimmed);
+  const relative = path.relative(worktreePath, resolved);
+  if (!relative || relative === ".") {
+    throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
+  }
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
+  }
+  return path.normalize(relative);
+}
+function hasTrackedEntries(worktreePath, relativePath) {
+  const result = runGit(worktreePath, ["ls-files", "--", relativePath]);
+  return result.status === 0 && result.stdout.trim().length > 0;
+}
+function parseWorktreeSetupHookOutput(rawStdout) {
+  const trimmed = rawStdout.trim();
+  if (!trimmed) {
+    throw new Error("worktree setup hook returned empty stdout; expected JSON object");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`worktree setup hook returned invalid JSON: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("worktree setup hook stdout must be a JSON object");
+  }
+  return parsed;
+}
+function runWorktreeSetupHook(hook, input) {
+  const result = spawnSync(hook.hookPath, [], {
+    cwd: input.worktreePath,
+    encoding: "utf-8",
+    input: JSON.stringify(input),
+    timeout: hook.timeoutMs,
+    shell: false
+  });
+  if (result.error) {
+    const code = "code" in result.error ? result.error.code : undefined;
+    if (code === "ETIMEDOUT") {
+      throw new Error(`worktree setup hook timed out after ${hook.timeoutMs}ms`);
+    }
+    throw new Error(`worktree setup hook failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const details = result.stderr.trim() || result.stdout.trim() || "no output";
+    throw new Error(`worktree setup hook failed with exit code ${result.status}: ${details}`);
+  }
+  const output = parseWorktreeSetupHookOutput(result.stdout);
+  if (output.syntheticPaths === undefined)
+    return [];
+  if (!Array.isArray(output.syntheticPaths)) {
+    throw new Error("worktree setup hook output field 'syntheticPaths' must be an array of relative paths");
+  }
+  const uniquePaths = new Set;
+  for (const candidate of output.syntheticPaths) {
+    if (typeof candidate !== "string") {
+      throw new Error("worktree setup hook output field 'syntheticPaths' must contain only strings");
+    }
+    const normalizedPath = normalizeSyntheticPath(input.worktreePath, candidate);
+    if (hasTrackedEntries(input.worktreePath, normalizedPath)) {
+      throw new Error(`worktree setup hook cannot mark tracked paths as synthetic: ${normalizedPath}`);
+    }
+    uniquePaths.add(normalizedPath);
+  }
+  return [...uniquePaths];
+}
+function createSingleWorktree(toplevel, cwdRelative, runId, index, baseCommit, setupHook, agent, baseDir) {
+  const branch = buildWorktreeBranch(runId, index);
+  const worktreePath = buildWorktreePath(baseDir, runId, index);
+  const add = runGit(toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"]);
+  if (add.status !== 0) {
+    const message = add.stderr.trim() || add.stdout.trim() || `failed to create worktree ${worktreePath}`;
+    throw new Error(message);
+  }
+  const agentCwd = cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath;
+  try {
+    const nodeModulesLinked = linkNodeModulesIfPresent(toplevel, worktreePath);
+    const syntheticPaths = nodeModulesLinked ? ["node_modules"] : [];
+    if (setupHook) {
+      const hookSyntheticPaths = runWorktreeSetupHook(setupHook, {
+        version: 1,
+        repoRoot: toplevel,
+        worktreePath,
+        agentCwd,
+        branch,
+        index,
+        runId,
+        baseCommit,
+        agent
+      });
+      syntheticPaths.push(...hookSyntheticPaths);
+    }
+    return {
+      path: worktreePath,
+      agentCwd,
+      branch,
+      index,
+      nodeModulesLinked,
+      syntheticPaths
+    };
+  } catch (error) {
+    try {
+      runGitChecked(toplevel, ["worktree", "remove", "--force", worktreePath]);
+    } catch {}
+    try {
+      runGitChecked(toplevel, ["branch", "-D", branch]);
+    } catch {}
+    throw error;
+  }
+}
+function removeSyntheticPath(worktree, syntheticPath) {
+  const resolved = path.resolve(worktree.path, syntheticPath);
+  const relative = path.relative(worktree.path, resolved);
+  if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return;
+  }
+  let stat;
+  try {
+    stat = fs.lstatSync(resolved);
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (code === "ENOENT")
+      return;
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    fs.unlinkSync(resolved);
+    return;
+  }
+  if (stat.isDirectory()) {
+    fs.rmSync(resolved, { recursive: true, force: true });
+    return;
+  }
+  fs.rmSync(resolved, { force: true });
+}
+function removeSyntheticPathsBeforeDiff(worktree) {
+  if (worktree.syntheticPaths.length === 0)
+    return;
+  const seen = new Set;
+  for (const syntheticPath of worktree.syntheticPaths) {
+    if (seen.has(syntheticPath))
+      continue;
+    seen.add(syntheticPath);
+    removeSyntheticPath(worktree, syntheticPath);
+  }
+}
+function emptyDiff(index, agent, branch, patchPath) {
+  return {
+    index,
+    agent,
+    branch,
+    diffStat: "",
+    filesChanged: 0,
+    insertions: 0,
+    deletions: 0,
+    patchPath
+  };
+}
+function parseNumstat(numstat) {
+  const lines = numstat.split(`
+`).map((line) => line.trim()).filter(Boolean);
+  let filesChanged = 0;
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of lines) {
+    const [rawInsertions, rawDeletions] = line.split("\t");
+    if (rawInsertions === undefined || rawDeletions === undefined)
+      continue;
+    filesChanged++;
+    if (/^\d+$/.test(rawInsertions))
+      insertions += parseInt(rawInsertions, 10);
+    if (/^\d+$/.test(rawDeletions))
+      deletions += parseInt(rawDeletions, 10);
+  }
+  return { filesChanged, insertions, deletions };
+}
+function captureWorktreeDiff(setup, worktree, agent, patchPath) {
+  removeSyntheticPathsBeforeDiff(worktree);
+  runGitChecked(worktree.path, ["add", "-A"]);
+  const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
+  const patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]);
+  const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
+  fs.writeFileSync(patchPath, patch, "utf-8");
+  if (!patch.trim()) {
+    return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
+  }
+  const parsed = parseNumstat(numstat);
+  return {
+    index: worktree.index,
+    agent,
+    branch: worktree.branch,
+    diffStat,
+    filesChanged: parsed.filesChanged,
+    insertions: parsed.insertions,
+    deletions: parsed.deletions,
+    patchPath
+  };
+}
+function writeEmptyPatch(patchPath) {
+  try {
+    fs.writeFileSync(patchPath, "", "utf-8");
+  } catch {}
+}
+function cleanupSingleWorktree(repoCwd, worktree) {
+  try {
+    runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
+  } catch {}
+  try {
+    runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
+  } catch {}
+}
+function hasWorktreeChanges(diff) {
+  return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
+}
+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 worktrees = [];
+  try {
+    for (let index = 0;index < count; index++) {
+      worktrees.push(createSingleWorktree(repo.toplevel, repo.cwdRelative, runId, index, repo.baseCommit, setupHook, options?.agents?.[index], baseDir));
+    }
+  } catch (error) {
+    cleanupWorktrees({
+      cwd: repo.toplevel,
+      worktrees,
+      baseCommit: repo.baseCommit
+    });
+    throw error;
+  }
+  return {
+    cwd: repo.toplevel,
+    worktrees,
+    baseCommit: repo.baseCommit
+  };
+}
+export function diffWorktrees(setup, agents, diffsDir) {
+  try {
+    fs.mkdirSync(diffsDir, { recursive: true });
+  } catch {
+    return [];
+  }
+  const diffs = [];
+  for (let index = 0;index < setup.worktrees.length; index++) {
+    const worktree = setup.worktrees[index];
+    const agent = agents[index] ?? `task-${index + 1}`;
+    const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
+    try {
+      diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
+    } catch {
+      writeEmptyPatch(patchPath);
+      diffs.push(emptyDiff(index, agent, worktree.branch, patchPath));
+    }
+  }
+  return diffs;
+}
+export function cleanupWorktrees(setup) {
+  for (let index = setup.worktrees.length - 1;index >= 0; index--) {
+    cleanupSingleWorktree(setup.cwd, setup.worktrees[index]);
+  }
+  try {
+    runGitChecked(setup.cwd, ["worktree", "prune"]);
+  } catch {}
+}
+export function formatWorktreeDiffSummary(diffs) {
+  const changed = diffs.filter(hasWorktreeChanges);
+  if (changed.length === 0)
+    return "";
+  const lines = ["=== Worktree Changes ===", ""];
+  for (const diff of changed) {
+    lines.push(`--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`);
+    if (diff.diffStat.trim().length > 0) {
+      lines.push(diff.diffStat);
+    }
+    lines.push("");
+  }
+  const patchesDir = path.dirname(changed[0].patchPath);
+  lines.push(`Full patches: ${patchesDir}`);
+  return lines.join(`
+`).trimEnd();
+}

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

@@ -1,2 +1,92 @@
-import*as Z from"node:fs";import*as J from"node:path";import*as V from"node:os";import*as G from"node:path";function z(Q){return Q.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function N(Q){let Y=Q?.env??process.env,$=Q&&Object.hasOwn(Q,"getuid")?Q.getuid:process.getuid?.bind(process);if(typeof $==="function")return`uid-${$()}`;for(let W of["USERNAME","USER","LOGNAME"]){let j=Y[W];if(j)return`user-${z(j)}`}let X=Q&&Object.hasOwn(Q,"userInfo")?Q.userInfo:V.userInfo;try{let W=X?.().username;if(W)return`user-${z(W)}`}catch{}let B=Y.USERPROFILE??Y.HOME;if(B)return`home-${z(B)}`;let K=Q&&Object.hasOwn(Q,"homedir")?Q.homedir:V.homedir;try{let W=K?.();if(W)return`home-${z(W)}`}catch{}return"shared"}var L=G.join(V.tmpdir(),`dm-subagents-${N()}`),P=G.join(L,"async-subagent-results"),f=G.join(L,"async-subagent-runs"),R=G.join(L,"chain-runs"),_=G.join(L,"artifacts");import*as q from"node:fs";import*as H from"node:os";import*as U from"node:path";var I=".dm",C="@duckmind/dm-coding-agent",b="DM_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT";function F(Q){return typeof Q==="string"&&Q.trim()?Q:void 0}function E(Q){if(!Q)return;try{let Y=JSON.parse(q.readFileSync(U.join(Q,"package.json"),"utf-8"));if(Y.name!==C)return;return F(Y.piConfig?.configDir)}catch{return}}function w(Q=process.argv[1],Y=process.env[b]){let $=E(Y);if($)return $;if(!Q)return;try{let X=U.dirname(q.realpathSync(Q));while(X!==U.dirname(X)){let B=E(X);if(B)return B;X=U.dirname(X)}}catch{}return}function S(Q,Y,$){return(Q&&typeof Q==="object"?F(Q.CONFIG_DIR_NAME):void 0)??w(Y,$)??I}function y(){return S()}function M(){let Q=process.env.DM_CODING_AGENT_DIR;if(Q==="~")return H.homedir();if(Q?.startsWith("~/"))return U.join(H.homedir(),Q.slice(2));return Q||U.join(H.homedir(),y(),"agent")}var O=".last-cleanup",x=".dm-subagents";function A(Q){return J.join(Q,x)}function D(Q){return J.join(A(Q),"artifacts")}function UQ(Q){return J.join(A(Q),"chain-runs")}function VQ(Q,Y){if(Y)return D(Y);if(Q){let $=J.dirname(Q);return J.join($,"subagent-artifacts")}return _}function GQ(Q,Y,$,X){let B=X!==void 0?`_${X}`:"",K=$.replace(/[^\w.-]/g,"_"),W=`${Y}_${K}${B}`;return{inputPath:J.join(Q,`${W}_input.md`),outputPath:J.join(Q,`${W}_output.md`),jsonlPath:J.join(Q,`${W}.jsonl`),transcriptPath:J.join(Q,`${W}_transcript.jsonl`),metadataPath:J.join(Q,`${W}_meta.json`)}}function KQ(Q){Z.mkdirSync(Q,{recursive:!0})}function jQ(Q,Y){Z.writeFileSync(Q,Y,"utf-8")}function HQ(Q,Y){Z.writeFileSync(Q,JSON.stringify(Y,null,2),"utf-8")}function zQ(Q,Y){Z.appendFileSync(Q,`${Y}
-`)}function T(Q,Y){if(!Z.existsSync(Q))return;let $=J.join(Q,O),X=Date.now();if(Z.existsSync($)){let W=Z.statSync($);if(X-W.mtimeMs<86400000)return}let B=Y*24*60*60*1000,K=X-B;for(let W of Z.readdirSync(Q)){if(W===O)continue;let j=J.join(Q,W);try{if(Z.statSync(j).mtimeMs<K)Z.unlinkSync(j)}catch{}}Z.writeFileSync($,String(X))}function LQ(Q){T(_,Q);let Y=J.join(M(),"sessions");if(!Z.existsSync(Y))return;let $;try{$=Z.readdirSync(Y)}catch{return}for(let X of $){let B=J.join(Y,X,"subagent-artifacts");try{T(B,Q)}catch{}}}export{HQ as writeMetadata,jQ as writeArtifact,A as getProjectSubagentsDir,UQ as getProjectChainRunsDir,D as getProjectArtifactsDir,VQ as getArtifactsDir,GQ as getArtifactPaths,KQ as ensureArtifactsDir,T as cleanupOldArtifacts,LQ as cleanupAllArtifactDirs,zQ as appendJsonl};
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { TEMP_ARTIFACTS_DIR } from "./types.js";
+import { getAgentDir } from "./utils.js";
+const CLEANUP_MARKER_FILE = ".last-cleanup";
+const PROJECT_ARTIFACT_ROOT = ".dm-subagents";
+export function getProjectSubagentsDir(cwd) {
+  return path.join(cwd, PROJECT_ARTIFACT_ROOT);
+}
+export function getProjectArtifactsDir(cwd) {
+  return path.join(getProjectSubagentsDir(cwd), "artifacts");
+}
+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");
+  }
+  return TEMP_ARTIFACTS_DIR;
+}
+export function getArtifactPaths(artifactsDir, runId, agent, index) {
+  const suffix = index !== undefined ? `_${index}` : "";
+  const safeAgent = agent.replace(/[^\w.-]/g, "_");
+  const base = `${runId}_${safeAgent}${suffix}`;
+  return {
+    inputPath: path.join(artifactsDir, `${base}_input.md`),
+    outputPath: path.join(artifactsDir, `${base}_output.md`),
+    jsonlPath: path.join(artifactsDir, `${base}.jsonl`),
+    transcriptPath: path.join(artifactsDir, `${base}_transcript.jsonl`),
+    metadataPath: path.join(artifactsDir, `${base}_meta.json`)
+  };
+}
+export function ensureArtifactsDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+export function writeArtifact(filePath, content) {
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+export function writeMetadata(filePath, metadata) {
+  fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+export function appendJsonl(filePath, line) {
+  fs.appendFileSync(filePath, `${line}
+`);
+}
+export function cleanupOldArtifacts(dir, maxAgeDays) {
+  if (!fs.existsSync(dir))
+    return;
+  const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
+  const now = Date.now();
+  if (fs.existsSync(markerPath)) {
+    const stat = fs.statSync(markerPath);
+    if (now - stat.mtimeMs < 24 * 60 * 60 * 1000)
+      return;
+  }
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+  const cutoff = now - maxAgeMs;
+  for (const file of fs.readdirSync(dir)) {
+    if (file === CLEANUP_MARKER_FILE)
+      continue;
+    const filePath = path.join(dir, file);
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < cutoff) {
+        fs.unlinkSync(filePath);
+      }
+    } catch {}
+  }
+  fs.writeFileSync(markerPath, String(now));
+}
+export function cleanupAllArtifactDirs(maxAgeDays) {
+  cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+  const sessionsBase = path.join(getAgentDir(), "sessions");
+  if (!fs.existsSync(sessionsBase))
+    return;
+  let dirs;
+  try {
+    dirs = fs.readdirSync(sessionsBase);
+  } catch {
+    return;
+  }
+  for (const dir of dirs) {
+    const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
+    try {
+      cleanupOldArtifacts(artifactsDir, maxAgeDays);
+    } catch {}
+  }
+}

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

@@ -1 +1,55 @@
-import*as J from"node:fs";import*as x from"node:path";var g=[10,25,50,100,200,500,1000,2000,4000],N=new Set(["EACCES","EBUSY","EPERM"]),k=typeof SharedArrayBuffer<"u"?new SharedArrayBuffer(4):void 0,v=k?new Int32Array(k):void 0;function O(j){if(j<=0)return;if(v)try{Atomics.wait(v,0,0,j);return}catch{}let q=Date.now()+j;while(Date.now()<q);}function V(j){let q=j?.code;return typeof q==="string"&&N.has(q)}function B(j,q,K,Q,X){for(let Z=0;;Z++)try{j.renameSync(q,K);return}catch(z){let G=Q[Z];if(G===void 0||!V(z))throw z;X(G)}}function L(j={}){let q=j.fs??J,K=j.now??Date.now,Q=j.pid??process.pid,X=j.random??Math.random,z=j.retryRenameErrors??process.platform==="win32"?j.retryDelaysMs??g:[],G=j.wait??O;return(H,C)=>{q.mkdirSync(x.dirname(H),{recursive:!0});let $=x.join(x.dirname(H),`.${x.basename(H)}.${Q}.${K()}.${X().toString(36).slice(2)}.tmp`);try{q.writeFileSync($,JSON.stringify(C,null,2),"utf-8"),B(q,$,H,z,G)}finally{q.rmSync($,{force:!0})}}}var U=L();export{U as writeAtomicJson,L as createAtomicJsonWriter};
+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);
+}
+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);
+    }
+  }
+}
+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 retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+  const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
+  const wait = options.wait ?? waitSync;
+  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`);
+    try {
+      fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
+      renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
+    } finally {
+      fsImpl.rmSync(tempPath, { force: true });
+    }
+  };
+}
+export const writeAtomicJson = createAtomicJsonWriter();