@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -0,0 +1,54 @@
+import { Container, Spacer, Text } from "@duckmind/dm-tui";
+function titleCase(value) {
+  return value.split("-").map((part) => part ? `${part[0]?.toUpperCase()}${part.slice(1)}` : part).join(" ");
+}
+function stateLabels(warning) {
+  const labels = [];
+  if (warning.state === "displayed")
+    labels.push("displayed");
+  if (warning.stale || warning.state === "stale")
+    labels.push("stale · no auto-follow");
+  if (warning.state === "failed")
+    labels.push("failed review");
+  if (warning.state === "stalemate")
+    labels.push("stalemate · auto-follow stopped");
+  if (warning.autoFollowAttempt !== undefined)
+    labels.push(`auto-follow attempt ${warning.autoFollowAttempt}`);
+  return labels;
+}
+export function formatWatchdogWarningRenderText(warning) {
+  const labels = stateLabels(warning);
+  const subject = warning.severity === "blocker" ? "Blocker" : "Concern";
+  const lines = [
+    `Subagent watchdog ${subject}${labels.length ? ` (${labels.join(", ")})` : ""}: ${warning.summary}`,
+    `Evidence: ${warning.evidence}`,
+    `Recommended action: ${warning.recommendedAction}`,
+    `Category: ${titleCase(warning.category)} · Source: ${warning.source}${warning.agent ? ` · Agent: ${warning.agent}` : ""}${warning.runId ? ` · Run: ${warning.runId}` : ""}`
+  ];
+  if (warning.state === "failed" && warning.error)
+    lines.push(`Failure: ${warning.error}`);
+  if (warning.state === "stalemate" && warning.stalemateRepeats !== undefined) {
+    lines.push(`Auto-follow stopped after ${warning.stalemateRepeats} repeated blocker warning${warning.stalemateRepeats === 1 ? "" : "s"}.`);
+  }
+  if (warning.stale || warning.state === "stale")
+    lines.push("This warning arrived after the watchdog catch-up timeout and must not auto-follow.");
+  return lines.join(`
+`);
+}
+export function renderWatchdogWarning(warning, options, theme) {
+  const text = formatWatchdogWarningRenderText(warning);
+  const lines = text.split(`
+`);
+  const container = new Container;
+  const color = warning.severity === "blocker" ? "error" : "warning";
+  const bold = theme.bold ?? ((value) => value);
+  container.addChild(new Text(theme.fg(color, bold(lines[0] ?? "Subagent watchdog warning")), 0, 0));
+  if (options.expanded) {
+    container.addChild(new Spacer(1));
+    for (const line of lines.slice(1))
+      container.addChild(new Text(theme.fg("dim", line), 0, 0));
+  } else if (lines[1]) {
+    container.addChild(new Text(theme.fg("dim", `  ⎿  ${lines[1]}`), 0, 0));
+  }
+  return container;
+}

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

