@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -3,28 +3,18 @@ import * as path from "node:path";
 import { THINKING_LEVELS } from "../shared/model-info.js";
 import { getAgentDir, getProjectConfigDir } from "../shared/utils.js";
 import {
-  WATCHDOG_DELIVERY_MODES,
-  WATCHDOG_LATE_WARNING_POLICIES,
   WATCHDOG_WARNING_SEVERITIES
 } from "./types.js";
 export const DEFAULT_WATCHDOG_CONFIG = {
   enabled: false,
-  delivery: "held",
-  showDuringRun: false,
-  syncBacklog: "off",
+  clarification: false,
   agentEndTimeoutMs: 30000,
-  lateWarningPolicy: "show-stale-no-autofollow",
   severityThreshold: "concern",
   maxWarnings: null,
   guidance: {
-    watchdogMd: true,
-    systemPromptPath: null
-  },
-  autoFollow: {
-    blockers: true,
-    maxAttempts: 3,
-    stalemateRepeats: 3
+    watchdogMd: true
   },
+  stalemateRepeats: 3,
   scope: {
     enabled: true
   },
@@ -37,71 +27,50 @@ export const DEFAULT_WATCHDOG_CONFIG = {
   children: {
     enabled: false,
     watchdogTailTimeoutMs: 120000,
-    autoFollow: {
-      blockers: true,
-      maxAttempts: 3,
-      stalemateRepeats: 3
-    },
     overrides: {}
   },
-  asyncCompletion: {
-    enabled: false,
-    autoFollowBlockers: false
-  },
   lsp: {
     enabled: true,
     timeoutMs: 3000,
     maxFiles: 20,
     maxDiagnostics: 50
-  },
-  compactAtPercent: 80,
-  reviewRetryDelayMs: 1000,
-  maxReviewFailures: 3
+  }
 };
 const WATCHDOG_FIELDS = new Set([
   "enabled",
-  "delivery",
-  "showDuringRun",
-  "syncBacklog",
+  "clarification",
   "agentEndTimeoutMs",
-  "lateWarningPolicy",
   "severityThreshold",
   "maxWarnings",
   "guidance",
-  "autoFollow",
+  "stalemateRepeats",
   "scope",
   "cadence",
   "main",
   "children",
-  "asyncCompletion",
   "lsp",
-  "compactAtPercent",
-  "reviewRetryDelayMs",
-  "maxReviewFailures"
+  "rules"
 ]);
-const GUIDANCE_FIELDS = new Set(["watchdogMd", "systemPromptPath"]);
-const AUTO_FOLLOW_FIELDS = new Set(["blockers", "maxAttempts", "stalemateRepeats"]);
+const RULES_FIELDS = new Set(["action", "roleModels"]);
+const ROLE_MODEL_RULE_FIELDS = new Set(["allow", "deny", "note"]);
+const GUIDANCE_FIELDS = new Set(["watchdogMd"]);
 const SCOPE_FIELDS = new Set(["enabled"]);
 const CADENCE_FIELDS = new Set(["everyNTools"]);
 const ENDPOINT_FIELDS = new Set(["enabled", "model", "thinking"]);
-const CHILDREN_FIELDS = new Set(["enabled", "model", "thinking", "watchdogTailTimeoutMs", "autoFollow", "overrides"]);
-const CHILD_OVERRIDE_FIELDS = new Set(["enabled", "model", "thinking"]);
-const ASYNC_COMPLETION_FIELDS = new Set(["enabled", "autoFollowBlockers"]);
+const CHILDREN_FIELDS = new Set(["enabled", "model", "thinking", "watchdogTailTimeoutMs", "cadence", "overrides"]);
+const CHILD_OVERRIDE_FIELDS = new Set(["enabled", "model", "thinking", "cadence"]);
 const LSP_FIELDS = new Set(["enabled", "timeoutMs", "maxFiles", "maxDiagnostics"]);
 function cloneDefaultConfig() {
   return {
     ...DEFAULT_WATCHDOG_CONFIG,
     guidance: { ...DEFAULT_WATCHDOG_CONFIG.guidance },
-    autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.autoFollow },
     scope: { ...DEFAULT_WATCHDOG_CONFIG.scope },
     cadence: { ...DEFAULT_WATCHDOG_CONFIG.cadence },
     main: { ...DEFAULT_WATCHDOG_CONFIG.main },
     children: {
       ...DEFAULT_WATCHDOG_CONFIG.children,
-      autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.children.autoFollow },
       overrides: {}
     },
