@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -1,6 +1,9 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
+import { discoverAgents, formatUnknownAgentError, unknownAgentDiagnosticContext } from "../agents/agents.js";
 import { normalizeSkillInput } from "../agents/skills.js";
+import { normalizeOutputOverride } from "../runs/shared/child-launch-plan.js";
 import { CHAIN_RUNS_DIR } from "./types.js";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const INITIAL_PROGRESS_CONTENT = `# Progress
@@ -14,9 +17,13 @@ In Progress
 
 ## Notes
 `;
-function normalizeOutputOverride(output) {
-  return output === "false" ? false : output;
-}
+export {
+  planChildLaunch,
+  resolveStepBehavior,
+  resolveTaskTextForFileUpdatePolicy,
+  suppressProgressForReadOnlyTask,
+  taskDisallowsFileUpdates
+} from "../runs/shared/child-launch-plan.js";
 export function isParallelStep(step) {
   return "parallel" in step && Array.isArray(step.parallel);
 }
@@ -80,56 +87,38 @@ export function resolveChainTemplates(steps) {
     return i === 0 ? "{task}" : "{previous}";
   });
 }
-export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
-  const stepOutput = normalizeOutputOverride(stepOverrides.output);
-  const output = stepOutput !== undefined ? stepOutput : normalizeOutputOverride(agentConfig.output) ?? false;
-  const reads = stepOverrides.reads !== undefined ? stepOverrides.reads : agentConfig.defaultReads ?? false;
-  const progress = stepOverrides.progress !== undefined ? stepOverrides.progress : agentConfig.defaultProgress ?? false;
-  let skills;
-  if (stepOverrides.skills === false) {
-    skills = false;
-  } else if (stepOverrides.skills !== undefined) {
-    skills = [...stepOverrides.skills];
-    if (chainSkills && chainSkills.length > 0) {
-      skills = [...new Set([...skills, ...chainSkills])];
-    }
-  } else {
-    skills = agentConfig.skills ? [...agentConfig.skills] : [];
-    if (chainSkills && chainSkills.length > 0) {
-      skills = [...new Set([...skills, ...chainSkills])];
-    }
-  }
-  const outputMode = stepOverrides.outputMode ?? "inline";
-  const model = stepOverrides.model ?? agentConfig.model;
-  return { output, outputMode, reads, progress, skills, model };
-}
-export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
-  if (!task)
-    return originalTask;
-  return originalTask ? task.replaceAll("{task}", originalTask) : task;
-}
-export function taskDisallowsFileUpdates(task) {
-  if (!task)
-    return false;
-  return /\breview[- ]only\b/i.test(task) || /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task) || /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task) || /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task) || /\bleave\s+files?\s+unchanged\b/i.test(task);
-}
-export function suppressProgressForReadOnlyTask(behavior, task, originalTask) {
-  const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
-  return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
+export function expandHomePath(filePath) {
+  if (filePath === "~")
+    return os.homedir();
+  if (filePath.startsWith("~/"))
+    return path.join(os.homedir(), filePath.slice(2));
+  return filePath;
+}
+export function resolveChainPath(filePath, chainDir) {
+  const expanded = expandHomePath(filePath);
+  return path.isAbsolute(expanded) ? expanded : path.join(chainDir, expanded);
+}
+export function resolveExistingReadInstructionPaths(reads, instructionCwd, existenceCwd = instructionCwd) {
+  return reads.flatMap((filePath) => {
+    const instructionPath = resolveChainPath(filePath, instructionCwd);
+    const existencePath = resolveChainPath(filePath, existenceCwd);
+    return fs.existsSync(existencePath) ? [instructionPath] : [];
+  });
 }
-function resolveChainPath(filePath, chainDir) {
-  return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
+export function resolveExistingReadPaths(reads, cwd) {
+  return resolveExistingReadInstructionPaths(reads, cwd);
 }
 export function writeInitialProgressFile(progressDir) {
   fs.mkdirSync(progressDir, { recursive: true });
   fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT);
 }
-export function buildChainInstructions(behavior, chainDir, isFirstProgressAgent, previousSummary) {
+export function buildChainInstructions(behavior, chainDir, isFirstProgressAgent, previousSummary, readExistenceDir = chainDir) {
   const prefixParts = [];
   const suffixParts = [];
   if (behavior.reads && behavior.reads.length > 0) {
-    const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
-    prefixParts.push(`[Read from: ${files.join(", ")}]`);
+    const files = resolveExistingReadInstructionPaths(behavior.reads, chainDir, readExistenceDir);
+    if (files.length > 0)
+      prefixParts.push(`[Read from: ${files.join(", ")}]`);
   }
   if (behavior.output) {
     const outputPath = resolveChainPath(behavior.output, chainDir);
@@ -158,11 +147,14 @@ ${previousSummary.trim()}`);
 `) : "";
   return { prefix, suffix };
 }
-export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSkills) {
+export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSkills, diagnostics) {
   return tasks.map((task, taskIndex) => {
     const config = agentConfigs.find((a) => a.name === task.agent);
     if (!config) {
-      throw new Error(`Unknown agent: ${task.agent}`);
+      if (!diagnostics)
+        throw new Error("resolveParallelBehaviors requires unknown-agent diagnostic context or fallback discovery input.");
+      const context = "directories" in diagnostics ? diagnostics : unknownAgentDiagnosticContext(discoverAgents(path.resolve(diagnostics.cwd), diagnostics.scope ?? "both"));
+      throw new Error(formatUnknownAgentError(task.agent, context));
     }
     const subdir = path.join(`parallel-${stepIndex}`, `${taskIndex}-${task.agent}`);
     let output = false;
@@ -196,7 +188,7 @@ export function resolveParallelBehaviors(tasks, agentConfigs, stepIndex, chainSk
         skills = [...new Set([...skills, ...chainSkills])];
       }
     }
-    const outputMode = task.outputMode ?? "inline";
+    const outputMode = task.outputMode ?? config.outputMode ?? "inline";
     const model = task.model ?? config.model;
     return { output, outputMode, reads, progress, skills, model };
   });

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

@@ -0,0 +1,16 @@
+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();
+    if (normalized === "ctrl")
+      return "Ctrl";
+    if (normalized === "alt")
+      return "Alt";
+    if (normalized === "shift")
+      return "Shift";
+    if (normalized === "super")
+      return "Super";
+    return normalized.length === 1 ? normalized.toUpperCase() : part.trim();
+  }).join("+");
+}

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

