@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/watchdog/register-main.js

@@ -1,7 +1,8 @@
 import { Text } from "@duckmind/dm-tui";
 import { resolveEffectiveThinking, splitKnownThinkingSuffix, THINKING_LEVELS } from "../shared/model-info.js";
 import { SLASH_TEXT_RESULT_TYPE } from "../shared/types.js";
-import { recommendStrongWatchdogModel, resolveWatchdogModelInput, parseWatchdogThinkingInput } from "./model-selection.js";
+import { captureWatchdogDiffBaseline } from "./diff-tool.js";
+import { formatWatchdogRecommendation, recommendWatchdogModel, resolveWatchdogModelInput, parseWatchdogThinkingInput } from "./model-selection.js";
 import { renderWatchdogWarning } from "./render.js";
 import { createMainWatchdogReview } from "./review.js";
 import { MainWatchdogRuntime } from "./runtime.js";
@@ -72,12 +73,11 @@ function childrenLine(snapshot) {
   }).join("; ")}` : "";
   return `Children: ${boolLabel(snapshot.config.enabled && children.enabled)} · model ${model} · thinking ${thinking}${overrideText}`;
 }
-function recommendationLine(ctx) {
+function recommendationLine(snapshot, ctx) {
   try {
-    const recommendation = recommendStrongWatchdogModel(ctx);
-    return `Recommended strong watchdog: ${recommendation.model}:${recommendation.thinking} (${recommendation.label}, complementary reviewer)`;
+    return formatWatchdogRecommendation(recommendWatchdogModel(ctx, snapshot.config.main));
   } catch (error) {
-    return `Recommended strong watchdog: unavailable (${messageFromError(error)})`;
+    return `Watchdog recommendation unavailable (${messageFromError(error)})`;
   }
 }
 function lspLine(snapshot) {
@@ -92,7 +92,8 @@ export function buildWatchdogStatus(snapshot, ctx) {
     "Subagent watchdog",
     `Main: ${boolLabel(snapshot.enabled)}${!snapshot.config.enabled && snapshot.sessionOverride === undefined ? " (default off)" : ""}`,
     `Runtime: ${statusLabel(snapshot.status)}${snapshot.bufferedDeltas > 0 ? ` · buffered deltas ${snapshot.bufferedDeltas}` : ""}`,
-    `Review trigger: ${snapshot.reviewTrigger === "repo-edits" ? "repo edits only" : "every non-empty turn delta"}`,
+    `Review trigger: ${snapshot.reviewTrigger === "repo-edits" ? snapshot.config.clarification ? "repo edits + bounded main orchestration activity" : "repo edits only" : "every non-empty turn delta"}`,
+    `Main clarification: ${snapshot.config.clarification ? "on" : "off"}`,
     `Scope context: ${snapshot.config.scope.enabled ? "on" : "off"}`,
     `Cadence: ${snapshot.config.cadence.everyNTools === null ? "boundary only" : `every ${snapshot.config.cadence.everyNTools} tools + boundary`}`,
     lspLine(snapshot),
@@ -100,9 +101,10 @@ export function buildWatchdogStatus(snapshot, ctx) {
     mainModelLine(snapshot, ctx),
     `Main thinking: ${mainThinkingLine(snapshot, ctx)}`,
     childrenLine(snapshot),
-    recommendationLine(ctx),
+    recommendationLine(snapshot, ctx),
     `Agent-end timeout: ${snapshot.config.agentEndTimeoutMs}ms`,
-    `Auto-follow: ${snapshot.enabled && snapshot.config.autoFollow.blockers ? "on for blockers" : "off"} · attempts ${snapshot.autoFollowAttempts}${snapshot.config.autoFollow.maxAttempts === null ? "" : `/${snapshot.config.autoFollow.maxAttempts}`}${snapshot.autoFollowQueued ? " · queued" : ""}${snapshot.autoFollowStalemate ? " · stalemate" : ""}`,
+    `Stalemate: ${snapshot.boundaryRepeats}/${snapshot.config.stalemateRepeats}${snapshot.stalemate ? " · stopped" : ""}`,
+    `Rules: ${snapshot.config.rules ? `${Object.keys(snapshot.config.rules.roleModels).length} role models · ${snapshot.config.rules.action}` : "none"}`,
     `Review model call: ${snapshot.reviewDescription}`
   ];
   if (snapshot.failedReviews > 0)
@@ -122,15 +124,15 @@ export function buildWatchdogStatus(snapshot, ctx) {
   } else {
     lines.push("", "Config: ok");
   }
-  lines.push("Sources:", ...snapshot.sources.map(sourceLine), "", "Model commands:", "- /subagents-watchdog recommend-model", "- /subagents-watchdog model recommended", "- /subagents-watchdog model <provider/model[:thinking]>", "- /subagents-watchdog model inherit", "- /subagents-watchdog session model recommended", 'Agent action: subagent({ action: "watchdog.configure", model: "recommended", scope: "session" })');
+  lines.push("Sources:", ...snapshot.sources.map(sourceLine), "", "Model commands:", "- /subagents-watchdog recommend-model", "- /subagents-watchdog model recommended (saves to user settings, not project settings)", "- /subagents-watchdog model <provider/model[:thinking]>", "- /subagents-watchdog model inherit", "- /subagents-watchdog session model recommended", 'Agent action: subagent({ action: "watchdog.configure", model: "recommended", scope: "session" })');
   return lines.join(`
 `);
 }
 function parseTestCommand(input) {
-  const match = input.match(/^test\s+(concern|blocker)\s+([\s\S]+)$/);
+  const match = input.match(/^test\s+(concern|blocker)\s+(low|medium|high)\s+([\s\S]+)$/);
   if (!match)
     return;
-  return { severity: match[1], text: match[2].trim() };
+  return { severity: match[1], importance: match[2], text: match[3].trim() };
 }
 function formatThinking(value) {
   if (value === undefined)
@@ -143,14 +145,14 @@ function parseThinkingCommand(raw) {
     return null;
   return parseWatchdogThinkingInput(value, "/subagents-watchdog thinking") ?? null;
 }
-function resolveModelCommandValue(ctx, raw) {
+function resolveModelCommandValue(runtime, ctx, raw) {
   const value = raw.trim();
   if (!value)
     throw new Error("Expected a model, 'recommended', or 'inherit'.");
   if (value === "inherit")
     return { model: null, thinking: null, description: "current session model and thinking" };
   if (value === "recommended") {
-    const recommendation = recommendStrongWatchdogModel(ctx);
+    const recommendation = recommendWatchdogModel(ctx, runtime.getSnapshot(ctx.cwd).config.main);
     return {
       model: recommendation.model,
       thinking: recommendation.thinking,
@@ -164,18 +166,18 @@ function resolveModelCommandValue(ctx, raw) {
     description: `${resolved.model}${resolved.thinking ? `:${resolved.thinking}` : ""}`
   };
 }
-function buildRecommendationText(ctx) {
-  const recommendation = recommendStrongWatchdogModel(ctx);
+function buildRecommendationText(runtime, ctx) {
+  const recommendation = recommendWatchdogModel(ctx, runtime.getSnapshot(ctx.cwd).config.main);
   return [
     "Subagent watchdog recommended model",
     `Current session: ${currentSessionModelLine(ctx)}`,
-    `Recommended: ${recommendation.model}:${recommendation.thinking}`,
+    recommendation.source === "configured" ? formatWatchdogRecommendation(recommendation) : `Recommended: ${recommendation.model}:${recommendation.thinking}`,
     `Reason: ${recommendation.reason}`,
     "",
     "Apply for this session:",
     "/subagents-watchdog session model recommended",
     "",
-    "Save as your user default:",
+    "Save as your user default (affects other projects without overrides; does not change project settings):",
     "/subagents-watchdog model recommended"
   ].join(`
 `);
@@ -195,25 +197,20 @@ function buildCheckText(runtime, ctx) {
   }
   lines.push(`Main thinking: ${mainThinkingLine(snapshot, ctx)}`);
   lines.push(lspLine(snapshot));
-  try {
-    const recommendation = recommendStrongWatchdogModel(ctx);
-    lines.push(`Recommended strong watchdog: ${recommendation.model}:${recommendation.thinking}`);
-  } catch (error) {
-    lines.push(`Recommended strong watchdog: unavailable (${messageFromError(error)})`);
-  }
+  lines.push(recommendationLine(snapshot, ctx));
   return lines.join(`
 `);
 }
-function createTestWarning(severity, text) {
+function createTestWarning(severity, importance, text) {
   return {
     severity,
     category: "other",
-    confidence: "high",
+    importance,
     source: "main",
     state: "displayed",
     summary: text,
     evidence: `Manual /subagents-watchdog test ${severity} message from the main session.`,
-    recommendedAction: severity === "blocker" ? "Verify the renderer, transcript delivery, and auto-follow policy." : "Verify the renderer and transcript delivery; decide manually whether any action is needed."
+    recommendedAction: severity === "blocker" ? "Verify the renderer and transcript delivery." : "Verify the renderer and transcript delivery; decide manually whether any action is needed."
   };
 }
 async function handleWatchdogCommand(dm, runtime, args, ctx) {
@@ -224,7 +221,7 @@ async function handleWatchdogCommand(dm, runtime, args, ctx) {
   }
   if (input === "recommend-model") {
     try {
-      sendSlashText(dm, buildRecommendationText(ctx));
+      sendSlashText(dm, buildRecommendationText(runtime, ctx));
     } catch (error) {
       sendSlashText(dm, `Subagent watchdog recommended model
 