@@ -0,0 +1,251 @@
+import { Agent } from "@duckmind/dm-agent-core";
+import { createReadOnlyTools, convertToLlm } from "@duckmind/dm-coding-agent";
+import { streamSimple } from "@duckmind/dm-ai/compat";
+import { Type } from "typebox";
+import { resolveModelCandidate } from "../runs/shared/model-fallback.js";
+import { agentStreamOptions } from "../shared/agent-stream-options.js";
+import { resolveEffectiveThinking, splitKnownThinkingSuffix, THINKING_LEVELS, toModelInfo } from "../shared/model-info.js";
+import {
+  WATCHDOG_WARNING_CATEGORIES,
+  WATCHDOG_WARNING_CONFIDENCES,
+  WATCHDOG_WARNING_SEVERITIES
+} from "./types.js";
+const WATCHDOG_ALLOWED_TOOL_NAMES = new Set(["read", "grep", "find", "ls", "watchdog_warn"]);
+const WatchdogWarnParams = Type.Object({
+  severity: Type.String({ enum: WATCHDOG_WARNING_SEVERITIES, description: "concern for actionable risk, blocker for a likely wrong or unsafe outcome" }),
+  summary: Type.String({ description: "One concise sentence naming the issue." }),
+  evidence: Type.String({ description: "Specific evidence from the turn delta or inspected files." }),
+  recommendedAction: Type.String({ description: "Specific action the parent should take before accepting or continuing." }),
+  category: Type.Optional(Type.String({ enum: WATCHDOG_WARNING_CATEGORIES })),
+  confidence: Type.Optional(Type.String({ enum: WATCHDOG_WARNING_CONFIDENCES }))
+}, { additionalProperties: false });
+function fullModelId(model) {
+  return `${model.provider}/${model.id}`;
+}
+function splitProviderModel(value) {
+  const slashIndex = value.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === value.length - 1)
+    return;
+  return { provider: value.slice(0, slashIndex), id: value.slice(slashIndex + 1) };
+}
+function assertThinkingLevel(value, source) {
+  if (THINKING_LEVELS.includes(value))
+    return value;
+  throw new Error(`Unsupported watchdog thinking level '${value}' from ${source}; expected ${THINKING_LEVELS.join(", ")} or false.`);
+}
+function contextThinkingLevel(ctx, currentThinkingLevel) {
+  if (currentThinkingLevel)
+    return currentThinkingLevel;
+  const value = ctx.thinkingLevel;
+  return typeof value === "string" && THINKING_LEVELS.includes(value) ? value : undefined;
+}
+function resolveReviewThinking(input) {
+  const fromModelOrConfig = resolveEffectiveThinking(input.modelString, input.configThinking);
+  if (fromModelOrConfig)
+    return assertThinkingLevel(fromModelOrConfig, "watchdog model/config");
+  if (input.configThinking === false)
+    return "off";
+  if (input.configThinking !== undefined)
+    return assertThinkingLevel(input.configThinking, "watchdog config");
+  if (input.allowContextThinking)
+    return contextThinkingLevel(input.ctx, input.currentThinkingLevel) ?? "off";
+  return "off";
+}
+function resolveConfiguredModel(ctx, rawModel) {
+  const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
+  const preferredProvider = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
+  const resolved = resolveModelCandidate(rawModel, availableModels, preferredProvider);
+  if (!resolved) {
+    throw new Error(`Configured watchdog model '${rawModel}' did not match exactly one authenticated available model. Use provider/model or configure credentials for the intended provider.`);
+  }
+  const { baseModel } = splitKnownThinkingSuffix(resolved);
+  const named = splitProviderModel(baseModel);
+  if (!named) {
+    throw new Error(`Configured watchdog model '${rawModel}' did not match exactly one authenticated available model. Use provider/model or configure credentials for the intended provider.`);
+  }
+  const model = ctx.modelRegistry.find(named.provider, named.id);
+  if (!model)
+    throw new Error(`Configured watchdog model '${rawModel}' was not found as '${baseModel}'.`);
+  if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
+    throw new Error(`Configured watchdog model '${baseModel}' is not authenticated. Configure credentials for provider '${named.provider}' or choose an authenticated model.`);
+  }
+  return { model, modelString: resolved };
+}
+async function resolveReviewAuth(ctx, model) {
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (auth.ok === false)
+    throw new Error(`Watchdog model auth failed for ${fullModelId(model)}: ${auth.error}`);
+  return {
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    ...auth.headers ? { headers: auth.headers } : {},
+    ...auth.env ? { env: auth.env } : {}
+  };
+}
+export async function resolveWatchdogReviewModel(ctx, config, options = {}) {
+  if (config.main.model) {
+    const resolved = resolveConfiguredModel(ctx, config.main.model);
+    return {
+      model: resolved.model,
+      thinkingLevel: resolveReviewThinking({
+        modelString: resolved.modelString,
+        configThinking: config.main.thinking,
+        ctx,
+        allowContextThinking: false,
+        currentThinkingLevel: options.currentThinkingLevel
+      }),
+      auth: await resolveReviewAuth(ctx, resolved.model),
+      explicit: true
+    };
+  }
+  const currentModel = ctx.model;
+  if (!currentModel) {
+    throw new Error("Main watchdog review cannot run because the current DM session model is unavailable and subagents.watchdog.main.model is not configured.");
+  }
+  return {
+    model: currentModel,
+    thinkingLevel: resolveReviewThinking({
+      modelString: fullModelId(currentModel),
+      configThinking: config.main.thinking,
+      ctx,
+      allowContextThinking: true,
+      currentThinkingLevel: options.currentThinkingLevel
+    }),
+    auth: await resolveReviewAuth(ctx, currentModel),
+    explicit: false
+  };
+}
+function nonEmptyString(value, field) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    throw new Error(`watchdog_warn.${field} must be a non-empty string.`);
+  return trimmed;
+}
+function toWatchdogWarning(params) {
+  return {
+    severity: params.severity,
+    category: params.category ?? "other",
+    confidence: params.confidence ?? "medium",
+    source: "main",
+    summary: nonEmptyString(params.summary, "summary"),
+    evidence: nonEmptyString(params.evidence, "evidence"),
+    recommendedAction: nonEmptyString(params.recommendedAction, "recommendedAction")
+  };
+}
+function createWatchdogWarnTool(request) {
+  return {
+    name: "watchdog_warn",
+    label: "Watchdog warning",
+    description: [
+      "Emit one actionable main-session watchdog warning.",
+      "Use only for medium/high confidence concerns or blockers that the parent should consider before accepting the work.",
+      "Do not use for nits, praise, informational notes, or clean reviews."
+    ].join(" "),
+    parameters: WatchdogWarnParams,
+    executionMode: "sequential",
+    async execute(_toolCallId, params) {
+      const warning = toWatchdogWarning(params);
+      const accepted = request.emitWarning(warning);
+      return {
+        content: [{
+          type: "text",
+          text: accepted ? "Watchdog warning recorded." : "Watchdog warning was ignored by the runtime guard because it was stale, duplicate, or over budget."
+        }],
+        details: { accepted }
+      };
+    }
+  };
+}
+function buildWatchdogSystemPrompt(ctx, options = {}) {
+  return [
+    "You are the main-session subagent watchdog for DM.",
+    `Working directory: ${ctx.cwd}`,
+    "Review only the supplied parent turn delta. Inspect repository files only when needed to verify a concrete concern.",
+    options.hasScope ? "When the review input includes a Current scope block, treat newer scope prompts as superseding/mutating older prompts and use category='scope-drift' for work that serves no current scope item." : undefined,
+    "You are read-only. You may use read, grep, find, and ls. Do not edit files, run shell commands, spawn agents, or mutate state.",
+    "Emit warnings only by calling watchdog_warn. Freeform assistant text is ignored and must not be used to report warnings.",
+    "Emit only medium/high confidence actionable concerns or blockers: missed user constraints, correctness risks, test gaps that matter, unsafe changes, stale facts, loop risks, or scope drift.",
+    "Do not emit nits, style preferences, low-confidence guesses, informational notes, praise, or summaries.",
+    "If the turn is clean, call no tools and end normally.",
+    "Use severity='blocker' only when the issue should stop acceptance until addressed; otherwise use severity='concern'."
+  ].filter((line) => Boolean(line)).join(`
+`);
+}
+function buildReviewPrompt(request, selection) {
+  return [
+    "Review this parent-session turn delta for subagent-watchdog-worthy issues.",
+    `Review id: ${request.reviewId}; epoch: ${request.epoch}; review model: ${fullModelId(selection.model)}; thinking: ${selection.thinkingLevel}.`,
+    "Call watchdog_warn for each qualifying concern or blocker. Call no tools when clean.",
+    "<turn_delta>",
+    request.delta,
+    "</turn_delta>"
+  ].join(`
+
+`);
+}
+function finalStopReason(agent) {
+  for (let index = agent.state.messages.length - 1;index >= 0; index--) {
+    const message = agent.state.messages[index];
+    if (message && typeof message === "object" && message.role === "assistant") {
+      const stopReason = message.stopReason;
+      if (stopReason === "error" || stopReason === "aborted" || stopReason === "length")
+        return stopReason;
+      return "stop";
+    }
+  }
+  return "stop";
+}
+function resolveContext(provider) {
+  return typeof provider === "function" ? provider() : provider;
+}
+export function createMainWatchdogReview(provider, options = {}) {
+  return async (request) => {
+    const ctx = resolveContext(provider);
+    if (!ctx)
+      throw new Error("Main watchdog review cannot run without an active DM extension context.");
+    if (ctx.signal?.aborted || request.signal?.aborted)
+      return { stopReason: "aborted" };
+    const selection = await resolveWatchdogReviewModel(ctx, request.config, {
+      currentThinkingLevel: options.getThinkingLevel?.()
+    });
+    if (ctx.signal?.aborted || request.signal?.aborted)
+      return { stopReason: "aborted" };
+    const auth = selection.auth;
+    const registeredProvider = ctx.modelRegistry.getRegisteredProviderConfig?.(selection.model.provider);
+    const baseStreamFn = options.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === selection.model.api ? registeredProvider.streamSimple : streamSimple);
+    const streamFn = (model, context, streamOptions) => baseStreamFn(model, context, {
+      ...streamOptions,
+      ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+      env: auth.env || streamOptions?.env ? { ...auth.env ?? {}, ...streamOptions?.env ?? {} } : undefined,
+      headers: { ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
+    });
+    const tools = [
+      ...(options.createReadOnlyTools ?? createReadOnlyTools)(ctx.cwd).filter((tool) => WATCHDOG_ALLOWED_TOOL_NAMES.has(tool.name) && tool.name !== "watchdog_warn"),
+      createWatchdogWarnTool(request)
+    ];
+    const agent = new Agent({
+      initialState: {
+        systemPrompt: buildWatchdogSystemPrompt(ctx, { hasScope: request.hasScope }),
+        model: selection.model,
+        thinkingLevel: selection.thinkingLevel,
+        tools
+      },
+      convertToLlm,
+      ...agentStreamOptions(streamFn),
+      getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
+      beforeToolCall: async ({ toolCall }) => WATCHDOG_ALLOWED_TOOL_NAMES.has(toolCall.name) ? undefined : { block: true, reason: `Watchdog reviews are read-only; tool '${toolCall.name}' is not allowed.` },
+      toolExecution: "sequential"
+    });
+    const abort = () => agent.abort();
+    ctx.signal?.addEventListener("abort", abort, { once: true });
+    request.signal?.addEventListener("abort", abort, { once: true });
+    try {
+      if (ctx.signal?.aborted || request.signal?.aborted)
+        return { stopReason: "aborted" };
+      await agent.prompt(buildReviewPrompt(request, selection));
+    } finally {
+      ctx.signal?.removeEventListener("abort", abort);
+      request.signal?.removeEventListener("abort", abort);
+    }
+    return { stopReason: finalStopReason(agent) };
+  };
+}