@@ -16,8 +16,10 @@ export function formatActivityLabel(lastActivityAt, activityState, now = Date.no
   const age = formatActivityAge(Math.max(0, now - lastActivityAt));
   if (activityState === "needs_attention")
     return `no activity for ${age}`;
-  if (activityState === "active_long_running")
-    return `active but long-running · last activity ${age} ago`;
+  if (activityState === "active_long_running") {
+    const activityAge = age === "now" ? "now" : `${age} ago`;
+    return `active but long-running · last activity ${activityAge}`;
+  }
   return age === "now" ? "active now" : `active ${age} ago`;
 }
 function isCompletedStepStatus(status) {
@@ -28,6 +30,8 @@ export function aggregateStepStatus(steps) {
     return "running";
   if (steps.some((step) => step.status === "failed"))
     return "failed";
+  if (steps.some((step) => step.status === "stopped"))
+    return "stopped";
   if (steps.some((step) => step.status === "paused"))
     return "paused";
   if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status)))
@@ -41,12 +45,15 @@ export function formatParallelOutcome(steps, total, options = {}) {
   const running = steps.filter((step) => step.status === "running").length;
   const done = steps.filter((step) => isCompletedStepStatus(step.status)).length;
   const failed = steps.filter((step) => step.status === "failed").length;
+  const stopped = steps.filter((step) => step.status === "stopped").length;
   const paused = steps.filter((step) => step.status === "paused").length;
   const parts = [`${done}/${total} done`];
   if (options.showRunning !== false && running > 0)
     parts.unshift(formatAgentRunningLabel(running));
   if (failed > 0)
     parts.push(`${failed} failed`);
+  if (stopped > 0)
+    parts.push(`${stopped} stopped`);
   if (paused > 0)
     parts.push(`${paused} paused`);
   return parts.join(" · ");

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

@@ -0,0 +1,41 @@
+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") {
+    const trimmed = value.trim();
+    if (thinkingLevelRanks.has(trimmed))
+      return trimmed;
+  }
+  throw new Error(`Invalid ${field}; expected one of ${THINKING_LEVELS.join(", ")}.`);
+}
+export function compareThinkingLevels(left, right) {
+  const leftRank = thinkingLevelRanks.get(left);
+  const rightRank = thinkingLevelRanks.get(right);
+  if (leftRank === undefined || rightRank === undefined)
+    throw new Error(`Invalid thinking level comparison; expected one of ${THINKING_LEVELS.join(", ")}.`);
+  return leftRank - rightRank;
+}
+export function intersectThinkingCeilings(...ceilings) {
+  const active = ceilings.filter((ceiling) => ceiling !== undefined);
+  if (active.length === 0)
+    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;
+  const requested = resolveEffectiveThinking(input.model, input.configThinking);
+  if (!requested)
+    return;
+  const requestedLevel = parseThinkingLevel(requested, "requested thinking level");
+  if (compareThinkingLevels(requestedLevel, input.ceiling) <= 0)
+    return;
+  const subject = [input.agent ? `agent '${input.agent}'` : undefined, input.runId ? `run '${input.runId}'` : undefined].filter((value) => Boolean(value)).join(" ");
+  throw new Error(`Thinking level '${requestedLevel}' exceeds configured maximum '${input.ceiling}'${subject ? ` for ${subject}` : ""}.`);
+}

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