@@ -275,7 +272,7 @@ Could not update ${getWatchdogUserSettingsPath()}: ${messageFromError(error)}`);
   if (input.startsWith("session model ")) {
     const rawModel = input.slice("session model ".length);
     try {
-      const value = resolveModelCommandValue(ctx, rawModel);
+      const value = resolveModelCommandValue(runtime, ctx, rawModel);
       const snapshot = value.model === null ? runtime.clearSessionModel(ctx.cwd) : runtime.setSessionModel({ model: value.model, thinking: value.thinking ?? null }, ctx.cwd);
       sendSlashText(dm, [
         `Subagent watchdog session model: ${value.description}.`,
@@ -294,7 +291,7 @@ ${messageFromError(error)}`);
   if (input.startsWith("model ")) {
     const rawModel = input.slice("model ".length);
     try {
-      const value = resolveModelCommandValue(ctx, rawModel);
+      const value = resolveModelCommandValue(runtime, ctx, rawModel);
       const settingsPath = writeWatchdogModelSettings({
         scope: "user",
         target: { kind: "main" },
@@ -304,7 +301,7 @@ ${messageFromError(error)}`);
       runtime.refreshConfig(ctx.cwd);
       const snapshot = runtime.getSnapshot(ctx.cwd);
       sendSlashText(dm, [
-        `Subagent watchdog model saved: ${value.description}.`,
+        `Subagent watchdog model saved to user settings: ${value.description}. Project and session overrides still take precedence.`,
         `Updated: ${settingsPath}`,
         `Main now: ${boolLabel(snapshot.enabled)}`,
         value.model === null ? "The watchdog now inherits the current session model and thinking." : "Run /subagents-watchdog on if the watchdog is still off.",
@@ -348,29 +345,28 @@ No settings files were changed.`);
   const test = parseTestCommand(input);
   if (test) {
     if (!test.text) {
-      ctx.ui.notify("Usage: /subagents-watchdog test concern|blocker <text>", "error");
+      ctx.ui.notify("Usage: /subagents-watchdog test concern|blocker low|medium|high <text>", "error");
       return;
     }
-    const warning = createTestWarning(test.severity, test.text);
-    const details = runtime.recordDisplayedWarning(warning);
-    dm.sendMessage(createWatchdogWarningMessage(details, { display: true, details }));
+    const warning = createTestWarning(test.severity, test.importance, test.text);
+    runtime.displayRecordedWarning(warning);
     return;
   }
-  ctx.ui.notify(`Usage: /subagents-watchdog [status|on|off|session on|session off|recommend-model|model recommended|model <provider/model[:thinking]>|model inherit|thinking ${THINKING_LEVELS.join("|")}|thinking inherit|session model recommended|check|test concern <text>|test blocker <text>]`, "error");
+  ctx.ui.notify(`Usage: /subagents-watchdog [status|on|off|session on|session off|recommend-model|model recommended|model <provider/model[:thinking]>|model inherit|thinking ${THINKING_LEVELS.join("|")}|thinking inherit|session model recommended|check|test concern|blocker low|medium|high <text>]`, "error");
 }
 export function registerMainWatchdog(dm, options = {}) {
   let currentContext;
+  let diffBaseline;
   const rememberContext = (ctx) => {
     currentContext = ctx;
   };
   const runtime = options.runtime ?? new MainWatchdogRuntime({
-    review: options.review ?? createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => dm.getThinkingLevel() }),
+    review: options.review ?? createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => dm.getThinkingLevel(), diffBaseline: () => diffBaseline }),
     reviewDescription: options.review ? "injected seam" : "real model review",
     reviewChangesOnly: true,
-    displayWarning: (details, delivery) => {
-      dm.sendMessage(createWatchdogWarningMessage(details, { display: true, details }), delivery?.deliverAs === "steer" ? { deliverAs: "steer" } : undefined);
-    },
-    sendUserMessage: (message) => dm.sendUserMessage(message)
+    displayWarning: (details, options) => dm.sendMessage(createWatchdogWarningMessage(details, { display: true, details }), options),
+    displayUserWarning: (details) => dm.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, details),
+    displayClarification: (content) => dm.sendMessage({ customType: "subagent_watchdog_clarification", content, display: true }, { deliverAs: "steer", triggerTurn: true })
   });
   dm.registerMessageRenderer(SUBAGENT_WATCHDOG_WARNING_TYPE, (message, renderOptions, theme) => {
     const details = message.details;
@@ -381,6 +377,12 @@ export function registerMainWatchdog(dm, options = {}) {
     }
     return renderWatchdogWarning(details, renderOptions, theme);
   });
