@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -0,0 +1,138 @@
+import { Agent } from "@duckmind/dm-agent-core";
+import { convertToLlm } from "@duckmind/dm-coding-agent";
+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 { decodeChildWatchdogConfig } from "./child-status.js";
+import { childResolvedConfig } from "./register-child.js";
+import { 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." })
+}, { additionalProperties: false });
+function conciseReason(value) {
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 500) : "Watchdog returned an empty reason.";
+}
+export function createWatchdogPermissionArbiter(options = {}) {
+  return async (request) => {
+    const preview = permissionArgsPreview(request.args);
+    const createdAt = Date.now();
+    const auditBase = { type: "permission.request", createdAt, toolName: request.toolName, preview, matchedRule: "ask", decisionSource: "watchdog" };
+    appendPermissionAudit(request.auditPath, auditBase);
+    let completed = false;
+    const finish = (approved, reason, decision) => {
+      const concise = conciseReason(reason);
+      if (completed)
+        return { approved, reason: concise, source: "watchdog" };
+      completed = true;
+      appendPermissionAudit(request.auditPath, {
+        type: "permission.decision",
+        createdAt: Date.now(),
+        requestCreatedAt: createdAt,
+        toolName: request.toolName,
+        decision,
+        approved,
+        decisionSource: "watchdog",
+        reason: concise
+      });
+      return { approved, reason: concise, source: "watchdog" };
+    };
+    let childConfig;
+    try {
+      childConfig = decodeChildWatchdogConfig(request.rawWatchdogConfig);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return finish(false, `Watchdog permission arbiter configuration is invalid: ${reason}`, "unavailable");
+    }
+    if (!childConfig)
+      return finish(false, "Watchdog permission arbiter is unavailable because the child watchdog is disabled.", "unavailable");
+    if (request.signal?.aborted || request.ctx.signal?.aborted)
+      return finish(false, "Watchdog permission decision was cancelled.", "cancelled");
+    let decision;
+    const tool = {
+      name: "watchdog_permission_decision",
+      label: "Watchdog permission decision",
+      description: "Approve or deny this exact child tool call. Call exactly once.",
+      parameters: PermissionDecisionParams,
+      executionMode: "sequential",
+      async execute(_toolCallId, params) {
+        if (!decision)
+          decision = params;
+        return { content: [{ type: "text", text: "Permission decision recorded." }], details: { recorded: true } };
+      }
+    };
+    let timeout;
+    let agent;
+    let abort;
+    try {
+      const run = async () => {
+        const config = childResolvedConfig(childConfig);
+        const selection = await resolveWatchdogReviewModel(request.ctx, config);
+        const auth = selection.auth;
+        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 ?? {} }
+        });
+        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(`
+`),
+            model: selection.model,
+            thinkingLevel: selection.thinkingLevel,
+            tools: [tool]
+          },
+          convertToLlm,
+          ...agentStreamOptions(streamFn),
+          getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
+          beforeToolCall: async ({ toolCall }) => toolCall.name === tool.name ? undefined : { block: true, reason: `Permission arbiter tool '${toolCall.name}' is not allowed.` },
+          toolExecution: "sequential"
+        });
+        await agent.prompt(`Tool: ${request.toolName}
+Redacted arguments: ${preview}`);
+        if (!decision)
+          return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
+        const approved = decision.decision === "approve";
+        return finish(approved, decision.reason, decision.decision);
+      };
+      return await Promise.race([
+        run(),
+        new Promise((resolve) => {
+          timeout = setTimeout(() => {
+            agent?.abort();
+            resolve(finish(false, "Watchdog permission decision timed out.", "timeout"));
+          }, childConfig.agentEndTimeoutMs);
+        }),
+        new Promise((resolve) => {
+          abort = () => {
+            agent?.abort();
+            resolve(finish(false, "Watchdog permission decision was cancelled.", "cancelled"));
+          };
+          request.signal?.addEventListener("abort", abort, { once: true });
+          request.ctx.signal?.addEventListener("abort", abort, { once: true });
+        })
+      ]);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return finish(false, `Watchdog permission arbiter failed closed: ${reason}`, reason.includes("timed out") ? "timeout" : "error");
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+      if (abort) {
+        request.signal?.removeEventListener("abort", abort);
+        request.ctx.signal?.removeEventListener("abort", abort);
+      }
+    }
+  };
+}
+export const requestWatchdogPermission = createWatchdogPermissionArbiter();

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

