@duckmind/dm-windows-x64 0.60.6 → 0.60.8

package/extensions/dm-subagents/src/runs/shared/nested-path.js

@@ -1 +1,41 @@
-import*as s from"node:path";var o=128,u=4;function f(n){return typeof n==="string"&&n.length>0&&n.length<=o&&!s.isAbsolute(n)&&!n.includes("/")&&!n.includes("\\")&&!n.includes("..")}function r(n){return typeof n==="number"&&Number.isFinite(n)?n:void 0}function i(n,t){return typeof n==="string"&&n.length>0?n.slice(0,t):void 0}function d(n){if(!Array.isArray(n))return[];return n.map((t)=>{if(!t||typeof t!=="object")return;let e=t;if(!f(e.runId))return;return{runId:e.runId,...r(e.stepIndex)!==void 0?{stepIndex:r(e.stepIndex)}:{},...i(e.agent,128)?{agent:i(e.agent,128)}:{}}}).filter((t)=>Boolean(t)).slice(0,u)}function c(n){if(!n)return[];try{return d(JSON.parse(n))}catch{return[]}}function p(n){let t=d(n);return t.length?JSON.stringify(t):""}export{d as sanitizeNestedPath,c as parseNestedPathEnv,f as isSafeNestedPathId,p as encodeNestedPathEnv,u as MAX_NESTED_PATH_ENTRIES};
+import * as path from "node:path";
+const MAX_NESTED_ID_LENGTH = 128;
+export const MAX_NESTED_PATH_ENTRIES = 4;
+export function isSafeNestedPathId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_NESTED_ID_LENGTH && !path.isAbsolute(value) && !value.includes("/") && !value.includes("\\") && !value.includes("..");
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function nonEmptyString(value, max) {
+  return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
+}
+export function sanitizeNestedPath(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((part) => {
+    if (!part || typeof part !== "object")
+      return;
+    const record = part;
+    if (!isSafeNestedPathId(record.runId))
+      return;
+    return {
+      runId: record.runId,
+      ...finiteNumber(record.stepIndex) !== undefined ? { stepIndex: finiteNumber(record.stepIndex) } : {},
+      ...nonEmptyString(record.agent, 128) ? { agent: nonEmptyString(record.agent, 128) } : {}
+    };
+  }).filter((part) => Boolean(part)).slice(0, MAX_NESTED_PATH_ENTRIES);
+}
+export function parseNestedPathEnv(value) {
+  if (!value)
+    return [];
+  try {
+    return sanitizeNestedPath(JSON.parse(value));
+  } catch {
+    return [];
+  }
+}
+export function encodeNestedPathEnv(value) {
+  const sanitized = sanitizeNestedPath(value);
+  return sanitized.length ? JSON.stringify(sanitized) : "";
+}

package/extensions/dm-subagents/src/runs/shared/nested-render.js