-    asyncCompletion: { ...DEFAULT_WATCHDOG_CONFIG.asyncCompletion },
     lsp: { ...DEFAULT_WATCHDOG_CONFIG.lsp }
   };
 }
@@ -160,34 +129,12 @@ function parseEnum(value, field, meta, values) {
     return value;
   throw invalid(meta, field, values.map((item) => `'${item}'`).join(" or "));
 }
-function parseSyncBacklog(value, field, meta) {
-  if (value === "off")
-    return "off";
-  return parseInteger(value, field, meta, "'off' or a positive integer", (candidate) => candidate >= 1);
-}
 function parseGuidancePatch(value, field, meta) {
   const input = parseObject(value, field, meta);
   assertKnownFields(input, GUIDANCE_FIELDS, field, meta);
   const patch = {};
   if ("watchdogMd" in input)
     patch.watchdogMd = parseBoolean(input.watchdogMd, `${field}.watchdogMd`, meta);
-  if ("systemPromptPath" in input) {
-    patch.systemPromptPath = input.systemPromptPath === null ? null : parseNonEmptyString(input.systemPromptPath, `${field}.systemPromptPath`, meta);
-  }
-  return patch;
-}
-function parseAutoFollowPatch(value, field, meta) {
-  const input = parseObject(value, field, meta);
-  assertKnownFields(input, AUTO_FOLLOW_FIELDS, field, meta);
-  const patch = {};
-  if ("blockers" in input)
-    patch.blockers = parseBoolean(input.blockers, `${field}.blockers`, meta);
-  if ("maxAttempts" in input) {
-    patch.maxAttempts = parseNullableInteger(input.maxAttempts, `${field}.maxAttempts`, meta, "null or a positive integer", (candidate) => candidate >= 1);
-  }
-  if ("stalemateRepeats" in input) {
-    patch.stalemateRepeats = parseInteger(input.stalemateRepeats, `${field}.stalemateRepeats`, meta, "a positive integer", (candidate) => candidate >= 1);
-  }
   return patch;
 }
 function parseScopePatch(value, field, meta) {
@@ -229,6 +176,8 @@ function parseChildOverridePatch(value, field, meta) {
     patch.model = parseNonEmptyString(input.model, `${field}.model`, meta);
   if ("thinking" in input)
     patch.thinking = parseThinking(input.thinking, `${field}.thinking`, meta);
+  if ("cadence" in input)
+    patch.cadence = parseCadencePatch(input.cadence, `${field}.cadence`, meta);
   return patch;
 }
 function parseChildrenPatch(value, field, meta) {
@@ -244,8 +193,8 @@ function parseChildrenPatch(value, field, meta) {
   if ("watchdogTailTimeoutMs" in input) {
     patch.watchdogTailTimeoutMs = parseInteger(input.watchdogTailTimeoutMs, `${field}.watchdogTailTimeoutMs`, meta, "a positive integer", (candidate) => candidate >= 1);
   }
-  if ("autoFollow" in input)
-    patch.autoFollow = parseAutoFollowPatch(input.autoFollow, `${field}.autoFollow`, meta);
+  if ("cadence" in input)
+    patch.cadence = parseCadencePatch(input.cadence, `${field}.cadence`, meta);
   if ("overrides" in input) {
     const overrides = parseObject(input.overrides, `${field}.overrides`, meta);
     patch.overrides = {};
@@ -257,16 +206,6 @@ function parseChildrenPatch(value, field, meta) {
   }
   return patch;
 }
-function parseAsyncCompletionPatch(value, field, meta) {
-  const input = parseObject(value, field, meta);
-  assertKnownFields(input, ASYNC_COMPLETION_FIELDS, field, meta);
-  const patch = {};
-  if ("enabled" in input)
-    patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta);
-  if ("autoFollowBlockers" in input)
-    patch.autoFollowBlockers = parseBoolean(input.autoFollowBlockers, `${field}.autoFollowBlockers`, meta);
-  return patch;
-}
 function parseLspPatch(value, field, meta) {
   const input = parseObject(value, field, meta);
   assertKnownFields(input, LSP_FIELDS, field, meta);
@@ -281,24 +220,49 @@ function parseLspPatch(value, field, meta) {
     patch.maxDiagnostics = parseInteger(input.maxDiagnostics, `${field}.maxDiagnostics`, meta, "a non-negative integer", (candidate) => candidate >= 0);
   return patch;
 }
+function parseStringList(value, field, meta) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || !entry.trim()))
+    throw invalid(meta, field, "an array of non-empty strings");
+  return value.map((entry) => entry.trim());
+}
+function parseRoleModelRule(value, field, meta) {
+  const input = parseObject(value, field, meta);
+  assertKnownFields(input, ROLE_MODEL_RULE_FIELDS, field, meta);
+  const rule = {};
+  if ("allow" in input)
+    rule.allow = parseStringList(input.allow, `${field}.allow`, meta);
+  if ("deny" in input)
+    rule.deny = parseStringList(input.deny, `${field}.deny`, meta);
+  if ("note" in input)
+    rule.note = parseNonEmptyString(input.note, `${field}.note`, meta);
+  return rule;
+}
+function parseRules(value, field, meta) {
+  const input = parseObject(value, field, meta);
+  assertKnownFields(input, RULES_FIELDS, field, meta);
+  const rules = { action: "warn", roleModels: {} };
+  if ("action" in input)
+    rules.action = parseEnum(input.action, `${field}.action`, meta, ["warn", "block"]);
+  if ("roleModels" in input) {
+    for (const [agent, rule] of Object.entries(parseObject(input.roleModels, `${field}.roleModels`, meta))) {
+      if (!agent.trim())
+        throw invalid(meta, `${field}.roleModels`, "agent names to be non-empty");
+      rules.roleModels[agent] = parseRoleModelRule(rule, `${field}.roleModels.${agent}`, meta);
+    }
+  }
+  return rules;
+}
 function parseWatchdogPatch(value, field, meta) {
   const input = parseObject(value, field, meta);
   assertKnownFields(input, WATCHDOG_FIELDS, field, meta);
   const patch = {};
   if ("enabled" in input)
     patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta);