@@ -0,0 +1,112 @@
+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
+} from "./child-status.js";
+export function childResolvedConfig(config) {
+  return {
+    ...DEFAULT_WATCHDOG_CONFIG,
+    enabled: true,
+    agentEndTimeoutMs: config.agentEndTimeoutMs,
+    maxWarnings: config.maxWarnings,
+    main: {
+      enabled: true,
+      ...config.model ? { model: config.model } : {},
+      ...config.thinking !== undefined ? { thinking: config.thinking } : {}
+    },
+    autoFollow: {
+      blockers: config.autoFollowBlockers,
+      maxAttempts: config.autoFollowMaxAttempts,
+      stalemateRepeats: config.stalemateRepeats
+    },
+    children: {
+      ...DEFAULT_WATCHDOG_CONFIG.children,
+      watchdogTailTimeoutMs: config.watchdogTailTimeoutMs
+    },
+    lsp: { ...config.lsp }
+  };
+}
+function childWarningDetails(details, config) {
+  return {
+    ...details,
+    source: details.source === "lsp" ? "lsp" : "child",
+    ...config.agent ? { agent: config.agent } : {},
+    ...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)
+    return;
+  let currentContext;
+  let seq = 0;
+  const emitStatus = (phase, followUpPending = false, reason) => {
+    writeStatus({
+      type: CHILD_WATCHDOG_STATUS_EVENT,
+      ...childConfig.runId ? { runId: childConfig.runId } : {},
+      ...childConfig.agent ? { agent: childConfig.agent } : {},
+      ...childConfig.childIndex !== undefined ? { childIndex: childConfig.childIndex, stepIndex: childConfig.childIndex } : {},
+      seq: ++seq,
+      phase,
+      ts: Date.now(),
+      followUpPending,
+      ...reason ? { reason } : {}
+    });
+  };
+  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() }),
+    reviewDescription: "child model review",
+    reviewChangesOnly: true,
+    displayWarning: (details) => {
+      const childDetails = childWarningDetails(details, childConfig);
+      dm.sendMessage(createWatchdogWarningMessage(childDetails, { display: true, details: childDetails }));
+    }
+  });
+  const rememberContext = (ctx) => {
+    currentContext = ctx;
+  };
+  const onRuntimeEvent = dm.on;
+  onRuntimeEvent("session_start", (_event, ctx) => {
+    rememberContext(ctx);
+    runtime.bindSession(ctx);
+    emitStatus("idle");
+  });
+  onRuntimeEvent("before_agent_start", (event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleBeforeAgentStart(event, ctx);
+  });
+  onRuntimeEvent("turn_end", (event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleTurnEnd(event, ctx);
+  });
+  onRuntimeEvent("agent_end", async (event, ctx) => {
+    rememberContext(ctx);
+    emitStatus("reviewing");
+    await runtime.handleAgentEnd(event, ctx);
+    const snapshot = runtime.getSnapshot(ctx.cwd);
+    if (snapshot.status === "failed")
+      emitStatus("failed", false, snapshot.lastError);
+    else if (snapshot.status === "stale")
+      emitStatus("stale", false, "review stale");
+    else
+      emitStatus("idle");
+  });
+  onRuntimeEvent("session_shutdown", () => {
+    currentContext = undefined;
+    runtime.dispose();
+    emitStatus("idle");
+  });
+  return runtime;
+}

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

