@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/watchdog/tool-actions.js

@@ -0,0 +1,151 @@
+import { THINKING_LEVELS } from "../shared/model-info.js";
+import { buildWatchdogStatus } from "./register-main.js";
+import { parseWatchdogThinkingInput, recommendStrongWatchdogModel, resolveWatchdogModelInput } from "./model-selection.js";
+import { writeWatchdogModelSettings } from "./settings.js";
+function result(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {},
+    details: { mode: "management", results: [] }
+  };
+}
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parseScope(raw) {
+  if (raw === undefined || raw === "session")
+    return "session";
+  if (raw === "user" || raw === "project")
+    return raw;
+  throw new Error("watchdog.configure scope must be 'session', 'user', or 'project'.");
+}
+function parseTarget(params) {
+  const target = params.target ?? "main";
+  if (target === "main")
+    return { kind: "main" };
+  if (target === "children")
+    return { kind: "children" };
+  if (target === "child") {
+    if (!params.agent?.trim())
+      throw new Error("watchdog.configure target='child' requires agent.");
+    return { kind: "child", agent: params.agent.trim() };
+  }
+  throw new Error("watchdog.configure target must be 'main', 'children', or 'child'.");
+}
+function parseThinking(raw) {
+  if (raw === undefined)
+    return;
+  if (raw === "inherit")
+    return null;
+  return parseWatchdogThinkingInput(raw, "watchdog.configure thinking") ?? undefined;
+}
+function resolveConfiguredValue(ctx, params) {
+  const thinking = parseThinking(params.thinking);
+  const rawModel = params.model?.trim();
+  if (!rawModel) {
+    if (thinking === undefined)
+      throw new Error("watchdog.configure requires model, thinking, or both.");
+    return { thinking, description: `thinking ${thinking === null ? "inherit" : thinking === false ? "off" : thinking}` };
+  }
+  if (rawModel === "inherit")
+    return { model: null, thinking: thinking ?? null, description: "inherit" };
+  if (rawModel === "recommended") {
+    const recommendation = recommendStrongWatchdogModel(ctx);
+    return {
+      model: recommendation.model,
+      thinking: recommendation.thinking,
+      description: `${recommendation.model}:${recommendation.thinking}`
+    };
+  }
+  const resolved = resolveWatchdogModelInput(ctx, rawModel);
+  return {
+    model: resolved.model,
+    thinking: resolved.thinking ?? thinking,
+    description: `${resolved.model}${resolved.thinking ?? thinking ? `:${resolved.thinking ?? thinking}` : ""}`
+  };
+}
+function buildRecommendationText(ctx) {
+  const recommendation = recommendStrongWatchdogModel(ctx);
+  return [
+    "Subagent watchdog recommended model",
+    `Recommended: ${recommendation.model}:${recommendation.thinking}`,
+    `Reason: ${recommendation.reason}`,
+    'Apply temporarily with subagent({ action: "watchdog.configure", scope: "session", model: "recommended" }).',
+    'Persist with scope: "project" or scope: "user" only when the user asks for that scope.'
+  ].join(`
+`);
+}
+function buildCheckText(runtime, ctx) {
+  if (!runtime)
+    return "Subagent watchdog runtime is unavailable.";
+  const snapshot = runtime.getSnapshot(ctx.cwd);
+  if (!snapshot.configOk)
+    return ["Subagent watchdog config check", "Config errors:", ...snapshot.errors.map((error) => `- ${error.message}`)].join(`
+`);
+  const lines = ["Subagent watchdog config check", "Config: ok"];
+  if (snapshot.config.main.model) {
+    const resolved = resolveWatchdogModelInput(ctx, snapshot.config.main.model);
+    lines.push(`Main model: ${resolved.model} auth ok`);
+  } else {
+    lines.push("Main model: current session");
+  }
+  lines.push(`LSP diagnostics: ${snapshot.lsp.enabled ? "on" : "off"} · ${snapshot.lsp.status}`);
+  try {
+    const recommendation = recommendStrongWatchdogModel(ctx);
+    lines.push(`Recommended strong watchdog: ${recommendation.model}:${recommendation.thinking}`);
+  } catch (error) {
+    lines.push(`Recommended strong watchdog unavailable: ${messageFromError(error)}`);
+  }
+  return lines.join(`
+`);
+}
+export function handleWatchdogToolAction(action, params, ctx, runtime) {
+  try {
+    if (action === "watchdog.status") {
+      if (!runtime)
+        return result("Subagent watchdog runtime is unavailable.", true);
+      return result(buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx));
+    }
+    if (action === "watchdog.recommend-model")
+      return result(buildRecommendationText(ctx));
+    if (action === "watchdog.check")
+      return result(buildCheckText(runtime, ctx));
+    if (action !== "watchdog.configure")
+      return result(`Unknown watchdog action: ${action}`, true);
+    const scope = parseScope(params.scope);
+    const target = parseTarget(params);
+    const value = resolveConfiguredValue(ctx, params);
+    if (scope === "session") {
+      if (!runtime)
+        return result("Subagent watchdog runtime is unavailable.", true);
+      if (target.kind !== "main")
+        return result("Session-scoped watchdog.configure currently supports target='main' only.", true);
+      runtime.setSessionModel({ model: value.model, thinking: value.thinking }, ctx.cwd);
+      return result([
+        `Subagent watchdog session model configured: ${value.description}.`,
+        "No settings files were changed.",
+        "",
+        buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx)
+      ].join(`
+`));
+    }
+    const settingsPath = writeWatchdogModelSettings({
+      scope,
+      cwd: ctx.cwd,
+      target,
+      model: value.model,
+      thinking: value.thinking
+    });
+    runtime?.refreshConfig(ctx.cwd);
+    const targetLabel = target.kind === "child" ? `child ${target.agent}` : target.kind;
+    return result([
+      `Subagent watchdog ${targetLabel} model configured: ${value.description}.`,
+      `Updated: ${settingsPath}`
+    ].join(`
+`));
+  } catch (error) {
+    return result(`Subagent watchdog action failed: ${messageFromError(error)}`, true);
+  }
+}
+export const WATCHDOG_TOOL_ACTIONS = ["watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model"];
+export const WATCHDOG_THINKING_VALUES = ["inherit", ...THINKING_LEVELS];

