@duckmind/dm-windows-x64 0.60.4 → 0.60.8

package/extensions/dm-subagents/src/shared/post-exit-stdio-guard.js

@@ -1 +1,68 @@
-function c(e,n){try{return e.kill(n)}catch{return!1}}function m(e,n){let{idleMs:a,hardMs:f}=n,u=!1,o=!1,d=!1,t,r,l=()=>{if(!o)try{e.stdout?.destroy()}catch{}if(!d)try{e.stderr?.destroy()}catch{}},i=()=>{if(t)clearTimeout(t),t=void 0;if(r)clearTimeout(r),r=void 0},s=()=>{if(!u)return;if(t)clearTimeout(t);t=setTimeout(l,a),t.unref?.()};return e.stdout?.on("data",s),e.stderr?.on("data",s),e.stdout?.on("end",()=>{if(o=!0,o&&d)i()}),e.stderr?.on("end",()=>{if(d=!0,o&&d)i()}),e.on("exit",()=>{if(u=!0,s(),r)return;r=setTimeout(l,f),r.unref?.()}),e.on("close",i),e.on("error",i),i}export{c as trySignalChild,m as attachPostExitStdioGuard};
+export function trySignalChild(child, signal) {
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+export function attachPostExitStdioGuard(child, options) {
+  const { idleMs, hardMs } = options;
+  let exited = false;
+  let stdoutEnded = false;
+  let stderrEnded = false;
+  let idleTimer;
+  let hardTimer;
+  const destroyUnendedStdio = () => {
+    if (!stdoutEnded) {
+      try {
+        child.stdout?.destroy();
+      } catch {}
+    }
+    if (!stderrEnded) {
+      try {
+        child.stderr?.destroy();
+      } catch {}
+    }
+  };
+  const clearTimers = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = undefined;
+    }
+    if (hardTimer) {
+      clearTimeout(hardTimer);
+      hardTimer = undefined;
+    }
+  };
+  const armIdleTimer = () => {
+    if (!exited)
+      return;
+    if (idleTimer)
+      clearTimeout(idleTimer);
+    idleTimer = setTimeout(destroyUnendedStdio, idleMs);
+    idleTimer.unref?.();
+  };
+  child.stdout?.on("data", armIdleTimer);
+  child.stderr?.on("data", armIdleTimer);
+  child.stdout?.on("end", () => {
+    stdoutEnded = true;
+    if (stdoutEnded && stderrEnded)
+      clearTimers();
+  });
+  child.stderr?.on("end", () => {
+    stderrEnded = true;
+    if (stdoutEnded && stderrEnded)
+      clearTimers();
+  });
+  child.on("exit", () => {
+    exited = true;
+    armIdleTimer();
+    if (hardTimer)
+      return;
+    hardTimer = setTimeout(destroyUnendedStdio, hardMs);
+    hardTimer.unref?.();
+  });
+  child.on("close", clearTimers);
+  child.on("error", clearTimers);
+  return clearTimers;
+}

package/extensions/dm-subagents/src/shared/session-identity.js

@@ -1 +1,6 @@
-function i(e){let n=e.getSessionFile()??e.getSessionId();if(!n)throw Error("Current session identity is unavailable.");return n}export{i as resolveCurrentSessionId};
+export function resolveCurrentSessionId(sessionManager) {
+  const sessionId = sessionManager.getSessionFile() ?? sessionManager.getSessionId();
+  if (!sessionId)
+    throw new Error("Current session identity is unavailable.");
+  return sessionId;
+}

package/extensions/dm-subagents/src/shared/session-tokens.js

