@duckmind/dm-windows-x64 0.60.6 → 0.60.9

package/extensions/dm-subagents/src/runs/shared/turn-budget.js

@@ -1,7 +1,50 @@
-var u=1;function a(t,e){if(!e)return t;let r=e.graceTurns===1?"1 additional assistant turn":`${e.graceTurns} additional assistant turns`,n=["## Turn budget",`This child run has a soft budget of ${e.maxTurns} assistant turn${e.maxTurns===1?"":"s"}.`,`After that, ${r} may be allowed only for a final wrap-up.`,"When you approach or reach the soft budget, stop starting new tool work and return the final answer immediately.","This runner uses process-mode execution, so live steering after launch may be unavailable; treat this instruction as the wrap-up request.","If you continue past the soft budget plus grace turns, the supervisor may abort the process and return only partial output."].join(`
-`);return t.trim()?`${t.trim()}
+export const DEFAULT_TURN_BUDGET_GRACE_TURNS = 1;
+export function appendTurnBudgetSystemPrompt(systemPrompt, budget) {
+  if (!budget)
+    return systemPrompt;
+  const grace = budget.graceTurns === 1 ? "1 additional assistant turn" : `${budget.graceTurns} additional assistant turns`;
+  const block = [
+    "## Turn budget",
+    `This child run has a soft budget of ${budget.maxTurns} assistant turn${budget.maxTurns === 1 ? "" : "s"}.`,
+    `After that, ${grace} may be allowed only for a final wrap-up.`,
+    "When you approach or reach the soft budget, stop starting new tool work and return the final answer immediately.",
+    "This runner uses process-mode execution, so live steering after launch may be unavailable; treat this instruction as the wrap-up request.",
+    "If you continue past the soft budget plus grace turns, the supervisor may abort the process and return only partial output."
+  ].join(`
+`);
+  return systemPrompt.trim() ? `${systemPrompt.trim()}
 
-${n}`:n}function s(t,e){return`Turn budget wrap-up was requested after ${e} assistant turn${e===1?"":"s"} (soft limit ${t.maxTurns}, grace ${t.graceTurns}). Process-mode live steering is unavailable, so the child was warned at launch to wrap up by this budget. Output may be partial.`}function o(t,e){return`Subagent exceeded turn budget after ${e} assistant turn${e===1?"":"s"} (soft limit ${t.maxTurns} + grace ${t.graceTurns}).`}function i(t,e){return e.trim()?`${t}
+${block}` : block;
+}
+export function turnBudgetSoftNote(budget, turnCount) {
+  return `Turn budget wrap-up was requested after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns}, grace ${budget.graceTurns}). Process-mode live steering is unavailable, so the child was warned at launch to wrap up by this budget. Output may be partial.`;
+}
+export function turnBudgetExceededMessage(budget, turnCount) {
+  return `Subagent exceeded turn budget after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns} + grace ${budget.graceTurns}).`;
+}
+export function formatTurnBudgetOutput(message, output) {
+  return output.trim() ? `${message}
 
 Partial output before turn-budget abort:
-${e}`:t}function d(t){return{...t,outcome:"within-budget",turnCount:0}}function l(t,e,r){return{...t,turnCount:e,outcome:r?"exceeded":"wrap-up-requested",wrapUpRequestedAtTurn:t.maxTurns,...r?{exceededAtTurn:e}:{}}}function c(t,e,r){let n=t.maxTurns+t.graceTurns;if(e<n)return!1;if(e>n)return!0;return!r}export{l as turnBudgetState,s as turnBudgetSoftNote,o as turnBudgetExceededMessage,c as shouldAbortForTurnBudget,d as initialTurnBudgetState,i as formatTurnBudgetOutput,a as appendTurnBudgetSystemPrompt,u as DEFAULT_TURN_BUDGET_GRACE_TURNS};
+${output}` : message;
+}
+export function initialTurnBudgetState(budget) {
+  return { ...budget, outcome: "within-budget", turnCount: 0 };
+}
+export function turnBudgetState(budget, turnCount, exceeded) {
+  return {
+    ...budget,
+    turnCount,
+    outcome: exceeded ? "exceeded" : "wrap-up-requested",
+    wrapUpRequestedAtTurn: budget.maxTurns,
+    ...exceeded ? { exceededAtTurn: turnCount } : {}
+  };
+}
+export function shouldAbortForTurnBudget(budget, turnCount, terminalAssistantStop) {
+  const hardLimit = budget.maxTurns + budget.graceTurns;
+  if (turnCount < hardLimit)
+    return false;
+  if (turnCount > hardLimit)
+    return true;
+  return !terminalAssistantStop;
+}

