@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/watchdog/change-signature.js

@@ -0,0 +1,220 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { PROJECT_SUBAGENTS_RELATIVE_DIR } from "../shared/artifacts.js";
+const IGNORED_CHANGE_PREFIXES = [`${PROJECT_SUBAGENTS_RELATIVE_DIR}/`, "tmp/", "node_modules/"];
+const IGNORED_CHANGE_PATHS = new Set([PROJECT_SUBAGENTS_RELATIVE_DIR, "tmp", "node_modules"]);
+const IGNORED_CHANGE_SEGMENTS = new Set([".git", "node_modules"]);
+const DEFAULT_MAX_HASH_FILE_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_HASH_TOTAL_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_HASH_ENTRIES = 2000;
+const TRACKED_ENTRY_PROBE_MAX_BYTES = 1024;
+function positiveEnvNumber(name, fallback) {
+  const parsed = Number(process.env[name]);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function maxHashFileBytes() {
+  return positiveEnvNumber("DM_SUBAGENTS_MAX_HASH_FILE_BYTES", DEFAULT_MAX_HASH_FILE_BYTES);
+}
+function maxHashTotalBytes() {
+  return positiveEnvNumber("DM_SUBAGENTS_MAX_HASH_TOTAL_BYTES", DEFAULT_MAX_HASH_TOTAL_BYTES);
+}
+function maxHashEntries() {
+  return positiveEnvNumber("DM_SUBAGENTS_MAX_HASH_ENTRIES", DEFAULT_MAX_HASH_ENTRIES);
+}
+function git(cwd, args) {
+  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+  if (result.status !== 0)
+    return;
+  return result.stdout;
+}
+function comparablePath(value) {
+  let resolved = path.resolve(value);
+  try {
+    resolved = fs.realpathSync.native(resolved);
+  } catch {}
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isHomeRepoRoot(root) {
+  return comparablePath(root) === comparablePath(os.homedir());
+}
+function hasTrackedEntries(root) {
+  const result = spawnSync("git", ["-C", root, "ls-files", "--cached", "--error-unmatch", "--", "."], {
+    encoding: "utf-8",
+    maxBuffer: TRACKED_ENTRY_PROBE_MAX_BYTES,
+    windowsHide: true
+  });
+  const errorCode = result.error?.code;
+  if (result.status === 0 || errorCode === "ENOBUFS")
+    return true;
+  if (result.status === 1)
+    return false;
+  return;
+}
+function normalizeRelPath(value) {
+  return value.replaceAll(path.sep, "/").replace(/^\.\//, "");
+}
+function ignoredRelPath(relPath) {
+  const normalized = normalizeRelPath(relPath);
+  return IGNORED_CHANGE_PATHS.has(normalized) || IGNORED_CHANGE_PREFIXES.some((prefix) => normalized.startsWith(prefix)) || normalized.split("/").some((segment) => IGNORED_CHANGE_SEGMENTS.has(segment));
+}
+function useHashEntryBudget(budget) {
+  if (budget.entries >= budget.maxEntries)
+    return false;
+  budget.entries++;
+  return true;
+}
+function hashFile(filePath) {
+  return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+function largeFileHash(stat) {
+  return "large:" + stat.size + ":" + Math.floor(stat.mtimeMs);
+}
+function hashFileEntry(normalized, fullPath, stat, budget) {
+  let hash;
+  if (stat.size > maxHashFileBytes() || budget.bytes + stat.size > budget.maxBytes) {
+    hash = largeFileHash(stat);
+  } else {
+    try {
+      hash = hashFile(fullPath);
+      budget.bytes += stat.size;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT")
+        return { path: normalized, state: "deleted" };
+      hash = largeFileHash(stat);
+      if (code !== "ERR_FS_FILE_TOO_LARGE") {
+        console.warn("[dm-subagents] watchdog hashFile fell back to metadata for", normalized + ":", error?.message);
+      }
+    }
+  }
+  return { path: normalized, state: "file", mode: stat.mode & 511, size: stat.size, hash };
+}
+function gitWorktreeEntry(normalized, fullPath) {
+  const status = git(fullPath, ["status", "--porcelain=v1", "-z", "--untracked-files=no"]);
+  return {
+    path: normalized,
+    state: "git-worktree",
+    head: git(fullPath, ["rev-parse", "HEAD"])?.trim(),
+    dirty: Boolean(status),
+    statusKey: status ? createHash("sha256").update(status).digest("hex") : undefined
+  };
+}
+function hashPath(root, relPath, budget) {
+  const normalized = normalizeRelPath(relPath);
+  if (!useHashEntryBudget(budget))
+    return { path: normalized, state: "skipped", reason: "entry-limit" };
+  const fullPath = path.join(root, normalized);
+  let stat;
+  try {
+    stat = fs.lstatSync(fullPath);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { path: normalized, state: "deleted" };
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    return { path: normalized, state: "symlink", target: fs.readlinkSync(fullPath) };
+  }
+  if (stat.isDirectory()) {
+    if (fs.existsSync(path.join(fullPath, ".git")))
+      return gitWorktreeEntry(normalized, fullPath);
+    const entries = fs.readdirSync(fullPath).map((entry) => normalizeRelPath(path.posix.join(normalized, entry))).filter((entry) => !ignoredRelPath(entry)).sort();
+    const remainingEntries = Math.max(0, budget.maxEntries - budget.entries);
+    const selectedEntries = entries.slice(0, remainingEntries);
+    const childEntries = selectedEntries.map((entry) => hashPath(root, entry, budget));
+    if (selectedEntries.length < entries.length) {
+      childEntries.push({ path: normalized, state: "skipped-children", reason: "entry-limit", count: entries.length - selectedEntries.length });
+    }
+    return { path: normalized, state: "dir", entries: childEntries };
+  }
+  if (stat.isFile())
+    return hashFileEntry(normalized, fullPath, stat, budget);
+  return { path: normalized, state: "other", mode: stat.mode };
+}
+function parsePorcelainZ(raw) {
+  const tokens = raw.split("\x00").filter(Boolean);
+  const entries = [];
+  for (let index = 0;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.length < 4)
+      continue;
+    const status = token.slice(0, 2);
+    const relPath = token.slice(3);
+    const paths = [relPath];
+    if (status[0] === "R" || status[0] === "C") {
+      const originalPath = tokens[++index];
+      if (originalPath)
+        paths.push(originalPath);
+    }
+    entries.push({ status, paths });
+  }
+  return entries;
+}
+function buildRepoChangeSignature(root, statusOutput) {
+  const entries = parsePorcelainZ(statusOutput).map((entry) => ({
+    status: entry.status,
+    paths: entry.paths.map(normalizeRelPath).filter((relPath) => !ignoredRelPath(relPath))
+  })).filter((entry) => entry.paths.length > 0).sort((a, b) => `${a.status} ${a.paths.join("\x00")}`.localeCompare(`${b.status} ${b.paths.join("\x00")}`));
+  const changedPaths = [...new Set(entries.flatMap((entry) => entry.paths))].sort();
+  const budget = { entries: 0, bytes: 0, maxEntries: maxHashEntries(), maxBytes: maxHashTotalBytes() };
+  const payload = entries.map((entry) => ({
+    status: entry.status,
+    paths: entry.paths,
+    content: entry.paths.map((relPath) => hashPath(root, relPath, budget))
+  }));
+  const key = createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+  return { root, key, changedPaths };
+}
+export function computeWatchdogRepoChangeSignature(cwd) {
+  const root = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
+  if (!root)
+    return;
+  const skipUntracked = isHomeRepoRoot(root) || hasTrackedEntries(root) === false;
+  const statusOutput = git(root, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    `--untracked-files=${skipUntracked ? "no" : "all"}`
+  ]);
+  if (statusOutput === undefined)
+    return;
+  try {
+    return buildRepoChangeSignature(root, statusOutput);
+  } catch (error) {
+    console.warn("[dm-subagents] watchdog repo change signature failed:", error?.message);
+    return;
+  }
+}
+function toolNameFromMessage(message) {
+  const value = message.toolName ?? message.name;
+  return typeof value === "string" ? value : "";
+}
+function toolResultSucceeded(message) {
+  return message.isError !== true && message.error === undefined;
+}
+function messageIndicatesRepoEdit(message) {
+  if (!message || typeof message !== "object")
+    return false;
+  const input = message;
+  const role = input.role;
+  if (role !== "toolResult" && role !== "tool")
+    return false;
+  const toolName = toolNameFromMessage(input);
+  return (toolName === "edit" || toolName === "write") && toolResultSucceeded(input);
+}
+export function eventIndicatesRepoEdit(event) {
+  if (!event || typeof event !== "object")
+    return false;
+  const input = event;
+  if (input.type === "turn_end" || input.event === "turn_end") {
+    return [input.message, ...Array.isArray(input.toolResults) ? input.toolResults : []].some(messageIndicatesRepoEdit);
+  }
+  if (input.type === "tool_result" || input.event === "tool_result")
+    return messageIndicatesRepoEdit({ role: "toolResult", ...input });
+  if (input.type !== "tool_result_end" && input.event !== "tool_result_end")
+    return false;
+  return messageIndicatesRepoEdit(input.message);
+}

package/extensions/dm-subagents/src/watchdog/child-status.js

@@ -0,0 +1,151 @@
+export const CHILD_WATCHDOG_CONFIG_ENV = "DM_SUBAGENT_WATCHDOG_CHILD_CONFIG";
+export const CHILD_WATCHDOG_STATUS_EVENT = "subagent.watchdog.status";
+export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "autofollow", "settling", "stale", "failed"];
+export function resolveChildWatchdogConfig(input) {
+  const override = input.agent ? input.config.children.overrides[input.agent] : undefined;
+  const enabled = input.config.enabled && (override?.enabled ?? input.config.children.enabled);
+  if (!enabled)
+    return;
+  const model = override?.model ?? input.config.children.model;
+  const thinking = override?.thinking ?? input.config.children.thinking;
+  return {
+    enabled: true,
+    ...input.runId ? { runId: input.runId } : {},
+    ...input.agent ? { agent: input.agent } : {},
+    ...input.childIndex !== undefined ? { childIndex: input.childIndex } : {},
+    watchdogTailTimeoutMs: input.config.children.watchdogTailTimeoutMs,
+    agentEndTimeoutMs: input.config.agentEndTimeoutMs,
+    maxWarnings: input.config.maxWarnings,
+    ...model ? { model } : {},
+    ...thinking !== undefined ? { thinking } : {},
+    lsp: { ...input.config.lsp },
+    autoFollowBlockers: input.config.children.autoFollow.blockers,
+    autoFollowMaxAttempts: input.config.children.autoFollow.maxAttempts,
+    stalemateRepeats: input.config.children.autoFollow.stalemateRepeats
+  };
+}
+export function encodeChildWatchdogConfig(config) {
+  return config ? JSON.stringify(config) : undefined;
+}
+function childConfigObject(value, field) {
+  if (value && typeof value === "object" && !Array.isArray(value))
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be an object.`);
+}
+function childConfigOptionalString(input, field) {
+  if (!(field in input))
+    return;
+  const value = input[field];
+  if (typeof value === "string" && value.trim())
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be a non-empty string.`);
+}
+function childConfigOptionalIndex(input, field) {
+  if (!(field in input))
+    return;
+  const value = input[field];
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0)
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be a non-negative integer.`);
+}
+function childConfigPositiveInteger(input, field) {
+  const value = input[field];
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1)
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be a positive integer.`);
+}
+function childConfigNullableNonNegativeInteger(input, field) {
+  const value = input[field];
+  if (value === null)
+    return null;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0)
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be null or a non-negative integer.`);
+}
+function childConfigBoolean(input, field) {
+  const value = input[field];
+  if (typeof value === "boolean")
+    return value;
+  throw new Error(`Invalid child watchdog config: ${field} must be a boolean.`);
+}
+function childConfigLsp(value) {
+  const input = childConfigObject(value, "lsp");
+  if (typeof input.enabled !== "boolean")
+    throw new Error("Invalid child watchdog config: lsp.enabled must be a boolean.");
+  if (typeof input.timeoutMs !== "number" || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1) {
+    throw new Error("Invalid child watchdog config: lsp.timeoutMs must be a positive integer.");
+  }
+  if (typeof input.maxFiles !== "number" || !Number.isInteger(input.maxFiles) || input.maxFiles < 1) {
+    throw new Error("Invalid child watchdog config: lsp.maxFiles must be a positive integer.");
+  }
+  if (typeof input.maxDiagnostics !== "number" || !Number.isInteger(input.maxDiagnostics) || input.maxDiagnostics < 0) {
+    throw new Error("Invalid child watchdog config: lsp.maxDiagnostics must be a non-negative integer.");
+  }
+  return {
+    enabled: input.enabled,
+    timeoutMs: input.timeoutMs,
+    maxFiles: input.maxFiles,
+    maxDiagnostics: input.maxDiagnostics
+  };
+}
+export function decodeChildWatchdogConfig(raw) {
+  if (!raw)
+    return;
+  const parsed = childConfigObject(JSON.parse(raw), "root");
+  if (parsed.enabled === false)
+    return;
+  if (parsed.enabled !== true)
+    throw new Error("Invalid child watchdog config: enabled must be true or false.");
+  const thinking = parsed.thinking;
+  if (thinking !== undefined && typeof thinking !== "string" && thinking !== false) {
+    throw new Error("Invalid child watchdog config: thinking must be a string or false.");
+  }
+  const runId = childConfigOptionalString(parsed, "runId");
+  const agent = childConfigOptionalString(parsed, "agent");
+  const childIndex = childConfigOptionalIndex(parsed, "childIndex");
+  const model = childConfigOptionalString(parsed, "model");
+  return {
+    enabled: true,
+    ...runId ? { runId } : {},
+    ...agent ? { agent } : {},
+    ...childIndex !== undefined ? { childIndex } : {},
+    watchdogTailTimeoutMs: childConfigPositiveInteger(parsed, "watchdogTailTimeoutMs"),
+    agentEndTimeoutMs: childConfigPositiveInteger(parsed, "agentEndTimeoutMs"),
+    maxWarnings: childConfigNullableNonNegativeInteger(parsed, "maxWarnings"),
+    ...model ? { model } : {},
+    ...thinking !== undefined ? { thinking } : {},
+    lsp: childConfigLsp(parsed.lsp),
+    autoFollowBlockers: childConfigBoolean(parsed, "autoFollowBlockers"),
+    autoFollowMaxAttempts: childConfigNullableNonNegativeInteger(parsed, "autoFollowMaxAttempts"),
+    stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats")
+  };
+}
+export function isChildWatchdogStatusEvent(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const event = value;
+  return event.type === CHILD_WATCHDOG_STATUS_EVENT && typeof event.seq === "number" && Number.isInteger(event.seq) && event.seq >= 0 && typeof event.ts === "number" && Number.isFinite(event.ts) && typeof event.followUpPending === "boolean" && typeof event.phase === "string" && CHILD_WATCHDOG_PHASES.includes(event.phase);
+}
+export function childWatchdogIsActive(snapshot) {
+  if (!snapshot)
+    return false;
+  return snapshot.followUpPending || snapshot.phase === "reviewing" || snapshot.phase === "autofollow" || snapshot.phase === "settling";
+}
+export function acceptChildWatchdogEvent(input) {
+  if (input.runId !== undefined && input.event.runId !== input.runId)
+    return;
+  if (input.agent !== undefined && input.event.agent !== input.agent)
+    return;
+  const eventIndex = input.event.childIndex ?? input.event.stepIndex;
+  if (input.childIndex !== undefined && eventIndex !== input.childIndex)
+    return;
+  if (input.current && input.event.seq <= input.current.seq)
+    return;
+  return {
+    phase: input.event.phase,
+    seq: input.event.seq,
+    lastUpdate: input.event.ts,
+    followUpPending: input.event.followUpPending,
+    ...input.event.reason ? { reason: input.event.reason } : {}
+  };
+}

package/extensions/dm-subagents/src/watchdog/emission-guard.js

@@ -0,0 +1,90 @@
+const CONTENT_FREE_PHRASES = new Set([
+  "stop",
+  "done",
+  "complete",
+  "completed",
+  "no issue",
+  "no issues",
+  "no concern",
+  "no concerns",
+  "nothing to add",
+  "lgtm",
+  "looks good",
+  "looks good to me",
+  "all good",
+  "ok",
+  "okay",
+  "none",
+  "n a"
+]);
+export function normalizeWatchdogEmissionText(value) {
+  return value.normalize("NFKC").toLowerCase().replace(/[’'`]/g, "").replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+export function watchdogWarningUnderlyingIdentity(warning) {
+  return [normalizeWatchdogEmissionText(warning.summary), normalizeWatchdogEmissionText(warning.evidence)].join(`
+`);
+}
+export function watchdogWarningIdentity(warning) {
+  return [warning.severity, watchdogWarningUnderlyingIdentity(warning)].join(`
+`);
+}
+function isContentFree(value) {
+  const normalized = normalizeWatchdogEmissionText(value);
+  return !normalized || CONTENT_FREE_PHRASES.has(normalized);
+}
+
+export class WatchdogEmissionGuard {
+  maxWarnings;
+  dedupeHistoryLimit;
+  acceptedCount = 0;
+  acceptedByUnderlyingIdentity = new Map;
+  historyOrder = [];
+  updateAcceptedUnderlyingIdentity;
+  updateAcceptedSeverity;
+  constructor(options = {}) {
+    this.maxWarnings = options.maxWarnings ?? null;
+    this.dedupeHistoryLimit = options.dedupeHistoryLimit ?? 200;
+  }
+  startModelUpdate() {
+    this.updateAcceptedUnderlyingIdentity = undefined;
+    this.updateAcceptedSeverity = undefined;
+  }
+  reset() {
+    this.acceptedCount = 0;
+    this.acceptedByUnderlyingIdentity.clear();
+    this.historyOrder = [];
+    this.startModelUpdate();
+  }
+  evaluate(warning) {
+    if (isContentFree(warning.summary) || isContentFree(warning.evidence) || isContentFree(warning.recommendedAction)) {
+      return { accepted: false, reason: "content-free" };
+    }
+    const underlyingIdentity = watchdogWarningUnderlyingIdentity(warning);
+    const identity = watchdogWarningIdentity(warning);
+    const priorSeverity = this.acceptedByUnderlyingIdentity.get(underlyingIdentity);
+    const escalation = priorSeverity === "concern" && warning.severity === "blocker";
+    if (this.updateAcceptedUnderlyingIdentity !== undefined) {
+      const updateEscalation = this.updateAcceptedUnderlyingIdentity === underlyingIdentity && this.updateAcceptedSeverity === "concern" && warning.severity === "blocker";
+      if (!updateEscalation)
+        return { accepted: false, reason: "update-budget", identity, underlyingIdentity };
+    }
+    if (priorSeverity !== undefined && !escalation)
+      return { accepted: false, reason: "duplicate", identity, underlyingIdentity };
+    if (this.maxWarnings !== null && this.acceptedCount >= this.maxWarnings && !escalation) {
+      return { accepted: false, reason: "max-warnings", identity, underlyingIdentity };
+    }
+    this.acceptedByUnderlyingIdentity.set(underlyingIdentity, warning.severity);
+    if (!priorSeverity) {
+      this.acceptedCount++;
+      this.historyOrder.push(underlyingIdentity);
+    }
+    while (this.historyOrder.length > this.dedupeHistoryLimit) {
+      const stale = this.historyOrder.shift();
+      if (stale)
+        this.acceptedByUnderlyingIdentity.delete(stale);
+    }
+    this.updateAcceptedUnderlyingIdentity = underlyingIdentity;
+    this.updateAcceptedSeverity = warning.severity;
+    return { accepted: true, identity, underlyingIdentity, escalation };
+  }
+}