@@ -1,2 +1,39 @@
-import*as k from"node:fs";import*as C from"node:path";function E(w){try{let m=k.readdirSync(w).filter((j)=>j.endsWith(".jsonl")).map((j)=>C.join(w,j));if(m.length===0)return null;return m.sort((j,q)=>k.statSync(q).mtimeMs-k.statSync(j).mtimeMs),m[0]??null}catch{return null}}function G(w){let m=E(w);if(!m)return null;try{let j=k.readFileSync(m,"utf-8"),q=0,z=0;for(let A of j.split(`
-`)){if(!A.trim())continue;try{let B=JSON.parse(A),v=B.usage??B.message?.usage;if(v)q+=v.inputTokens??v.input??0,z+=v.outputTokens??v.output??0}catch{}}return{input:q,output:z,total:q+z}}catch{return null}}export{G as parseSessionTokens};
+import * as fs from "node:fs";
+import * as path from "node:path";
+function findLatestSessionFile(sessionDir) {
+  try {
+    const files = fs.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => path.join(sessionDir, f));
+    if (files.length === 0)
+      return null;
+    files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return files[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+export function parseSessionTokens(sessionDir) {
+  const sessionFile = findLatestSessionFile(sessionDir);
+  if (!sessionFile)
+    return null;
+  try {
+    const content = fs.readFileSync(sessionFile, "utf-8");
+    let input = 0;
+    let output = 0;
+    for (const line of content.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const entry = JSON.parse(line);
+        const usage = entry.usage ?? entry.message?.usage;
+        if (usage) {
+          input += usage.inputTokens ?? usage.input ?? 0;
+          output += usage.outputTokens ?? usage.output ?? 0;
+        }
+      } catch {}
+    }
+    return { input, output, total: input + output };
+  } catch {
+    return null;
+  }
+}

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

@@ -1,8 +1,9 @@
-import*as U from"node:fs";import*as B from"node:path";function S(Q,Z=(Y,J)=>`=== Parallel Task ${Y+1} (${J}) ===`){return Q.map((Y,J)=>{let $=Z(Y.taskIndex??J,Y.agent),q=Boolean(Y.output?.trim()),W=Y.timedOut?`TIMED OUT${Y.error?`: ${Y.error}`:""}`:Y.exitCode===-1?"SKIPPED":Y.exitCode!==0&&Y.exitCode!==null?`FAILED (exit code ${Y.exitCode})${Y.error?`: ${Y.error}`:""}`:Y.error?`WARNING: ${Y.error}`:!q&&Y.outputTargetPath&&Y.outputTargetExists===!1?`EMPTY OUTPUT (expected output file missing: ${Y.outputTargetPath})`:!q&&!Y.outputTargetPath?"EMPTY OUTPUT (no textual response returned)":"",X=W?q?`${W}
-${Y.output}`:W:Y.output;return`${$}
-${X}`}).join(`
-
-`)}function T(Q){if(Q===!1)return!1;if(Q===!0||Q===void 0)return;if(Array.isArray(Q))return[...new Set(Q.map((Y)=>Y.trim()).filter((Y)=>Y.length>0))];let Z=Q.trim();if(Z.startsWith("["))try{let Y=JSON.parse(Z);if(Array.isArray(Y))return T(Y)}catch{}return[...new Set(Q.split(",").map((Y)=>Y.trim()).filter((Y)=>Y.length>0))]}import*as j from"node:os";import*as _ from"node:path";function z(Q){return Q.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function D(Q){let Z=Q?.env??process.env,Y=Q&&Object.hasOwn(Q,"getuid")?Q.getuid:process.getuid?.bind(process);if(typeof Y==="function")return`uid-${Y()}`;for(let W of["USERNAME","USER","LOGNAME"]){let X=Z[W];if(X)return`user-${z(X)}`}let J=Q&&Object.hasOwn(Q,"userInfo")?Q.userInfo:j.userInfo;try{let W=J?.().username;if(W)return`user-${z(W)}`}catch{}let $=Z.USERPROFILE??Z.HOME;if($)return`home-${z($)}`;let q=Q&&Object.hasOwn(Q,"homedir")?Q.homedir:j.homedir;try{let W=q?.();if(W)return`home-${z(W)}`}catch{}return"shared"}var L=_.join(j.tmpdir(),`dm-subagents-${D()}`),t=_.join(L,"async-subagent-results"),e=_.join(L,"async-subagent-runs"),H=_.join(L,"chain-runs"),QQ=_.join(L,"artifacts");var x=86400000,y=`# Progress
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { normalizeSkillInput } from "../agents/skills.js";
+import { CHAIN_RUNS_DIR } from "./types.js";
+const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const INITIAL_PROGRESS_CONTENT = `# Progress
 
 ## Status
 In Progress
@@ -12,12 +13,198 @@ In Progress
 ## Files Changed
 
 ## Notes
-`;function A(Q){return Q==="false"?!1:Q}function F(Q){return"parallel"in Q&&Array.isArray(Q.parallel)}function M(Q){return"expand"in Q&&"collect"in Q&&"parallel"in Q&&!Array.isArray(Q.parallel)}function JQ(Q){if(F(Q))return Q.parallel.map((Z)=>Z.agent);if(M(Q))return[Q.parallel.agent];return[Q.agent]}function WQ(Q,Z){let Y=B.join(Z?B.resolve(Z):H,Q);return U.mkdirSync(Y,{recursive:!0}),Y}function XQ(Q){try{U.rmSync(Q,{recursive:!0})}catch{}}function qQ(){if(!U.existsSync(H))return;let Q=Date.now(),Z;try{Z=U.readdirSync(H)}catch{return}for(let Y of Z)try{let J=B.join(H,Y),$=U.statSync(J);if($.isDirectory()&&Q-$.mtimeMs>x)U.rmSync(J,{recursive:!0})}catch{}}function BQ(Q){return Q.map((Z,Y)=>{if(F(Z))return Z.parallel.map(($)=>{if($.task)return $.task;return"{previous}"});if(M(Z))return Z.parallel.task??"{previous}";let J=Z;if(J.task)return J.task;return Y===0?"{task}":"{previous}"})}function UQ(Q,Z,Y){let J=A(Z.output),$=J!==void 0?J:A(Q.output)??!1,q=Z.reads!==void 0?Z.reads:Q.defaultReads??!1,W=Z.progress!==void 0?Z.progress:Q.defaultProgress??!1,X;if(Z.skills===!1)X=!1;else if(Z.skills!==void 0){if(X=[...Z.skills],Y&&Y.length>0)X=[...new Set([...X,...Y])]}else if(X=Q.skills?[...Q.skills]:[],Y&&Y.length>0)X=[...new Set([...X,...Y])];let V=Z.outputMode??"inline",G=Z.model??Q.model;return{output:$,outputMode:V,reads:q,progress:W,skills:X,model:G}}function v(Q,Z){if(!Q)return Z;return Z?Q.replaceAll("{task}",Z):Q}function P(Q){if(!Q)return!1;return/\breview[- ]only\b/i.test(Q)||/\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(Q)||/\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(Q)||/\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(Q)||/\bleave\s+files?\s+unchanged\b/i.test(Q)}function VQ(Q,Z,Y){let J=v(Z,Y);return Q.progress&&P(J)?{...Q,progress:!1}:Q}function R(Q,Z){return B.isAbsolute(Q)?Q:B.join(Z,Q)}function GQ(Q){U.mkdirSync(Q,{recursive:!0}),U.writeFileSync(B.join(Q,"progress.md"),y)}function KQ(Q,Z,Y,J){let $=[],q=[];if(Q.reads&&Q.reads.length>0){let V=Q.reads.map((G)=>R(G,Z));$.push(`[Read from: ${V.join(", ")}]`)}if(Q.output){let V=R(Q.output,Z);$.push(`[Write to: ${V}]`)}if(Q.progress){let V=B.join(Z,"progress.md");if(Y)q.push(`Create and maintain progress at: ${V}`);else q.push(`Update progress at: ${V}`)}if(J&&J.trim())q.push(`Previous step output:
-${J.trim()}`);let W=$.length>0?$.join(`
-`)+`
+`;
+function normalizeOutputOverride(output) {
+  return output === "false" ? false : output;
+}
+export function isParallelStep(step) {
+  return "parallel" in step && Array.isArray(step.parallel);
+}
+export function isDynamicParallelStep(step) {
+  return "expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel);
+}
+export function getStepAgents(step) {
+  if (isParallelStep(step)) {
+    return step.parallel.map((t) => t.agent);
+  }
+  if (isDynamicParallelStep(step)) {
+    return [step.parallel.agent];
+  }
+  return [step.agent];
+}
+export function createChainDir(runId, baseDir) {
+  const chainDir = path.join(baseDir ? path.resolve(baseDir) : CHAIN_RUNS_DIR, runId);
+  fs.mkdirSync(chainDir, { recursive: true });
+  return chainDir;
+}
+export function removeChainDir(chainDir) {
+  try {
+    fs.rmSync(chainDir, { recursive: true });
+  } catch {}
+}
+export function cleanupOldChainDirs() {
+  if (!fs.existsSync(CHAIN_RUNS_DIR))
+    return;
+  const now = Date.now();
+  let dirs;
+  try {
+    dirs = fs.readdirSync(CHAIN_RUNS_DIR);
+  } catch {
+    return;
+  }
+  for (const dir of dirs) {
+    try {
+      const dirPath = path.join(CHAIN_RUNS_DIR, dir);
+      const stat = fs.statSync(dirPath);
+      if (stat.isDirectory() && now - stat.mtimeMs > CHAIN_DIR_MAX_AGE_MS) {
+        fs.rmSync(dirPath, { recursive: true });
+      }
+    } catch {}
+  }
+}
+export function resolveChainTemplates(steps) {
+  return steps.map((step, i) => {
+    if (isParallelStep(step)) {
+      return step.parallel.map((task) => {
+        if (task.task)
+          return task.task;
+        return "{previous}";
+      });
+    }
+    if (isDynamicParallelStep(step)) {
+      return step.parallel.task ?? "{previous}";
+    }
+    const seq = step;
+    if (seq.task)
+      return seq.task;
+    return i === 0 ? "{task}" : "{previous}";
+  });
+}
+export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
+  const stepOutput = normalizeOutputOverride(stepOverrides.output);
+  const output = stepOutput !== undefined ? stepOutput : normalizeOutputOverride(agentConfig.output) ?? false;
+  const reads = stepOverrides.reads !== undefined ? stepOverrides.reads : agentConfig.defaultReads ?? false;
+  const progress = stepOverrides.progress !== undefined ? stepOverrides.progress : agentConfig.defaultProgress ?? false;
+  let skills;
+  if (stepOverrides.skills === false) {
+    skills = false;
+  } else if (stepOverrides.skills !== undefined) {
+    skills = [...stepOverrides.skills];
+    if (chainSkills && chainSkills.length > 0) {
+      skills = [...new Set([...skills, ...chainSkills])];
+    }
+  } else {
+    skills = agentConfig.skills ? [...agentConfig.skills] : [];
+    if (chainSkills && chainSkills.length > 0) {
+      skills = [...new Set([...skills, ...chainSkills])];
+    }
+  }
+  const outputMode = stepOverrides.outputMode ?? "inline";
+  const model = stepOverrides.model ?? agentConfig.model;
+  return { output, outputMode, reads, progress, skills, model };
+}
+export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
+  if (!task)
+    return originalTask;
+  return originalTask ? task.replaceAll("{task}", originalTask) : task;
+}
+export function taskDisallowsFileUpdates(task) {
+  if (!task)
+    return false;
+  return /\breview[- ]only\b/i.test(task) || /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task) || /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task) || /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task) || /\bleave\s+files?\s+unchanged\b/i.test(task);
+}
+export function suppressProgressForReadOnlyTask(behavior, task, originalTask) {
+  const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
+  return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
+}
+function resolveChainPath(filePath, chainDir) {
+  return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
+}
+export function writeInitialProgressFile(progressDir) {
+  fs.mkdirSync(progressDir, { recursive: true });
+  fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT);
+}
+export function buildChainInstructions(behavior, chainDir, isFirstProgressAgent, previousSummary) {
+  const prefixParts = [];
+  const suffixParts = [];
+  if (behavior.reads && behavior.reads.length > 0) {
+    const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
+    prefixParts.push(`[Read from: ${files.join(", ")}]`);
+  }
+  if (behavior.output) {
+    const outputPath = resolveChainPath(behavior.output, chainDir);
+    prefixParts.push(`[Write to: ${outputPath}]`);
+  }
+  if (behavior.progress) {
+    const progressPath = path.join(chainDir, "progress.md");
+    if (isFirstProgressAgent) {
+      suffixParts.push(`Create and maintain progress at: ${progressPath}`);
+    } else {
+      suffixParts.push(`Update progress at: ${progressPath}`);
+    }
+  }
+  if (previousSummary && previousSummary.trim()) {
+    suffixParts.push(`Previous step output:
+${previousSummary.trim()}`);
+  }
+  const prefix = prefixParts.length > 0 ? prefixParts.join(`
+`) + `
 
-`:"",X=q.length>0?`
+` : "";
+  const suffix = suffixParts.length > 0 ? `
 
 ---
-`+q.join(`
-`):"";return{prefix:W,suffix:X}}function jQ(Q,Z,Y,J){return Q.map(($,q)=>{let W=Z.find((w)=>w.name===$.agent);if(!W)throw Error(`Unknown agent: ${$.agent}`);let X=B.join(`parallel-${Y}`,`${q}-${$.agent}`),V=!1,G=A($.output),O=A(W.output);if(G!==void 0)if(G===!1)V=!1;else if(B.isAbsolute(G))V=G;else V=B.join(X,G);else if(O)V=B.join(X,O);let N=$.reads!==void 0?$.reads:W.defaultReads??!1,I=$.progress!==void 0?$.progress:W.defaultProgress??!1,E=T($.skill),K;if(E===!1)K=!1;else if(E!==void 0){if(K=[...E],J&&J.length>0)K=[...new Set([...K,...J])]}else if(K=W.skills?[...W.skills]:[],J&&J.length>0)K=[...new Set([...K,...J])];let C=$.outputMode??"inline",b=$.model??W.model;return{output:V,outputMode:C,reads:N,progress:I,skills:K,model:b}})}function _Q(Q,Z,Y,J){for(let $=0;$<Y;$++){let q=B.join(Q,`parallel-${Z}`,`${$}-${J[$]}`);U.mkdirSync(q,{recursive:!0})}}export{GQ as writeInitialProgressFile,P as taskDisallowsFileUpdates,VQ as suppressProgressForReadOnlyTask,v as resolveTaskTextForFileUpdatePolicy,UQ as resolveStepBehavior,jQ as resolveParallelBehaviors,BQ as resolveChainTemplates,XQ as removeChainDir,F as isParallelStep,M as isDynamicParallelStep,JQ as getStepAgents,_Q as createParallelDirs,WQ as createChainDir,qQ as cleanupOldChainDirs,KQ as buildChainInstructions,S as aggregateParallelOutputs};
+` + suffixParts.join(`
+`) : "";
+  return { prefix, suffix };
+}
+export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSkills) {
+  return tasks.map((task, taskIndex) => {
+    const config = agentConfigs.find((a) => a.name === task.agent);
+    if (!config) {
+      throw new Error(`Unknown agent: ${task.agent}`);
+    }
+    const subdir = path.join(`parallel-${stepIndex}`, `${taskIndex}-${task.agent}`);
+    let output = false;
+    const taskOutput = normalizeOutputOverride(task.output);
+    const configOutput = normalizeOutputOverride(config.output);
+    if (taskOutput !== undefined) {
+      if (taskOutput === false) {
+        output = false;
+      } else if (path.isAbsolute(taskOutput)) {
+        output = taskOutput;
+      } else {
+        output = path.join(subdir, taskOutput);
+      }
+    } else if (configOutput) {
+      output = path.join(subdir, configOutput);
+    }
+    const reads = task.reads !== undefined ? task.reads : config.defaultReads ?? false;
+    const progress = task.progress !== undefined ? task.progress : config.defaultProgress ?? false;
+    const taskSkillInput = normalizeSkillInput(task.skill);
+    let skills;
+    if (taskSkillInput === false) {
+      skills = false;
+    } else if (taskSkillInput !== undefined) {
+      skills = [...taskSkillInput];
+      if (chainSkills && chainSkills.length > 0) {
+        skills = [...new Set([...skills, ...chainSkills])];
+      }
+    } else {
+      skills = config.skills ? [...config.skills] : [];
+      if (chainSkills && chainSkills.length > 0) {
+        skills = [...new Set([...skills, ...chainSkills])];
+      }
+    }
+    const outputMode = task.outputMode ?? "inline";
+    const model = task.model ?? config.model;
+    return { output, outputMode, reads, progress, skills, model };
+  });
+}
+export function createParallelDirs(chainDir, stepIndex, taskCount, agentNames) {
+  for (let i = 0;i < taskCount; i++) {
+    const subdir = path.join(chainDir, `parallel-${stepIndex}`, `${i}-${agentNames[i]}`);
+    fs.mkdirSync(subdir, { recursive: true });
+  }
+}
+export { aggregateParallelOutputs } from "../runs/shared/parallel-utils.js";