package/extensions/dm-subagents/src/watchdog/turn-delta.js

@@ -0,0 +1,169 @@
+import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "./types.js";
+function textFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      if (typeof block === "string")
+        return block;
+      if (block && typeof block === "object") {
+        const item = block;
+        if (item.type === "text" && typeof item.text === "string")
+          return item.text;
+        if (item.type === "thinking" && typeof item.thinking === "string")
+          return ["Thinking:", item.thinking].join(`
+`);
+        if (item.type === "toolCall")
+          return formatToolCall(item.name, item.input ?? item.args ?? item.arguments);
+        if (typeof item.content === "string")
+          return item.content;
+      }
+      return "";
+    }).filter(Boolean).join(`
+`);
+  }
+  if (content === undefined || content === null)
+    return "";
+  return formatValue(content);
+}
+function formatValue(value, indent = "") {
+  if (typeof value === "string")
+    return value;
+  if (value === undefined)
+    return "undefined";
+  if (value === null || typeof value === "number" || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => `${indent}- ${formatValue(item, `${indent}  `)}`).join(`
+`);
+  }
+  if (typeof value === "object") {
+    const lines = [];
+    for (const [key, item] of Object.entries(value)) {
+      if (typeof item === "string" && item.includes(`
+`))
+        lines.push(`${indent}${key}:
+${item}`);
+      else
+        lines.push(`${indent}${key}: ${formatValue(item, `${indent}  `)}`);
+    }
+    return lines.join(`
+`);
+  }
+  return String(value);
+}
+function redactEditWriteInput(input) {
+  if (Array.isArray(input))
+    return input.map(redactEditWriteInput);
+  if (!input || typeof input !== "object")
+    return input;
+  const sanitized = {};
+  for (const [key, value] of Object.entries(input)) {
+    sanitized[key] = ["oldText", "newText", "content"].includes(key) && typeof value === "string" ? `[omitted ${value.length} chars; use tool result diff]` : redactEditWriteInput(value);
+  }
+  return sanitized;
+}
+function formatToolArguments(name, input) {
+  if (name === "edit" || name === "write")
+    return formatValue(redactEditWriteInput(input));
+  return formatValue(input);
+}
+function formatToolCall(name, input) {
+  const toolName = typeof name === "string" && name ? name : "tool";
+  return [`Tool call: ${toolName}`, "Arguments:", formatToolArguments(toolName, input ?? {})].join(`
+`);
+}
+function formatToolResult(name, content, details, error, isError) {
+  const failed = isError === true || Boolean(error);
+  const lines = [`Tool result: ${name}`];
+  if (failed)
+    lines.push(`Error: ${error ? typeof error === "string" ? error : formatValue(error) : "tool reported an error"}`);
+  if (!failed && details && typeof details === "object" && "diff" in details && typeof details.diff === "string") {
+    lines.push("Diff:", details.diff);
+  } else {
+    const body = textFromContent(content);
+    if (body)
+      lines.push(failed ? "Output:" : "Result:", body);
+  }
+  return lines.join(`
+`);
+}
+function messagesFromEvent(event) {
+  if (!event || typeof event !== "object")
+    return [];
+  const input = event;
+  if (input.type === "turn_end" || input.event === "turn_end") {
+    return [input.message, ...Array.isArray(input.toolResults) ? input.toolResults : []].filter(Boolean);
+  }
+  if (input.message)
+    return [input.message];
+  if (input.type === "tool_execution_start" || input.event === "tool_execution_start") {
+    return [{ role: "toolCall", name: input.toolName ?? input.name, input: input.args ?? input.input }];
+  }
+  if (input.type === "tool_execution_end" || input.event === "tool_execution_end") {
+    const result = input.result && typeof input.result === "object" && !Array.isArray(input.result) ? input.result : undefined;
+    return [{
+      role: "toolResult",
+      toolName: input.toolName ?? input.name,
+      content: result?.content ?? input.content ?? input.result,
+      details: result?.details ?? input.details,
+      error: input.error,
+      isError: input.isError
+    }];
+  }
+  if (input.type === "tool_result" || input.event === "tool_result") {
+    return [{ role: "toolResult", toolName: input.toolName ?? input.name, content: input.content, details: input.details, error: input.error, isError: input.isError }];
+  }
+  return [];
+}
+export function formatWatchdogReviewMessage(message) {
+  if (!message || typeof message !== "object")
+    return;
+  const input = message;
+  if (input.role === "custom" && input.customType === SUBAGENT_WATCHDOG_WARNING_TYPE)
+    return;
+  if (input.role === "assistant") {
+    const text = textFromContent(input.content);
+    const lines = text ? ["Assistant:", text] : ["Assistant: (no text)"];
+    if (input.stopReason === "stop")
+      lines.push("Assistant stop: stop");
+    return lines.join(`
+`);
+  }
+  if (input.role === "toolCall")
+    return formatToolCall(input.name ?? input.toolName, input.input ?? input.args ?? input.arguments);
+  if (input.role === "toolResult" || input.role === "tool") {
+    return formatToolResult(input.toolName ?? input.name ?? "tool", input.content, input.details, input.error, input.isError);
+  }
+  if (input.role === "user") {
+    const text = textFromContent(input.content);
+    return text ? ["User:", text].join(`
+`) : undefined;
+  }
+  return;
+}
+export function formatWatchdogTurnDelta(input) {
+  const sections = [];
+  if (input.includeUserPrompt && input.userPrompt?.trim())
+    sections.push(["User prompt:", input.userPrompt].join(`
+`));
+  for (const message of input.messages ?? []) {
+    const section = formatWatchdogReviewMessage(message);
+    if (section)
+      sections.push(section);
+  }
+  for (const event of input.events ?? []) {
+    for (const message of messagesFromEvent(event)) {
+      const section = formatWatchdogReviewMessage(message);
+      if (section)
+        sections.push(section);
+    }
+  }
+  if (input.finalAssistantStop)
+    sections.push("Final assistant stop: stop without tool call");
+  return sections.join(`
+
+---
+
+`);
+}

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

