@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/shared/required-child-extensions.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const MAX_REQUIRED_EXTENSIONS = 32;
+const MAX_PATH_BYTES = 4096;
+const EMPTY_SNAPSHOT = Object.freeze([]);
+export function snapshotRequiredChildExtensions(value, label = "Required child extensions", canonicalizeFiles = false) {
+  if (!Array.isArray(value) || value.length > MAX_REQUIRED_EXTENSIONS)
+    throw new Error(`${label} must be an array of at most ${MAX_REQUIRED_EXTENSIONS} entries.`);
+  const ids = new Set;
+  const paths = new Set;
+  return Object.freeze(value.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry) || Object.keys(entry).some((key) => key !== "id" && key !== "path"))
+      throw new Error(`${label} entry ${index} requires only id and path.`);
+    const id = "id" in entry ? entry.id : undefined;
+    const rawPath = "path" in entry ? entry.path : undefined;
+    if (typeof id !== "string" || !ID_PATTERN.test(id))
+      throw new Error(`${label} entry ${index} requires a safe id of at most 128 characters.`);
+    if (ids.has(id))
+      throw new Error(`${label} id '${id}' is duplicated.`);
+    if (typeof rawPath !== "string" || !rawPath.trim() || rawPath.includes("\x00") || Buffer.byteLength(rawPath, "utf8") > MAX_PATH_BYTES || !canonicalizeFiles && !path.isAbsolute(rawPath))
+      throw new Error(`${label} '${id}' requires ${canonicalizeFiles ? "a" : "an absolute"} non-empty path of at most ${MAX_PATH_BYTES} bytes without NUL.`);
+    let extensionPath = rawPath;
+    if (canonicalizeFiles) {
+      try {
+        extensionPath = fs.realpathSync(path.resolve(rawPath));
+        if (!fs.statSync(extensionPath).isFile())
+          throw new Error("not a file");
+      } catch (error) {
+        throw new Error(`${label} '${id}' is not an importable file: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (paths.has(extensionPath))
+      throw new Error(`${label} path '${extensionPath}' is duplicated.`);
+    ids.add(id);
+    paths.add(extensionPath);
+    return Object.freeze({ id, path: extensionPath });
+  }));
+}
+function registry() {
+  const key = Symbol.for("dm-subagents.required-child-extensions.v1");
+  const root = globalThis;
+  const existing = root[key];
+  if (existing === undefined) {
+    const created = { version: 1, bySession: new Map };
+    root[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || !("version" in existing) || existing.version !== 1 || !("bySession" in existing) || !(existing.bySession instanceof Map))
+    throw new Error("Malformed or unsupported required child extension registry.");
+  return { version: 1, bySession: existing.bySession };
+}
+export function registerRequiredChildExtensions(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => key !== "sessionId" && key !== "extensions"))
+    throw new Error("Required child extension registration requires only sessionId and extensions.");
+  if (typeof input.sessionId !== "string" || !input.sessionId || input.sessionId.trim() !== input.sessionId || input.sessionId.length > 256 || input.sessionId.includes("\x00"))
+    throw new Error("Required child extension registration requires a non-empty trimmed sessionId of at most 256 characters without NUL.");
+  const frozen = snapshotRequiredChildExtensions(input.extensions, "Required child extensions", true);
+  const store = registry();
+  if (store.bySession.has(input.sessionId))
+    throw new Error(`Required child extensions are already registered for session '${input.sessionId}'; dispose them first.`);
+  store.bySession.set(input.sessionId, frozen);
+  return { dispose() {
+    if (store.bySession.get(input.sessionId) === frozen)
+      store.bySession.delete(input.sessionId);
+  } };
+}
+export function resolveRequiredChildExtensions(sessionId) {
+  if (!sessionId)
+    return EMPTY_SNAPSHOT;
+  return registry().bySession.get(sessionId) ?? EMPTY_SNAPSHOT;
+}

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

@@ -1,5 +1,3 @@
-import { Key } from "@duckmind/dm-tui";
-export const FLEET_OPEN_SHORTCUT = Key.ctrlAlt("f");
 export function formatShortcutLabel(shortcut) {
   return shortcut.split("+").map((part) => {
     const normalized = part.trim().toLowerCase();

package/extensions/dm-subagents/src/shared/thinking-ceiling.js

@@ -1,5 +1,4 @@
 import { resolveEffectiveThinking, THINKING_LEVELS } from "./model-info.js";
-export const SUBAGENT_THINKING_CEILING_ENV = "DM_SUBAGENT_THINKING_CEILING";
 const thinkingLevelRanks = new Map(THINKING_LEVELS.map((level, index) => [level, index]));
 export function parseThinkingLevel(value, field = "thinking level") {
   if (typeof value === "string") {
@@ -22,11 +21,6 @@ export function intersectThinkingCeilings(...ceilings) {
     return;
   return active.reduce((lowest, ceiling) => compareThinkingLevels(ceiling, lowest) < 0 ? ceiling : lowest);
 }
-export function decodeThinkingCeiling(value) {
-  if (value === undefined || value === "")
-    return;
-  return parseThinkingLevel(value, "inherited thinking ceiling");
-}
 export function assertThinkingWithinCeiling(input) {
   if (!input.ceiling)
     return;

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

@@ -3,6 +3,7 @@ import * as path from "node:path";
 export const SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 3;
 export const INTERCOM_DETACH_REQUEST_EVENT = "dm-intercom:detach-request";
 export const INTERCOM_DETACH_RESPONSE_EVENT = "dm-intercom:detach-response";
+export const INTERCOM_SESSION_IDENTITY_EVENT = "intercom:session-identity";
 export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
 export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
 export const SUBAGENT_PROCESS_TERMINAL_EVENT = "subagent:process-terminal";
@@ -101,7 +102,7 @@ export const POLL_INTERVAL_MS = 250;
 export const WIDGET_ANIMATION_INTERVAL_MS = 1000;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
-export const SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "validate", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "worktree.cleanup", "lane.status", "lane.recordMerge", "lane.recordSupersession", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "debug.run", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "dismiss", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"];
+export const SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "validate", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "worktree.cleanup", "lane.status", "lane.recordMerge", "lane.recordSupersession", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.command", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "debug.run", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "dismiss", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"];
 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;
@@ -139,26 +140,29 @@ function normalizeNonNegativeInteger(value) {
 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 const SUBAGENT_MAX_DEPTH_ENV = "DM_SUBAGENT_MAX_DEPTH";
+export function resolveCurrentMaxSubagentDepth(configMaxDepth, runtime) {
+  return normalizeMaxSubagentDepth(runtime ? runtime.maxDepth : process.env[SUBAGENT_MAX_DEPTH_ENV]) ?? 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;
+export function resolveCurrentSubagentDepth(runtime) {
+  const depth = runtime ? runtime.depth : 0;
+  return Number.isFinite(depth) ? depth : 0;
+}
+export function checkSubagentDepth(configMaxDepth, runtime) {
+  const depth = resolveCurrentSubagentDepth(runtime);
+  const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth, runtime);
+  const blocked = 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;
+export function resolveChildDepth(maxDepth, runtime) {
   return {
-    DM_SUBAGENT_DEPTH: String(nextDepth),
-    DM_SUBAGENT_MAX_DEPTH: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth())
+    depth: resolveCurrentSubagentDepth(runtime) + 1,
+    maxDepth: normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth(undefined, runtime)
   };
 }
 export function normalizeMaxSubagentSpawnsPerSession(value) {

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

@@ -102,6 +102,9 @@ function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 export function readStatus(asyncDir) {
+  if (Buffer.byteLength(path.basename(asyncDir), "utf-8") > 255) {
+    return null;
+  }
   const statusPath = path.join(asyncDir, "status.json");
   let stat;
   try {
@@ -191,6 +194,10 @@ export function findLatestSessionFile(sessionDir) {
   const latest = files[0];
   return latest ? latest.path : null;
 }
+const PI_TURN_TIMING_FOOTER = /(?:\r?\n)*\x1b\[38;2;136;136;136m✻ Turn took [^()\r\n]+ \(Total time [^·\r\n]+ · \d+ turns?\)\x1b\[0m[ \t]*$/u;
+function stripPiTurnTimingFooter(text) {
+  return text.replace(PI_TURN_TIMING_FOOTER, "");
+}
 export function getFinalOutput(messages) {
   const validTextParts = [];
   for (let i = messages.length - 1;i >= 0; i--) {
@@ -200,22 +207,30 @@ export function getFinalOutput(messages) {
     const hasAssistantError = "errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0 || "stopReason" in msg && msg.stopReason === "error";
     if (hasAssistantError)
       continue;
-    const messageText = msg.content.filter((part) => part.type === "text" && part.text.trim().length > 0).map((part) => part.type === "text" ? part.text : "").join(`
+    const messageText = msg.content.flatMap((part) => {
+      if (part.type !== "text")
+        return [];
+      const text = stripPiTurnTimingFooter(part.text);
+      return text.trim().length > 0 ? [text] : [];
+    }).join(`
 `);
     for (let j = msg.content.length - 1;j >= 0; j--) {
       const part = msg.content[j];
-      if (!part || part.type !== "text" || part.text.trim().length === 0)
+      if (!part || part.type !== "text")
+        continue;
+      const text = stripPiTurnTimingFooter(part.text);
+      if (text.trim().length === 0)
         continue;
-      validTextParts.push(part.text);
-      if (/```acceptance[-_]report\s*\n[\s\S]*?```/i.test(part.text))
+      validTextParts.push(text);
+      if (/```acceptance[-_]report\s*\n[\s\S]*?```/i.test(text))
         return messageText;
-      for (const match of part.text.matchAll(/```(?:json|jsonc|json5)\s*\n([\s\S]*?)```/gi)) {
+      for (const match of text.matchAll(/```(?:json|jsonc|json5)\s*\n([\s\S]*?)```/gi)) {
         const body = match[1] ?? "";
         if (/"(?:criteriaSatisfied|criteria_satisfied)"/.test(body) && /"(?:changedFiles|changed_files|testsAddedOrUpdated|tests_added_or_updated|commandsRun|commands_run|validationOutput|validation_output|residualRisks|residual_risks|noStagedFiles|no_staged_files|diffSummary|diff_summary|reviewFindings|review_findings|manualNotes|manual_notes)"/.test(body)) {
           return messageText;
         }
       }
-      if (/ACCEPTANCE_REPORT\s*:/i.test(part.text))
+      if (/ACCEPTANCE_REPORT\s*:/i.test(text))
         return messageText;
     }
   }
@@ -360,7 +375,7 @@ export function boundStreamedToolCalls(result) {
 }
 export function hasEmptyTerminalAssistantResponse(messages) {
   const lastAssistant = messages.findLast((message) => message.role === "assistant");
-  return lastAssistant?.role === "assistant" && Array.isArray(lastAssistant.content) && lastAssistant.content.length === 0 && lastAssistant.usage.output === 0;
+  return lastAssistant?.role === "assistant" && Array.isArray(lastAssistant.content) && (lastAssistant.content.length === 0 && lastAssistant.usage.output === 0 || messages.at(-1) === lastAssistant && lastAssistant.stopReason === "stop" && !lastAssistant.errorMessage && lastAssistant.content.length > 0 && lastAssistant.content.every((part) => part.type === "text" && part.text === ""));
 }
 export function formatEmptyTerminalAssistantResponseError(messages) {
   const lastAssistant = messages.findLast((message) => message.role === "assistant");

package/extensions/dm-subagents/src/shared/watch-strategy.js

@@ -1,3 +1,5 @@
 export function shouldUseNativeFsWatch(_purpose, platform = process.platform) {
+  if (_purpose === "retained-nested-route-tracker" && platform === "win32")
+    return false;
   return platform !== "darwin";
 }

package/extensions/dm-subagents/src/shared/workflow-child-permit.js

@@ -82,3 +82,73 @@ export function workflowChildPermitConsumed(permit) {
   const state = records.get(permit)?.state;
   return state === "claimed" || state === "consumed";
 }
+const resourceRecords = new WeakMap;
+function cloneWorkflowResourceAuthority(authority) {
+  if (!authority || typeof authority !== "object" || Array.isArray(authority))
+    throw new Error("Workflow resource authority must be an object.");
+  if (authority.host === undefined)
+    return Object.freeze({});
+  if (!Array.isArray(authority.host) || authority.host.length > 32)
+    throw new Error("Workflow resource host authority must be an array of at most 32 grants.");
+  const keys = new Set;
+  const host = Array.from(authority.host, (grant) => {
+    if (!grant || typeof grant !== "object" || Object.keys(grant).some((field) => field !== "key" && field !== "command"))
+      throw new Error("Workflow resource host grant must contain only key and command.");
+    const { key, command } = grant;
+    if (typeof key !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(key) || keys.has(key))
+      throw new Error("Workflow resource host grant requires a unique safe key.");
+    if (typeof command !== "string" || !command.trim() || Buffer.byteLength(command.trim(), "utf8") > 16 * 1024 || command.includes("\x00"))
+      throw new Error("Workflow resource host grant requires a non-empty command of at most 16384 bytes without NUL.");
+    keys.add(key);
+    return Object.freeze({ key, command: command.trim() });
+  });
+  return Object.freeze({ host: Object.freeze(host) });
+}
+export function createWorkflowResourcePermit(input) {
+  const resourceName = required(input.resourceName, "resourceName");
+  const resourceId = required(input.resourceId, "resourceId");
+  const scriptDigest = required(input.scriptDigest, "scriptDigest");
+  if (!Number.isInteger(input.resourceVersion) || input.resourceVersion < 1)
+    throw new Error("resourceVersion must be a positive integer.");
+  const authority = cloneWorkflowResourceAuthority(input.authority);
+  const permit = Object.freeze(Object.create(null));
+  resourceRecords.set(permit, {
+    resourceName,
+    resourceVersion: input.resourceVersion,
+    resourceId,
+    scriptDigest,
+    authority,
+    provenance: Object.freeze({
+      kind: "workflow",
+      name: resourceName,
+      version: input.resourceVersion,
+      invocation: "named",
+      expansion: "resolved",
+      id: resourceId
+    }),
+    state: "available"
+  });
+  return permit;
+}
+export function consumeWorkflowResourcePermit(permit, script) {
+  const record = resourceRecords.get(permit);
+  if (!record)
+    return "Workflow resource permit is invalid.";
+  if (record.state !== "available")
+    return "Workflow resource permit is already consumed.";
+  if (stableJsonDigest(script) !== record.scriptDigest)
+    return "Workflow resource permit does not match the resolved workflow script.";
+  record.state = "consumed";
+  return { provenance: record.provenance, authority: record.authority };
+}
+export function authorizeWorkflowResourceHost(permit, key, command) {
+  const record = resourceRecords.get(permit);
+  if (!record || record.state !== "consumed")
+    return "Workflow resource authority is unavailable.";
+  const host = record.authority.host;
+  if (!host)
+    return "runs.host is not allowed for this workflow resource.";
+  if (!host.some((grant) => grant.key === key && grant.command === command.trim()))
+    return `The command for runs.host('${key}') is not allowed for workflow resource '${record.resourceName}'.`;
+  return;
+}

package/extensions/dm-subagents/src/slash/delegation-adapters.js

@@ -102,6 +102,17 @@ function buildDelegationMessages(result, fallbackText) {
     return [];
   return [{ role: "assistant", content }];
 }
+function isFiniteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function buildDelegationUpdateUsage(entry) {
+  if (!entry)
+    return;
+  const { inputTokens, outputTokens, cacheRead, cacheWrite, turnCount } = entry;
+  if (!isFiniteNonNegative(inputTokens) || !isFiniteNonNegative(outputTokens) || !isFiniteNonNegative(cacheRead) || !isFiniteNonNegative(cacheWrite) || !isFiniteNonNegative(turnCount))
+    return;
+  return { input: inputTokens, output: outputTokens, cacheRead, cacheWrite, turns: turnCount };
+}
 export function toDelegationUpdate(requestId, update) {
   const progress = update.details?.progress?.[0];
   const taskProgress = update.details?.progress?.map((entry) => {
@@ -136,6 +147,7 @@ export function toDelegationUpdate(requestId, update) {
     recentTools: sanitizeRecentTools(progress?.recentTools),
     model: progress ? resolveProgressModel(update, progress) : undefined,
     toolCount: progress?.toolCount,
+    usage: buildDelegationUpdateUsage(progress),
     durationMs: progress?.durationMs,
     tokens: progress?.tokens,
     taskProgress
@@ -154,6 +166,7 @@ export function toSubagentDelegationExecutionParams(request) {
     ...request.result.kind === "structured" ? { outputSchema: request.result.schema } : {},
     acceptance: false,
     artifacts: request.artifacts,
+    ...request.intercomBridge !== undefined ? { intercomBridge: request.intercomBridge } : {},
     delegatedThinkingOverride: request.thinking,
     delegatedAllowZeroToolBudget: true,
     async: false,
@@ -178,7 +191,8 @@ export function toSubagentDelegationUpdate(request, result) {
     ...legacy.model ? { model: legacy.model } : {},
     ...typeof legacy.toolCount === "number" ? { toolCount: legacy.toolCount } : {},
     ...typeof legacy.durationMs === "number" ? { durationMs: legacy.durationMs } : {},
-    ...typeof legacy.tokens === "number" ? { tokens: legacy.tokens } : {}
+    ...typeof legacy.tokens === "number" ? { tokens: legacy.tokens } : {},
+    ...legacy.usage ? { usage: legacy.usage } : {}
   };
 }
 function resolveSubagentDelegationStatus(result, aborted) {

package/extensions/dm-subagents/src/slash/delegation-request.js

@@ -1,3 +1,4 @@
+import { validateIntercomBridgeConfig } from "../intercom/intercom-bridge.js";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.js";
 import { cloneJsonWithinByteLimit } from "./delegation-json.js";
 const supportedFields = new Set([
@@ -14,6 +15,7 @@ const supportedFields = new Set([
   "toolBudget",
   "skill",
   "artifacts",
+  "intercomBridge",
   "result"
 ]);
 const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -89,6 +91,16 @@ export function parseSubagentDelegationRequest(data) {
   if (value.artifacts !== undefined && typeof value.artifacts !== "boolean") {
     return { ok: false, ...identity, error: "artifacts must be a boolean." };
   }
+  let intercomBridge;
+  if (value.intercomBridge !== undefined) {
+    const bridge = validateIntercomBridgeConfig({ value: value.intercomBridge, label: "intercomBridge" });
+    if (!bridge.ok)
+      return { ok: false, ...identity, error: bridge.error };
+    if (typeof bridge.value.instructionFile === "string" && Buffer.byteLength(bridge.value.instructionFile, "utf8") > MAX_SHORT_TEXT_BYTES) {
+      return { ok: false, ...identity, error: "intercomBridge.instructionFile exceeds 1 KiB when UTF-8 encoded." };
+    }
+    intercomBridge = bridge.value;
+  }
   if (Buffer.byteLength(value.task, "utf8") > MAX_TASK_BYTES) {
     return { ok: false, ...identity, error: "Delegation task exceeds 1 MiB when UTF-8 encoded." };
   }
@@ -146,6 +158,7 @@ export function parseSubagentDelegationRequest(data) {
     ok: true,
     request: {
       ...value,
+      ...intercomBridge ? { intercomBridge } : {},
       result: structuredSchema ? { kind: "structured", schema: structuredSchema } : { kind: "text" }
     }
   };

package/extensions/dm-subagents/src/slash/prompt-template-bridge.js

@@ -28,6 +28,30 @@ function hasStructuredDelegationMarker(data) {
 function validId(value) {
   return typeof value === "string" && value.trim().length > 0 && value.length <= 256 && !/[\r\n]/.test(value);
 }
+function sameStringArray(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right || left.length !== right.length)
+    return false;
+  return left.every((value, index) => value === right[index]);
+}
+function sameRecentTools(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right || left.length !== right.length)
+    return false;
+  return left.every((tool, index) => tool.tool === right[index]?.tool && tool.args === right[index]?.args);
+}
+function sameUpdateUsage(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right)
+    return false;
+  return left.input === right.input && left.output === right.output && left.cacheRead === right.cacheRead && left.cacheWrite === right.cacheWrite && left.turns === right.turns;
+}
+function sameStructuredDelegationUpdateProgress(left, right) {
+  return left.requestId === right.requestId && left.ownerRunId === right.ownerRunId && left.nodeId === right.nodeId && left.runId === right.runId && left.currentTool === right.currentTool && left.currentToolArgs === right.currentToolArgs && left.recentOutput === right.recentOutput && sameStringArray(left.recentOutputLines, right.recentOutputLines) && sameRecentTools(left.recentTools, right.recentTools) && left.model === right.model && left.toolCount === right.toolCount && left.tokens === right.tokens && sameUpdateUsage(left.usage, right.usage);
+}
 export function registerPromptTemplateDelegationBridge(options) {
   const legacyControllers = new Map;
   const pendingLegacyCancels = new Map;
@@ -253,13 +277,16 @@ export function registerPromptTemplateDelegationBridge(options) {
     options.events.emit(structuredRequest ? SUBAGENT_DELEGATION_STARTED_EVENT : PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, structuredRequest ? { requestId, ownerRunId: structuredRequest.ownerRunId, nodeId: structuredRequest.nodeId } : { requestId });
     try {
       const executeRequest = structuredRequest && options.executeStructured ? options.executeStructured : options.execute;
+      let lastStructuredUpdate;
       const result = await executeRequest(requestId, params, controller.signal, ctx, (update) => {
         if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller))
           return;
         if (structuredRequest) {
           const payload = toSubagentDelegationUpdate(structuredRequest, update);
-          if (payload)
+          if (payload && (!lastStructuredUpdate || !sameStructuredDelegationUpdateProgress(lastStructuredUpdate, payload))) {
+            lastStructuredUpdate = payload;
             options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
+          }
           return;
         }
         const payload = toDelegationUpdate(requestId, update);

package/extensions/dm-subagents/src/slash/prompt-workflows.js

@@ -22,8 +22,21 @@ function readPromptFiles(cwd) {
       continue;
     }
     for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(".md"))
-        files.push(path.join(dir, entry.name));
+      if (!entry.name.endsWith(".md"))
+        continue;
+      const filePath = path.join(dir, entry.name);
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          isFile = fs.statSync(filePath).isFile();
+        } catch (error) {
+          if (error.code !== "ENOENT")
+            throw error;
+          isFile = false;
+        }
+      }
+      if (isFile)
+        files.push(filePath);
     }
   }
   return files;