@@ -1 +1,105 @@
-import*as V from"node:os";import*as L from"node:path";function G($){return $.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function O($){let q=$?.env??process.env,J=$&&Object.hasOwn($,"getuid")?$.getuid:process.getuid?.bind(process);if(typeof J==="function")return`uid-${J()}`;for(let Y of["USERNAME","USER","LOGNAME"]){let X=q[Y];if(X)return`user-${G(X)}`}let Q=$&&Object.hasOwn($,"userInfo")?$.userInfo:V.userInfo;try{let Y=Q?.().username;if(Y)return`user-${G(Y)}`}catch{}let W=q.USERPROFILE??q.HOME;if(W)return`home-${G(W)}`;let A=$&&Object.hasOwn($,"homedir")?$.homedir:V.homedir;try{let Y=A?.();if(Y)return`home-${G(Y)}`}catch{}return"shared"}var K=L.join(V.tmpdir(),`dm-subagents-${O()}`),h=L.join(K,"async-subagent-results"),c=L.join(K,"async-subagent-runs"),I=L.join(K,"chain-runs"),n=L.join(K,"artifacts");function T($){return $<1000?String($):$<1e4?`${($/1000).toFixed(1)}k`:`${Math.round($/1000)}k`}function z($){if($<1000)return`${$}ms`;if($<60000)return`${($/1000).toFixed(1)}s`;return`${Math.floor($/60000)}m${Math.floor($%60000/1000)}s`}function M($){let q=process.env.HOME;if(q&&$.startsWith(q))return`~${$.slice(q.length)}`;return $}function C($){if($<1000)return"now";if($<60000)return`${Math.floor($/1000)}s`;return`${Math.floor($/60000)}m`}function E($,q,J=Date.now()){if($===void 0){if(q==="needs_attention")return"needs attention";if(q==="active_long_running")return"active but long-running";return}let Q=C(Math.max(0,J-$));if(q==="needs_attention")return`no activity for ${Q}`;if(q==="active_long_running")return`active but long-running · last activity ${Q} ago`;return Q==="now"?"active now":`active ${Q} ago`}function F($){let q={total:0,running:0,paused:0,complete:0,failed:0,queued:0};for(let J of $??[]){q.total++,q[J.state]++;let Q=F([...J.children??[],...J.steps?.flatMap((W)=>W.children??[])??[]]);q.total+=Q.total,q.running+=Q.running,q.paused+=Q.paused,q.complete+=Q.complete,q.failed+=Q.failed,q.queued+=Q.queued}return q}function j($){let q=F($);if(q.total===0)return;let J=[q.running>0?`${q.running} running`:"",q.paused>0?`${q.paused} paused`:"",q.failed>0?`${q.failed} failed`:"",q.complete>0?`${q.complete} complete`:"",q.queued>0?`${q.queued} queued`:""].filter(Boolean);return`+${q.total} nested run${q.total===1?"":"s"}${J.length?` (${J.join(", ")})`:""}`}function b($){if($.agent)return $.agent;if($.agents?.length)return $.agents.length===1?$.agents[0]:`${$.agents.slice(0,2).join(", ")}${$.agents.length>2?` +${$.agents.length-2}`:""}`;return $.id}function R($){let q=[];if($.currentTool&&$.currentToolStartedAt!==void 0)q.push(`tool ${$.currentTool} ${z(Math.max(0,Date.now()-$.currentToolStartedAt))}`);else if($.currentTool)q.push(`tool ${$.currentTool}`);if($.currentPath)q.push(M($.currentPath));if($.turnCount!==void 0)q.push(`${$.turnCount} turns`);if($.toolCount!==void 0)q.push(`${$.toolCount} tools`);if($.totalTokens)q.push(`${T($.totalTokens.total)} tok`);let J=E($.lastActivityAt,$.activityState);return J||q.length?[J,...q].filter(Boolean).join(" | "):void 0}function S($,q){let J=[],Q=(W,A,Y)=>{if(!W?.length||J.length>=q.maxLines)return;if(A>q.maxDepth){let X=j(W);if(X&&J.length<q.maxLines)J.push(`${Y}↳ ${X}`);return}for(let X=0;X<W.length;X++){let Z=W[X];if(J.length>=q.maxLines){let U=j(W.slice(X));if(U)J[J.length-1]=`${Y}↳ ${U}`;return}let _=Z.state==="running"?R(Z):void 0,N=Z.error?` | error: ${Z.error}`:"";if(J.push(`${Y}↳ ${b(Z)} [${Z.id}] ${Z.state}${_?` | ${_}`:""}${N}`),q.commandHints&&J.length<q.maxLines)J.push(`${Y}  Status: subagent({ action: "status", id: "${Z.id}" })`);if(A===q.maxDepth){let U=j([...Z.steps?.flatMap((B)=>B.children??[])??[],...Z.children??[]]);if(U&&J.length<q.maxLines)J.push(`${Y}  ↳ ${U}`);continue}for(let[U,B]of(Z.steps??[]).entries()){if(J.length>=q.maxLines)return;let H=B.status==="running"?R(B):void 0;J.push(`${Y}  ${U+1}. ${B.agent} ${B.status}${H?` | ${H}`:""}${B.error?` | error: ${B.error}`:""}`),Q(B.children,A+1,`${Y}    `)}Q(Z.children,A+1,`${Y}  `)}};return Q($,0,q.indent),J}function X$($,q={}){return S($,{indent:q.indent??"  ",maxDepth:q.maxDepth??2,maxLines:q.maxLines??40,commandHints:q.commandHints??!1})}export{X$ as formatNestedRunStatusLines,j as formatNestedAggregate,F as countNestedRuns};
+import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.js";
+import { formatActivityLabel } from "../../shared/status-format.js";
+export function countNestedRuns(children) {
+  const counts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, queued: 0 };
+  for (const child of children ?? []) {
+    counts.total++;
+    counts[child.state]++;
+    const nested = countNestedRuns([...child.children ?? [], ...child.steps?.flatMap((step) => step.children ?? []) ?? []]);
+    counts.total += nested.total;
+    counts.running += nested.running;
+    counts.paused += nested.paused;
+    counts.complete += nested.complete;
+    counts.failed += nested.failed;
+    counts.queued += nested.queued;
+  }
+  return counts;
+}
+export function formatNestedAggregate(children) {
+  const counts = countNestedRuns(children);
+  if (counts.total === 0)
+    return;
+  const parts = [
+    counts.running > 0 ? `${counts.running} running` : "",
+    counts.paused > 0 ? `${counts.paused} paused` : "",
+    counts.failed > 0 ? `${counts.failed} failed` : "",
+    counts.complete > 0 ? `${counts.complete} complete` : "",
+    counts.queued > 0 ? `${counts.queued} queued` : ""
+  ].filter(Boolean);
+  return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+}
+function nestedRunLabel(run) {
+  if (run.agent)
+    return run.agent;
+  if (run.agents?.length)
+    return run.agents.length === 1 ? run.agents[0] : `${run.agents.slice(0, 2).join(", ")}${run.agents.length > 2 ? ` +${run.agents.length - 2}` : ""}`;
+  return run.id;
+}
+function formatNestedActivity(input) {
+  const facts = [];
+  if (input.currentTool && input.currentToolStartedAt !== undefined)
+    facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
+  else if (input.currentTool)
+    facts.push(`tool ${input.currentTool}`);
+  if (input.currentPath)
+    facts.push(shortenPath(input.currentPath));
+  if (input.turnCount !== undefined)
+    facts.push(`${input.turnCount} turns`);
+  if (input.toolCount !== undefined)
+    facts.push(`${input.toolCount} tools`);
+  if (input.totalTokens)
+    facts.push(`${formatTokens(input.totalTokens.total)} tok`);
+  const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
+  return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
+}
+function formatNestedRunLines(children, options) {
+  const lines = [];
+  const append = (items, depth, indent) => {
+    if (!items?.length || lines.length >= options.maxLines)
+      return;
+    if (depth > options.maxDepth) {
+      const aggregate = formatNestedAggregate(items);
+      if (aggregate && lines.length < options.maxLines)
+        lines.push(`${indent}↳ ${aggregate}`);
+      return;
+    }
+    for (let index = 0;index < items.length; index++) {
+      const child = items[index];
+      if (lines.length >= options.maxLines) {
+        const aggregate = formatNestedAggregate(items.slice(index));
+        if (aggregate)
+          lines[lines.length - 1] = `${indent}↳ ${aggregate}`;
+        return;
+      }
+      const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
+      const error = child.error ? ` | error: ${child.error}` : "";
+      lines.push(`${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity ? ` | ${activity}` : ""}${error}`);
+      if (options.commandHints && lines.length < options.maxLines)
+        lines.push(`${indent}  Status: subagent({ action: "status", id: "${child.id}" })`);
+      if (depth === options.maxDepth) {
+        const aggregate = formatNestedAggregate([...child.steps?.flatMap((step) => step.children ?? []) ?? [], ...child.children ?? []]);
+        if (aggregate && lines.length < options.maxLines)
+          lines.push(`${indent}  ↳ ${aggregate}`);
+        continue;
+      }
+      for (const [stepIndex, step] of (child.steps ?? []).entries()) {
+        if (lines.length >= options.maxLines)
+          return;
+        const stepActivity = step.status === "running" ? formatNestedActivity(step) : undefined;
+        lines.push(`${indent}  ${stepIndex + 1}. ${step.agent} ${step.status}${stepActivity ? ` | ${stepActivity}` : ""}${step.error ? ` | error: ${step.error}` : ""}`);
+        append(step.children, depth + 1, `${indent}    `);
+      }
+      append(child.children, depth + 1, `${indent}  `);
+    }
+  };
+  append(children, 0, options.indent);
+  return lines;
+}
+export function formatNestedRunStatusLines(children, options = {}) {
+  return formatNestedRunLines(children, {
+    indent: options.indent ?? "  ",
+    maxDepth: options.maxDepth ?? 2,
+    maxLines: options.maxLines ?? 40,
+    commandHints: options.commandHints ?? false
+  });
+}