+  const registerEntryRenderer = dm.registerEntryRenderer;
+  if (typeof registerEntryRenderer === "function")
+    registerEntryRenderer.call(dm, SUBAGENT_WATCHDOG_WARNING_TYPE, (entry, renderOptions, theme) => {
+      const details = entry.data;
+      return details?.summary && details.evidence && details.recommendedAction ? renderWatchdogWarning(details, renderOptions, theme) : undefined;
+    });
   dm.registerCommand("subagents-watchdog", {
     description: "Show or toggle the default-off subagent watchdog",
     handler: (args, ctx) => {
@@ -390,6 +392,7 @@ export function registerMainWatchdog(dm, options = {}) {
   });
   dm.on("session_start", (_event, ctx) => {
     rememberContext(ctx);
+    diffBaseline = captureWatchdogDiffBaseline(ctx.cwd);
     runtime.bindSession(ctx);
   });
   dm.on("before_agent_start", (event, ctx) => {
@@ -400,6 +403,11 @@ export function registerMainWatchdog(dm, options = {}) {
     rememberContext(ctx);
     runtime.handleTurnEnd(event, ctx);
   });
+  dm.on("input", (event) => {
+    if (event.source !== "extension")
+      runtime.handleUserInput();
+  });
+  dm.on("model_select", () => runtime.handleModelChange());
   dm.on("tool_result", (_event, ctx) => {
     rememberContext(ctx);
     runtime.handleToolResult(ctx);
@@ -408,9 +416,9 @@ export function registerMainWatchdog(dm, options = {}) {
     rememberContext(ctx);
     return runtime.handleAgentEnd(event, ctx);
   });
-  dm.on("session_before_switch", () => runtime.reset("session switch", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true, resetAutoFollow: true }));
-  dm.on("session_before_fork", () => runtime.reset("session fork", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true, resetAutoFollow: true }));
-  dm.on("session_compact", () => runtime.reset("session compact", { clearScope: true }));
+  dm.on("session_before_switch", () => runtime.reset("session switch", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true }));
+  dm.on("session_before_fork", () => runtime.reset("session fork", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true }));
+  dm.on("session_compact", () => runtime.reset("session compact", { clearActivity: true }));
   dm.on("session_shutdown", () => {
     currentContext = undefined;
     runtime.dispose();

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

@@ -7,13 +7,11 @@ function stateLabels(warning) {
   if (warning.state === "displayed")
     labels.push("displayed");
   if (warning.stale || warning.state === "stale")
-    labels.push("stale · no auto-follow");
+    labels.push("stale");
   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}`);
+    labels.push("stalemate");
   return labels;
 }
 export function formatWatchdogWarningRenderText(warning) {
@@ -23,15 +21,15 @@ export function formatWatchdogWarningRenderText(warning) {
     `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}` : ""}`
+    `Importance: ${titleCase(warning.importance)} · 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"}.`);
+    lines.push(`Same warning ${warning.stalemateRepeats} time${warning.stalemateRepeats === 1 ? "" : "s"} in a row; the watchdog stopped continuing the run.`);
   }
   if (warning.stale || warning.state === "stale")