@@ -0,0 +1,419 @@
+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 { renderWatchdogWarning } from "./render.js";
+import { createMainWatchdogReview } from "./review.js";
+import { MainWatchdogRuntime } from "./runtime.js";
+import { getWatchdogUserSettingsPath, writeUserWatchdogEnabled, writeWatchdogModelSettings } from "./settings.js";
+import {
+  SUBAGENT_WATCHDOG_WARNING_TYPE
+} from "./types.js";
+import { createWatchdogWarningMessage } from "./warning-format.js";
+function sendSlashText(dm, text) {
+  dm.sendMessage({ customType: SLASH_TEXT_RESULT_TYPE, content: text, display: true });
+}
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function boolLabel(value) {
+  return value ? "on" : "off";
+}
+function statusLabel(status) {
+  return status.replaceAll("-", " ");
+}
+function sourceLine(source) {
+  const location = source.path ? ` ${source.path}` : "";
+  return `- ${source.scope}${location}: ${source.exists ? "found" : "not found"}`;
+}
+function currentSessionModelLine(ctx) {
+  const model = ctx.model;
+  if (model && typeof model.provider === "string" && typeof model.id === "string")
+    return `current session (${model.provider}/${model.id})`;
+  return "current session (not configured)";
+}
+function mainThinkingLine(snapshot, ctx) {
+  const configuredModel = snapshot.config.main.model;
+  const configuredThinking = snapshot.config.main.thinking;
+  if (configuredModel) {
+    const effective = resolveEffectiveThinking(configuredModel, configuredThinking);
+    if (effective)
+      return effective;
+    return "off (default for explicit watchdog model)";
+  }
+  if (configuredThinking === false)
+    return "off";
+  if (configuredThinking !== undefined)
+    return configuredThinking;
+  const currentThinking = ctx.thinkingLevel;
+  return typeof currentThinking === "string" ? `current session (${currentThinking})` : "current session";
+}
+function mainModelLine(snapshot, ctx) {
+  if (snapshot.config.main.model) {
+    const source = snapshot.sessionModelOverride?.model ? "session override" : "configured";
+    return `Main model: ${splitKnownThinkingSuffix(snapshot.config.main.model).baseModel} (${source})`;
+  }
+  return `Main model: ${currentSessionModelLine(ctx)}`;
+}
+function childrenLine(snapshot) {
+  const children = snapshot.config.children;
+  const model = children.model ? splitKnownThinkingSuffix(children.model).baseModel : "current child session";
+  const thinking = children.thinking === undefined ? "current child session" : children.thinking === false ? "off" : children.thinking;
+  const overrides = Object.entries(children.overrides);
+  const overrideText = overrides.length ? ` · overrides ${overrides.map(([agent, override]) => {
+    const bits = [agent];
+    if (override.enabled !== undefined)
+      bits.push(boolLabel(override.enabled));
+    if (override.model)
+      bits.push(splitKnownThinkingSuffix(override.model).baseModel);
+    if (override.thinking !== undefined)
+      bits.push(`thinking ${override.thinking === false ? "off" : override.thinking}`);
+    return bits.join(" ");
+  }).join("; ")}` : "";
+  return `Children: ${boolLabel(snapshot.config.enabled && children.enabled)} · model ${model} · thinking ${thinking}${overrideText}`;
+}
+function recommendationLine(ctx) {
+  try {
+    const recommendation = recommendStrongWatchdogModel(ctx);
+    return `Recommended strong watchdog: ${recommendation.model}:${recommendation.thinking} (${recommendation.label}, complementary reviewer)`;
+  } catch (error) {
+    return `Recommended strong watchdog: unavailable (${messageFromError(error)})`;
+  }
+}
+function lspLine(snapshot) {
+  const lsp = snapshot.lsp;
+  const provider = lsp.provider ? ` · ${lsp.provider}` : "";
+  const counts = lsp.diagnosticCount > 0 || lsp.freshDiagnosticCount > 0 ? ` · ${lsp.freshDiagnosticCount} new/${lsp.diagnosticCount} total` : "";
+  const message = lsp.message ? ` · ${lsp.message}` : "";
+  return `LSP diagnostics: ${lsp.enabled ? "on" : "off"} · ${lsp.status}${provider}${counts}${message}`;
+}
+export function buildWatchdogStatus(snapshot, ctx) {
+  const lines = [
+    "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"}`,
+    `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),
+    `Session override: ${snapshot.sessionOverride === undefined ? "none" : boolLabel(snapshot.sessionOverride)}`,
+    mainModelLine(snapshot, ctx),
+    `Main thinking: ${mainThinkingLine(snapshot, ctx)}`,
+    childrenLine(snapshot),
+    recommendationLine(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" : ""}`,
+    `Review model call: ${snapshot.reviewDescription}`
+  ];
+  if (snapshot.failedReviews > 0)
+    lines.push(`Failed reviews: ${snapshot.failedReviews}`);
+  if (snapshot.staleReviews > 0)
+    lines.push(`Stale reviews: ${snapshot.staleReviews}`);
+  if (snapshot.changedPaths?.length) {
+    lines.push(`Changed paths: ${snapshot.changedPaths.slice(0, 8).join(", ")}${snapshot.changedPaths.length > 8 ? `, +${snapshot.changedPaths.length - 8} more` : ""}`);
+  }
+  if (snapshot.lastWarning) {
+    lines.push(`Last warning: ${snapshot.lastWarning.severity} · ${snapshot.lastWarning.state ?? "candidate"} · ${snapshot.lastWarning.summary}`);
+  }
+  if (snapshot.lastError)
+    lines.push(`Last error: ${snapshot.lastError}`);
+  if (!snapshot.configOk) {
+    lines.push("", "Config errors:", ...snapshot.errors.map((error) => `- ${error.message}`), "Watchdog is disabled until the config is fixed.");
+  } 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" })');
+  return lines.join(`
+`);
+}
+function parseTestCommand(input) {
+  const match = input.match(/^test\s+(concern|blocker)\s+([\s\S]+)$/);
+  if (!match)
+    return;
+  return { severity: match[1], text: match[2].trim() };
+}
+function formatThinking(value) {
+  if (value === undefined)
+    return "inherit";
+  return value === false ? "off" : value;
+}
+function parseThinkingCommand(raw) {
+  const value = raw.trim();
+  if (value === "inherit")
+    return null;
+  return parseWatchdogThinkingInput(value, "/subagents-watchdog thinking") ?? null;
+}
+function resolveModelCommandValue(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);
+    return {
+      model: recommendation.model,
+      thinking: recommendation.thinking,
+      description: `${recommendation.model}:${recommendation.thinking} (${recommendation.label})`
+    };
+  }
+  const resolved = resolveWatchdogModelInput(ctx, value);
+  return {
+    model: resolved.model,
+    thinking: resolved.thinking ?? null,
+    description: `${resolved.model}${resolved.thinking ? `:${resolved.thinking}` : ""}`
+  };
+}
+function buildRecommendationText(ctx) {
+  const recommendation = recommendStrongWatchdogModel(ctx);
+  return [
+    "Subagent watchdog recommended model",
+    `Current session: ${currentSessionModelLine(ctx)}`,
+    `Recommended: ${recommendation.model}:${recommendation.thinking}`,
+    `Reason: ${recommendation.reason}`,
+    "",
+    "Apply for this session:",
+    "/subagents-watchdog session model recommended",
+    "",
+    "Save as your user default:",
+    "/subagents-watchdog model recommended"
+  ].join(`
+`);
+}
+function buildCheckText(runtime, ctx) {
+  const snapshot = runtime.getSnapshot(ctx.cwd);
+  if (!snapshot.configOk) {
+    return ["Subagent watchdog config check", "", "Config errors:", ...snapshot.errors.map((error) => `- ${error.message}`)].join(`
+`);
+  }
+  const lines = ["Subagent watchdog config check", "", "Config: ok"];
+  if (snapshot.config.main.model) {
+    const resolved = resolveWatchdogModelInput(ctx, snapshot.config.main.model);
+    lines.push(`Main model: ${resolved.model} auth ok`);
+  } else {
+    lines.push(`Main model: ${currentSessionModelLine(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)})`);
+  }
+  return lines.join(`
+`);
+}
+function createTestWarning(severity, text) {
+  return {
+    severity,
+    category: "other",
+    confidence: "high",
+    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."
+  };
+}
+async function handleWatchdogCommand(dm, runtime, args, ctx) {
+  const input = args.trim();
+  if (!input || input === "status") {
+    sendSlashText(dm, buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx));
+    return;
+  }
+  if (input === "recommend-model") {
+    try {
+      sendSlashText(dm, buildRecommendationText(ctx));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog recommended model
+
+${messageFromError(error)}`);
+    }
+    return;
+  }
+  if (input === "check") {
+    try {
+      sendSlashText(dm, buildCheckText(runtime, ctx));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog config check
+
+${messageFromError(error)}`);
+    }
+    return;
+  }
+  if (input === "on" || input === "off") {
+    const enabled = input === "on";
+    try {
+      const settingsPath = writeUserWatchdogEnabled(enabled);
+      const snapshot = runtime.getSnapshot(ctx.cwd);
+      sendSlashText(dm, [
+        `Subagent watchdog ${boolLabel(enabled)} saved to user settings.`,
+        `Updated: ${settingsPath}`,
+        `Main now: ${boolLabel(snapshot.enabled)}${snapshot.sessionOverride !== undefined ? ` (session override ${boolLabel(snapshot.sessionOverride)})` : ""}`
+      ].join(`
+`));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog
+
+Could not update ${getWatchdogUserSettingsPath()}: ${messageFromError(error)}`);
+    }
+    return;
+  }
+  if (input === "session on" || input === "session off") {
+    const enabled = input.endsWith("on");
+    const snapshot = runtime.setSessionEnabled(enabled, ctx.cwd);
+    sendSlashText(dm, [
+      `Subagent watchdog session override: ${boolLabel(enabled)}.`,
+      "No settings files were changed.",
+      "",
+      buildWatchdogStatus(snapshot, ctx)
+    ].join(`
+`));
+    return;
+  }
+  if (input.startsWith("session model ")) {
+    const rawModel = input.slice("session model ".length);
+    try {
+      const value = resolveModelCommandValue(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}.`,
+        "No settings files were changed.",
+        "",
+        buildWatchdogStatus(snapshot, ctx)
+      ].join(`
+`));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog session model
+
+${messageFromError(error)}`);
+    }
+    return;
+  }
+  if (input.startsWith("model ")) {
+    const rawModel = input.slice("model ".length);
+    try {
+      const value = resolveModelCommandValue(ctx, rawModel);
+      const settingsPath = writeWatchdogModelSettings({
+        scope: "user",
+        target: { kind: "main" },
+        model: value.model,
+        thinking: value.thinking
+      });
+      runtime.refreshConfig(ctx.cwd);
+      const snapshot = runtime.getSnapshot(ctx.cwd);
+      sendSlashText(dm, [
+        `Subagent watchdog model saved: ${value.description}.`,
+        `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.",
+        "",
+        buildWatchdogStatus(snapshot, ctx)
+      ].join(`
+`));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog model
+
+${messageFromError(error)}
+No settings files were changed.`);
+    }
+    return;
+  }
+  if (input.startsWith("thinking ")) {
+    const rawThinking = input.slice("thinking ".length);
+    try {
+      const thinking = parseThinkingCommand(rawThinking);
+      const settingsPath = writeWatchdogModelSettings({
+        scope: "user",
+        target: { kind: "main" },
+        thinking
+      });
+      runtime.refreshConfig(ctx.cwd);
+      sendSlashText(dm, [
+        `Subagent watchdog thinking saved: ${formatThinking(thinking ?? undefined)}.`,
+        `Updated: ${settingsPath}`,
+        "",
+        buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx)
+      ].join(`
+`));
+    } catch (error) {
+      sendSlashText(dm, `Subagent watchdog thinking
+
+${messageFromError(error)}
+No settings files were changed.`);
+    }
+    return;
+  }
+  const test = parseTestCommand(input);
+  if (test) {
+    if (!test.text) {
+      ctx.ui.notify("Usage: /subagents-watchdog test concern|blocker <text>", "error");
+      return;
+    }
+    const warning = createTestWarning(test.severity, test.text);
+    const details = runtime.recordDisplayedWarning(warning);
+    dm.sendMessage(createWatchdogWarningMessage(details, { display: true, details }));
+    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");
+}
+export function registerMainWatchdog(dm, options = {}) {
+  let currentContext;
+  const rememberContext = (ctx) => {
+    currentContext = ctx;
+  };
+  const runtime = options.runtime ?? new MainWatchdogRuntime({
+    review: options.review ?? createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => dm.getThinkingLevel() }),
+    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)
+  });
+  dm.registerMessageRenderer(SUBAGENT_WATCHDOG_WARNING_TYPE, (message, renderOptions, theme) => {
+    const details = message.details;
+    if (!details?.summary || !details.evidence || !details.recommendedAction) {
+      const content = typeof message.content === "string" ? message.content : message.content.filter((entry) => entry.type === "text").map((entry) => entry.text).join(`
+`);
+      return new Text(content, 0, 0);
+    }
+    return renderWatchdogWarning(details, renderOptions, theme);
+  });
+  dm.registerCommand("subagents-watchdog", {
+    description: "Show or toggle the default-off subagent watchdog",
+    handler: (args, ctx) => {
+      rememberContext(ctx);
+      return handleWatchdogCommand(dm, runtime, args, ctx);
+    }
+  });
+  dm.on("session_start", (_event, ctx) => {
+    rememberContext(ctx);
+    runtime.bindSession(ctx);
+  });
+  dm.on("before_agent_start", (event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleBeforeAgentStart(event, ctx);
+  });
+  dm.on("turn_end", (event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleTurnEnd(event, ctx);
+  });
+  dm.on("tool_result", (_event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleToolResult(ctx);
+  });
+  dm.on("agent_end", (event, ctx) => {
+    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_shutdown", () => {
+    currentContext = undefined;
+    runtime.dispose();
+  });
+  return runtime;
+}