-  if ("delivery" in input)
-    patch.delivery = parseEnum(input.delivery, `${field}.delivery`, meta, WATCHDOG_DELIVERY_MODES);
-  if ("showDuringRun" in input)
-    patch.showDuringRun = parseBoolean(input.showDuringRun, `${field}.showDuringRun`, meta);
-  if ("syncBacklog" in input)
-    patch.syncBacklog = parseSyncBacklog(input.syncBacklog, `${field}.syncBacklog`, meta);
+  if ("clarification" in input)
+    patch.clarification = parseBoolean(input.clarification, `${field}.clarification`, meta);
   if ("agentEndTimeoutMs" in input) {
     patch.agentEndTimeoutMs = parseInteger(input.agentEndTimeoutMs, `${field}.agentEndTimeoutMs`, meta, "a positive integer", (candidate) => candidate >= 1);
   }
-  if ("lateWarningPolicy" in input) {
-    patch.lateWarningPolicy = parseEnum(input.lateWarningPolicy, `${field}.lateWarningPolicy`, meta, WATCHDOG_LATE_WARNING_POLICIES);
-  }
   if ("severityThreshold" in input) {
     patch.severityThreshold = parseEnum(input.severityThreshold, `${field}.severityThreshold`, meta, WATCHDOG_WARNING_SEVERITIES);
   }
@@ -307,8 +271,9 @@ function parseWatchdogPatch(value, field, meta) {
   }
   if ("guidance" in input)
     patch.guidance = parseGuidancePatch(input.guidance, `${field}.guidance`, meta);
-  if ("autoFollow" in input)
-    patch.autoFollow = parseAutoFollowPatch(input.autoFollow, `${field}.autoFollow`, meta);
+  if ("stalemateRepeats" in input) {
+    patch.stalemateRepeats = parseInteger(input.stalemateRepeats, `${field}.stalemateRepeats`, meta, "a positive integer", (candidate) => candidate >= 1);
+  }
   if ("scope" in input)
     patch.scope = parseScopePatch(input.scope, `${field}.scope`, meta);
   if ("cadence" in input)