package/extensions/dm-subagents/src/shared/status-format.js

@@ -1 +1,53 @@
-function g(n){if(n<1000)return"now";if(n<60000)return`${Math.floor(n/1000)}s`;return`${Math.floor(n/60000)}m`}function c(n,t,u=Date.now()){if(n===void 0){if(t==="needs_attention")return"needs attention";if(t==="active_long_running")return"active but long-running";return}let e=g(Math.max(0,u-n));if(t==="needs_attention")return`no activity for ${e}`;if(t==="active_long_running")return`active but long-running · last activity ${e} ago`;return e==="now"?"active now":`active ${e} ago`}function s(n){return n==="complete"||n==="completed"}function d(n){if(n.some((t)=>t.status==="running"))return"running";if(n.some((t)=>t.status==="failed"))return"failed";if(n.some((t)=>t.status==="paused"))return"paused";if(n.length>0&&n.every((t)=>s(t.status)))return"complete";return"pending"}function l(n){return n===1?"1 agent running":`${n} agents running`}function p(n,t,u={}){let e=n.filter((r)=>r.status==="running").length,f=n.filter((r)=>s(r.status)).length,o=n.filter((r)=>r.status==="failed").length,a=n.filter((r)=>r.status==="paused").length,i=[`${f}/${t} done`];if(u.showRunning!==!1&&e>0)i.unshift(l(e));if(o>0)i.push(`${o} failed`);if(a>0)i.push(`${a} paused`);return i.join(" · ")}export{p as formatParallelOutcome,l as formatAgentRunningLabel,c as formatActivityLabel,d as aggregateStepStatus};
+function formatActivityAge(ms) {
+  if (ms < 1000)
+    return "now";
+  if (ms < 60000)
+    return `${Math.floor(ms / 1000)}s`;
+  return `${Math.floor(ms / 60000)}m`;
+}
+export function formatActivityLabel(lastActivityAt, activityState, now = Date.now()) {
+  if (lastActivityAt === undefined) {
+    if (activityState === "needs_attention")
+      return "needs attention";
+    if (activityState === "active_long_running")
+      return "active but long-running";
+    return;
+  }
+  const age = formatActivityAge(Math.max(0, now - lastActivityAt));
+  if (activityState === "needs_attention")
+    return `no activity for ${age}`;
+  if (activityState === "active_long_running")
+    return `active but long-running · last activity ${age} ago`;
+  return age === "now" ? "active now" : `active ${age} ago`;
+}
+function isCompletedStepStatus(status) {
+  return status === "complete" || status === "completed";
+}
+export function aggregateStepStatus(steps) {
+  if (steps.some((step) => step.status === "running"))
+    return "running";
+  if (steps.some((step) => step.status === "failed"))
+    return "failed";
+  if (steps.some((step) => step.status === "paused"))
+    return "paused";
+  if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status)))
+    return "complete";
+  return "pending";
+}
+export function formatAgentRunningLabel(count) {
+  return count === 1 ? "1 agent running" : `${count} agents running`;
+}
+export function formatParallelOutcome(steps, total, options = {}) {
+  const running = steps.filter((step) => step.status === "running").length;
+  const done = steps.filter((step) => isCompletedStepStatus(step.status)).length;
+  const failed = steps.filter((step) => step.status === "failed").length;
+  const paused = steps.filter((step) => step.status === "paused").length;
+  const parts = [`${done}/${total} done`];
+  if (options.showRunning !== false && running > 0)
+    parts.unshift(formatAgentRunningLabel(running));
+  if (failed > 0)
+    parts.push(`${failed} failed`);
+  if (paused > 0)
+    parts.push(`${paused} paused`);
+  return parts.join(" · ");
+}

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