package/extensions/dm-subagents/src/runs/shared/workflow-graph.js

@@ -1 +1,196 @@
-import*as z from"node:os";import*as _ from"node:path";function L(W){return W.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function w(W){let $=W?.env??process.env,Y=W&&Object.hasOwn(W,"getuid")?W.getuid:process.getuid?.bind(process);if(typeof Y==="function")return`uid-${Y()}`;for(let q of["USERNAME","USER","LOGNAME"]){let J=$[q];if(J)return`user-${L(J)}`}let Z=W&&Object.hasOwn(W,"userInfo")?W.userInfo:z.userInfo;try{let q=Z?.().username;if(q)return`user-${L(q)}`}catch{}let Q=$.USERPROFILE??$.HOME;if(Q)return`home-${L(Q)}`;let B=W&&Object.hasOwn(W,"homedir")?W.homedir:z.homedir;try{let q=B?.();if(q)return`home-${L(q)}`}catch{}return"shared"}var N=_.join(z.tmpdir(),`dm-subagents-${w()}`),i=_.join(N,"async-subagent-results"),s=_.join(N,"async-subagent-runs"),x=_.join(N,"chain-runs"),e=_.join(N,"artifacts");function M(W){return"parallel"in W&&Array.isArray(W.parallel)}function O(W){return"expand"in W&&"collect"in W&&"parallel"in W&&!Array.isArray(W.parallel)}function y(W){switch(W){case"complete":case"completed":return"completed";case"running":return"running";case"failed":return"failed";case"paused":return"paused";case"detached":return"detached";case"pending":return"pending";default:return}}function D(W){if(!W)return;if(W.detached)return"detached";if(W.interrupted)return"paused";return W.exitCode===0?"completed":"failed"}function T(W,$){return y(W.stepStatuses?.[$]?.status)??D(W.results?.[$])??(W.currentFlatIndex===$?"running":"pending")}function R(W,$,Y){if(!$)return;let Z=W.find((Q)=>Q.title===$);if(!Z)Z={title:$,nodeIds:[]},W.push(Z);Z.nodeIds.push(Y)}function f(W,$){return W.label?.trim()||W.agent||`Step ${$+1}`}function b(W){if(W.some(($)=>$==="running"))return"running";if(W.some(($)=>$==="failed"))return"failed";if(W.some(($)=>$==="paused"))return"paused";if(W.some(($)=>$==="detached"))return"detached";if(W.length>0&&W.every(($)=>$==="completed"))return"completed";if(W.some(($)=>$==="completed"))return"running";return"pending"}function JW(W){let $=[],Y=[],Z=0,Q;for(let B=0;B<W.steps.length;B++){let q=W.steps[B];if(M(q)){let A=`step-${B}`,V=[],j=[];for(let K=0;K<q.parallel.length;K++){let X=q.parallel[K],U=T(W,Z);j.push(U);let G=`step-${B}-agent-${K}`,H={id:G,kind:"agent",agent:X.agent,phase:X.phase,label:X.label?.trim()||X.agent||`Agent ${K+1}`,status:U,flatIndex:Z,stepIndex:B,outputName:X.as,structured:Boolean(X.outputSchema),acceptanceStatus:W.results?.[Z]?.acceptance?.status,error:W.stepStatuses?.[Z]?.error??W.results?.[Z]?.error};if(V.push(H),R(Y,X.phase,G),U==="running"||W.currentFlatIndex===Z)Q=G;Z++}let I=b(j);if(W.currentStepIndex===B&&!Q)Q=A;$.push({id:A,kind:"parallel-group",label:q.parallel.length===1?"Parallel task":`Parallel group (${q.parallel.length})`,status:I,stepIndex:B,children:V});continue}if(O(q)){let A=`step-${B}`,V=W.dynamicChildren?.[B]??[],j=W.dynamicGroupStatuses?.[B],I=[],K=[];for(let U=0;U<V.length;U++){let G=V[U],H=T(W,G.flatIndex);K.push(H);let E=`step-${B}-item-${G.itemKey.replace(/[^a-zA-Z0-9_-]/g,"-")}`,C={id:E,kind:"agent",agent:G.agent,phase:q.parallel.phase??q.phase,label:G.label?.trim()||q.parallel.label?.trim()||`${G.agent} ${G.itemKey}`,status:H,flatIndex:G.flatIndex,stepIndex:B,itemKey:G.itemKey,outputName:G.outputName,structured:G.structured,acceptanceStatus:W.results?.[G.flatIndex]?.acceptance?.status,error:W.stepStatuses?.[G.flatIndex]?.error??W.results?.[G.flatIndex]?.error??G.error};if(I.push(C),R(Y,C.phase,E),H==="running"||W.currentFlatIndex===G.flatIndex)Q=E}let X=j?.status??(I.length>0?b(K):W.currentStepIndex===B?"running":"pending");if(W.currentStepIndex===B&&!Q)Q=A;if($.push({id:A,kind:"dynamic-parallel-group",label:q.label?.trim()||q.parallel.label?.trim()||`Dynamic fanout (${q.collect.as})`,status:X,stepIndex:B,outputName:q.collect.as,structured:Boolean(q.collect.outputSchema),acceptanceStatus:j?.acceptance?.status,error:j?.error,dynamic:{sourceOutput:q.expand.from.output,sourcePath:q.expand.from.path,itemName:q.expand.item??"item",maxItems:q.expand.maxItems,collectAs:q.collect.as},children:I}),V.length>0)Z=Math.max(Z,...V.map((U)=>U.flatIndex+1));continue}let J=q,S=T(W,Z),F=`step-${B}`;if($.push({id:F,kind:"step",agent:J.agent,phase:J.phase,label:f(J,B),status:S,flatIndex:Z,stepIndex:B,outputName:J.as,structured:Boolean(J.outputSchema),acceptanceStatus:W.results?.[Z]?.acceptance?.status,error:W.stepStatuses?.[Z]?.error??W.results?.[Z]?.error}),R(Y,J.phase,F),S==="running"||W.currentFlatIndex===Z||W.currentStepIndex===B)Q=F;Z++}return{runId:W.runId,mode:W.mode??"chain",phases:Y,nodes:$,currentNodeId:Q}}export{JW as buildWorkflowGraphSnapshot};
+import { isDynamicParallelStep, isParallelStep } from "../../shared/settings.js";
+function normalizeStatus(status) {
+  switch (status) {
+    case "complete":
+    case "completed":
+      return "completed";
+    case "running":
+      return "running";
+    case "failed":
+      return "failed";
+    case "paused":
+      return "paused";
+    case "detached":
+      return "detached";
+    case "pending":
+      return "pending";
+    default:
+      return;
+  }
+}
+function resultStatus(result) {
+  if (!result)
+    return;
+  if (result.detached)
+    return "detached";
+  if (result.interrupted)
+    return "paused";
+  return result.exitCode === 0 ? "completed" : "failed";
+}
+function nodeStatus(input, flatIndex) {
+  return normalizeStatus(input.stepStatuses?.[flatIndex]?.status) ?? resultStatus(input.results?.[flatIndex]) ?? (input.currentFlatIndex === flatIndex ? "running" : "pending");
+}
+function pushPhase(phases, phase, nodeId) {
+  if (!phase)
+    return;
+  let group = phases.find((candidate) => candidate.title === phase);
+  if (!group) {
+    group = { title: phase, nodeIds: [] };
+    phases.push(group);
+  }
+  group.nodeIds.push(nodeId);
+}
+function seqLabel(step, stepIndex) {
+  return step.label?.trim() || step.agent || `Step ${stepIndex + 1}`;
+}
+function summarizeParallelStatuses(statuses) {
+  if (statuses.some((status) => status === "running"))
+    return "running";
+  if (statuses.some((status) => status === "failed"))
+    return "failed";
+  if (statuses.some((status) => status === "paused"))
+    return "paused";
+  if (statuses.some((status) => status === "detached"))
+    return "detached";
+  if (statuses.length > 0 && statuses.every((status) => status === "completed"))
+    return "completed";
+  if (statuses.some((status) => status === "completed"))
+    return "running";
+  return "pending";
+}
+export function buildWorkflowGraphSnapshot(input) {
+  const nodes = [];
+  const phases = [];
+  let flatIndex = 0;
+  let currentNodeId;
+  for (let stepIndex = 0;stepIndex < input.steps.length; stepIndex++) {
+    const step = input.steps[stepIndex];
+    if (isParallelStep(step)) {
+      const groupId = `step-${stepIndex}`;
+      const children = [];
+      const childStatuses = [];
+      for (let taskIndex = 0;taskIndex < step.parallel.length; taskIndex++) {
+        const task = step.parallel[taskIndex];
+        const status = nodeStatus(input, flatIndex);
+        childStatuses.push(status);
+        const childId = `step-${stepIndex}-agent-${taskIndex}`;
+        const child = {
+          id: childId,
+          kind: "agent",
+          agent: task.agent,
+          phase: task.phase,
+          label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
+          status,
+          flatIndex,
+          stepIndex,
+          outputName: task.as,
+          structured: Boolean(task.outputSchema),
+          acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
+          error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error
+        };
+        children.push(child);
+        pushPhase(phases, task.phase, childId);
+        if (status === "running" || input.currentFlatIndex === flatIndex)
+          currentNodeId = childId;
+        flatIndex++;
+      }
+      const groupStatus = summarizeParallelStatuses(childStatuses);
+      if (input.currentStepIndex === stepIndex && !currentNodeId)
+        currentNodeId = groupId;
+      nodes.push({
+        id: groupId,
+        kind: "parallel-group",
+        label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
+        status: groupStatus,
+        stepIndex,
+        children
+      });
+      continue;
+    }
+    if (isDynamicParallelStep(step)) {
+      const groupId = `step-${stepIndex}`;
+      const materialized = input.dynamicChildren?.[stepIndex] ?? [];
+      const groupOverride = input.dynamicGroupStatuses?.[stepIndex];
+      const children = [];
+      const childStatuses = [];
+      for (let taskIndex = 0;taskIndex < materialized.length; taskIndex++) {
+        const task = materialized[taskIndex];
+        const status = nodeStatus(input, task.flatIndex);
+        childStatuses.push(status);
+        const childId = `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
+        const child = {
+          id: childId,
+          kind: "agent",
+          agent: task.agent,
+          phase: step.parallel.phase ?? step.phase,
+          label: task.label?.trim() || step.parallel.label?.trim() || `${task.agent} ${task.itemKey}`,
+          status,
+          flatIndex: task.flatIndex,
+          stepIndex,
+          itemKey: task.itemKey,
+          outputName: task.outputName,
+          structured: task.structured,
+          acceptanceStatus: input.results?.[task.flatIndex]?.acceptance?.status,
+          error: input.stepStatuses?.[task.flatIndex]?.error ?? input.results?.[task.flatIndex]?.error ?? task.error
+        };
+        children.push(child);
+        pushPhase(phases, child.phase, childId);
+        if (status === "running" || input.currentFlatIndex === task.flatIndex)
+          currentNodeId = childId;
+      }
+      const groupStatus = groupOverride?.status ?? (children.length > 0 ? summarizeParallelStatuses(childStatuses) : input.currentStepIndex === stepIndex ? "running" : "pending");
+      if (input.currentStepIndex === stepIndex && !currentNodeId)
+        currentNodeId = groupId;
+      nodes.push({
+        id: groupId,
+        kind: "dynamic-parallel-group",
+        label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
+        status: groupStatus,
+        stepIndex,
+        outputName: step.collect.as,
+        structured: Boolean(step.collect.outputSchema),
+        acceptanceStatus: groupOverride?.acceptance?.status,
+        error: groupOverride?.error,
+        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
+      });
+      if (materialized.length > 0)
+        flatIndex = Math.max(flatIndex, ...materialized.map((child) => child.flatIndex + 1));
+      continue;
+    }
+    const seq = step;
+    const status = nodeStatus(input, flatIndex);
+    const id = `step-${stepIndex}`;
+    nodes.push({
+      id,
+      kind: "step",
+      agent: seq.agent,
+      phase: seq.phase,
+      label: seqLabel(seq, stepIndex),
+      status,
+      flatIndex,
+      stepIndex,
+      outputName: seq.as,
+      structured: Boolean(seq.outputSchema),
+      acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
+      error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error
+    });
+    pushPhase(phases, seq.phase, id);
+    if (status === "running" || input.currentFlatIndex === flatIndex || input.currentStepIndex === stepIndex)
+      currentNodeId = id;
+    flatIndex++;
+  }
+  return {
+    runId: input.runId,
+    mode: input.mode ?? "chain",
+    phases,
+    nodes,
+    currentNodeId
+  };
+}