@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -1,6 +1,7 @@
-export const CHILD_WATCHDOG_CONFIG_ENV = "DM_SUBAGENT_WATCHDOG_CHILD_CONFIG";
+import { WATCHDOG_WARNING_CATEGORIES, WATCHDOG_WARNING_IMPORTANCES } from "./types.js";
+export const CHILD_WATCHDOG_WARNING_LIMIT = 20;
 export const CHILD_WATCHDOG_STATUS_EVENT = "subagent.watchdog.status";
-export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "autofollow", "settling", "stale", "failed"];
+export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "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);
@@ -8,8 +9,8 @@ export function resolveChildWatchdogConfig(input) {
     return;
   const model = override?.model ?? input.config.children.model;
   const thinking = override?.thinking ?? input.config.children.thinking;
+  const cadence = override?.cadence ?? input.config.children.cadence ?? input.config.cadence;
   return {
-    enabled: true,
     ...input.runId ? { runId: input.runId } : {},
     ...input.agent ? { agent: input.agent } : {},
     ...input.childIndex !== undefined ? { childIndex: input.childIndex } : {},
@@ -19,14 +20,10 @@ export function resolveChildWatchdogConfig(input) {
     ...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
+    stalemateRepeats: input.config.stalemateRepeats,
+    cadence: { everyNTools: cadence.everyNTools ?? null }
   };
 }
-export function encodeChildWatchdogConfig(config) {
-  return config ? JSON.stringify(config) : undefined;
-}
 function childConfigObject(value, field) {
   if (value && typeof value === "object" && !Array.isArray(value))
     return value;
@@ -62,11 +59,14 @@ function childConfigNullableNonNegativeInteger(input, field) {
     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 childConfigCadence(value) {
+  const input = childConfigObject(value, "cadence");
+  const everyNTools = input.everyNTools;
+  if (everyNTools === null)
+    return { everyNTools: null };
+  if (typeof everyNTools === "number" && Number.isInteger(everyNTools) && everyNTools >= 5)
+    return { everyNTools };
+  throw new Error("Invalid child watchdog config: cadence.everyNTools must be null or an integer >= 5.");
 }
 function childConfigLsp(value) {
   const input = childConfigObject(value, "lsp");
@@ -92,9 +92,12 @@ export function decodeChildWatchdogConfig(raw) {
   if (!raw)
     return;
   const parsed = childConfigObject(JSON.parse(raw), "root");
+  if (Object.hasOwn(parsed, "fallbackModels")) {
+    throw new Error("Invalid child watchdog config: fallbackModels was removed; configure one model instead.");
+  }
   if (parsed.enabled === false)
     return;
-  if (parsed.enabled !== true)
+  if ("enabled" in parsed && 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) {
@@ -105,7 +108,6 @@ export function decodeChildWatchdogConfig(raw) {
   const childIndex = childConfigOptionalIndex(parsed, "childIndex");
   const model = childConfigOptionalString(parsed, "model");
   return {
-    enabled: true,
     ...runId ? { runId } : {},
     ...agent ? { agent } : {},
     ...childIndex !== undefined ? { childIndex } : {},
@@ -115,21 +117,23 @@ export function decodeChildWatchdogConfig(raw) {
     ...model ? { model } : {},
     ...thinking !== undefined ? { thinking } : {},
     lsp: childConfigLsp(parsed.lsp),
-    autoFollowBlockers: childConfigBoolean(parsed, "autoFollowBlockers"),
-    autoFollowMaxAttempts: childConfigNullableNonNegativeInteger(parsed, "autoFollowMaxAttempts"),
-    stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats")
+    stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats"),
+    cadence: childConfigCadence(parsed.cadence)
   };
 }
 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);
+  const warningValue = event.warning;
+  const warning = warningValue;
+  const validWarning = warningValue === undefined || warningValue !== null && typeof warningValue === "object" && !Array.isArray(warningValue) && (warning.severity === "concern" || warning.severity === "blocker") && typeof warning.importance === "string" && WATCHDOG_WARNING_IMPORTANCES.includes(warning.importance) && typeof warning.category === "string" && WATCHDOG_WARNING_CATEGORIES.includes(warning.category) && typeof warning.summary === "string" && typeof warning.evidence === "string" && typeof warning.recommendedAction === "string" && typeof warning.addressed === "boolean" && typeof warning.stalemate === "boolean" && (warning.displayedAt === undefined || typeof warning.displayedAt === "string");
+  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.phase === "string" && CHILD_WATCHDOG_PHASES.includes(event.phase) && validWarning;
 }
 export function childWatchdogIsActive(snapshot) {
   if (!snapshot)
     return false;
-  return snapshot.followUpPending || snapshot.phase === "reviewing" || snapshot.phase === "autofollow" || snapshot.phase === "settling";
+  return snapshot.phase === "reviewing";
 }
 export function acceptChildWatchdogEvent(input) {
   if (input.runId !== undefined && input.event.runId !== input.runId)
@@ -141,11 +145,26 @@ export function acceptChildWatchdogEvent(input) {
     return;
   if (input.current && input.event.seq <= input.current.seq)
     return;
+  const warnings = input.event.warning ? [...input.current?.warnings ?? [], input.event.warning].slice(-CHILD_WATCHDOG_WARNING_LIMIT) : input.current?.warnings;
   return {
     phase: input.event.phase,
     seq: input.event.seq,
     lastUpdate: input.event.ts,
-    followUpPending: input.event.followUpPending,
-    ...input.event.reason ? { reason: input.event.reason } : {}
+    ...input.event.reason ? { reason: input.event.reason } : {},
+    ...warnings?.length ? { warnings } : {}
   };
 }
+export function applyChildWatchdogMessage(current, message) {
+  if (message?.role !== "assistant" || !current?.warnings?.some((entry) => !entry.addressed))
+    return;
+  return { ...current, warnings: current.warnings.map((entry) => entry.addressed ? entry : { ...entry, addressed: true }) };
+}
+export function unresolvedChildWatchdogBlockers(progress) {
+  return (progress?.warnings ?? []).filter((warning) => warning.severity === "blocker" && (!warning.addressed || warning.stalemate));
+}
+export function childWatchdogProgressForModel(progress) {
+  if (!progress)
+    return;
+  const warnings = (progress.warnings ?? []).filter((warning) => warning.importance === "high");
+  return { ...progress, warnings: warnings.length ? warnings : undefined };
+}

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

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+import * as path from "node:path";
+import { Type } from "typebox";
+export const WATCHDOG_DIFF_TOOL_NAME = "watchdog_diff";
+export const WATCHDOG_DIFF_MAX_CHARS = 24000;
+export const WATCHDOG_DIFF_UNAVAILABLE_BASELINE = "watchdog_diff unavailable: this cwd has no valid Git HEAD baseline. No diff can be shown; inspect files with independent read-only tools instead.";
+const MAX_UNTRACKED_FILES = 50;
+const WatchdogDiffParams = Type.Object({
+  path: Type.Optional(Type.String({ description: "Restrict the diff to one file or directory, relative to the repo root." })),
+  stat: Type.Optional(Type.Boolean({ description: "Return per-file change counts instead of the full diff." }))
+}, { additionalProperties: false });
+function runGit(root, args) {
+  const result = spawnSync("git", ["-C", root, ...args], { encoding: "utf-8", maxBuffer: 16 * 1024 * 1024, windowsHide: true });
+  return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: (result.stderr ?? "").trim() };
+}
+export function captureWatchdogDiffBaseline(cwd) {
+  const toplevel = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!toplevel.ok)
+    return;
+  const head = runGit(cwd, ["rev-parse", "HEAD"]);
+  if (!head.ok)
+    return;
+  const root = toplevel.stdout.trim();
+  const ref = head.stdout.trim();
+  return root && ref ? { root, ref } : undefined;
+}
+function validatePath(value) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  if (trimmed.startsWith("-"))
+    throw new Error("watchdog_diff path must not start with '-'.");
+  if (path.isAbsolute(trimmed))
+    throw new Error("watchdog_diff path must be relative to the repo root.");
+  if (trimmed.split(/[\\/]/).includes(".."))
+    throw new Error("watchdog_diff path must not contain '..'.");
+  return trimmed;
+}
+function bound(text) {
+  if (text.length <= WATCHDOG_DIFF_MAX_CHARS)
+    return text;
+  const marker = `
+
+[... ${text.length - WATCHDOG_DIFF_MAX_CHARS} characters omitted; call again with a narrower path ...]`;
+  return `${text.slice(0, WATCHDOG_DIFF_MAX_CHARS - marker.length)}${marker}`;
+}
+export function createWatchdogDiffTool(baseline, options = {}) {
+  const workingTreeAtLaunch = options.workingTreeAtLaunch === true;
+  return {
+    name: WATCHDOG_DIFF_TOOL_NAME,
+    label: "Watchdog diff",
+    description: !baseline ? "Report that a Git HEAD diff baseline is unavailable in this cwd. No diff is generated." : workingTreeAtLaunch ? "Show the current staged and unstaged working-tree delta against reviewer-launch HEAD, plus untracked file paths. Committed ranges are not included. Optional path narrows it; stat:true returns per-file counts only." : "Show the repository diff since the review baseline, plus untracked file paths. Optional path narrows it; stat:true returns per-file counts only.",
+    parameters: WatchdogDiffParams,
+    executionMode: "sequential",
+    async execute(_toolCallId, params) {
+      if (!baseline) {
+        return { content: [{ type: "text", text: WATCHDOG_DIFF_UNAVAILABLE_BASELINE }], details: { chars: WATCHDOG_DIFF_UNAVAILABLE_BASELINE.length } };
+      }
+      const pathFilter = validatePath(params.path);
+      const diff = runGit(baseline.root, ["diff", "--no-color", "--no-ext-diff", ...params.stat === true ? ["--stat"] : [], baseline.ref, "--", ...pathFilter ? [pathFilter] : []]);
+      if (!diff.ok)
+        throw new Error(`git diff failed: ${diff.stderr || "unknown error"}`);
+      const untrackedResult = runGit(baseline.root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathFilter ? [pathFilter] : []]);
+      if (workingTreeAtLaunch) {
+        const currentHead = runGit(baseline.root, ["rev-parse", "HEAD"]);
+        if (!currentHead.ok || currentHead.stdout.trim() !== baseline.ref) {
+          const text = "Reviewer-launch HEAD changed or is unavailable. Committed changes are unsupported; relaunch the reviewer or supply a diff artifact.";
+          return { content: [{ type: "text", text }], details: { chars: text.length } };
+        }
+      }
+      const untracked = untrackedResult.ok ? untrackedResult.stdout.split("\x00").filter(Boolean) : [];
+      const sections = [diff.stdout.trimEnd()];
+      if (untracked.length) {
+        const shown = untracked.slice(0, MAX_UNTRACKED_FILES);
+        sections.push(["Untracked files (use read to inspect):", ...shown.map((file) => ` ${file}`)].join(`
+`));
+        if (untracked.length > shown.length)
+          sections.push(`... ${untracked.length - shown.length} more untracked files`);
+      }
+      const text = bound(sections.filter(Boolean).join(`
+
+`)) || (workingTreeAtLaunch ? `No working-tree changes against reviewer-launch HEAD ${baseline.ref.slice(0, 12)}. Committed changes are not included.` : `No changes since baseline ${baseline.ref.slice(0, 12)}.`);
+      return { content: [{ type: "text", text }], details: { chars: text.length } };
+    }
+  };
+}

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

@@ -55,7 +55,7 @@ export class WatchdogEmissionGuard {
     this.historyOrder = [];
     this.startModelUpdate();
   }
-  evaluate(warning) {
+  evaluate(warning, options = {}) {
     if (isContentFree(warning.summary) || isContentFree(warning.evidence) || isContentFree(warning.recommendedAction)) {
       return { accepted: false, reason: "content-free" };
     }
@@ -68,9 +68,10 @@ export class WatchdogEmissionGuard {
       if (!updateEscalation)
         return { accepted: false, reason: "update-budget", identity, underlyingIdentity };
     }
-    if (priorSeverity !== undefined && !escalation)
+    const repeat = priorSeverity !== undefined && options.allowRepeatOf === identity;
+    if (priorSeverity !== undefined && !escalation && !repeat)
       return { accepted: false, reason: "duplicate", identity, underlyingIdentity };
-    if (this.maxWarnings !== null && this.acceptedCount >= this.maxWarnings && !escalation) {
+    if (this.maxWarnings !== null && this.acceptedCount >= this.maxWarnings && !escalation && !repeat) {
       return { accepted: false, reason: "max-warnings", identity, underlyingIdentity };
     }
     this.acceptedByUnderlyingIdentity.set(underlyingIdentity, warning.severity);

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

@@ -0,0 +1,19 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir, getProjectConfigDir } from "../shared/utils.js";
+export const WATCHDOG_GUIDANCE_MAX_CHARS = 8000;
+function readOptional(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+export function loadWatchdogGuidance(cwd, enabled) {
+  if (!enabled)
+    return "";
+  const sections = [getProjectConfigDir(cwd), getAgentDir()].map((dir) => readOptional(path.join(dir, "WATCHDOG.md"))).filter(Boolean);
+  return sections.join(`
+
+`).slice(0, WATCHDOG_GUIDANCE_MAX_CHARS);
+}

package/extensions/dm-subagents/src/watchdog/lsp-diagnostics.js

@@ -175,7 +175,7 @@ export function watchdogWarningFromLspDiagnostics(result) {
   return {
     severity,
     category: "correctness",
-    confidence: "high",
+    importance: "high",
     source: "lsp",
     summary: `LSP found ${count} ${kind}${count === 1 ? "" : "s"} in changed ${count === 1 ? "file" : "files"}.`,
     evidence: evidence || formatDiagnostic(primary),

package/extensions/dm-subagents/src/watchdog/model-selection.js

@@ -1,4 +1,4 @@
-import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-fallback.js";
+import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-resolution.js";
 import {
   getSupportedThinkingLevels,
   splitKnownThinkingSuffix,
@@ -134,6 +134,7 @@ function resolveStrongCandidate(ctx, family) {
       continue;
     const current = ctx.model ? fullModelId(toModelInfo(ctx.model)) : "no current session model";
     return {
+      source: "suggested",
       model: resolved.model,
       thinking: STRONG_WATCHDOG_THINKING,
       label: preference.label,
@@ -152,3 +153,19 @@ export function recommendStrongWatchdogModel(ctx) {
   const current = ctx.model ? fullModelId(toModelInfo(ctx.model)) : "the current session";
   throw new Error(`No authenticated strong complementary watchdog model was found for ${current}. Configure access to Opus 4.8 or GPT 5.5, then run the recommendation again.`);
 }
+export function recommendWatchdogModel(ctx, configured) {
+  if (!configured.model)
+    return recommendStrongWatchdogModel(ctx);
+  const resolved = resolveWatchdogModelInput(ctx, configured.model);
+  const thinking = resolved.thinking ?? parseWatchdogThinkingInput(configured.thinking) ?? "off";
+  return {
+    ...resolved,
+    source: "configured",
+    thinking: thinking === false ? "off" : thinking,
+    label: "configured watchdog",
+    reason: "Keep the configured watchdog model and thinking; no replacement recommendation is needed. This is not a strength or independence assessment."
+  };
+}
+export function formatWatchdogRecommendation(recommendation) {
+  return `${recommendation.source === "configured" ? "Keep configured watchdog" : "Recommended strong watchdog"}: ${recommendation.model}:${recommendation.thinking}`;
+}

package/extensions/dm-subagents/src/watchdog/permission-arbiter.js

@@ -4,9 +4,10 @@ import { streamSimple } from "@duckmind/dm-ai/compat";
 import { Type } from "typebox";
 import { appendPermissionAudit, permissionArgsPreview } from "../runs/shared/permissions.js";
 import { agentStreamOptions } from "../shared/agent-stream-options.js";
+import { opencodeSessionHeaders } from "../shared/opencode-session-headers.js";
 import { decodeChildWatchdogConfig } from "./child-status.js";
 import { childResolvedConfig } from "./register-child.js";
-import { resolveWatchdogReviewModel } from "./review.js";
+import { formatWatchdogCwdSection, resolveWatchdogReviewModel } from "./review.js";
 const PermissionDecisionParams = Type.Object({
   decision: Type.String({ enum: ["approve", "deny"] }),
   reason: Type.String({ description: "One concise reason for this exact decision." })
@@ -71,26 +72,31 @@ export function createWatchdogPermissionArbiter(options = {}) {
         const config = childResolvedConfig(childConfig);
         const selection = await resolveWatchdogReviewModel(request.ctx, config);
         const auth = selection.auth;
+        const sessionId = request.ctx.sessionManager.getSessionId();
         const registeredProvider = request.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 ?? {} }
+          headers: { ...opencodeSessionHeaders(model, sessionId), ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
         });
+        const systemPrompt = [
+          "You are the dm-subagents watchdog permission arbiter.",
+          "Decide only whether this exact non-bash child tool call should proceed.",
+          "Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
+          "Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator.",
+          "",
+          formatWatchdogCwdSection(request.ctx.cwd)
+        ].join(`
+`);
+        const tools = [tool];
         agent = new Agent({
           initialState: {
-            systemPrompt: [
-              "You are the dm-subagents watchdog permission arbiter.",
-              "Decide only whether this exact non-bash child tool call should proceed.",
-              "Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
-              "Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator."
-            ].join(`
-`),
+            systemPrompt,
             model: selection.model,
             thinkingLevel: selection.thinkingLevel,
-            tools: [tool]
+            tools
           },
           convertToLlm,
           ...agentStreamOptions(streamFn),

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

@@ -1,12 +1,12 @@
+import { captureWatchdogDiffBaseline } from "./diff-tool.js";
 import { MainWatchdogRuntime } from "./runtime.js";
 import { createMainWatchdogReview } from "./review.js";
 import { DEFAULT_WATCHDOG_CONFIG } from "./settings.js";
 import { createWatchdogWarningMessage } from "./warning-format.js";
 import {
-  CHILD_WATCHDOG_CONFIG_ENV,
-  CHILD_WATCHDOG_STATUS_EVENT,
-  decodeChildWatchdogConfig
+  CHILD_WATCHDOG_STATUS_EVENT
 } from "./child-status.js";
+import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "./types.js";
 export function childResolvedConfig(config) {
   return {
     ...DEFAULT_WATCHDOG_CONFIG,
@@ -18,11 +18,8 @@ export function childResolvedConfig(config) {
       ...config.model ? { model: config.model } : {},
       ...config.thinking !== undefined ? { thinking: config.thinking } : {}
     },
-    autoFollow: {
-      blockers: config.autoFollowBlockers,
-      maxAttempts: config.autoFollowMaxAttempts,
-      stalemateRepeats: config.stalemateRepeats
-    },
+    stalemateRepeats: config.stalemateRepeats,
+    cadence: { ...config.cadence },
     children: {
       ...DEFAULT_WATCHDOG_CONFIG.children,
       watchdogTailTimeoutMs: config.watchdogTailTimeoutMs
@@ -38,19 +35,16 @@ function childWarningDetails(details, config) {
     ...config.runId ? { runId: config.runId } : {}
   };
 }
-function writeStatus(event) {
-  try {
-    process.stdout.write(`${JSON.stringify(event)}
-`);
-  } catch {}
-}
-export function registerChildWatchdog(dm, rawConfig = process.env[CHILD_WATCHDOG_CONFIG_ENV]) {
-  const childConfig = decodeChildWatchdogConfig(rawConfig);
-  if (!childConfig?.enabled)
+export function registerChildWatchdog(dm, childConfig, writeStatus, structuredTerminal) {
+  if (!childConfig)
     return;
+  if (!writeStatus)
+    throw new Error("Child watchdog status sink is missing; the host must pass ChildRuntimeConfig.watchdogStatus.");
   let currentContext;
+  let diffBaseline;
+  let agentSettled = false;
   let seq = 0;
-  const emitStatus = (phase, followUpPending = false, reason) => {
+  const emitStatus = (phase, reason, warning) => {
     writeStatus({
       type: CHILD_WATCHDOG_STATUS_EVENT,
       ...childConfig.runId ? { runId: childConfig.runId } : {},
@@ -59,19 +53,29 @@ export function registerChildWatchdog(dm, rawConfig = process.env[CHILD_WATCHDOG
       seq: ++seq,
       phase,
       ts: Date.now(),
-      followUpPending,
-      ...reason ? { reason } : {}
+      ...reason ? { reason } : {},
+      ...warning ? { warning } : {}
     });
   };
   const resolved = childResolvedConfig(childConfig);
   const runtime = new MainWatchdogRuntime({
     resolveConfig: () => ({ ok: true, config: resolved, errors: [], sources: [{ scope: "session", exists: true }] }),
-    review: createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => dm.getThinkingLevel() }),
+    review: createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => dm.getThinkingLevel(), diffBaseline: () => diffBaseline }),
     reviewDescription: "child model review",
     reviewChangesOnly: true,
-    displayWarning: (details) => {
+    displayWarning: (details, options) => {
+      const childDetails = childWarningDetails(details, childConfig);
+      emitStatus("reviewing", undefined, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}, addressed: false, stalemate: childDetails.state === "stalemate" });
+      const message = createWatchdogWarningMessage(childDetails, { display: true, details: childDetails });
+      if (agentSettled)
+        dm.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, childDetails);
+      else
+        dm.sendMessage(message, options);
+    },
+    displayUserWarning: (details) => {
       const childDetails = childWarningDetails(details, childConfig);
-      dm.sendMessage(createWatchdogWarningMessage(childDetails, { display: true, details: childDetails }));
+      emitStatus("reviewing", undefined, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}, addressed: false, stalemate: childDetails.state === "stalemate" });
+      dm.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, childDetails);
     }
   });
   const rememberContext = (ctx) => {
@@ -80,16 +84,22 @@ export function registerChildWatchdog(dm, rawConfig = process.env[CHILD_WATCHDOG
   const onRuntimeEvent = dm.on;
   onRuntimeEvent("session_start", (_event, ctx) => {
     rememberContext(ctx);
+    diffBaseline = captureWatchdogDiffBaseline(ctx.cwd);
     runtime.bindSession(ctx);
     emitStatus("idle");
   });
   onRuntimeEvent("before_agent_start", (event, ctx) => {
+    agentSettled = false;
     rememberContext(ctx);
     runtime.handleBeforeAgentStart(event, ctx);
   });
   onRuntimeEvent("turn_end", (event, ctx) => {
     rememberContext(ctx);
-    runtime.handleTurnEnd(event, ctx);
+    runtime.handleTurnEnd(event, ctx, structuredTerminal?.captured === true);
+  });
+  onRuntimeEvent("tool_result", (_event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleToolResult(ctx);
   });
   onRuntimeEvent("agent_end", async (event, ctx) => {
     rememberContext(ctx);
@@ -97,12 +107,15 @@ export function registerChildWatchdog(dm, rawConfig = process.env[CHILD_WATCHDOG
     await runtime.handleAgentEnd(event, ctx);
     const snapshot = runtime.getSnapshot(ctx.cwd);
     if (snapshot.status === "failed")
-      emitStatus("failed", false, snapshot.lastError);
+      emitStatus("failed", snapshot.lastError);
     else if (snapshot.status === "stale")
-      emitStatus("stale", false, "review stale");
+      emitStatus("stale", "review stale");
     else
       emitStatus("idle");
   });
+  onRuntimeEvent("agent_settled", () => {
+    agentSettled = true;
+  });
   onRuntimeEvent("session_shutdown", () => {
     currentContext = undefined;
     runtime.dispose();