package/extensions/dm-subagents/src/runs/shared/parallel-utils.js

@@ -1,5 +1,82 @@
-function Q(q){return"parallel"in q&&Array.isArray(q.parallel)}function T(q){return"expand"in q&&"collect"in q&&"parallel"in q&&!Array.isArray(q.parallel)}function V(q){let H=[];for(let j of q)if(Q(j))for(let z of j.parallel)H.push(z);else if(T(j))continue;else H.push(j);return H}var W=20;class U{available;queue=[];constructor(q){this.available=Math.max(1,Math.floor(q)||1)}acquire(){if(this.available>0)return this.available--,Promise.resolve();return new Promise((q)=>{this.queue.push(q)})}release(){let q=this.queue.shift();if(q)q();else this.available++}}async function X(q,H,j,z){let K=Math.max(1,Math.floor(H)||1),I=Array(q.length),J=0;async function M(N){while(J<q.length){let B=J++;if(z){await z.acquire();try{I[B]=await j(q[B],B)}finally{z.release()}}else I[B]=await j(q[B],B)}}return await Promise.all(Array.from({length:Math.min(K,q.length)},(N,B)=>M(B))),I}function Y(q,H=(j,z)=>`=== Parallel Task ${j+1} (${z}) ===`){return q.map((j,z)=>{let K=H(j.taskIndex??z,j.agent),I=Boolean(j.output?.trim()),J=j.timedOut?`TIMED OUT${j.error?`: ${j.error}`:""}`:j.exitCode===-1?"SKIPPED":j.exitCode!==0&&j.exitCode!==null?`FAILED (exit code ${j.exitCode})${j.error?`: ${j.error}`:""}`:j.error?`WARNING: ${j.error}`:!I&&j.outputTargetPath&&j.outputTargetExists===!1?`EMPTY OUTPUT (expected output file missing: ${j.outputTargetPath})`:!I&&!j.outputTargetPath?"EMPTY OUTPUT (no textual response returned)":"",M=J?I?`${J}
-${j.output}`:J:j.output;return`${K}
-${M}`}).join(`
+export function isParallelGroup(step) {
+  return "parallel" in step && Array.isArray(step.parallel);
+}
+export function isDynamicRunnerGroup(step) {
+  return "expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel);
+}
+export function flattenSteps(steps) {
+  const flat = [];
+  for (const step of steps) {
+    if (isParallelGroup(step)) {
+      for (const task of step.parallel)
+        flat.push(task);
+    } else if (isDynamicRunnerGroup(step)) {
+      continue;
+    } else {
+      flat.push(step);
+    }
+  }
+  return flat;
+}
+export const DEFAULT_GLOBAL_CONCURRENCY_LIMIT = 20;
 
-`)}var Z=4;export{X as mapConcurrent,Q as isParallelGroup,T as isDynamicRunnerGroup,V as flattenSteps,Y as aggregateParallelOutputs,U as Semaphore,Z as MAX_PARALLEL_CONCURRENCY,W as DEFAULT_GLOBAL_CONCURRENCY_LIMIT};
+export class Semaphore {
+  available;
+  queue = [];
+  constructor(limit) {
+    this.available = Math.max(1, Math.floor(limit) || 1);
+  }
+  acquire() {
+    if (this.available > 0) {
+      this.available--;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.available++;
+    }
+  }
+}
+export async function mapConcurrent(items, limit, fn, globalSemaphore) {
+  const safeLimit = Math.max(1, Math.floor(limit) || 1);
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker(_workerIndex) {
+    while (next < items.length) {
+      const i = next++;
+      if (globalSemaphore) {
+        await globalSemaphore.acquire();
+        try {
+          results[i] = await fn(items[i], i);
+        } finally {
+          globalSemaphore.release();
+        }
+      } else {
+        results[i] = await fn(items[i], i);
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)));
+  return results;
+}
+export function aggregateParallelOutputs(results, headerFormat = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`) {
+  return results.map((r, i) => {
+    const header = headerFormat(r.taskIndex ?? i, r.agent);
+    const hasOutput = Boolean(r.output?.trim());
+    const status = r.timedOut ? `TIMED OUT${r.error ? `: ${r.error}` : ""}` : r.exitCode === -1 ? "SKIPPED" : r.exitCode !== 0 && r.exitCode !== null ? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}` : r.error ? `WARNING: ${r.error}` : !hasOutput && r.outputTargetPath && r.outputTargetExists === false ? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})` : !hasOutput && !r.outputTargetPath ? "EMPTY OUTPUT (no textual response returned)" : "";
+    const body = status ? hasOutput ? `${status}
+${r.output}` : status : r.output;
+    return `${header}
+${body}`;
+  }).join(`
+
+`);
+}
+export const MAX_PARALLEL_CONCURRENCY = 4;

package/extensions/dm-subagents/src/runs/shared/run-history.js

@@ -1,5 +1,52 @@
-import*as q from"node:fs";import*as _ from"node:path";import*as W from"node:fs";import*as G from"node:os";import*as X from"node:path";import*as U from"node:os";import*as V from"node:path";function j(Q){return Q.trim().replace(/[^A-Za-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function E(Q){let Y=Q?.env??process.env,J=Q&&Object.hasOwn(Q,"getuid")?Q.getuid:process.getuid?.bind(process);if(typeof J==="function")return`uid-${J()}`;for(let B of["USERNAME","USER","LOGNAME"]){let L=Y[B];if(L)return`user-${j(L)}`}let Z=Q&&Object.hasOwn(Q,"userInfo")?Q.userInfo:U.userInfo;try{let B=Z?.().username;if(B)return`user-${j(B)}`}catch{}let $=Y.USERPROFILE??Y.HOME;if($)return`home-${j($)}`;let K=Q&&Object.hasOwn(Q,"homedir")?Q.homedir:U.homedir;try{let B=K?.();if(B)return`home-${j(B)}`}catch{}return"shared"}var z=V.join(U.tmpdir(),`dm-subagents-${E()}`),v=V.join(z,"async-subagent-results"),P=V.join(z,"async-subagent-runs"),O=V.join(z,"chain-runs"),f=V.join(z,"artifacts");var T=".dm",N="@duckmind/dm-coding-agent",R="DM_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT";function F(Q){return typeof Q==="string"&&Q.trim()?Q:void 0}function A(Q){if(!Q)return;try{let Y=JSON.parse(W.readFileSync(X.join(Q,"package.json"),"utf-8"));if(Y.name!==N)return;return F(Y.piConfig?.configDir)}catch{return}}function I(Q=process.argv[1],Y=process.env[R]){let J=A(Y);if(J)return J;if(!Q)return;try{let Z=X.dirname(W.realpathSync(Q));while(Z!==X.dirname(Z)){let $=A(Z);if($)return $;Z=X.dirname(Z)}}catch{}return}function C(Q,Y,J){return(Q&&typeof Q==="object"?F(Q.CONFIG_DIR_NAME):void 0)??I(Y,J)??T}function b(){return C()}function H(){let Q=process.env.DM_CODING_AGENT_DIR;if(Q==="~")return G.homedir();if(Q?.startsWith("~/"))return X.join(G.homedir(),Q.slice(2));return Q||X.join(G.homedir(),b(),"agent")}var w=1200,S=1000;function M(){return _.join(H(),"run-history.jsonl")}function WQ(Q,Y,J,Z){try{let $={agent:Q,task:Y.slice(0,200),ts:Math.floor(Date.now()/1000),status:J===0?"ok":"error",duration:Z,...J!==0?{exit:J}:{}},K=M();q.mkdirSync(_.dirname(K),{recursive:!0}),q.appendFileSync(K,`${JSON.stringify($)}
-`)}catch{}}function XQ(Q){let Y=M();if(!q.existsSync(Y))return[];let J;try{J=q.readFileSync(Y,"utf-8")}catch{return[]}let Z=J.split(`
-`).map(($)=>$.trim()).filter(($)=>$.length>0);if(Z.length>w){Z=Z.slice(-S);try{q.writeFileSync(Y,`${Z.join(`
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "../../shared/utils.js";
+const ROTATE_READ_THRESHOLD = 1200;
+const ROTATE_KEEP = 1000;
+function getHistoryPath() {
+  return path.join(getAgentDir(), "run-history.jsonl");
+}
+export function recordRun(agent, task, exitCode, durationMs) {
+  try {
+    const entry = {
+      agent,
+      task: task.slice(0, 200),
+      ts: Math.floor(Date.now() / 1000),
+      status: exitCode === 0 ? "ok" : "error",
+      duration: durationMs,
+      ...exitCode !== 0 ? { exit: exitCode } : {}
+    };
+    const historyPath = getHistoryPath();
+    fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+    fs.appendFileSync(historyPath, `${JSON.stringify(entry)}
+`);
+  } catch {}
+}
+export function loadRunsForAgent(agent) {
+  const historyPath = getHistoryPath();
+  if (!fs.existsSync(historyPath))
+    return [];
+  let raw;
+  try {
+    raw = fs.readFileSync(historyPath, "utf-8");
+  } catch {
+    return [];
+  }
+  let lines = raw.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length > ROTATE_READ_THRESHOLD) {
+    lines = lines.slice(-ROTATE_KEEP);
+    try {
+      fs.writeFileSync(historyPath, `${lines.join(`
 `)}
-`,"utf-8")}catch{}}return Z.map(($)=>{try{return JSON.parse($)}catch{return}}).filter(($)=>Boolean($)&&$.agent===Q).reverse()}export{WQ as recordRun,XQ as loadRunsForAgent};
+`, "utf-8");
+    } catch {}
+  }
+  return lines.map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return;
+    }
+  }).filter((entry) => Boolean(entry) && entry.agent === agent).reverse();
+}