@@ -1,8 +1,186 @@
-import*as Z from"node:os";import*as Q from"node:path";var k=1,M="pi-intercom:detach-request",P="pi-intercom:detach-response",y="subagent:async-started",D="subagent:async-complete",S="subagent:control-event",b="subagent:control-intercom",x="subagent:result-intercom",d="subagent:result-intercom-delivery",m={bytes:204800,lines:5000},h={enabled:!0,includeInput:!0,includeOutput:!0,includeJsonl:!1,includeTranscript:!0,includeMetadata:!0,cleanupDays:7};function O(j){return j.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function E(j){let q=j?.env??process.env,J=j&&Object.hasOwn(j,"getuid")?j.getuid:process.getuid?.bind(process);if(typeof J==="function")return`uid-${J()}`;for(let C of["USERNAME","USER","LOGNAME"]){let R=q[C];if(R)return`user-${O(R)}`}let K=j&&Object.hasOwn(j,"userInfo")?j.userInfo:Z.userInfo;try{let C=K?.().username;if(C)return`user-${O(C)}`}catch{}let Y=q.USERPROFILE??q.HOME;if(Y)return`home-${O(Y)}`;let F=j&&Object.hasOwn(j,"homedir")?j.homedir:Z.homedir;try{let C=F?.();if(C)return`home-${O(C)}`}catch{}return"shared"}var _=8,A=4,B=Q.join(Z.tmpdir(),`dm-subagents-${E()}`),v=Q.join(B,"async-subagent-results"),g=Q.join(B,"async-subagent-runs"),c=Q.join(B,"chain-runs"),f=Q.join(B,"artifacts"),r="subagent-async",u="subagent-slash-result",l="subagent-slash-text-result",p="subagent:slash:request",s="subagent:slash:started",n="subagent:slash:response",i="subagent:slash:update",o="subagent:slash:cancel",a=250,t=4,H=2,T=40,e=["list","get","models","create","update","delete","eject","disable","enable","reset","status","interrupt","resume","steer","append-step","doctor","schedule","schedule-list","schedule-status","schedule-cancel"],w="You are a delegated subagent running from a fork of the parent session. Treat the inherited conversation as reference-only context, not a live thread to continue. Do not continue or answer prior messages as if they are waiting for a reply. Your sole job is to execute the task below and return a focused result for that task using your tools.";function I(j){let q=typeof j==="number"?j:typeof j==="string"?Number(j):NaN;if(!Number.isInteger(q)||q<1)return;return q}function jj(j){return I(j)??_}function qj(j,q){return I(j)??I(q)??A}function Cj(j){return Q.join(B,`async-cfg-${j}.json`)}function Jj(j,q){if(q===!1)return j;let K=`${q??w}
+import * as os from "node:os";
+import * as path from "node:path";
+export const SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 1;
+export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
+export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
+export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
+export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
+export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
+export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
+export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
+export const DEFAULT_MAX_OUTPUT = {
+  bytes: 200 * 1024,
+  lines: 5000
+};
+export const DEFAULT_ARTIFACT_CONFIG = {
+  enabled: true,
+  includeInput: true,
+  includeOutput: true,
+  includeJsonl: false,
+  includeTranscript: true,
+  includeMetadata: true,
+  cleanupDays: 7
+};
+function sanitizeTempScopeSegment(value) {
+  const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "unknown";
+}
+export function resolveTempScopeId(options) {
+  const env = options?.env ?? process.env;
+  const getuid = options && Object.hasOwn(options, "getuid") ? options.getuid : process.getuid?.bind(process);
+  if (typeof getuid === "function") {
+    return `uid-${getuid()}`;
+  }
+  for (const key of ["USERNAME", "USER", "LOGNAME"]) {
+    const value = env[key];
+    if (value)
+      return `user-${sanitizeTempScopeSegment(value)}`;
+  }
+  const userInfo = options && Object.hasOwn(options, "userInfo") ? options.userInfo : os.userInfo;
+  try {
+    const username = userInfo?.().username;
+    if (username)
+      return `user-${sanitizeTempScopeSegment(username)}`;
+  } catch {}
+  const homedir = env.USERPROFILE ?? env.HOME;
+  if (homedir)
+    return `home-${sanitizeTempScopeSegment(homedir)}`;
+  const resolveHomedir = options && Object.hasOwn(options, "homedir") ? options.homedir : os.homedir;
+  try {
+    const fallbackHomedir = resolveHomedir?.();
+    if (fallbackHomedir)
+      return `home-${sanitizeTempScopeSegment(fallbackHomedir)}`;
+  } catch {}
+  return "shared";
+}
+const MAX_PARALLEL = 8;
+export const MAX_CONCURRENCY = 4;
+export const TEMP_ROOT_DIR = path.join(os.tmpdir(), `dm-subagents-${resolveTempScopeId()}`);
+export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
+export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
+export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
+export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
+export const WIDGET_KEY = "subagent-async";
+export const SLASH_RESULT_TYPE = "subagent-slash-result";
+export const SLASH_TEXT_RESULT_TYPE = "subagent-slash-text-result";
+export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
+export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
+export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
+export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
+export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
+export const POLL_INTERVAL_MS = 250;
+export const MAX_WIDGET_JOBS = 4;
+export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
+export const DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION = 40;
+export const SUBAGENT_ACTIONS = ["list", "get", "models", "create", "update", "delete", "eject", "disable", "enable", "reset", "status", "interrupt", "resume", "steer", "append-step", "doctor", "schedule", "schedule-list", "schedule-status", "schedule-cancel"];
+export const DEFAULT_FORK_PREAMBLE = "You are a delegated subagent running from a fork of the parent session. " + "Treat the inherited conversation as reference-only context, not a live thread to continue. " + "Do not continue or answer prior messages as if they are waiting for a reply. " + "Your sole job is to execute the task below and return a focused result for that task using your tools.";
+function normalizeTopLevelParallelValue(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isInteger(parsed) || parsed < 1)
+    return;
+  return parsed;
+}
+export function resolveTopLevelParallelMaxTasks(value) {
+  return normalizeTopLevelParallelValue(value) ?? MAX_PARALLEL;
+}
+export function resolveTopLevelParallelConcurrency(override, configValue) {
+  return normalizeTopLevelParallelValue(override) ?? normalizeTopLevelParallelValue(configValue) ?? MAX_CONCURRENCY;
+}
+export function getAsyncConfigPath(suffix) {
+  return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
+}
+export function wrapForkTask(task, preamble) {
+  if (preamble === false)
+    return task;
+  const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;
+  const wrappedPrefix = `${effectivePreamble}
 
 Task:
-`;if(j.startsWith(K))return j;return`${K}${j}`}function L(j){let q=typeof j==="number"?j:typeof j==="string"?Number(j):NaN;if(!Number.isInteger(q)||q<0)return;return q}function $(j){return L(j)}function N(j){return $(process.env.DM_SUBAGENT_MAX_DEPTH)??$(j)??H}function Kj(j,q){let J=$(j)??H,K=$(q);return K===void 0?J:Math.min(J,K)}function Qj(j){let q=Number(process.env.DM_SUBAGENT_DEPTH??"0"),J=N(j);return{blocked:Number.isFinite(q)&&q>=J,depth:q,maxDepth:J}}function Yj(j){let q=Number(process.env.DM_SUBAGENT_DEPTH??"0"),J=Number.isFinite(q)?q+1:1;return{DM_SUBAGENT_DEPTH:String(J),DM_SUBAGENT_MAX_DEPTH:String($(j)??N())}}function U(j){return L(j)}function Zj(j){return U(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_SESSION)??U(j)??T}function V(j){if(j<1024)return`${j}B`;if(j<1048576)return`${(j/1024).toFixed(1)}KB`;return`${(j/1048576).toFixed(1)}MB`}function $j(j,q,J){let K=j.split(`
-`),Y=Buffer.byteLength(j,"utf-8");if(Y<=q.bytes&&K.length<=q.lines)return{text:j,truncated:!1};let F=K;if(K.length>q.lines)F=K.slice(0,q.lines);let C=F.join(`
-`);if(Buffer.byteLength(C,"utf-8")>q.bytes){let G=0,W=C.length;while(G<W){let X=Math.floor((G+W+1)/2);if(Buffer.byteLength(C.slice(0,X),"utf-8")<=q.bytes)G=X;else W=X-1}C=C.slice(0,G)}return{text:`[TRUNCATED: showing first ${C.split(`
-`).length} of ${K.length} lines, ${V(Buffer.byteLength(C))} of ${V(Y)}${J?` - full output at ${J}`:""}]
-`+C,truncated:!0,originalBytes:Y,originalLines:K.length,artifactPath:J}}export{Jj as wrapForkTask,$j as truncateOutput,jj as resolveTopLevelParallelMaxTasks,qj as resolveTopLevelParallelConcurrency,E as resolveTempScopeId,Zj as resolveMaxSubagentSpawnsPerSession,N as resolveCurrentMaxSubagentDepth,Kj as resolveChildMaxSubagentDepth,U as normalizeMaxSubagentSpawnsPerSession,$ as normalizeMaxSubagentDepth,Yj as getSubagentDepthEnv,Cj as getAsyncConfigPath,Qj as checkSubagentDepth,r as WIDGET_KEY,B as TEMP_ROOT_DIR,f as TEMP_ARTIFACTS_DIR,x as SUBAGENT_RESULT_INTERCOM_EVENT,d as SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,k as SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,b as SUBAGENT_CONTROL_INTERCOM_EVENT,S as SUBAGENT_CONTROL_EVENT,y as SUBAGENT_ASYNC_STARTED_EVENT,D as SUBAGENT_ASYNC_COMPLETE_EVENT,e as SUBAGENT_ACTIONS,l as SLASH_TEXT_RESULT_TYPE,i as SLASH_SUBAGENT_UPDATE_EVENT,s as SLASH_SUBAGENT_STARTED_EVENT,n as SLASH_SUBAGENT_RESPONSE_EVENT,p as SLASH_SUBAGENT_REQUEST_EVENT,o as SLASH_SUBAGENT_CANCEL_EVENT,u as SLASH_RESULT_TYPE,v as RESULTS_DIR,a as POLL_INTERVAL_MS,t as MAX_WIDGET_JOBS,A as MAX_CONCURRENCY,P as INTERCOM_DETACH_RESPONSE_EVENT,M as INTERCOM_DETACH_REQUEST_EVENT,H as DEFAULT_SUBAGENT_MAX_DEPTH,T as DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION,m as DEFAULT_MAX_OUTPUT,w as DEFAULT_FORK_PREAMBLE,h as DEFAULT_ARTIFACT_CONFIG,c as CHAIN_RUNS_DIR,g as ASYNC_DIR};
+`;
+  if (task.startsWith(wrappedPrefix))
+    return task;
+  return `${wrappedPrefix}${task}`;
+}
+function normalizeNonNegativeInteger(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isInteger(parsed) || parsed < 0)
+    return;
+  return parsed;
+}
+export function normalizeMaxSubagentDepth(value) {
+  return normalizeNonNegativeInteger(value);
+}
+export function resolveCurrentMaxSubagentDepth(configMaxDepth) {
+  return normalizeMaxSubagentDepth(process.env.DM_SUBAGENT_MAX_DEPTH) ?? normalizeMaxSubagentDepth(configMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+}
+export function resolveChildMaxSubagentDepth(parentMaxDepth, agentMaxDepth) {
+  const normalizedParent = normalizeMaxSubagentDepth(parentMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+  const normalizedAgent = normalizeMaxSubagentDepth(agentMaxDepth);
+  return normalizedAgent === undefined ? normalizedParent : Math.min(normalizedParent, normalizedAgent);
+}
+export function checkSubagentDepth(configMaxDepth) {
+  const depth = Number(process.env.DM_SUBAGENT_DEPTH ?? "0");
+  const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
+  const blocked = Number.isFinite(depth) && depth >= maxDepth;
+  return { blocked, depth, maxDepth };
+}
+export function getSubagentDepthEnv(maxDepth) {
+  const parentDepth = Number(process.env.DM_SUBAGENT_DEPTH ?? "0");
+  const nextDepth = Number.isFinite(parentDepth) ? parentDepth + 1 : 1;
+  return {
+    DM_SUBAGENT_DEPTH: String(nextDepth),
+    DM_SUBAGENT_MAX_DEPTH: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth())
+  };
+}
+export function normalizeMaxSubagentSpawnsPerSession(value) {
+  return normalizeNonNegativeInteger(value);
+}
+export function resolveMaxSubagentSpawnsPerSession(configMaxSpawns) {
+  return normalizeMaxSubagentSpawnsPerSession(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_SESSION) ?? normalizeMaxSubagentSpawnsPerSession(configMaxSpawns) ?? DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+export function truncateOutput(output, config, artifactPath) {
+  const lines = output.split(`
+`);
+  const bytes = Buffer.byteLength(output, "utf-8");
+  if (bytes <= config.bytes && lines.length <= config.lines) {
+    return { text: output, truncated: false };
+  }
+  let truncatedLines = lines;
+  if (lines.length > config.lines) {
+    truncatedLines = lines.slice(0, config.lines);
+  }
+  let result = truncatedLines.join(`
+`);
+  if (Buffer.byteLength(result, "utf-8") > config.bytes) {
+    let low = 0;
+    let high = result.length;
+    while (low < high) {
+      const mid = Math.floor((low + high + 1) / 2);
+      if (Buffer.byteLength(result.slice(0, mid), "utf-8") <= config.bytes) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    result = result.slice(0, low);
+  }
+  const keptLines = result.split(`
+`).length;
+  const marker = `[TRUNCATED: showing first ${keptLines} of ${lines.length} lines, ${formatBytes(Buffer.byteLength(result))} of ${formatBytes(bytes)}${artifactPath ? ` - full output at ${artifactPath}` : ""}]
+`;
+  return {
+    text: marker + result,
+    truncated: true,
+    originalBytes: bytes,
+    originalLines: lines.length,
+    artifactPath
+  };
+}