@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -7,17 +7,33 @@ import {
   WatchdogLspDiagnosticsLedger,
   watchdogWarningFromLspDiagnostics
 } from "./lsp-diagnostics.js";
-import { WatchdogScopeArtifact, isWatchdogAutoFollowPromptEvent } from "./scope.js";
+import { ruleViolationWarning } from "./rules.js";
+import { WatchdogScopeArtifact } from "./scope.js";
 import { resolveWatchdogConfig } from "./settings.js";
-import { formatWatchdogTurnDelta } from "./turn-delta.js";
+import { formatWatchdogOrchestrationActivity, formatWatchdogTurnDelta } from "./turn-delta.js";
+import {
+  WATCHDOG_WARNING_IMPORTANCES
+} from "./types.js";
 import { normalizeWatchdogWarningDetails } from "./warning-format.js";
 const DEFAULT_REVIEW = () => ({ warnings: [] });
 const MAX_REVIEW_INPUT_CHARS = 24000;
+const REVIEW_INPUT_HEAD_CHARS = 6000;
 const REVIEW_DELTA_SEPARATOR = `
 
 ---
 
 `;
+export function boundWatchdogReviewText(text, cap = MAX_REVIEW_INPUT_CHARS) {
+  if (text.length <= cap)
+    return text;
+  const head = Math.min(REVIEW_INPUT_HEAD_CHARS, Math.floor(cap / 4));
+  const marker = `
+
+[... about ${text.length - cap} characters omitted ...]
+
+`;
+  return `${text.slice(0, head)}${marker}${text.slice(text.length - (cap - head - marker.length))}`;
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -42,7 +58,7 @@ export class MainWatchdogRuntime {
   reviewConnected;
   reviewDescription;
   displayWarning;
-  sendUserMessage;
+  displayUserWarning;
   reviewChangesOnly;
   lspDiagnostics;
   repoChangeSignature;
@@ -70,7 +86,6 @@ export class MainWatchdogRuntime {
   userPrompt;
   waiters = [];
   lastWarning;
-  displayedWarningSequence = 0;
   lastError;
   lastReviewInputSignature;
   turnStartChangeSignature;
@@ -80,16 +95,19 @@ export class MainWatchdogRuntime {
   observedRepoEditThisTurn = false;
   toolResultsThisRun = 0;
   midRunReviewing = false;
-  autoFollowQueued = false;
-  autoFollowAttempts = 0;
-  consecutiveAutoFollowIdentity;
-  consecutiveAutoFollowRepeats = 0;
-  autoFollowStalemate = false;
-  pendingAutoFollowPrompts = [];
+  lastBoundaryIdentity;
+  boundaryRepeats = 0;
+  stalemate = false;
+  ruleWarningsThisRun = new Set;
   midRunGeneration = 0;
   activeReviewAbortController;
   failedReviews = 0;
   staleReviews = 0;
+  displayClarification;
+  askedThisPrompt = false;
+  activityTail = "";
+  activityPending = false;
+  activityReviewUsed = false;
   constructor(options = {}) {
     this.cwd = options.cwd ?? process.cwd();
     this.resolveConfig = options.resolveConfig ?? resolveWatchdogConfig;
@@ -97,7 +115,8 @@ export class MainWatchdogRuntime {
     this.reviewConnected = Boolean(options.review);
     this.reviewDescription = options.reviewDescription ?? (options.review ? "injected seam" : "not wired");
     this.displayWarning = options.displayWarning;
-    this.sendUserMessage = options.sendUserMessage;
+    this.displayUserWarning = options.displayUserWarning;
+    this.displayClarification = options.displayClarification;
     this.reviewChangesOnly = options.reviewChangesOnly === true;
     this.lspDiagnostics = options.lspDiagnostics ?? collectWatchdogLspDiagnostics;
     this.repoChangeSignature = options.repoChangeSignature ?? computeWatchdogRepoChangeSignature;
@@ -112,11 +131,14 @@ export class MainWatchdogRuntime {
     this.sessionOverrideEnabled = undefined;
     this.sessionModelOverride = undefined;
     this.refreshConfig(ctx.cwd);
-    this.reset("session_start", { clearReviewInputSignature: true, resetChangeSignature: true, clearLspLedger: true, clearScope: true, resetAutoFollow: true });
+    this.reset("session_start", { clearReviewInputSignature: true, resetChangeSignature: true, clearLspLedger: true, clearScope: true });
+    this.resetBoundaryRepeats();
   }
   refreshConfig(cwd = this.cwd) {
     this.cwd = cwd;
     const wasEnabled = this.isEnabled();
+    const hadClarification = this.configResult.config.clarification;
+    const previousMain = this.configResult.config.main;
     const session = this.sessionOverrideEnabled === undefined && this.sessionModelOverride === undefined ? undefined : {
       ...this.sessionOverrideEnabled === undefined ? {} : { enabled: this.sessionOverrideEnabled },
       main: {
@@ -131,6 +153,12 @@ export class MainWatchdogRuntime {
     }
     if (wasEnabled && !this.isEnabled())
       this.invalidateActiveReview("watchdog disabled");
+    if (!this.isEnabled() || !this.configResult.config.clarification)
+      this.clearActivity();
+    if (this.displayClarification && (hadClarification || this.configResult.config.clarification) && (this.reviewing || this.waitingAtAgentEnd)) {
+      if (!this.configResult.config.clarification || previousMain.model !== this.configResult.config.main.model || previousMain.thinking !== this.configResult.config.main.thinking)
+        this.invalidateActiveReview("clarification configuration changed");
+    }
     return this.configResult;
   }
   setSessionEnabled(enabled, cwd = this.cwd) {
@@ -168,6 +196,7 @@ export class MainWatchdogRuntime {
     return this.getSnapshot();
   }
   reset(_reason = "reset", options = {}) {
+    this.activeReviewAbortController?.abort();
     this.abortActiveAgentEnd();
     this.epoch++;
     this.status = "idle";
@@ -183,17 +212,15 @@ export class MainWatchdogRuntime {
     this.observedRepoEditThisTurn = false;
     this.toolResultsThisRun = 0;
     this.midRunReviewing = false;
-    this.autoFollowQueued = false;
+    this.ruleWarningsThisRun.clear();
     if (options.clearLspLedger) {
       this.lspLedger.reset();
       this.lastLspSnapshot = undefined;
     }
-    if (options.clearScope) {
+    if (options.clearScope)
       this.scope.reset();
-      this.pendingAutoFollowPrompts = [];
-    }
-    if (options.resetAutoFollow)
-      this.resetAutoFollowState();
+    if (options.clearScope || options.clearActivity)
+      this.clearActivity();
     if (options.clearReviewInputSignature)
       this.lastReviewInputSignature = undefined;
     if (options.resetChangeSignature)
@@ -202,6 +229,8 @@ export class MainWatchdogRuntime {
     this.resolveWaiters(true);
   }
   dispose() {
+    this.clearActivity();
+    this.activeReviewAbortController?.abort();
     this.disposed = true;
     this.abortActiveAgentEnd();
     this.epoch++;
@@ -219,21 +248,19 @@ export class MainWatchdogRuntime {
     this.observedRepoEditThisTurn = false;
     this.toolResultsThisRun = 0;
     this.midRunReviewing = false;
-    this.autoFollowQueued = false;
     this.resolveWaiters(false);
   }
   handleBeforeAgentStart(event, ctx) {
     if (this.disposed)
       return;
     const incomingPrompt = promptFromBeforeAgentStart(event);
-    const pendingIndex = incomingPrompt === undefined ? -1 : this.pendingAutoFollowPrompts.indexOf(incomingPrompt);
-    const autoFollowPrompt = pendingIndex >= 0 || isWatchdogAutoFollowPromptEvent(event);
-    if (pendingIndex >= 0)
-      this.pendingAutoFollowPrompts.splice(pendingIndex, 1);
-    this.reset("before_agent_start", { resetAutoFollow: !autoFollowPrompt });
+    this.reset("before_agent_start");
+    this.askedThisPrompt = false;
+    this.activityReviewUsed = false;
+    this.resetBoundaryRepeats();
     this.refreshConfig(ctx.cwd);
     this.userPrompt = incomingPrompt;
-    if (!autoFollowPrompt && this.userPrompt?.trim()) {
+    if (this.userPrompt?.trim()) {
       this.includeUserPromptInNextDelta = true;
       this.scope.addPrompt(this.userPrompt);
     } else {
@@ -241,18 +268,26 @@ export class MainWatchdogRuntime {
     }
     this.resetRepoChangeBaseline();
   }
-  handleTurnEnd(event, ctx) {
+  handleTurnEnd(event, ctx, structuredTerminal = false) {
     if (this.disposed)
       return;
     this.refreshConfig(ctx.cwd);
     if (!this.isEnabled())
       return;
     try {
+      if (this.displayClarification && this.configResult.config.clarification && this.boundaryRepeats === 0) {
+        const activity = formatWatchdogOrchestrationActivity(event);
+        if (activity) {
+          this.activityTail = [this.activityTail, boundWatchdogReviewText(activity, 3000)].filter(Boolean).join(REVIEW_DELTA_SEPARATOR).slice(-6000);
+          this.activityPending = true;
+        }
+      }
       this.observedRepoEditThisTurn ||= eventIndicatesRepoEdit(event);
       const delta = formatWatchdogTurnDelta({
         includeUserPrompt: this.includeUserPromptInNextDelta,
         userPrompt: this.userPrompt,
-        events: [event]
+        events: [event],
+        structuredTerminal
       });
       this.includeUserPromptInNextDelta = false;
       this.enqueueDelta(delta);
@@ -292,29 +327,28 @@ export class MainWatchdogRuntime {
     this.refreshConfig(ctx.cwd);
     if (!this.isEnabled())
       return;
-    const changeSignature = this.resolveReviewChangeSignature(ctx.cwd);
-    if (this.reviewChangesOnly && !changeSignature) {
-      this.clearPendingDeltas();
-      if (this.status === "queued")
-        this.status = "idle";
-      this.resolveWaiters(true);
+    if (ctx.signal?.aborted)
       return;
-    }
-    if (changeSignature && changeSignature.key === this.lastReviewedChangeSignature) {
+    const changeSignature = this.resolveReviewChangeSignature(this.currentRepoChangeSignature(ctx.cwd), ctx.cwd);
+    const activityReview = Boolean(this.displayClarification && this.configResult.config.clarification && !this.activityReviewUsed && this.boundaryRepeats === 0 && this.activityPending);
+    const knownEvidence = changeSignature && changeSignature.key === this.lastReviewedChangeSignature;
+    if (!activityReview && (knownEvidence || this.reviewChangesOnly && !changeSignature)) {
       this.clearPendingDeltas();
-      this.status = "idle";
+      if (knownEvidence || this.status === "queued")
+        this.status = "idle";
       this.resolveWaiters(true);
       return;
     }
     this.cancelMidRunReview();
+    if (activityReview && (!changeSignature || knownEvidence))
+      this.activityReviewUsed = true;
+    this.activityPending = false;
     this.waitingAtAgentEnd = true;
     const agentEndEpoch = this.epoch;
     const agentEndId = ++this.agentEndIdCounter;
     const lspAbortController = new AbortController;
     this.activeAgentEndId = agentEndId;
     this.activeAgentEndAbortController = lspAbortController;
-    let displayedDuringAgentEnd;
-    const previousDisplayedSequence = this.displayedWarningSequence;
     try {
       this.guard.startModelUpdate();
       const lspBlock = await this.collectLspDiagnostics(changeSignature, {
@@ -342,7 +376,9 @@ export class MainWatchdogRuntime {
         this.resolveWaiters(true);
         return;
       }
-      const outcome = await this.reviewDelta(delta, this.configResult.config.agentEndTimeoutMs);
+      const outcome = await this.reviewDelta(delta, this.configResult.config.agentEndTimeoutMs, { allowClarification: true });
+      if (!this.isAgentEndCurrent(agentEndEpoch, agentEndId))
+        return;
       this.waitingAtAgentEnd = false;
       if (outcome === "timeout") {
         this.staleReviews++;
@@ -352,15 +388,21 @@ export class MainWatchdogRuntime {
         this.resolveWaiters(true);
         return;
       }
-      if (outcome === "completed" && this.status !== "failed" && this.status !== "stale") {
+      if ((outcome === "completed" || typeof outcome === "object") && this.status !== "failed" && this.status !== "stale") {
         this.lastReviewInputSignature = signature;
         if (changeSignature)
           this.lastReviewedChangeSignature = changeSignature.key;
         this.currentChangedPaths = changeSignature?.changedPaths;
         this.status = "idle";
+        if (typeof outcome === "object" && !ctx.signal?.aborted)
+          this.displayClarification?.([
+            "Main watchdog clarification:",
+            outcome.question,
+            `Evidence: ${outcome.evidence}`,
+            "Consider this missing context as you continue the task. This is not approval, permission, or a warning. The reviewer has yielded; no reply or follow-up review is required."
+          ].join(`
+`));
       }
-      displayedDuringAgentEnd = this.displayedWarningSequence !== previousDisplayedSequence ? this.lastWarning : undefined;
-      this.queueAutoFollowIfNeeded(displayedDuringAgentEnd);
       this.resolveWaiters(true);
     } finally {
       if (this.activeAgentEndAbortController === lspAbortController)
@@ -369,10 +411,18 @@ export class MainWatchdogRuntime {
         this.activeAgentEndId = undefined;
     }
   }
-  recordDisplayedWarning(warning) {
+  displayRuleWarning(violation) {
+    if (this.disposed || this.ruleWarningsThisRun.has(violation.summary))
+      return;
+    this.ruleWarningsThisRun.add(violation.summary);
+    const details = normalizeWatchdogWarningDetails(ruleViolationWarning(violation), { state: "displayed", displayedAt: new Date().toISOString() });
+    this.lastWarning = details;
+    this.routeWarning(details, { deliverAs: "steer" });
+  }
+  displayRecordedWarning(warning) {
     const details = normalizeWatchdogWarningDetails(warning, { state: "displayed", source: warning.source ?? "main" });
     this.lastWarning = details;
-    return details;
+    this.routeWarning(details);
   }
   getSnapshot(cwd) {
     if (cwd)
@@ -395,14 +445,21 @@ export class MainWatchdogRuntime {
       staleReviews: this.staleReviews,
       reviewConnected: this.reviewConnected,
       reviewDescription: this.reviewDescription,
-      autoFollowQueued: this.autoFollowQueued,
-      autoFollowAttempts: this.autoFollowAttempts,
-      autoFollowStalemate: this.autoFollowStalemate,
+      boundaryRepeats: this.boundaryRepeats,
+      stalemate: this.stalemate,
       reviewTrigger: this.reviewChangesOnly ? "repo-edits" : "turn-delta",
       ...this.currentChangedPaths?.length ? { changedPaths: [...this.currentChangedPaths] } : {},
       lsp: this.lspSnapshot()
     };
   }
+  handleUserInput() {
+    if (this.displayClarification && this.configResult.config.clarification && (this.reviewing || this.waitingAtAgentEnd))
+      this.reset("new user input");
+  }
+  handleModelChange() {
+    if (this.displayClarification && this.configResult.config.clarification && (this.reviewing || this.waitingAtAgentEnd))
+      this.reset("model changed");
+  }
   async waitForIdle(timeoutMs = 1000) {
     return this.waitForSettled(timeoutMs);
   }
@@ -421,12 +478,18 @@ export class MainWatchdogRuntime {
     return !this.disposed && this.epoch === epoch && this.activeReviewId === reviewId;
   }
   warningMeetsThreshold(warning) {
-    return this.configResult.config.severityThreshold === "concern" || warning.severity === "blocker";
+    return WATCHDOG_WARNING_IMPORTANCES.includes(warning.importance) && (this.configResult.config.severityThreshold === "concern" || warning.severity === "blocker");
+  }
+  routeWarning(details, options) {
+    if (details.importance === "high")
+      this.displayWarning?.(details, options);
+    else
+      this.displayUserWarning?.(details);
   }
   acceptWarning(epoch, reviewId, warning) {
     if (!this.isCurrent(epoch, reviewId) || !this.isEnabled() || !this.warningMeetsThreshold(warning))
       return false;
-    const decision = this.guard.evaluate(warning);
+    const decision = this.guard.evaluate(warning, { allowRepeatOf: this.repeatableBoundaryIdentity() });
     if (!decision.accepted)
       return false;
     const details = normalizeWatchdogWarningDetails(warning, {
@@ -441,7 +504,7 @@ export class MainWatchdogRuntime {
   displayBoundaryWarning(warning) {
     if (!this.isEnabled() || !this.warningMeetsThreshold(warning))
       return false;
-    const decision = this.guard.evaluate(warning);
+    const decision = this.guard.evaluate(warning, { allowRepeatOf: this.repeatableBoundaryIdentity() });
     if (!decision.accepted)
       return false;
     const details = normalizeWatchdogWarningDetails(warning, {
@@ -450,12 +513,11 @@ export class MainWatchdogRuntime {
       identity: decision.identity,
       displayedAt: new Date().toISOString()
     });
-    this.lastWarning = details;
-    this.displayedWarningSequence++;
-    this.displayWarning?.(details);
+    this.deliverBoundaryWarning(details);
     return true;
   }
   invalidateActiveReview(_reason) {
+    this.activeReviewAbortController?.abort();
     this.abortActiveAgentEnd();
     this.epoch++;
     this.status = "idle";
@@ -512,6 +574,7 @@ export class MainWatchdogRuntime {
     let timeout;
     const abortController = new AbortController;
     this.activeReviewAbortController = abortController;
+    const allowClarification = Boolean(options.allowClarification && this.displayClarification && this.configResult.config.clarification && !this.askedThisPrompt && !this.stalemate);
     const reviewPromise = Promise.resolve().then(() => this.review({
       delta,
       epoch: reviewEpoch,
@@ -519,7 +582,8 @@ export class MainWatchdogRuntime {
       config: this.configResult.config,
       hasScope: this.scopeBlock().trim().length > 0,
       signal: abortController.signal,
-      emitWarning: (warning) => this.acceptWarning(reviewEpoch, reviewId, warning)
+      emitWarning: (warning) => this.acceptWarning(reviewEpoch, reviewId, warning),
+      ...allowClarification ? { allowClarification: true } : {}
     }));
     try {
       const result = await Promise.race([
@@ -536,10 +600,19 @@ export class MainWatchdogRuntime {
         return "stale";
       if (!result)
         return "stale";
+      if (allowClarification && this.configResult.config.clarification && result.clarification && (!result.stopReason || result.stopReason === "stop") && !this.activeReviewWarning && !result.warnings?.length && !abortController.signal.aborted) {
+        const question = result.clarification.question.trim();
+        const evidence = result.clarification.evidence.trim();
+        if (question && evidence) {
+          this.askedThisPrompt = true;
+          return { question: boundWatchdogReviewText(question, 1000), evidence: boundWatchdogReviewText(evidence, 2000) };
+        }
+      }
       for (const warning of result.warnings ?? [])
         this.acceptWarning(reviewEpoch, reviewId, warning);
       if (result.stopReason && result.stopReason !== "stop") {
-        this.fail(`Watchdog review ended with stop reason '${result.stopReason}'.`);
+        const detail = result.errorMessage?.trim() ? ` ${boundWatchdogReviewText(result.errorMessage.trim(), 600)}` : "";
+        this.fail(`Watchdog review ended with stop reason '${result.stopReason}'.${detail}`);
         return "completed";
       }
       this.displayAcceptedReviewWarning(options.correction);
@@ -571,57 +644,35 @@ export class MainWatchdogRuntime {
       state: "displayed",
       displayedAt: new Date().toISOString()
     };
-    this.lastWarning = details;
-    this.displayedWarningSequence++;
-    this.displayWarning?.(details, correction ? { deliverAs: "steer" } : undefined);
-  }
-  resetAutoFollowState() {
-    this.autoFollowQueued = false;
-    this.autoFollowAttempts = 0;
-    this.consecutiveAutoFollowIdentity = undefined;
-    this.consecutiveAutoFollowRepeats = 0;
-    this.autoFollowStalemate = false;
-  }
-  queueAutoFollowIfNeeded(warning) {
-    if (!warning || warning.severity !== "blocker" || warning.stale || !this.configResult.config.autoFollow.blockers || !this.isEnabled())
+    if (correction) {
+      this.lastWarning = details;
+      this.routeWarning(details, { deliverAs: "steer" });
       return;
-    const identity = warning.identity ?? reviewInputSignature([warning.severity, warning.summary, warning.evidence].join(`
+    }
+    this.deliverBoundaryWarning(details);
+  }
+  deliverBoundaryWarning(details) {
+    const identity = details.identity ?? reviewInputSignature([details.severity, details.summary, details.evidence].join(`
 `));
-    if (this.consecutiveAutoFollowIdentity === identity)
-      this.consecutiveAutoFollowRepeats++;
+    if (this.lastBoundaryIdentity === identity)
+      this.boundaryRepeats++;
     else {
-      this.consecutiveAutoFollowIdentity = identity;
-      this.consecutiveAutoFollowRepeats = 1;
-    }
-    if (this.consecutiveAutoFollowRepeats >= this.configResult.config.autoFollow.stalemateRepeats) {
-      this.autoFollowStalemate = true;
-      this.lastWarning = { ...warning, state: "stalemate", stalemateRepeats: this.consecutiveAutoFollowRepeats };
-      return;
+      this.lastBoundaryIdentity = identity;
+      this.boundaryRepeats = 1;
     }
-    const maxAttempts = this.configResult.config.autoFollow.maxAttempts;
-    if (maxAttempts !== null && this.autoFollowAttempts >= maxAttempts)
-      return;
-    if (!this.sendUserMessage)
-      return;
-    this.autoFollowAttempts++;
-    this.autoFollowQueued = true;
-    const prompt = [
-      "Watchdog auto-follow: address this blocker before continuing.",
-      `Summary: ${warning.summary}`,
-      `Evidence: ${warning.evidence}`,
-      `Recommended action: ${warning.recommendedAction}`
-    ].join(`
-`);
-    this.pendingAutoFollowPrompts.push(prompt);
-    if (this.pendingAutoFollowPrompts.length > 8)
-      this.pendingAutoFollowPrompts.shift();
-    Promise.resolve(this.sendUserMessage(prompt)).catch((error) => {
-      this.autoFollowQueued = false;
-      const index = this.pendingAutoFollowPrompts.indexOf(prompt);
-      if (index >= 0)
-        this.pendingAutoFollowPrompts.splice(index, 1);
-      this.lastError = `Watchdog auto-follow failed: ${errorMessage(error)}`;
-    });
+    const stalemate = this.boundaryRepeats >= this.configResult.config.stalemateRepeats;
+    const delivered = stalemate ? { ...details, state: "stalemate", stalemateRepeats: this.boundaryRepeats } : details;
+    this.stalemate = stalemate;
+    this.lastWarning = delivered;
+    this.routeWarning(delivered, stalemate ? { triggerTurn: false } : undefined);
+  }
+  repeatableBoundaryIdentity() {
+    return this.waitingAtAgentEnd && !this.stalemate ? this.lastBoundaryIdentity : undefined;
+  }
+  resetBoundaryRepeats() {
+    this.lastBoundaryIdentity = undefined;
+    this.boundaryRepeats = 0;
+    this.stalemate = false;
   }
   currentRepoChangeSignature(cwd = this.cwd) {
     return this.reviewChangesOnly && this.isEnabled() ? this.repoChangeSignature(cwd) : undefined;
@@ -635,10 +686,9 @@ export class MainWatchdogRuntime {
     this.currentChangedPaths = this.turnStartChangeSignature?.changedPaths;
     this.observedRepoEditThisTurn = false;
   }
-  resolveReviewChangeSignature(cwd = this.cwd) {
+  resolveReviewChangeSignature(current, cwd) {
     if (!this.reviewChangesOnly)
       return;
-    const current = this.currentRepoChangeSignature(cwd);
     if (current) {
       this.currentChangedPaths = current.changedPaths;
       if (current.key === this.turnStartChangeSignature?.key)
@@ -728,7 +778,7 @@ export class MainWatchdogRuntime {
     if (!entry)
       return;
     if (entry.length > MAX_REVIEW_INPUT_CHARS)
-      entry = entry.slice(-MAX_REVIEW_INPUT_CHARS);
+      entry = boundWatchdogReviewText(entry);
     this.pendingDeltas.push(entry);
     this.pendingDeltaChars += entry.length;
     while (this.pendingDeltas.length > 1 && this.pendingDeltaChars + (this.pendingDeltas.length - 1) * REVIEW_DELTA_SEPARATOR.length > MAX_REVIEW_INPUT_CHARS) {
@@ -742,16 +792,18 @@ export class MainWatchdogRuntime {
     const scopeBlock = this.scopeBlock();
     const changes = changeSignature?.changedPaths.length ? ["Changed repo paths:", ...changeSignature.changedPaths.slice(0, 200).map((file) => `- ${file}`)].join(`
 `) : "";
-    const contextPieces = [scopeBlock, changes, lspBlock].filter(Boolean);
+    const activity = this.activityTail ? `Recent delivered orchestration activity (oldest first; bounded observations, not a task board; waits/holds are not evidence of neglect):
+${this.activityTail}` : "";
+    const contextPieces = [scopeBlock, changes, lspBlock, activity].filter(Boolean);
     if (!contextPieces.length)
-      return input.length > MAX_REVIEW_INPUT_CHARS ? input.slice(-MAX_REVIEW_INPUT_CHARS) : input;
+      return boundWatchdogReviewText(input);
     const maxContextLength = Math.floor(MAX_REVIEW_INPUT_CHARS / 2);
     const maxPieceLength = Math.max(1000, Math.floor(maxContextLength / contextPieces.length));
-    const boundedContext = contextPieces.map((piece) => piece.length > maxPieceLength ? `${piece.slice(0, maxPieceLength - 6)}
+    const boundedContext = contextPieces.map((piece) => piece.length > maxPieceLength ? piece === activity ? boundWatchdogReviewText(piece, maxPieceLength) : `${piece.slice(0, maxPieceLength - 6)}
 - ...` : piece).join(REVIEW_DELTA_SEPARATOR);
     const separatorLength = input ? REVIEW_DELTA_SEPARATOR.length : 0;
     const inputBudget = MAX_REVIEW_INPUT_CHARS - boundedContext.length - separatorLength;
-    const boundedInput = inputBudget <= 0 ? "" : input.length > inputBudget ? input.slice(-inputBudget) : input;
+    const boundedInput = inputBudget <= 0 ? "" : boundWatchdogReviewText(input, inputBudget);
     return [boundedContext, boundedInput].filter(Boolean).join(REVIEW_DELTA_SEPARATOR);
   }
   scopeBlock() {
@@ -761,6 +813,12 @@ export class MainWatchdogRuntime {
     this.pendingDeltas = [];
     this.pendingDeltaChars = 0;
   }
+  clearActivity() {
+    if (!this.activityTail)
+      return;
+    this.activityTail = "";
+    this.activityPending = false;
+  }
   fail(message) {
     this.failedReviews++;
     this.lastError = message;

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

@@ -1,4 +1,3 @@
-export const WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER = Symbol("subagent-watchdog-auto-follow-prompt");
 const MAX_SCOPE_ENTRIES = 8;
 const MAX_SCOPE_ENTRY_CHARS = 2000;
 const MAX_SCOPE_TOTAL_CHARS = 16000;
@@ -26,7 +25,7 @@ export class WatchdogScopeArtifact {
       return "";
     return [
       "Current scope:",
-      "The following real user prompts are the current scope record, newest last. Newer prompts supersede and mutate older prompts: they may add, modify, or remove requirements. Flag work that serves no current scope item as category 'scope-drift'.",
+      "The following real user prompts are the current scope record, newest last. Side questions are additive, not scope drift or cancellation of older objectives; only explicit changes supersede requirements. Use watchdog_warn for evidence-backed reminders of forgotten authorized work, not dependencies still pending or explicit holds. The orchestrator owns task tracking. Flag unauthorized work as category 'scope-drift'.",
       ...this.entries.map((entry, index) => [
         `Scope prompt ${index + 1} (${entry.createdAt}):`,
         entry.prompt
@@ -47,10 +46,3 @@ export class WatchdogScopeArtifact {
     }
   }
 }
-export function isWatchdogAutoFollowPromptEvent(event) {
-  return Boolean(event && typeof event === "object" && event[WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER]);
-}
-export function markWatchdogAutoFollowPromptEvent(event) {
-  Object.defineProperty(event, WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER, { value: true });
-  return event;
-}