package/extensions/dm-subagents/src/runs/shared/single-output.js

@@ -1,14 +1,155 @@
-import*as K from"node:fs";import*as H from"node:path";function Y(j,A){if(j===!1||j==="false")return!1;if(j===!0||j==="true")return A;if(typeof j==="string"&&j.length>0)return j;return}function Z(j,A,E,G){if(typeof j!=="string"||!j||j==="false"||j==="true")return;if(H.isAbsolute(j))return j;if(G)return H.resolve(G,j);let J=E?H.isAbsolute(E)?E:H.resolve(A,E):A;return H.resolve(J,j)}function Q(j){return[`Write your findings to exactly this path: ${j}`,"This path is authoritative for this run.","Ignore any other output filename or output path mentioned elsewhere, including output destinations in the base agent prompt, system prompt, or task instructions."].join(`
-`)}function _(j,A){if(!A)return j;return`${j}
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function normalizeSingleOutputOverride(output, defaultOutput) {
+  if (output === false || output === "false")
+    return false;
+  if (output === true || output === "true")
+    return defaultOutput;
+  if (typeof output === "string" && output.length > 0)
+    return output;
+  return;
+}
+export function resolveSingleOutputPath(output, runtimeCwd, requestedCwd, relativeBaseDir) {
+  if (typeof output !== "string" || !output || output === "false" || output === "true")
+    return;
+  if (path.isAbsolute(output))
+    return output;
+  if (relativeBaseDir)
+    return path.resolve(relativeBaseDir, output);
+  const baseCwd = requestedCwd ? path.isAbsolute(requestedCwd) ? requestedCwd : path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+  return path.resolve(baseCwd, output);
+}
+function formatOutputPathInstruction(outputPath) {
+  return [
+    `Write your findings to exactly this path: ${outputPath}`,
+    "This path is authoritative for this run.",
+    "Ignore any other output filename or output path mentioned elsewhere, including output destinations in the base agent prompt, system prompt, or task instructions."
+  ].join(`
+`);
+}
+export function injectSingleOutputInstruction(task, outputPath) {
+  if (!outputPath)
+    return task;
+  return `${task}
 
 ---
 **Output:**
-${Q(A)}`}function $(j,A){if(!A)return j;let E=`Runtime output path override:
-${Q(A)}`;return j?`${j}
+${formatOutputPathInstruction(outputPath)}`;
+}
+export function injectOutputPathSystemPrompt(systemPrompt, outputPath) {
+  if (!outputPath)
+    return systemPrompt;
+  const instruction = `Runtime output path override:
+${formatOutputPathInstruction(outputPath)}`;
+  return systemPrompt ? `${systemPrompt}
 
-${E}`:E}function U(j){if(!j)return 0;return(j.match(/\r\n|\r|\n/g)?.length??0)+(/[\r\n]$/.test(j)?0:1)}function V(j){if(j<1024)return`${j} B`;let A=["KB","MB","GB","TB"],E=j/1024,G=0;while(E>=1024&&G<A.length-1)E/=1024,G++;return`${E.toFixed(1)} ${A[G]}`}function W(j,A){let E=H.resolve(j),G=Buffer.byteLength(A,"utf-8"),J=U(A);return{path:E,bytes:G,lines:J,message:`Output saved to: ${E} (${V(G)}, ${J} ${J===1?"line":"lines"}). Read this file if needed.`}}function z(j,A,E){if(j==="file-only"&&!A)return`${E} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;return}function L(j){if(!j)return;try{let A=K.statSync(j);return{exists:!0,mtimeMs:A.mtimeMs,size:A.size}}catch{return{exists:!1}}}function X(j,A){if(!j)return{};try{return K.mkdirSync(H.dirname(j),{recursive:!0}),K.writeFileSync(j,A,"utf-8"),{savedPath:j}}catch(E){return{error:E instanceof Error?E.message:String(E)}}}function T(j,A,E){if(!j)return{fullOutput:A};let G=!1;try{let F=K.statSync(j);G=!E?.exists||F.mtimeMs!==E.mtimeMs||F.size!==E.size}catch(F){let N=F&&typeof F==="object"&&"code"in F?F.code:void 0;if(N!=="ENOENT"&&N!=="ENOTDIR")return{fullOutput:A,saveError:`Failed to inspect output file: ${F instanceof Error?F.message:String(F)}`}}if(G)try{return{fullOutput:K.readFileSync(j,"utf-8"),savedPath:j}}catch(F){return{fullOutput:A,saveError:`Failed to read changed output file: ${F instanceof Error?F.message:String(F)}`}}let J=X(j,A);if(J.savedPath)return{fullOutput:A,savedPath:J.savedPath};return{fullOutput:A,saveError:J.error}}function M(j){let A=j.truncatedOutput||j.fullOutput;if(j.exitCode===0&&j.savedPath){let E=j.outputReference??W(j.savedPath,j.fullOutput);if(j.outputMode==="file-only")return{displayOutput:E.message,savedPath:j.savedPath,outputReference:E};return A+=`
+${instruction}` : instruction;
+}
+function countLines(text) {
+  if (!text)
+    return 0;
+  const newlineMatches = text.match(/\r\n|\r|\n/g);
+  return (newlineMatches?.length ?? 0) + (/[\r\n]$/.test(text) ? 0 : 1);
+}
+function formatByteSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+export function formatSavedOutputReference(savedPath, fullOutput) {
+  const absolutePath = path.resolve(savedPath);
+  const bytes = Buffer.byteLength(fullOutput, "utf-8");
+  const lines = countLines(fullOutput);
+  return {
+    path: absolutePath,
+    bytes,
+    lines,
+    message: `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`
+  };
+}
+export function validateFileOnlyOutputMode(outputMode, outputPath, context) {
+  if (outputMode === "file-only" && !outputPath) {
+    return `${context} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;
+  }
+  return;
+}
+export function captureSingleOutputSnapshot(outputPath) {
+  if (!outputPath)
+    return;
+  try {
+    const stat = fs.statSync(outputPath);
+    return { exists: true, mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return { exists: false };
+  }
+}
+function persistSingleOutput(outputPath, fullOutput) {
+  if (!outputPath)
+    return {};
+  try {
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, fullOutput, "utf-8");
+    return { savedPath: outputPath };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+export function resolveSingleOutput(outputPath, fallbackOutput, beforeRun) {
+  if (!outputPath)
+    return { fullOutput: fallbackOutput };
+  let changedSinceStart = false;
+  try {
+    const stat = fs.statSync(outputPath);
+    changedSinceStart = !beforeRun?.exists || stat.mtimeMs !== beforeRun.mtimeMs || stat.size !== beforeRun.size;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      return {
+        fullOutput: fallbackOutput,
+        saveError: `Failed to inspect output file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  if (changedSinceStart) {
+    try {
+      return { fullOutput: fs.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
+    } catch (error) {
+      return {
+        fullOutput: fallbackOutput,
+        saveError: `Failed to read changed output file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  const save = persistSingleOutput(outputPath, fallbackOutput);
+  if (save.savedPath)
+    return { fullOutput: fallbackOutput, savedPath: save.savedPath };
+  return { fullOutput: fallbackOutput, saveError: save.error };
+}
+export function finalizeSingleOutput(params) {
+  let displayOutput = params.truncatedOutput || params.fullOutput;
+  if (params.exitCode === 0 && params.savedPath) {
+    const outputReference = params.outputReference ?? formatSavedOutputReference(params.savedPath, params.fullOutput);
+    if (params.outputMode === "file-only") {
+      return { displayOutput: outputReference.message, savedPath: params.savedPath, outputReference };
+    }
+    displayOutput += `
 
-${E.message}`,{displayOutput:A,savedPath:j.savedPath,outputReference:E}}if(j.exitCode===0&&j.saveError&&j.outputPath)return A+=`
+${outputReference.message}`;
+    return { displayOutput, savedPath: params.savedPath, outputReference };
+  }
+  if (params.exitCode === 0 && params.saveError && params.outputPath) {
+    displayOutput += `
 
-Output file error: ${j.outputPath}
-${j.saveError}`,{displayOutput:A,saveError:j.saveError};return{displayOutput:A}}export{z as validateFileOnlyOutputMode,Z as resolveSingleOutputPath,T as resolveSingleOutput,Y as normalizeSingleOutputOverride,_ as injectSingleOutputInstruction,$ as injectOutputPathSystemPrompt,W as formatSavedOutputReference,M as finalizeSingleOutput,L as captureSingleOutputSnapshot};
+Output file error: ${params.outputPath}
+${params.saveError}`;
+    return { displayOutput, saveError: params.saveError };
+  }
+  return { displayOutput };
+}

package/extensions/dm-subagents/src/runs/shared/structured-output.js

@@ -1 +1,58 @@
-import*as e from"node:fs";import*as i from"node:os";import*as a from"node:path";import{Compile as c}from"typebox/compile";var h="DM_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA",S="DM_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";function p(t,r="outputSchema"){if(!t||typeof t!=="object"||Array.isArray(t))throw Error(`${r} must be a JSON Schema object.`)}function l(t,r){p(t);let s=r??i.tmpdir();e.mkdirSync(s,{recursive:!0});let u=e.mkdtempSync(a.join(s,"dm-subagent-structured-")),n=a.join(u,"schema.json"),o=a.join(u,"output.json");return e.writeFileSync(n,JSON.stringify(t),{mode:384}),{schema:t,schemaPath:n,outputPath:o}}function m(t,r){let s;try{s=c(t)}catch(n){return{status:"invalid",message:`invalid outputSchema: ${n instanceof Error?n.message:String(n)}`}}if(s.Check(r))return{status:"valid"};return{status:"invalid",message:[...s.Errors(r)].slice(0,8).map((n)=>{return`${n.instancePath?n.instancePath.replace(/^\//,"").replace(/\//g,"."):"root"}: ${n.message}`}).join("; ")||"schema validation failed"}}function f(t){if(!e.existsSync(t.outputPath))return{error:"Missing structured_output call; this step has outputSchema and must finish by calling structured_output."};let r;try{r=JSON.parse(e.readFileSync(t.outputPath,"utf-8"))}catch(u){return{error:`Failed to read structured output: ${u instanceof Error?u.message:String(u)}`}}let s=m(t.schema,r);if(s.status==="invalid")return{error:`Structured output validation failed: ${s.message}`};return{value:r}}function g(t){if(!t)return;try{e.rmSync(a.dirname(t.schemaPath),{recursive:!0,force:!0})}catch{}}export{m as validateStructuredOutputValue,f as readStructuredOutput,l as createStructuredOutputRuntime,g as cleanupStructuredOutputRuntime,p as assertJsonSchemaObject,h as STRUCTURED_OUTPUT_SCHEMA_ENV,S as STRUCTURED_OUTPUT_CAPTURE_ENV};
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Compile } from "typebox/compile";
+export const STRUCTURED_OUTPUT_SCHEMA_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
+export const STRUCTURED_OUTPUT_CAPTURE_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
+export function assertJsonSchemaObject(schema, label = "outputSchema") {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    throw new Error(`${label} must be a JSON Schema object.`);
+  }
+}
+export function createStructuredOutputRuntime(schema, baseDir) {
+  assertJsonSchemaObject(schema);
+  const rootDir = baseDir ?? os.tmpdir();
+  fs.mkdirSync(rootDir, { recursive: true });
+  const dir = fs.mkdtempSync(path.join(rootDir, "dm-subagent-structured-"));
+  const schemaPath = path.join(dir, "schema.json");
+  const outputPath = path.join(dir, "output.json");
+  fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 384 });
+  return { schema, schemaPath, outputPath };
+}
+export function validateStructuredOutputValue(schema, value) {
+  let validator;
+  try {
+    validator = Compile(schema);
+  } catch (error) {
+    return { status: "invalid", message: `invalid outputSchema: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (validator.Check(value))
+    return { status: "valid" };
+  const errors = [...validator.Errors(value)].slice(0, 8).map((error) => {
+    const pathText = error.instancePath ? error.instancePath.replace(/^\//, "").replace(/\//g, ".") : "root";
+    return `${pathText}: ${error.message}`;
+  });
+  return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
+}
+export function readStructuredOutput(runtime) {
+  if (!fs.existsSync(runtime.outputPath)) {
+    return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
+  }
+  let value;
+  try {
+    value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8"));
+  } catch (error) {
+    return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const validation = validateStructuredOutputValue(runtime.schema, value);
+  if (validation.status === "invalid")
+    return { error: `Structured output validation failed: ${validation.message}` };
+  return { value };
+}
+export function cleanupStructuredOutputRuntime(runtime) {
+  if (!runtime)
+    return;
+  try {
+    fs.rmSync(path.dirname(runtime.schemaPath), { recursive: true, force: true });
+  } catch {}
+}