@@ -0,0 +1,29 @@
+export const SUBAGENT_WATCHDOG_WARNING_TYPE = "subagent_watchdog_warning";
+export const WATCHDOG_WARNING_SEVERITIES = ["concern", "blocker"];
+export const WATCHDOG_WARNING_CATEGORIES = [
+  "correctness",
+  "missed-constraint",
+  "test-gap",
+  "unsafe-change",
+  "scope-drift",
+  "stale-fact",
+  "loop-risk",
+  "other"
+];
+export const WATCHDOG_WARNING_CONFIDENCES = ["medium", "high"];
+export const WATCHDOG_WARNING_SOURCES = ["main", "child", "async-completion", "lsp"];
+export const WATCHDOG_LSP_DIAGNOSTIC_SEVERITIES = ["error", "warning", "info", "hint"];
+export const WATCHDOG_LSP_STATUSES = ["disabled", "ok", "skipped", "unavailable", "timeout", "failed"];
+export const WATCHDOG_RUNTIME_STATUSES = ["idle", "queued", "reviewing", "waiting-at-agent-end", "stale", "failed"];
+export const WATCHDOG_WARNING_STATES = [
+  "candidate",
+  "confirmed",
+  "displayed",
+  "stale",
+  "failed",
+  "resolved",
+  "stalemate",
+  "suppressed"
+];
+export const WATCHDOG_LATE_WARNING_POLICIES = ["show-stale-no-autofollow"];
+export const WATCHDOG_DELIVERY_MODES = ["held"];