-    lines.push("This warning arrived after the watchdog catch-up timeout and must not auto-follow.");
+    lines.push("This warning arrived after the watchdog catch-up timeout.");
   return lines.join(`
 `);
 }

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

@@ -2,22 +2,27 @@ 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 { resolveModelCandidate } from "../runs/shared/model-resolution.js";
 import { agentStreamOptions } from "../shared/agent-stream-options.js";
+import { opencodeSessionHeaders } from "../shared/opencode-session-headers.js";
 import { resolveEffectiveThinking, splitKnownThinkingSuffix, THINKING_LEVELS, toModelInfo } from "../shared/model-info.js";
+import { createWatchdogDiffTool, WATCHDOG_DIFF_TOOL_NAME } from "./diff-tool.js";
+import { loadWatchdogGuidance } from "./guidance.js";
+import { boundWatchdogReviewText } from "./runtime.js";
 import {
   WATCHDOG_WARNING_CATEGORIES,
-  WATCHDOG_WARNING_CONFIDENCES,
+  WATCHDOG_WARNING_IMPORTANCES,
   WATCHDOG_WARNING_SEVERITIES
 } from "./types.js";
-const WATCHDOG_ALLOWED_TOOL_NAMES = new Set(["read", "grep", "find", "ls", "watchdog_warn"]);
+const WATCHDOG_ALLOWED_TOOL_NAMES = new Set(["read", "grep", "find", "ls", "watchdog_warn", WATCHDOG_DIFF_TOOL_NAME]);
+const WatchdogAskParams = Type.Object({ question: Type.String(), evidence: Type.String() }, { additionalProperties: false });
 const WatchdogWarnParams = Type.Object({
   severity: Type.String({ enum: WATCHDOG_WARNING_SEVERITIES, description: "concern for actionable risk, blocker for a likely wrong or unsafe outcome" }),
+  importance: Type.String({ enum: WATCHDOG_WARNING_IMPORTANCES, description: "low or medium for user-only visibility; high when the parent model must receive the finding" }),
   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 }))