@@ -1,20 +1,41 @@
 import * as os from "node:os";
 import * as path from "node:path";
-export const SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 1;
-export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
-export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
+export const SUBAGENT_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 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";
+export const SUBAGENT_FOREGROUND_COMPLETE_EVENT = "subagent:foreground-complete";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
+export const SUBAGENT_STEERING_NOTICE_EVENT = "subagent:steering-notice";
+export const SUBAGENT_CHILD_STATUS_EVENT = "subagent:child-status";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
+export const FLEET_KEYBINDING_ACTIONS = [
+  "close",
+  "scrollUp",
+  "scrollDown",
+  "selectUp",
+  "selectDown",
+  "selectFirst",
+  "selectLast",
+  "pageUp",
+  "pageDown",
+  "refresh",
+  "steer",
+  "inspect",
+  "stop",
+  "toggleTools"
+];
 export const DEFAULT_MAX_OUTPUT = {
   bytes: 200 * 1024,
   lines: 5000
 };
 export const DEFAULT_ARTIFACT_CONFIG = {
   enabled: true,
+  dir: "session",
   includeInput: true,
   includeOutput: true,
   includeJsonl: false,
@@ -56,11 +77,18 @@ export function resolveTempScopeId(options) {
 }
 const MAX_PARALLEL = 8;
 export const MAX_CONCURRENCY = 4;
-export const TEMP_ROOT_DIR = path.join(os.tmpdir(), `dm-subagents-${resolveTempScopeId()}`);
+const configuredTempRoot = process.env.DM_SUBAGENTS_TEMP_ROOT?.trim();
+export const TEMP_ROOT_DIR = configuredTempRoot ? path.resolve(configuredTempRoot) : path.join(os.tmpdir(), `dm-subagents-${resolveTempScopeId()}`);
 export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
 export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
 export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
 export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
+export const DIRS = {
+  results: RESULTS_DIR,
+  async: ASYNC_DIR,
+  chain: CHAIN_RUNS_DIR,
+  artifacts: TEMP_ARTIFACTS_DIR
+};
 export const WIDGET_KEY = "subagent-async";
 export const SLASH_RESULT_TYPE = "subagent-slash-result";
 export const SLASH_TEXT_RESULT_TYPE = "subagent-slash-text-result";
@@ -70,10 +98,10 @@ export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
 export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
 export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
 export const POLL_INTERVAL_MS = 250;
+export const WIDGET_ANIMATION_INTERVAL_MS = 1000;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
-export const DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION = 40;
-export const SUBAGENT_ACTIONS = ["list", "get", "models", "create", "update", "delete", "eject", "disable", "enable", "reset", "status", "interrupt", "resume", "steer", "append-step", "doctor", "schedule", "schedule-list", "schedule-status", "schedule-cancel"];
+export const 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 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;
@@ -137,7 +165,19 @@ export function normalizeMaxSubagentSpawnsPerSession(value) {
   return normalizeNonNegativeInteger(value);
 }
 export function resolveMaxSubagentSpawnsPerSession(configMaxSpawns) {
-  return normalizeMaxSubagentSpawnsPerSession(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_SESSION) ?? normalizeMaxSubagentSpawnsPerSession(configMaxSpawns) ?? DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION;
+  const envMaxSpawns = normalizeMaxSubagentSpawnsPerSession(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_SESSION);
+  if (envMaxSpawns !== undefined)
+    return envMaxSpawns === 0 ? undefined : envMaxSpawns;
+  const configuredMaxSpawns = normalizeMaxSubagentSpawnsPerSession(configMaxSpawns);
+  return configuredMaxSpawns === 0 ? undefined : configuredMaxSpawns;
+}
+export const DEFAULT_MAX_SUBAGENT_SPAWNS_PER_RUN = 64;
+export function normalizeMaxSubagentSpawnsPerRun(value) {
+  const normalized = normalizeNonNegativeInteger(value);
+  return normalized !== undefined && normalized > 0 ? normalized : undefined;
+}
+export function resolveMaxSubagentSpawnsPerRun(configMaxSpawns) {
+  return normalizeMaxSubagentSpawnsPerRun(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_RUN) ?? normalizeMaxSubagentSpawnsPerRun(configMaxSpawns) ?? DEFAULT_MAX_SUBAGENT_SPAWNS_PER_RUN;
 }
 function formatBytes(bytes) {
   if (bytes < 1024)

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

@@ -0,0 +1,12 @@
+export function decodeUtf8Tail(bytes) {
+  let start = 0;
+  while (start < bytes.length && (bytes[start] & 192) === 128)
+    start += 1;
+  return bytes.subarray(start).toString("utf-8");
+}
+export function utf8Tail(value, maxBytes) {
+  const bytes = Buffer.from(value, "utf-8");
+  if (bytes.length <= maxBytes)
+    return { text: value, truncated: false };
+  return { text: decodeUtf8Tail(bytes.subarray(bytes.length - maxBytes)), truncated: true };
+}