@@ -317,19 +282,10 @@ function parseWatchdogPatch(value, field, meta) {
     patch.main = parseEndpointPatch(input.main, `${field}.main`, meta);
   if ("children" in input)
     patch.children = parseChildrenPatch(input.children, `${field}.children`, meta);
-  if ("asyncCompletion" in input)
-    patch.asyncCompletion = parseAsyncCompletionPatch(input.asyncCompletion, `${field}.asyncCompletion`, meta);
   if ("lsp" in input)
     patch.lsp = parseLspPatch(input.lsp, `${field}.lsp`, meta);
-  if ("compactAtPercent" in input) {
-    patch.compactAtPercent = parseInteger(input.compactAtPercent, `${field}.compactAtPercent`, meta, "an integer from 50 through 95", (candidate) => candidate >= 50 && candidate <= 95);
-  }
-  if ("reviewRetryDelayMs" in input) {
-    patch.reviewRetryDelayMs = parseInteger(input.reviewRetryDelayMs, `${field}.reviewRetryDelayMs`, meta, "a positive integer", (candidate) => candidate >= 1);
-  }
-  if ("maxReviewFailures" in input) {
-    patch.maxReviewFailures = parseInteger(input.maxReviewFailures, `${field}.maxReviewFailures`, meta, "a positive integer", (candidate) => candidate >= 1);
-  }
+  if ("rules" in input)
+    patch.rules = parseRules(input.rules, `${field}.rules`, meta);
   return patch;
 }
 function parseSettingsObject(settings, meta) {

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

@@ -1,7 +1,7 @@
 import { THINKING_LEVELS } from "../shared/model-info.js";
 import { buildWatchdogStatus } from "./register-main.js";
-import { parseWatchdogThinkingInput, recommendStrongWatchdogModel, resolveWatchdogModelInput } from "./model-selection.js";
-import { writeWatchdogModelSettings } from "./settings.js";
+import { formatWatchdogRecommendation, parseWatchdogThinkingInput, recommendStrongWatchdogModel, recommendWatchdogModel, resolveWatchdogModelInput } from "./model-selection.js";
+import { resolveWatchdogConfig, writeWatchdogModelSettings } from "./settings.js";
 function result(text, isError = false) {
   return {
     content: [{ type: "text", text }],
@@ -39,7 +39,7 @@ function parseThinking(raw) {
     return null;
   return parseWatchdogThinkingInput(raw, "watchdog.configure thinking") ?? undefined;
 }
-function resolveConfiguredValue(ctx, params) {
+function resolveConfiguredValue(ctx, params, runtime) {
   const thinking = parseThinking(params.thinking);
   const rawModel = params.model?.trim();
   if (!rawModel) {
@@ -50,7 +50,7 @@ function resolveConfiguredValue(ctx, params) {
   if (rawModel === "inherit")
     return { model: null, thinking: thinking ?? null, description: "inherit" };
   if (rawModel === "recommended") {
-    const recommendation = recommendStrongWatchdogModel(ctx);
+    const recommendation = (params.target ?? "main") === "main" ? recommendWatchdogModel(ctx, (runtime?.getSnapshot(ctx.cwd).config ?? resolveWatchdogConfig(ctx.cwd).config).main) : recommendStrongWatchdogModel(ctx);
     return {
       model: recommendation.model,
       thinking: recommendation.thinking,
@@ -64,11 +64,11 @@ function resolveConfiguredValue(ctx, params) {
     description: `${resolved.model}${resolved.thinking ?? thinking ? `:${resolved.thinking ?? thinking}` : ""}`
   };
 }
-function buildRecommendationText(ctx) {
-  const recommendation = recommendStrongWatchdogModel(ctx);
+function buildRecommendationText(ctx, runtime) {
+  const recommendation = recommendWatchdogModel(ctx, (runtime?.getSnapshot(ctx.cwd).config ?? resolveWatchdogConfig(ctx.cwd).config).main);
   return [
     "Subagent watchdog recommended model",
-    `Recommended: ${recommendation.model}:${recommendation.thinking}`,
+    recommendation.source === "configured" ? formatWatchdogRecommendation(recommendation) : `Recommended: ${recommendation.model}:${recommendation.thinking}`,
     `Reason: ${recommendation.reason}`,
     'Apply temporarily with subagent({ action: "watchdog.configure", scope: "session", model: "recommended" }).',
     'Persist with scope: "project" or scope: "user" only when the user asks for that scope.'
@@ -91,10 +91,9 @@ function buildCheckText(runtime, ctx) {
   }
   lines.push(`LSP diagnostics: ${snapshot.lsp.enabled ? "on" : "off"} · ${snapshot.lsp.status}`);
   try {
-    const recommendation = recommendStrongWatchdogModel(ctx);
-    lines.push(`Recommended strong watchdog: ${recommendation.model}:${recommendation.thinking}`);
+    lines.push(formatWatchdogRecommendation(recommendWatchdogModel(ctx, snapshot.config.main)));
   } catch (error) {
-    lines.push(`Recommended strong watchdog unavailable: ${messageFromError(error)}`);
+    lines.push(`Watchdog recommendation unavailable: ${messageFromError(error)}`);
   }
   return lines.join(`
 `);
@@ -107,14 +106,14 @@ export function handleWatchdogToolAction(action, params, ctx, runtime) {
       return result(buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx));
     }
     if (action === "watchdog.recommend-model")
-      return result(buildRecommendationText(ctx));
+      return result(buildRecommendationText(ctx, runtime));
     if (action === "watchdog.check")
       return result(buildCheckText(runtime, ctx));
     if (action !== "watchdog.configure")
       return result(`Unknown watchdog action: ${action}`, true);
     const scope = parseScope(params.scope);
     const target = parseTarget(params);
-    const value = resolveConfiguredValue(ctx, params);
+    const value = resolveConfiguredValue(ctx, params, runtime);
     if (scope === "session") {
       if (!runtime)
         return result("Subagent watchdog runtime is unavailable.", true);

package/extensions/dm-subagents/src/watchdog/turn-delta.js

@@ -116,7 +116,7 @@ function messagesFromEvent(event) {
   }
   return [];
 }
-export function formatWatchdogReviewMessage(message) {
+export function formatWatchdogReviewMessage(message, options = {}) {
   if (!message || typeof message !== "object")
     return;
   const input = message;
@@ -124,7 +124,7 @@ export function formatWatchdogReviewMessage(message) {
     return;
   if (input.role === "assistant") {
     const text = textFromContent(input.content);
-    const lines = text ? ["Assistant:", text] : ["Assistant: (no text)"];
+    const lines = text ? ["Assistant:", text] : [options.structuredTerminal ? "Assistant: (validated structured output is the terminal response; no prose is required)" : "Assistant: (no text)"];
     if (input.stopReason === "stop")
       lines.push("Assistant stop: stop");
     return lines.join(`
@@ -148,22 +148,47 @@ export function formatWatchdogTurnDelta(input) {
     sections.push(["User prompt:", input.userPrompt].join(`
 `));
   for (const message of input.messages ?? []) {
-    const section = formatWatchdogReviewMessage(message);
+    const section = formatWatchdogReviewMessage(message, { structuredTerminal: input.structuredTerminal });
     if (section)
       sections.push(section);
   }
   for (const event of input.events ?? []) {
     for (const message of messagesFromEvent(event)) {
-      const section = formatWatchdogReviewMessage(message);
+      const section = formatWatchdogReviewMessage(message, { structuredTerminal: input.structuredTerminal });
       if (section)
         sections.push(section);
     }
   }
   if (input.finalAssistantStop)
-    sections.push("Final assistant stop: stop without tool call");
+    sections.push(input.structuredTerminal ? "Final assistant stop: validated structured output completed the response" : "Final assistant stop: stop without tool call");
   return sections.join(`
 
 ---
 
 `);
 }
+export function formatWatchdogOrchestrationActivity(event) {
+  const turn = event;
+  if (turn?.type !== "turn_end" || !Array.isArray(turn.message?.content) || !Array.isArray(turn.toolResults))
+    return "";
+  const sections = [];
+  for (const call of turn.message.content) {
+    if (call?.type !== "toolCall" || typeof call.id !== "string")
+      continue;
+    const args = call.arguments;
+    if (!args || typeof args !== "object")
+      continue;
+    const eligible = call.name === "bg_wait" || call.name === "subagent_supervisor" && ["pending", "list", "reply"].includes(args.action) || call.name === "subagent" && (["status", "resume", "interrupt", "steer", "stop"].includes(args.action) || args.action === undefined && (typeof args.agent === "string" || typeof args.workflowScript === "string" || typeof args.workflowScriptPath === "string"));
+    if (!eligible)
+      continue;
+    const result = turn.toolResults.find((value) => {
+      const result = value;
+      return result?.role === "toolResult" && result.toolCallId === call.id && result.toolName === call.name;
+    });
+    if (result)
+      sections.push(formatToolCall(call.name, args), formatWatchdogReviewMessage(result) ?? "");
+  }
+  return sections.join(`
+
+`);
+}

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

@@ -10,8 +10,8 @@ export const WATCHDOG_WARNING_CATEGORIES = [
   "loop-risk",
   "other"
 ];
-export const WATCHDOG_WARNING_CONFIDENCES = ["medium", "high"];
-export const WATCHDOG_WARNING_SOURCES = ["main", "child", "async-completion", "lsp"];
+export const WATCHDOG_WARNING_IMPORTANCES = ["low", "medium", "high"];
+export const WATCHDOG_WARNING_SOURCES = ["main", "child", "lsp"];
 export const WATCHDOG_LSP_DIAGNOSTIC_SEVERITIES = ["error", "warning", "info", "hint"];
 export const WATCHDOG_LSP_STATUSES = ["disabled", "ok", "skipped", "unavailable", "timeout", "failed"];
 export const WATCHDOG_RUNTIME_STATUSES = ["idle", "queued", "reviewing", "waiting-at-agent-end", "stale", "failed"];
@@ -25,5 +25,3 @@ export const WATCHDOG_WARNING_STATES = [
   "stalemate",
   "suppressed"
 ];
-export const WATCHDOG_LATE_WARNING_POLICIES = ["show-stale-no-autofollow"];
-export const WATCHDOG_DELIVERY_MODES = ["held"];

package/extensions/dm-subagents/src/watchdog/warning-format.js

@@ -24,17 +24,16 @@ export function formatWatchdogWarningContent(warning) {
   const details = normalizeWatchdogWarningDetails(warning);
   const attrs = [
     `severity="${escapeXmlAttribute(details.severity)}"`,
+    `importance="${escapeXmlAttribute(details.importance)}"`,
     `category="${escapeXmlAttribute(details.category)}"`,
     `source="${escapeXmlAttribute(details.source)}"`,
     `guidance="weigh, don't blindly obey"`
   ];
   const optionalTags = [
-    tag("confidence", details.confidence),
     tag("agent", details.agent),
     tag("run_id", details.runId),
     tag("state", details.state),
-    tag("stale", details.stale),
-    tag("auto_follow_attempt", details.autoFollowAttempt)
+    tag("stale", details.stale)
   ];
   return [
     `<subagent_watchdog ${attrs.join(" ")}>`,

package/extensions/dm-subagents/src/workflows/chat-progress.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { workflowPreflightLaneForRuntimeKey } from "./workflow-preflight.js";
 export const WORKFLOW_CHAT_PROGRESS_MODES = ["auto", "off", "live-card"];
 function git(cwd, args) {
   const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
@@ -71,8 +72,6 @@ function cleanLabel(value) {
 }
 export function buildWorkflowChatProgressRows(trace, preflight) {
   const rows = new Map;
-  for (const lane of preflight?.lanes ?? [])
-    rows.set(lane.key, { key: lane.key, state: "planned", preflight: lane });
   for (const entry of trace) {
     if (entry.operation !== "run")
       continue;
@@ -88,9 +87,10 @@ export function buildWorkflowChatProgressRows(trace, preflight) {
       }
       continue;
     }
+    const lane = workflowPreflightLaneForRuntimeKey(preflight, entry.key, [entry.generatedLaneKey]);
     const next = existing ?? { key: entry.key, state: "running" };
-    if (existing?.preflight)
-      next.preflight = existing.preflight;
+    if (lane && !next.preflight)
+      next.preflight = lane;
     next.state = entry.state === "completed" ? "complete" : entry.state === "failed" ? "failed" : entry.state === "detached" ? "detached" : entry.state === "stopped" ? "stopped" : "running";
     const label = cleanLabel(entry.label);
     const phase = cleanLabel(entry.phase);