@duckmind/dm-windows-x64 0.60.6 → 0.60.8

package/extensions/dm-subagents/src/runs/background/chain-append.js

@@ -1,2 +1,245 @@
-import{randomUUID as l}from"node:crypto";import*as K from"node:fs";import*as H from"node:path";import*as f from"node:fs";import*as G from"node:path";var k=[10,25,50,100,200,500,1000,2000,4000],m=new Set(["EACCES","EBUSY","EPERM"]),b=typeof SharedArrayBuffer<"u"?new SharedArrayBuffer(4):void 0,I=b?new Int32Array(b):void 0;function h(Z){if(Z<=0)return;if(I)try{Atomics.wait(I,0,0,Z);return}catch{}let $=Date.now()+Z;while(Date.now()<$);}function g(Z){let $=Z?.code;return typeof $==="string"&&m.has($)}function c(Z,$,Q,X,J){for(let W=0;;W++)try{Z.renameSync($,Q);return}catch(Y){let B=X[W];if(B===void 0||!g(Y))throw Y;J(B)}}function u(Z={}){let $=Z.fs??f,Q=Z.now??Date.now,X=Z.pid??process.pid,J=Z.random??Math.random,Y=Z.retryRenameErrors??process.platform==="win32"?Z.retryDelaysMs??k:[],B=Z.wait??h;return(M,P)=>{$.mkdirSync(G.dirname(M),{recursive:!0});let N=G.join(G.dirname(M),`.${G.basename(M)}.${X}.${Q()}.${J().toString(36).slice(2)}.tmp`);try{$.writeFileSync(N,JSON.stringify(P,null,2),"utf-8"),c($,N,M,Y,B)}finally{$.rmSync(N,{force:!0})}}}var T=u();import*as V from"node:fs";import*as q from"node:os";import*as j from"node:path";function E(Z){return Z.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function d(Z){let $=Z?.env??process.env,Q=Z&&Object.hasOwn(Z,"getuid")?Z.getuid:process.getuid?.bind(process);if(typeof Q==="function")return`uid-${Q()}`;for(let Y of["USERNAME","USER","LOGNAME"]){let B=$[Y];if(B)return`user-${E(B)}`}let X=Z&&Object.hasOwn(Z,"userInfo")?Z.userInfo:q.userInfo;try{let Y=X?.().username;if(Y)return`user-${E(Y)}`}catch{}let J=$.USERPROFILE??$.HOME;if(J)return`home-${E(J)}`;let W=Z&&Object.hasOwn(Z,"homedir")?Z.homedir:q.homedir;try{let Y=W?.();if(Y)return`home-${E(Y)}`}catch{}return"shared"}var F=j.join(q.tmpdir(),`dm-subagents-${d()}`),XZ=j.join(F,"async-subagent-results"),YZ=j.join(F,"async-subagent-runs"),p=j.join(F,"chain-runs"),o=j.join(F,"artifacts");import*as U from"node:fs";import*as _ from"node:path";function z(Z){return"parallel"in Z&&Array.isArray(Z.parallel)}function L(Z){return"expand"in Z&&"collect"in Z&&"parallel"in Z&&!Array.isArray(Z.parallel)}var O=new Map;function A(Z){return Z instanceof Error?Z.message:String(Z)}function w(Z){return typeof Z==="object"&&Z!==null&&"code"in Z&&Z.code==="ENOENT"}function S(Z){let $=_.join(Z,"status.json"),Q;try{Q=U.statSync($)}catch(Y){if(w(Y))return null;throw Error(`Failed to inspect async status file '${$}': ${A(Y)}`,{cause:Y instanceof Error?Y:void 0})}let X=O.get($);if(X&&X.mtime===Q.mtimeMs)return X.status;let J;try{J=U.readFileSync($,"utf-8")}catch(Y){if(w(Y))return null;throw Error(`Failed to read async status file '${$}': ${A(Y)}`,{cause:Y instanceof Error?Y:void 0})}let W;try{W=JSON.parse(J)}catch(Y){throw Error(`Failed to parse async status file '${$}': ${A(Y)}`,{cause:Y instanceof Error?Y:void 0})}if(O.set($,{mtime:Q.mtimeMs,status:W}),O.size>50){let Y=O.keys().next().value;if(Y)O.delete(Y)}return W}function D(Z,$){V.appendFileSync(Z,`${$}
-`)}var r="append-requests";function R(Z){return H.join(Z,r)}function i(Z,$){return H.join(R(Z),`${$.createdAt}-${$.id}.json`)}function C(Z){let $=R(Z);try{return K.readdirSync($).filter((Q)=>Q.endsWith(".json")).map((Q)=>H.join($,Q)).sort()}catch(Q){if(Q.code==="ENOENT")return[];throw Q}}function a(Z){return C(Z).length}function kZ(Z){let $=[];for(let Q of Z)if(z(Q))$.push(...Q.parallel.map((X)=>X.outputName).filter((X)=>Boolean(X)));else if(L(Q)){if(Q.collect.as)$.push(Q.collect.as)}else if(Q.outputName)$.push(Q.outputName);return $}function mZ(Z){let $=S(Z.asyncDir);if(!$)throw Error(`No async run status found for '${Z.runId}'.`);if($.runId!==Z.runId)throw Error(`Async run id mismatch: expected '${Z.runId}', found '${$.runId}'.`);if($.mode!=="chain")throw Error(`Run '${Z.runId}' is ${$.mode}; only active chain runs accept appended steps.`);if($.state!=="running")throw Error(`Run '${Z.runId}' is ${$.state}; only running chain runs accept appended steps.`);if(!(($.steps??[]).some((B)=>B.status==="running"||B.status==="pending")||($.pendingAppends??0)>0))throw Error(`Run '${Z.runId}' has no running or pending chain steps left; append-step must target an in-progress chain.`);if(Z.steps.length===0)throw Error("append-step requires one chain step.");let X={id:l(),createdAt:Z.now??Date.now(),steps:Z.steps};K.mkdirSync(R(Z.asyncDir),{recursive:!0}),T(i(Z.asyncDir,X),X);let J=a(Z.asyncDir),W=H.join(Z.asyncDir,"status.json"),Y={...$,pendingAppends:J,lastUpdate:X.createdAt};return T(W,Y),D(H.join(Z.asyncDir,"events.jsonl"),JSON.stringify({type:"subagent.chain.append.requested",ts:X.createdAt,runId:Z.runId,requestId:X.id,stepCount:Z.steps.length,pendingAppends:J})),{request:X,pendingCount:J}}function x(Z){let $=JSON.parse(K.readFileSync(Z,"utf-8"));if(!$.id||typeof $.id!=="string")return;if(!Number.isFinite($.createdAt))return;if(!Array.isArray($.steps)||$.steps.length===0)return;return{id:$.id,createdAt:$.createdAt,steps:$.steps}}function hZ(Z){return C(Z).map(($)=>x($)).filter(($)=>Boolean($)).sort(($,Q)=>$.createdAt-Q.createdAt||$.id.localeCompare(Q.id))}function gZ(Z){let $=[];for(let Q of C(Z)){let X=x(Q);try{K.unlinkSync(Q)}catch{}if(X)$.push(X)}return $.sort((Q,X)=>Q.createdAt-X.createdAt||Q.id.localeCompare(X.id))}function y(Z){return{agent:Z.agent,phase:Z.phase,label:Z.label,outputName:Z.outputName,structured:Z.structured,status:"pending",...Z.sessionFile?{sessionFile:Z.sessionFile}:{},skills:Z.skills,model:Z.model,thinking:Z.thinking,attemptedModels:Z.modelCandidates&&Z.modelCandidates.length>0?Z.modelCandidates:Z.model?[Z.model]:void 0,recentTools:[],recentOutput:[]}}function s(Z){if(z(Z))return Z.parallel.map(y);if(L(Z))return[{agent:`expand:${Z.parallel.agent}`,phase:Z.phase??Z.parallel.phase,label:Z.label??Z.parallel.label??`Dynamic fanout (${Z.collect.as})`,outputName:Z.collect.as,structured:Boolean(Z.collect.outputSchema),status:"pending",recentTools:[],recentOutput:[]}];return[y(Z)]}function v(Z,$,Q){if(!$)return;let X=Z.phases.find((J)=>J.title===$);if(!X)X={title:$,nodeIds:[]},Z.phases.push(X);X.nodeIds.push(Q)}function t(Z,$,Q){return{id:`step-${$}`,kind:"step",agent:Z.agent,phase:Z.phase,label:Z.label?.trim()||Z.agent||`Step ${$+1}`,status:"pending",flatIndex:Q,stepIndex:$,outputName:Z.outputName,structured:Z.structured}}function e(Z,$,Q,X){let J=Z.parallel.map((W,Y)=>{let B=`step-${$}-agent-${Y}`;return v(X,W.phase,B),{id:B,kind:"agent",agent:W.agent,phase:W.phase,label:W.label?.trim()||W.agent||`Agent ${Y+1}`,status:"pending",flatIndex:Q+Y,stepIndex:$,outputName:W.outputName,structured:W.structured}});return{id:`step-${$}`,kind:"parallel-group",label:Z.parallel.length===1?"Parallel task":`Parallel group (${Z.parallel.length})`,status:"pending",stepIndex:$,children:J}}function ZZ(Z,$){return{id:`step-${$}`,kind:"dynamic-parallel-group",label:Z.label?.trim()||Z.parallel.label?.trim()||`Dynamic fanout (${Z.collect.as})`,status:"pending",stepIndex:$,outputName:Z.collect.as,structured:Boolean(Z.collect.outputSchema),dynamic:{sourceOutput:Z.expand.from.output,sourcePath:Z.expand.from.path,itemName:Z.expand.item??"item",maxItems:Z.expand.maxItems,collectAs:Z.collect.as},children:[]}}function $Z(Z,$,Q,X){if(!Z)return;if(z($)){Z.nodes.push(e($,Q,X,Z));return}if(L($)){Z.nodes.push(ZZ($,Q));return}let J=t($,Q,X);Z.nodes.push(J),v(Z,$.phase,J.id)}function cZ(Z){let $=0,Q=0;for(let X of Z.steps){let J=Z.status.chainStepCount??Z.status.steps?.length??0,W=Z.status.steps?.length??0,Y=s(X);if(Z.status.steps??=[],Z.status.steps.push(...Y),z(X))Z.status.parallelGroups??=[],Z.status.parallelGroups.push({start:W,count:X.parallel.length,stepIndex:J});else if(L(X))Z.status.parallelGroups??=[],Z.status.parallelGroups.push({start:W,count:1,stepIndex:J});$Z(Z.status.workflowGraph,X,J,W),Z.status.chainStepCount=J+1,$++,Q+=Y.length}return Z.status.pendingAppends=Z.pendingAppends??0,Z.status.lastUpdate=Z.now??Date.now(),{addedChainSteps:$,addedFlatSteps:Q}}export{kZ as runnerStepOutputNames,hZ as readPendingChainAppendRequests,mZ as enqueueChainAppendRequest,a as countPendingChainAppendRequests,gZ as consumeChainAppendRequests,cZ as appendRunnerStepsToStatus};
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import { appendJsonl } from "../../shared/artifacts.js";
+import { readStatus } from "../../shared/utils.js";
+import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.js";
+const APPEND_REQUESTS_DIR = "append-requests";
+function appendDir(asyncDir) {
+  return path.join(asyncDir, APPEND_REQUESTS_DIR);
+}
+function appendRequestPath(asyncDir, request) {
+  return path.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
+}
+function listAppendRequestFiles(asyncDir) {
+  const dir = appendDir(asyncDir);
+  try {
+    return fs.readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => path.join(dir, entry)).sort();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+}
+export function countPendingChainAppendRequests(asyncDir) {
+  return listAppendRequestFiles(asyncDir).length;
+}
+export function runnerStepOutputNames(steps) {
+  const names = [];
+  for (const step of steps) {
+    if (isParallelGroup(step)) {
+      names.push(...step.parallel.map((task) => task.outputName).filter((name) => Boolean(name)));
+    } else if (isDynamicRunnerGroup(step)) {
+      if (step.collect.as)
+        names.push(step.collect.as);
+    } else if (step.outputName) {
+      names.push(step.outputName);
+    }
+  }
+  return names;
+}
+export function enqueueChainAppendRequest(input) {
+  const status = readStatus(input.asyncDir);
+  if (!status)
+    throw new Error(`No async run status found for '${input.runId}'.`);
+  if (status.runId !== input.runId)
+    throw new Error(`Async run id mismatch: expected '${input.runId}', found '${status.runId}'.`);
+  if (status.mode !== "chain")
+    throw new Error(`Run '${input.runId}' is ${status.mode}; only active chain runs accept appended steps.`);
+  if (status.state !== "running")
+    throw new Error(`Run '${input.runId}' is ${status.state}; only running chain runs accept appended steps.`);
+  const stillInProgress = (status.steps ?? []).some((step) => step.status === "running" || step.status === "pending") || (status.pendingAppends ?? 0) > 0;
+  if (!stillInProgress)
+    throw new Error(`Run '${input.runId}' has no running or pending chain steps left; append-step must target an in-progress chain.`);
+  if (input.steps.length === 0)
+    throw new Error("append-step requires one chain step.");
+  const request = {
+    id: randomUUID(),
+    createdAt: input.now ?? Date.now(),
+    steps: input.steps
+  };
+  fs.mkdirSync(appendDir(input.asyncDir), { recursive: true });
+  writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
+  const pendingCount = countPendingChainAppendRequests(input.asyncDir);
+  const statusPath = path.join(input.asyncDir, "status.json");
+  const updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
+  writeAtomicJson(statusPath, updatedStatus);
+  appendJsonl(path.join(input.asyncDir, "events.jsonl"), JSON.stringify({
+    type: "subagent.chain.append.requested",
+    ts: request.createdAt,
+    runId: input.runId,
+    requestId: request.id,
+    stepCount: input.steps.length,
+    pendingAppends: pendingCount
+  }));
+  return { request, pendingCount };
+}
+function readAppendRequest(filePath) {
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  if (!raw.id || typeof raw.id !== "string")
+    return;
+  if (!Number.isFinite(raw.createdAt))
+    return;
+  if (!Array.isArray(raw.steps) || raw.steps.length === 0)
+    return;
+  return { id: raw.id, createdAt: raw.createdAt, steps: raw.steps };
+}
+export function readPendingChainAppendRequests(asyncDir) {
+  return listAppendRequestFiles(asyncDir).map((filePath) => readAppendRequest(filePath)).filter((request) => Boolean(request)).sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
+}
+export function consumeChainAppendRequests(asyncDir) {
+  const requests = [];
+  for (const filePath of listAppendRequestFiles(asyncDir)) {
+    const request = readAppendRequest(filePath);
+    try {
+      fs.unlinkSync(filePath);
+    } catch {}
+    if (request)
+      requests.push(request);
+  }
+  return requests.sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
+}
+function statusStepForTask(task) {
+  return {
+    agent: task.agent,
+    phase: task.phase,
+    label: task.label,
+    outputName: task.outputName,
+    structured: task.structured,
+    status: "pending",
+    ...task.sessionFile ? { sessionFile: task.sessionFile } : {},
+    skills: task.skills,
+    model: task.model,
+    thinking: task.thinking,
+    attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+    recentTools: [],
+    recentOutput: []
+  };
+}
+function statusStepsForRunnerStep(step) {
+  if (isParallelGroup(step))
+    return step.parallel.map(statusStepForTask);
+  if (isDynamicRunnerGroup(step)) {
+    return [{
+      agent: `expand:${step.parallel.agent}`,
+      phase: step.phase ?? step.parallel.phase,
+      label: step.label ?? step.parallel.label ?? `Dynamic fanout (${step.collect.as})`,
+      outputName: step.collect.as,
+      structured: Boolean(step.collect.outputSchema),
+      status: "pending",
+      recentTools: [],
+      recentOutput: []
+    }];
+  }
+  return [statusStepForTask(step)];
+}
+function pushPhase(graph, phase, nodeId) {
+  if (!phase)
+    return;
+  let group = graph.phases.find((candidate) => candidate.title === phase);
+  if (!group) {
+    group = { title: phase, nodeIds: [] };
+    graph.phases.push(group);
+  }
+  group.nodeIds.push(nodeId);
+}
+function graphNodeForSequential(step, stepIndex, flatIndex) {
+  return {
+    id: `step-${stepIndex}`,
+    kind: "step",
+    agent: step.agent,
+    phase: step.phase,
+    label: step.label?.trim() || step.agent || `Step ${stepIndex + 1}`,
+    status: "pending",
+    flatIndex,
+    stepIndex,
+    outputName: step.outputName,
+    structured: step.structured
+  };
+}
+function graphNodeForParallel(step, stepIndex, flatIndex, graph) {
+  const children = step.parallel.map((task, taskIndex) => {
+    const childId = `step-${stepIndex}-agent-${taskIndex}`;
+    pushPhase(graph, task.phase, childId);
+    return {
+      id: childId,
+      kind: "agent",
+      agent: task.agent,
+      phase: task.phase,
+      label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
+      status: "pending",
+      flatIndex: flatIndex + taskIndex,
+      stepIndex,
+      outputName: task.outputName,
+      structured: task.structured
+    };
+  });
+  return {
+    id: `step-${stepIndex}`,
+    kind: "parallel-group",
+    label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
+    status: "pending",
+    stepIndex,
+    children
+  };
+}
+function graphNodeForDynamic(step, stepIndex) {
+  return {
+    id: `step-${stepIndex}`,
+    kind: "dynamic-parallel-group",
+    label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
+    status: "pending",
+    stepIndex,
+    outputName: step.collect.as,
+    structured: Boolean(step.collect.outputSchema),
+    dynamic: {
+      sourceOutput: step.expand.from.output,
+      sourcePath: step.expand.from.path,
+      itemName: step.expand.item ?? "item",
+      maxItems: step.expand.maxItems,
+      collectAs: step.collect.as
+    },
+    children: []
+  };
+}
+function appendWorkflowNode(graph, step, stepIndex, flatIndex) {
+  if (!graph)
+    return;
+  if (isParallelGroup(step)) {
+    graph.nodes.push(graphNodeForParallel(step, stepIndex, flatIndex, graph));
+    return;
+  }
+  if (isDynamicRunnerGroup(step)) {
+    graph.nodes.push(graphNodeForDynamic(step, stepIndex));
+    return;
+  }
+  const node = graphNodeForSequential(step, stepIndex, flatIndex);
+  graph.nodes.push(node);
+  pushPhase(graph, step.phase, node.id);
+}
+export function appendRunnerStepsToStatus(input) {
+  let addedChainSteps = 0;
+  let addedFlatSteps = 0;
+  for (const step of input.steps) {
+    const stepIndex = input.status.chainStepCount ?? input.status.steps?.length ?? 0;
+    const flatIndex = input.status.steps?.length ?? 0;
+    const statusSteps = statusStepsForRunnerStep(step);
+    input.status.steps ??= [];
+    input.status.steps.push(...statusSteps);
+    if (isParallelGroup(step)) {
+      input.status.parallelGroups ??= [];
+      input.status.parallelGroups.push({ start: flatIndex, count: step.parallel.length, stepIndex });
+    } else if (isDynamicRunnerGroup(step)) {
+      input.status.parallelGroups ??= [];
+      input.status.parallelGroups.push({ start: flatIndex, count: 1, stepIndex });
+    }
+    appendWorkflowNode(input.status.workflowGraph, step, stepIndex, flatIndex);
+    input.status.chainStepCount = stepIndex + 1;
+    addedChainSteps++;
+    addedFlatSteps += statusSteps.length;
+  }
+  input.status.pendingAppends = input.pendingAppends ?? 0;
+  input.status.lastUpdate = input.now ?? Date.now();
+  return { addedChainSteps, addedFlatSteps };
+}

package/extensions/dm-subagents/src/runs/background/chain-root-attachment.js

@@ -1 +1,136 @@
-import*as j from"node:fs";import*as H from"node:path";import*as W from"node:fs";import*as F from"node:path";import*as q from"node:os";import*as B from"node:path";function V(A){return A.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function z(A){let $=A?.env??process.env,J=A&&Object.hasOwn(A,"getuid")?A.getuid:process.getuid?.bind(process);if(typeof J==="function")return`uid-${J()}`;for(let Q of["USERNAME","USER","LOGNAME"]){let X=$[Q];if(X)return`user-${V(X)}`}let O=A&&Object.hasOwn(A,"userInfo")?A.userInfo:q.userInfo;try{let Q=O?.().username;if(Q)return`user-${V(Q)}`}catch{}let Y=$.USERPROFILE??$.HOME;if(Y)return`home-${V(Y)}`;let Z=A&&Object.hasOwn(A,"homedir")?A.homedir:q.homedir;try{let Q=Z?.();if(Q)return`home-${V(Q)}`}catch{}return"shared"}var K=B.join(q.tmpdir(),`dm-subagents-${z()}`),v=B.join(K,"async-subagent-results"),c=B.join(K,"async-subagent-runs"),I=B.join(K,"chain-runs"),k=B.join(K,"artifacts");var U=new Map;function E(A){return A instanceof Error?A.message:String(A)}function T(A){return typeof A==="object"&&A!==null&&"code"in A&&A.code==="ENOENT"}function L(A){let $=F.join(A,"status.json"),J;try{J=W.statSync($)}catch(Q){if(T(Q))return null;throw Error(`Failed to inspect async status file '${$}': ${E(Q)}`,{cause:Q instanceof Error?Q:void 0})}let O=U.get($);if(O&&O.mtime===J.mtimeMs)return O.status;let Y;try{Y=W.readFileSync($,"utf-8")}catch(Q){if(T(Q))return null;throw Error(`Failed to read async status file '${$}': ${E(Q)}`,{cause:Q instanceof Error?Q:void 0})}let Z;try{Z=JSON.parse(Y)}catch(Q){throw Error(`Failed to parse async status file '${$}': ${E(Q)}`,{cause:Q instanceof Error?Q:void 0})}if(U.set($,{mtime:J.mtimeMs,status:Z}),U.size>50){let Q=U.keys().next().value;if(Q)U.delete(Q)}return Z}var N=new Set(["complete","failed","paused"]),C=new Set(["complete","completed","failed","paused"]);function b(A){try{return JSON.parse(j.readFileSync(A,"utf-8"))}catch($){if(typeof $==="object"&&$!==null&&"code"in $&&$.code==="ENOENT")return;throw $}}function R(A,$){return A?.steps?.[$]}function S(A,$){if(!A)return!1;let J=R(A,$);if(J&&C.has(J.status))return!0;return N.has(A.state)}function y(A,$){if(!A)return;if($?.success===!0)return"complete";if($?.success===!1)return A.state==="paused"?"paused":"failed";if(A.state==="complete"||A.state==="failed"||A.state==="paused")return A.state;if(A.success===!0)return"complete";if(A.success===!1)return"failed";return}function w(A,$,J){let O=J?.agent??$.steps?.[A.index]?.agent??"subagent",Y=J?.timedOut===!0||$.timedOut===!0,Z=J?.error??$.error??`Attached async root ${A.runId} ended without a result file at ${A.resultPath}.`;return{agent:O,output:Z,success:!1,exitCode:1,error:Z,...Y?{timedOut:!0}:{},...J?.sessionFile??$.sessionFile?{sessionFile:J?.sessionFile??$.sessionFile}:{},...J?.model?{model:J.model}:{},...J?.attemptedModels?{attemptedModels:J.attemptedModels}:{},...J?.modelAttempts?{modelAttempts:J.modelAttempts}:{},...J?.totalCost?{totalCost:J.totalCost}:{},...J?.structuredOutput!==void 0?{structuredOutput:J.structuredOutput}:{},...J?.structuredOutputPath?{structuredOutputPath:J.structuredOutputPath}:{},...J?.structuredOutputSchemaPath?{structuredOutputSchemaPath:J.structuredOutputSchemaPath}:{},...J?.acceptance?{acceptance:J.acceptance}:{}}}function x(A,$,J){let O=R($,A.index);return{agent:O?.agent??$?.steps?.[A.index]?.agent??"subagent",output:J,success:!1,exitCode:1,error:J,timedOut:!0,...O?.sessionFile??$?.sessionFile?{sessionFile:O?.sessionFile??$?.sessionFile}:{},...O?.model?{model:O.model}:{},...O?.attemptedModels?{attemptedModels:O.attemptedModels}:{},...O?.modelAttempts?{modelAttempts:O.modelAttempts}:{},...O?.totalCost?{totalCost:O.totalCost}:{}}}function D(A,$,J){let O=J.results?.[A.index],Y=R($,A.index),Z=y(J,O),Q=O?.agent??Y?.agent??$?.steps?.[A.index]?.agent??"subagent",X=O?.output??J.summary??"",G=O?.timedOut===!0||Y?.timedOut===!0||J.timedOut===!0||$?.timedOut===!0,M=Z==="complete"&&!G,_=O?.error??(M?void 0:J.error??J.summary??$?.error??`Attached async root ${A.runId} did not complete successfully.`);return{agent:Q,output:M?X:X||_||"",success:M,exitCode:M?0:1,..._?{error:_}:{},...G?{timedOut:!0}:{},...O?.sessionFile??Y?.sessionFile??$?.sessionFile?{sessionFile:O?.sessionFile??Y?.sessionFile??$?.sessionFile}:{},...O?.intercomTarget?{intercomTarget:O.intercomTarget}:{},...O?.model??Y?.model?{model:O?.model??Y?.model}:{},...O?.attemptedModels??Y?.attemptedModels?{attemptedModels:O?.attemptedModels??Y?.attemptedModels}:{},...O?.modelAttempts??Y?.modelAttempts?{modelAttempts:O?.modelAttempts??Y?.modelAttempts}:{},...O?.totalCost??Y?.totalCost?{totalCost:O?.totalCost??Y?.totalCost}:{},...O?.structuredOutput!==void 0?{structuredOutput:O.structuredOutput}:Y?.structuredOutput!==void 0?{structuredOutput:Y.structuredOutput}:{},...O?.structuredOutputPath??Y?.structuredOutputPath?{structuredOutputPath:O?.structuredOutputPath??Y?.structuredOutputPath}:{},...O?.structuredOutputSchemaPath??Y?.structuredOutputSchemaPath?{structuredOutputSchemaPath:O?.structuredOutputSchemaPath??Y?.structuredOutputSchemaPath}:{},...O?.acceptance??Y?.acceptance?{acceptance:O?.acceptance??Y?.acceptance}:{}}}async function qA(A,$={}){let J=$.pollIntervalMs??500,O=$.terminalResultGraceMs??1000,Y=$.now??Date.now,Z;for(;;){let Q=L(A.asyncDir);if($.shouldAbort?.())return x(A,Q,$.timeoutMessage??"Subagent timed out.");let X=b(A.resultPath);if(X)return D(A,Q,X);if(S(Q,A.index)){if(Z??=Y(),Y()-Z>=O)return w(A,Q,R(Q,A.index))}else Z=void 0;if(!Q&&!j.existsSync(A.asyncDir))throw Error(`Attached async root '${A.runId}' directory does not exist: ${A.asyncDir}`);await new Promise((G)=>setTimeout(G,J))}}function BA(A,$){return H.join(A,`${$}.json`)}export{qA as waitForImportedAsyncRoot,BA as resolveAsyncRootResultPath};
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readStatus } from "../../shared/utils.js";
+const TERMINAL_STATES = new Set(["complete", "failed", "paused"]);
+const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "paused"]);
+function readResultFile(resultPath) {
+  try {
+    return JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+function selectedStatusStep(status, index) {
+  return status?.steps?.[index];
+}
+function isTerminalStatus(status, index) {
+  if (!status)
+    return false;
+  const step = selectedStatusStep(status, index);
+  if (step && TERMINAL_STEP_STATUSES.has(step.status))
+    return true;
+  return TERMINAL_STATES.has(status.state);
+}
+function resultState(result, child) {
+  if (!result)
+    return;
+  if (child?.success === true)
+    return "complete";
+  if (child?.success === false)
+    return result.state === "paused" ? "paused" : "failed";
+  if (result.state === "complete" || result.state === "failed" || result.state === "paused")
+    return result.state;
+  if (result.success === true)
+    return "complete";
+  if (result.success === false)
+    return "failed";
+  return;
+}
+function outputFromTerminalStatus(root, status, step) {
+  const agent = step?.agent ?? status.steps?.[root.index]?.agent ?? "subagent";
+  const timedOut = step?.timedOut === true || status.timedOut === true;
+  const message = step?.error ?? status.error ?? `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`;
+  return {
+    agent,
+    output: message,
+    success: false,
+    exitCode: 1,
+    error: message,
+    ...timedOut ? { timedOut: true } : {},
+    ...step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {},
+    ...step?.model ? { model: step.model } : {},
+    ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
+    ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
+    ...step?.totalCost ? { totalCost: step.totalCost } : {},
+    ...step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {},
+    ...step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {},
+    ...step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {},
+    ...step?.acceptance ? { acceptance: step.acceptance } : {}
+  };
+}
+function outputFromTimeout(root, status, message) {
+  const step = selectedStatusStep(status, root.index);
+  return {
+    agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
+    output: message,
+    success: false,
+    exitCode: 1,
+    error: message,
+    timedOut: true,
+    ...step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {},
+    ...step?.model ? { model: step.model } : {},
+    ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
+    ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
+    ...step?.totalCost ? { totalCost: step.totalCost } : {}
+  };
+}
+function buildImportedResult(root, status, result) {
+  const child = result.results?.[root.index];
+  const step = selectedStatusStep(status, root.index);
+  const state = resultState(result, child);
+  const agent = child?.agent ?? step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent";
+  const output = child?.output ?? result.summary ?? "";
+  const timedOut = child?.timedOut === true || step?.timedOut === true || result.timedOut === true || status?.timedOut === true;
+  const success = state === "complete" && !timedOut;
+  const error = child?.error ?? (success ? undefined : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+  return {
+    agent,
+    output: success ? output : output || error || "",
+    success,
+    exitCode: success ? 0 : 1,
+    ...error ? { error } : {},
+    ...timedOut ? { timedOut: true } : {},
+    ...child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {},
+    ...child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {},
+    ...child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {},
+    ...child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {},
+    ...child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {},
+    ...child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {},
+    ...child?.structuredOutput !== undefined ? { structuredOutput: child.structuredOutput } : step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {},
+    ...child?.structuredOutputPath ?? step?.structuredOutputPath ? { structuredOutputPath: child?.structuredOutputPath ?? step?.structuredOutputPath } : {},
+    ...child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath } : {},
+    ...child?.acceptance ?? step?.acceptance ? { acceptance: child?.acceptance ?? step?.acceptance } : {}
+  };
+}
+export async function waitForImportedAsyncRoot(root, options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? 500;
+  const terminalResultGraceMs = options.terminalResultGraceMs ?? 1000;
+  const now = options.now ?? Date.now;
+  let terminalSince;
+  for (;; ) {
+    const status = readStatus(root.asyncDir);
+    if (options.shouldAbort?.())
+      return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.");
+    const result = readResultFile(root.resultPath);
+    if (result)
+      return buildImportedResult(root, status, result);
+    if (isTerminalStatus(status, root.index)) {
+      terminalSince ??= now();
+      if (now() - terminalSince >= terminalResultGraceMs) {
+        return outputFromTerminalStatus(root, status, selectedStatusStep(status, root.index));
+      }
+    } else {
+      terminalSince = undefined;
+    }
+    if (!status && !fs.existsSync(root.asyncDir)) {
+      throw new Error(`Attached async root '${root.runId}' directory does not exist: ${root.asyncDir}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+}
+export function resolveAsyncRootResultPath(resultsDir, runId) {
+  return path.join(resultsDir, `${runId}.json`);
+}

package/extensions/dm-subagents/src/runs/background/completion-batcher.js

@@ -1 +1,94 @@
-var R={enabled:!0,debounceMs:150,maxWaitMs:1000,stragglerDebounceMs:75,stragglerMaxWaitMs:400,stragglerWindowMs:2000};function q(j){if(typeof j!=="number"||!Number.isFinite(j)||!Number.isInteger(j)||j<1)return;return j}function x(j,k){return{enabled:typeof k?.enabled==="boolean"?k.enabled:typeof j?.enabled==="boolean"?j.enabled:R.enabled,debounceMs:q(k?.debounceMs)??q(j?.debounceMs)??R.debounceMs,maxWaitMs:q(k?.maxWaitMs)??q(j?.maxWaitMs)??R.maxWaitMs,stragglerDebounceMs:q(k?.stragglerDebounceMs)??q(j?.stragglerDebounceMs)??R.stragglerDebounceMs,stragglerMaxWaitMs:q(k?.stragglerMaxWaitMs)??q(j?.stragglerMaxWaitMs)??R.stragglerMaxWaitMs,stragglerWindowMs:q(k?.stragglerWindowMs)??q(j?.stragglerWindowMs)??R.stragglerWindowMs}}var U={setTimeout:(j,k)=>setTimeout(j,k),clearTimeout:(j)=>clearTimeout(j)};function y(j){if(j&&typeof j==="object"&&"unref"in j&&typeof j.unref==="function")j.unref()}function W(j){let k=j.timers??U,V=j.now??Date.now,J=j.config;if(!J.enabled)return{push(S){j.emit([S])},flush(){},dispose(){}};let K=[],z=null,Q=null,X=!1,Y=null,$=()=>{if(z)k.clearTimeout(z),z=null;if(Q)k.clearTimeout(Q),Q=null},Z=()=>{if($(),K.length===0)return;let S=K;K=[],Y=V(),j.emit(S)};return{push(S){if(K.length===0)X=Y!==null&&V()-Y<J.stragglerWindowMs;if(K.push(S),z)k.clearTimeout(z);let w=X?J.stragglerDebounceMs:J.debounceMs;if(z=k.setTimeout(Z,w),y(z),!Q){let B=X?J.stragglerMaxWaitMs:J.maxWaitMs;Q=k.setTimeout(Z,B),y(Q)}},flush:Z,dispose(){$(),K=[]}}}export{x as resolveCompletionBatchConfig,W as createCompletionBatcher,R as DEFAULT_COMPLETION_BATCH_CONFIG};
+export const DEFAULT_COMPLETION_BATCH_CONFIG = {
+  enabled: true,
+  debounceMs: 150,
+  maxWaitMs: 1000,
+  stragglerDebounceMs: 75,
+  stragglerMaxWaitMs: 400,
+  stragglerWindowMs: 2000
+};
+function parsePositiveInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1)
+    return;
+  return value;
+}
+export function resolveCompletionBatchConfig(globalConfig, override) {
+  const enabled = typeof override?.enabled === "boolean" ? override.enabled : typeof globalConfig?.enabled === "boolean" ? globalConfig.enabled : DEFAULT_COMPLETION_BATCH_CONFIG.enabled;
+  return {
+    enabled,
+    debounceMs: parsePositiveInt(override?.debounceMs) ?? parsePositiveInt(globalConfig?.debounceMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.debounceMs,
+    maxWaitMs: parsePositiveInt(override?.maxWaitMs) ?? parsePositiveInt(globalConfig?.maxWaitMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.maxWaitMs,
+    stragglerDebounceMs: parsePositiveInt(override?.stragglerDebounceMs) ?? parsePositiveInt(globalConfig?.stragglerDebounceMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerDebounceMs,
+    stragglerMaxWaitMs: parsePositiveInt(override?.stragglerMaxWaitMs) ?? parsePositiveInt(globalConfig?.stragglerMaxWaitMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerMaxWaitMs,
+    stragglerWindowMs: parsePositiveInt(override?.stragglerWindowMs) ?? parsePositiveInt(globalConfig?.stragglerWindowMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerWindowMs
+  };
+}
+const defaultTimers = {
+  setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+function unrefHandle(handle) {
+  if (handle && typeof handle === "object" && "unref" in handle && typeof handle.unref === "function") {
+    handle.unref();
+  }
+}
+export function createCompletionBatcher(options) {
+  const timers = options.timers ?? defaultTimers;
+  const now = options.now ?? Date.now;
+  const config = options.config;
+  if (!config.enabled) {
+    return {
+      push(item) {
+        options.emit([item]);
+      },
+      flush() {},
+      dispose() {}
+    };
+  }
+  let pending = [];
+  let debounceTimer = null;
+  let maxWaitTimer = null;
+  let straggler = false;
+  let lastEmitAt = null;
+  const clearTimers = () => {
+    if (debounceTimer) {
+      timers.clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    if (maxWaitTimer) {
+      timers.clearTimeout(maxWaitTimer);
+      maxWaitTimer = null;
+    }
+  };
+  const emitGroup = () => {
+    clearTimers();
+    if (pending.length === 0)
+      return;
+    const items = pending;
+    pending = [];
+    lastEmitAt = now();
+    options.emit(items);
+  };
+  return {
+    push(item) {
+      if (pending.length === 0) {
+        straggler = lastEmitAt !== null && now() - lastEmitAt < config.stragglerWindowMs;
+      }
+      pending.push(item);
+      if (debounceTimer)
+        timers.clearTimeout(debounceTimer);
+      const debounceDelay = straggler ? config.stragglerDebounceMs : config.debounceMs;
+      debounceTimer = timers.setTimeout(emitGroup, debounceDelay);
+      unrefHandle(debounceTimer);
+      if (!maxWaitTimer) {
+        const maxWaitDelay = straggler ? config.stragglerMaxWaitMs : config.maxWaitMs;
+        maxWaitTimer = timers.setTimeout(emitGroup, maxWaitDelay);
+        unrefHandle(maxWaitTimer);
+      }
+    },
+    flush: emitGroup,
+    dispose() {
+      clearTimers();
+      pending = [];
+    }
+  };
+}

package/extensions/dm-subagents/src/runs/background/completion-dedupe.js

@@ -1 +1,54 @@
-function o(n){if(typeof n!=="string")return;let e=n.trim();return e.length>0?e:void 0}function r(n){if(typeof n!=="number")return;return Number.isFinite(n)?n:void 0}function d(n,e){let t=o(n.id);if(t)return`id:${t}`;let i=o(n.sessionId)??"no-session",s=o(n.agent)??"unknown",u=r(n.timestamp),c=r(n.taskIndex),f=r(n.totalTasks),m=typeof n.success==="boolean"?n.success?"1":"0":"?";return["meta",i,s,u!==void 0?String(u):"no-ts",c!==void 0?String(c):"-",f!==void 0?String(f):"-",m,e].join(":")}function a(n,e,t){for(let[i,s]of n.entries())if(e-s>t)n.delete(i)}function g(n,e,t,i){if(a(n,t,i),n.has(e))return!0;return n.set(e,t),!1}function p(n){let e=globalThis,t=e[n];if(t instanceof Map)return t;let i=new Map;return e[n]=i,i}export{g as markSeenWithTtl,p as getGlobalSeenMap,d as buildCompletionKey};
+function asNonEmptyString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function asFiniteNumber(value) {
+  if (typeof value !== "number")
+    return;
+  return Number.isFinite(value) ? value : undefined;
+}
+export function buildCompletionKey(data, fallback) {
+  const id = asNonEmptyString(data.id);
+  if (id)
+    return `id:${id}`;
+  const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
+  const agent = asNonEmptyString(data.agent) ?? "unknown";
+  const timestamp = asFiniteNumber(data.timestamp);
+  const taskIndex = asFiniteNumber(data.taskIndex);
+  const totalTasks = asFiniteNumber(data.totalTasks);
+  const success = typeof data.success === "boolean" ? data.success ? "1" : "0" : "?";
+  return [
+    "meta",
+    sessionId,
+    agent,
+    timestamp !== undefined ? String(timestamp) : "no-ts",
+    taskIndex !== undefined ? String(taskIndex) : "-",
+    totalTasks !== undefined ? String(totalTasks) : "-",
+    success,
+    fallback
+  ].join(":");
+}
+function pruneSeenMap(seen, now, ttlMs) {
+  for (const [key, ts] of seen.entries()) {
+    if (now - ts > ttlMs)
+      seen.delete(key);
+  }
+}
+export function markSeenWithTtl(seen, key, now, ttlMs) {
+  pruneSeenMap(seen, now, ttlMs);
+  if (seen.has(key))
+    return true;
+  seen.set(key, now);
+  return false;
+}
+export function getGlobalSeenMap(storeKey) {
+  const globalStore = globalThis;
+  const existing = globalStore[storeKey];
+  if (existing instanceof Map)
+    return existing;
+  const map = new Map;
+  globalStore[storeKey] = map;
+  return map;
+}