package/extensions/dm-subagents/src/watchdog/warning-format.js

@@ -0,0 +1,58 @@
+import {
+  SUBAGENT_WATCHDOG_WARNING_TYPE
+} from "./types.js";
+function escapeXmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlAttribute(value) {
+  return escapeXmlText(value).replace(/"/g, "&quot;");
+}
+function tag(name, value) {
+  if (value === undefined)
+    return;
+  return `<${name}>${escapeXmlText(String(value))}</${name}>`;
+}
+export function normalizeWatchdogWarningDetails(warning, extras = {}) {
+  return {
+    ...warning,
+    category: warning.category ?? extras.category ?? "other",
+    source: warning.source ?? extras.source ?? "main",
+    ...extras
+  };
+}
+export function formatWatchdogWarningContent(warning) {
+  const details = normalizeWatchdogWarningDetails(warning);
+  const attrs = [
+    `severity="${escapeXmlAttribute(details.severity)}"`,
+    `category="${escapeXmlAttribute(details.category)}"`,
+    `source="${escapeXmlAttribute(details.source)}"`,
+    `guidance="weigh, don't blindly obey"`
+  ];
+  const optionalTags = [
+    tag("confidence", details.confidence),
+    tag("agent", details.agent),
+    tag("run_id", details.runId),
+    tag("state", details.state),
+    tag("stale", details.stale),
+    tag("auto_follow_attempt", details.autoFollowAttempt)
+  ];
+  return [
+    `<subagent_watchdog ${attrs.join(" ")}>`,
+    `<summary>${escapeXmlText(details.summary)}</summary>`,
+    `<evidence>${escapeXmlText(details.evidence)}</evidence>`,
+    `<recommended_action>${escapeXmlText(details.recommendedAction)}</recommended_action>`,
+    ...optionalTags.filter((line) => Boolean(line)),
+    details.severity === "blocker" ? "<blocker_guidance>If this warning changes the outcome, produce a new self-contained final answer after addressing it.</blocker_guidance>" : undefined,
+    "</subagent_watchdog>"
+  ].filter((line) => Boolean(line)).join(`
+`);
+}
+export function createWatchdogWarningMessage(warning, options = {}) {
+  const details = normalizeWatchdogWarningDetails(warning, options.details);
+  return {
+    customType: SUBAGENT_WATCHDOG_WARNING_TYPE,
+    content: formatWatchdogWarningContent(details),
+    display: options.display ?? true,
+    details
+  };
+}

package/extensions/dm-subagents/src/workflows/chat-progress.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const WORKFLOW_CHAT_PROGRESS_MODES = ["auto", "off", "live-card"];
+function git(cwd, args) {
+  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
+  if (result.status !== 0)
+    return;
+  const output = result.stdout.trim();
+  return output || undefined;
+}
+function realPath(value) {
+  try {
+    return fs.realpathSync.native(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+export function resolveGitRepositoryIdentity(cwd) {
+  if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true")
+    return;
+  const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+  const commonDir = git(cwd, ["rev-parse", "--git-common-dir"]);
+  if (!root || !commonDir)
+    return;
+  const commonDirPath = path.isAbsolute(commonDir) ? commonDir : [path.resolve(cwd, commonDir), path.resolve(root, commonDir)].find((candidate) => fs.existsSync(candidate)) ?? path.resolve(root, commonDir);
+  return {
+    root: realPath(root),
+    commonDir: realPath(commonDirPath)
+  };
+}
+function isSameGitRepositoryIdentity(left, right) {
+  if (!left || !right)
+    return false;
+  return left.commonDir === right.commonDir || left.root === right.root;
+}
+export function isSameGitRepository(leftCwd, rightCwd) {
+  return isSameGitRepositoryIdentity(resolveGitRepositoryIdentity(leftCwd), resolveGitRepositoryIdentity(rightCwd));
+}
+function normalizeRequestedMode(value) {
+  if (value === undefined)
+    return { mode: "auto" };
+  if (typeof value !== "string" || !WORKFLOW_CHAT_PROGRESS_MODES.includes(value)) {
+    return { error: `chatProgress must be one of: ${WORKFLOW_CHAT_PROGRESS_MODES.join(", ")}.` };
+  }
+  return { mode: value };
+}
+export function resolveWorkflowChatProgress(input) {
+  const requested = normalizeRequestedMode(input.requested);
+  if (requested.error)
+    return { error: requested.error };
+  const parentIdentity = resolveGitRepositoryIdentity(input.parentCwd);
+  const workflowIdentity = resolveGitRepositoryIdentity(input.workflowCwd);
+  const sameRepo = !!(parentIdentity && workflowIdentity && (parentIdentity.commonDir === workflowIdentity.commonDir || parentIdentity.root === workflowIdentity.root));
+  const repoLabel = workflowIdentity ? path.basename(workflowIdentity.root) : undefined;
+  const repoRelation = sameRepo ? "same" : "other";
+  const requestedMode = requested.mode ?? "auto";
+  let mode;
+  if (requestedMode === "auto")
+    mode = sameRepo && !input.background ? "live-card" : "off";
+  else
+    mode = requestedMode;
+  if (mode === "live-card" && !sameRepo)
+    return { error: "chatProgress: 'live-card' is only available for workflowScript runs in the same Git repository." };
+  if (mode === "live-card" && input.background)
+    return { error: "chatProgress: 'live-card' is unavailable for async workflowScript. Async workflows have no inline live card; omit chatProgress or use auto/off. Use async:false only when the parent must block." };
+  return { projection: { mode, repoRelation, ...repoLabel ? { repoLabel } : {} } };
+}
+function cleanLabel(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function buildWorkflowChatProgressRows(trace, preflight) {
+  const rows = new Map;
+  for (const lane of preflight?.lanes ?? [])
+    rows.set(lane.key, { key: lane.key, state: "planned", preflight: lane });
+  for (const entry of trace) {
+    if (entry.operation !== "run")
+      continue;
+    const existing = rows.get(entry.key);
+    if (entry.state === "reused") {
+      if (existing) {
+        const label = cleanLabel(entry.label);
+        const phase = cleanLabel(entry.phase);
+        if (label)
+          existing.label = label;
+        if (phase)
+          existing.phase = phase;
+      }
+      continue;
+    }
+    const next = existing ?? { key: entry.key, state: "running" };
+    if (existing?.preflight)
+      next.preflight = existing.preflight;
+    next.state = entry.state === "completed" ? "complete" : entry.state === "failed" ? "failed" : entry.state === "detached" ? "detached" : entry.state === "stopped" ? "stopped" : "running";
+    const label = cleanLabel(entry.label);
+    const phase = cleanLabel(entry.phase);
+    if (label)
+      next.label = label;
+    if (phase)
+      next.phase = phase;
+    if (entry.runId === undefined)
+      delete next.runId;
+    else
+      next.runId = entry.runId;
+    if (entry.durationMs === undefined)
+      delete next.durationMs;
+    else
+      next.durationMs = entry.durationMs;
+    if (entry.error === undefined)
+      delete next.error;
+    else
+      next.error = entry.error;
+    rows.set(entry.key, next);
+  }
+  return [...rows.values()];
+}