+  category: Type.Optional(Type.String({ enum: WATCHDOG_WARNING_CATEGORIES }))
 }, { additionalProperties: false });
 function fullModelId(model) {
   return `${model.provider}/${model.id}`;
@@ -71,10 +76,18 @@ function resolveConfiguredModel(ctx, rawModel) {
   }
   return { model, modelString: resolved };
 }
+
+class WatchdogAuthError extends Error {
+}
 async function resolveReviewAuth(ctx, model) {
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  let auth;
+  try {
+    auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  } catch (error) {
+    throw new WatchdogAuthError(`Watchdog model auth failed for ${fullModelId(model)}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
   if (auth.ok === false)
-    throw new Error(`Watchdog model auth failed for ${fullModelId(model)}: ${auth.error}`);
+    throw new WatchdogAuthError(`Watchdog model auth failed for ${fullModelId(model)}: ${auth.error}`);
   return {
     ...auth.apiKey ? { apiKey: auth.apiKey } : {},
     ...auth.headers ? { headers: auth.headers } : {},
@@ -123,8 +136,8 @@ function nonEmptyString(value, field) {
 function toWatchdogWarning(params) {
   return {
     severity: params.severity,
+    importance: params.importance,
     category: params.category ?? "other",
-    confidence: params.confidence ?? "medium",
     source: "main",
     summary: nonEmptyString(params.summary, "summary"),
     evidence: nonEmptyString(params.evidence, "evidence"),
@@ -137,7 +150,7 @@ function createWatchdogWarnTool(request) {
     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.",
+      "Set importance explicitly: low or medium for user-only visibility, high only when the parent model must receive the finding.",
       "Do not use for nits, praise, informational notes, or clean reviews."
     ].join(" "),
     parameters: WatchdogWarnParams,
@@ -155,18 +168,30 @@ function createWatchdogWarnTool(request) {
     }
   };
 }
-function buildWatchdogSystemPrompt(ctx, options = {}) {
+export function formatWatchdogCwdSection(cwd) {
+  if (/[\p{Cc}\p{Zl}\p{Zp}<>]/u.test(cwd))
+    throw new Error("Watchdog cwd cannot contain control, line-separator, or angle-bracket characters.");
+  return `<cwd>
+${cwd}
+</cwd>`;
+}
+export function buildWatchdogSystemPrompt(ctx, options = {}) {
+  const guidance = options.guidance?.trim();
   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.",
+    options.hasScope ? "Use the Current scope record alongside supplied activity evidence; an unrelated user question does not cancel older authorized work." : undefined,
+    `You are read-only. You may use ${options.hasDiff ? "read, grep, find, ls, and watchdog_diff (the full repo diff since the session baseline; pass a path to narrow it)" : "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.",
+    "Emit only 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, unsupported 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'."
+    "Use severity='blocker' only when the issue should stop acceptance until addressed; otherwise use severity='concern'.",
+    guidance ? `
+Standing instructions from WATCHDOG.md (project first, then user):
+${guidance}` : undefined,
+    `
+${formatWatchdogCwdSection(ctx.cwd)}`
   ].filter((line) => Boolean(line)).join(`
 `);
 }
@@ -182,18 +207,6 @@ function buildReviewPrompt(request, selection) {
 
 `);
 }
-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;
 }
@@ -202,50 +215,112 @@ export function createMainWatchdogReview(provider, options = {}) {
     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)
+    const aborted = () => ctx.signal?.aborted || request.signal?.aborted;
+    if (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, {
+    try {
+      return (await runWatchdogAttempt(ctx, request, options)).result;
+    } catch (error) {
+      if (error instanceof WatchdogAuthError)
+        throw error.cause ?? error;
+      throw error;
+    }
+  };
+}
+async function runWatchdogAttempt(ctx, request, options) {
+  const selection = await resolveWatchdogReviewModel(ctx, request.config, {
+    currentThinkingLevel: options.getThinkingLevel?.()
+  });
+  if (ctx.signal?.aborted || request.signal?.aborted)
+    return { result: { 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 sessionId = ctx.sessionManager.getSessionId();
+  const streamFn = (model, context, streamOptions) => {
+    if (clarification)
+      throw new Error("Watchdog review yielded for clarification.");
+    return baseStreamFn(model, context, {
       ...streamOptions,
       ...auth.apiKey ? { apiKey: auth.apiKey } : {},
       env: auth.env || streamOptions?.env ? { ...auth.env ?? {}, ...streamOptions?.env ?? {} } : undefined,
-      headers: { ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
+      headers: { ...opencodeSessionHeaders(model, sessionId), ...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 diffBaseline = options.diffBaseline?.();
+  let clarification;
+  let warned = false;
+  let toolCount = 0;
+  const warnRequest = request.allowClarification ? { ...request, emitWarning: (warning) => {
+    if (clarification)
+      return false;
+    const accepted = request.emitWarning(warning);
+    warned ||= accepted;
+    return accepted;
+  } } : request;
+  const tools = [
+    ...(options.createReadOnlyTools ?? createReadOnlyTools)(ctx.cwd).filter((tool) => WATCHDOG_ALLOWED_TOOL_NAMES.has(tool.name) && tool.name !== "watchdog_warn"),
+    createWatchdogWarnTool(warnRequest),
+    ...diffBaseline ? [createWatchdogDiffTool(diffBaseline)] : []
+  ];
+  if (request.allowClarification)
+    tools.push({
+      name: "watchdog_ask",
+      label: "Watchdog clarification",
+      description: "Send one focused question when missing task status, intent or other orchestrator context prevents a concrete review judgment. Yields and ends this review so the orchestrator can handle the message and continue; no answer or follow-up review is required. Never ask for approval or permission, or after recording a warning. Question and evidence are capped at 1000 and 2000 characters.",
+      parameters: WatchdogAskParams,
+      executionMode: "sequential",
+      async execute(_id, rawParams) {
+        const params = rawParams;
+        if (warned || clarification || ctx.signal?.aborted || request.signal?.aborted)
+          throw new Error("Clarification unavailable after warning, yield, or cancellation.");
+        if (!params.question.trim() || !params.evidence.trim())
+          throw new Error("A focused question and concrete evidence are required.");
+        clarification = { question: boundWatchdogReviewText(params.question.trim(), 1000), evidence: boundWatchdogReviewText(params.evidence.trim(), 2000) };
+        agent.abort();
+        return { content: [{ type: "text", text: "Review yielded for clarification." }], details: {} };
+      }
     });
-    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) };
+  const systemPrompt = buildWatchdogSystemPrompt(ctx, {
+    hasScope: request.hasScope,
+    guidance: loadWatchdogGuidance(ctx.cwd, request.config.guidance.watchdogMd),
+    hasDiff: diffBaseline !== undefined
+  });
+  const agent = new Agent({
+    initialState: {
+      systemPrompt,
+      model: selection.model,
+      thinkingLevel: selection.thinkingLevel,
+      tools
+    },
+    convertToLlm,
+    ...agentStreamOptions(streamFn),
+    getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
+    beforeToolCall: async ({ toolCall }) => !clarification && (WATCHDOG_ALLOWED_TOOL_NAMES.has(toolCall.name) || request.allowClarification && toolCall.name === "watchdog_ask") ? undefined : { block: true, reason: `Watchdog reviews are read-only; tool '${toolCall.name}' is not allowed.` },
+    toolExecution: "sequential"
+  });
+  agent.subscribe((event) => {
+    if (event.type === "tool_execution_start")
+      toolCount++;
+  });
+  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 { result: { stopReason: "aborted" } };
+    await agent.prompt(buildReviewPrompt(request, selection));
+  } finally {
+    ctx.signal?.removeEventListener("abort", abort);
+    request.signal?.removeEventListener("abort", abort);
+  }
+  if (ctx.signal?.aborted || request.signal?.aborted)
+    return { result: { stopReason: "aborted" } };
+  const terminal = agent.state.messages.findLast((message) => message.role === "assistant");
+  const reason = terminal && "stopReason" in terminal ? terminal.stopReason : undefined;
+  const stopReason = reason === "error" || reason === "aborted" || reason === "length" ? reason : "stop";
+  const error = terminal && "errorMessage" in terminal && typeof terminal.errorMessage === "string" ? terminal.errorMessage : undefined;
+  return {
+    result: clarification ? { clarification } : error ? { stopReason, errorMessage: error } : { stopReason }
   };
 }

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

@@ -0,0 +1,55 @@
+import { splitKnownThinkingSuffix } from "../shared/model-info.js";
+import { resolveWatchdogConfig } from "./settings.js";
+import { createWatchdogWarningMessage } from "./warning-format.js";
+function loadWatchdogLaunchRules(cwd) {
+  const result = resolveWatchdogConfig(cwd);
+  return result.ok ? result.config.rules : undefined;
+}
+export function watchdogGlobMatch(pattern, value) {
+  const source = pattern.split("").map((char) => char === "*" ? ".*" : char === "?" ? "." : char.replace(/[.+^${}()|[\]\\]/g, "\\$&")).join("");
+  return new RegExp(`^${source}$`).test(value);
+}
+function modelMatches(patterns, model) {
+  const base = splitKnownThinkingSuffix(model).baseModel;
+  return patterns.find((pattern) => watchdogGlobMatch(pattern, model) || watchdogGlobMatch(pattern, base));
+}
+export function evaluateLaunchRule(rules, agent, model) {
+  const roleRule = rules?.roleModels[agent];
+  if (!roleRule || !model)
+    return;
+  const note = roleRule.note ? ` ${roleRule.note}` : "";
+  const denied = roleRule.deny?.length ? modelMatches(roleRule.deny, model) : undefined;
+  if (denied !== undefined) {
+    return {
+      agent,
+      summary: `Agent '${agent}' was launched with denied model '${model}'.`,
+      evidence: `subagents.watchdog.rules.roleModels.${agent}.deny matches '${denied}'.${note}`,
+      recommendedAction: roleRule.allow?.length ? `Use one of: ${roleRule.allow.join(", ")}.` : "Choose a different model for this role."
+    };
+  }
+  if (!roleRule.allow?.length || modelMatches(roleRule.allow, model) !== undefined)
+    return;
+  return {
+    agent,
+    summary: `Agent '${agent}' was launched with model '${model}', which is not in its allowed list.`,
+    evidence: `subagents.watchdog.rules.roleModels.${agent}.allow is [${roleRule.allow.join(", ")}].${note}`,
+    recommendedAction: `Use one of: ${roleRule.allow.join(", ")}.`
+  };
+}
+export function ruleViolationWarning(violation) {
+  return { severity: "concern", category: "missed-constraint", importance: "high", source: "main", ...violation };
+}
+export function applyWatchdogLaunchRules(input) {
+  const rules = loadWatchdogLaunchRules(input.cwd);
+  const violation = evaluateLaunchRule(rules, input.agent, input.model);
+  if (!violation)
+    return;
+  if (rules?.action === "block")
+    return `Launch blocked by subagents.watchdog.rules: ${violation.summary}`;
+  input.warn?.(violation);
+  return;
+}
+export function sendRuleViolationWarning(dm, violation) {
+  const warning = ruleViolationWarning(violation);
+  dm.sendMessage(createWatchdogWarningMessage(warning, { display: true, details: { state: "displayed", displayedAt: new Date().toISOString() } }), { deliverAs: "steer" });
+}