bosun 0.41.0 → 0.41.2

package/infra/monitor.mjs

@@ -499,7 +499,7 @@ async function ensureWorkflowAutomationEngine() {
 
   workflowAutomationInitPromise = (async () => {
     try {
-      const [{ getWorkflowEngine }, { createTask }, wfNodes, workflowTemplates] = await Promise.all([
+      const [{ getWorkflowEngine }, { createTask, getTask }, wfNodes, workflowTemplates] = await Promise.all([
         import("../workflow/workflow-engine.mjs"),
         import("../kanban/kanban-adapter.mjs"),
         import("../workflow/workflow-nodes.mjs"),
@@ -532,6 +532,8 @@ async function ensureWorkflowAutomationEngine() {
           ),
         listTasks: async (projectId, filters = {}) =>
           listKanbanTasks(String(projectId || ""), filters || {}),
+        getTask: async (taskId) =>
+          getTask(String(taskId || "").trim()),
       };
 
       const agentPoolService = {
@@ -613,15 +615,47 @@ async function ensureWorkflowAutomationEngine() {
         config?.workflowDefaults && typeof config.workflowDefaults === "object"
           ? config.workflowDefaults.templates || []
           : [];
+      const typedWorkflowTemplateConfig =
+        typeof workflowTemplates?.resolveWorkflowTemplateConfig === "function"
+          ? workflowTemplates.resolveWorkflowTemplateConfig(config?.workflows || [])
+          : { templateIds: [], overridesById: {} };
+
       const requestedTemplateIds = new Set(
         typeof workflowTemplates?.resolveWorkflowTemplateIds === "function"
           ? workflowTemplates.resolveWorkflowTemplateIds({
               profileId: configuredWorkflowProfile,
               templateIds: configuredWorkflowTemplates,
+              workflows: config?.workflows || [],
             })
           : [],
       );
-      const staleWorkflowTemplateIds = ["template-task-batch-pr"];
+      for (const templateId of typedWorkflowTemplateConfig.templateIds || []) {
+        const overrides = typedWorkflowTemplateConfig.overridesById?.[templateId] || {};
+        let installed = (engine.list?.() || []).find(
+          (wf) => String(wf?.metadata?.installedFrom || "").trim() === templateId,
+        );
+
+        if (!installed && typeof workflowTemplates?.installTemplate === "function") {
+          installed = workflowTemplates.installTemplate(templateId, engine, overrides);
+        }
+
+        if (!installed) continue;
+        const def = engine.get?.(installed.id);
+        if (!def) continue;
+
+        def.enabled = true;
+        def.variables = {
+          ...(def.variables || {}),
+          ...overrides,
+        };
+        def.metadata = {
+          ...(def.metadata || {}),
+          configuredFrom: "workflows.config",
+        };
+        engine.save(def);
+      }
+
+      const staleWorkflowTemplateIds = ["template-task-batch-pr", "template-continuation-loop"];
       if (typeof workflowTemplates?.reconcileInstalledTemplates === "function") {
         const reconcile = workflowTemplates.reconcileInstalledTemplates(engine, {
           autoUpdateUnmodified: true,
@@ -647,7 +681,7 @@ async function ensureWorkflowAutomationEngine() {
         def.metadata = {
           ...(def.metadata || {}),
           autoDisabledReason:
-            "disabled on startup because the template is no longer requested by workflowDefaults",
+            "disabled on startup because the template is no longer requested by workflowDefaults/workflows config",
         };
         engine.save(def);
         console.log(
@@ -846,6 +880,133 @@ function resolvePlannerPromptFallback() {
   };
 }
 
+const PLANNER_PATTERN_COUNTER_RELATIVE_PATH =
+  ".bosun/workflow-runs/planner-pattern-feedback.json";
+const PLANNER_FAILURE_SIGNAL_WEIGHTS = Object.freeze({
+  agentAttempts: 0.35,
+  consecutiveNoCommits: 1.25,
+  blockedReason: 1.5,
+  debtTrend: 0.4,
+  taskDebt: 0.5,
+});
+const PLANNER_FAILURE_COUNTER_DECAY = 0.8;
+const PLANNER_FAILURE_COUNTER_IDLE_DECAY = 0.95;
+const PLANNER_FAILURE_THRESHOLD = 2.5;
+
+function normalizePlannerAreaKey(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function normalizePlannerArchetypeKey(value) {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  return normalized || "general";
+}
+
+function inferPlannerTaskArchetype(task) {
+  const explicit =
+    task?.meta?.planner?.archetype ||
+    task?.meta?.archetype ||
+    task?.archetype ||
+    "";
+  if (String(explicit || "").trim()) {
+    return normalizePlannerArchetypeKey(explicit);
+  }
+  const title = String(task?.title || "").trim().toLowerCase();
+  const conventional = title.match(
+    /^(?:\[[^\]]+\]\s*)?([a-z][a-z0-9_-]*)(?:\([^)]*\))?:/,
+  );
+  if (conventional?.[1]) return normalizePlannerArchetypeKey(conventional[1]);
+  if (title.includes("test")) return "test";
+  if (title.includes("doc")) return "docs";
+  if (title.includes("refactor")) return "refactor";
+  return "general";
+}
+
+function resolvePlannerTaskPatternAreas(task) {
+  const candidates = []
+    .concat(Array.isArray(task?.repo_areas) ? task.repo_areas : [])
+    .concat(Array.isArray(task?.repoAreas) ? task.repoAreas : [])
+    .concat(Array.isArray(task?.meta?.repo_areas) ? task.meta.repo_areas : [])
+    .concat(Array.isArray(task?.meta?.repoAreas) ? task.meta.repoAreas : [])
+    .concat(
+      Array.isArray(task?.meta?.planner?.repo_areas)
+        ? task.meta.planner.repo_areas
+        : [],
+    )
+    .concat(
+      Array.isArray(task?.meta?.planner?.repoAreas)
+        ? task.meta.planner.repoAreas
+        : [],
+    );
+  if (!candidates.length) return ["global"];
+  const dedup = new Set();
+  const areas = [];
+  for (const candidate of candidates) {
+    const areaKey = normalizePlannerAreaKey(candidate);
+    if (!areaKey || dedup.has(areaKey)) continue;
+    dedup.add(areaKey);
+    areas.push(areaKey);
+  }
+  return areas.length > 0 ? areas : ["global"];
+}
+
+function buildPlannerPatternKey(repoArea, archetype) {
+  return `${normalizePlannerAreaKey(repoArea) || "global"}::${normalizePlannerArchetypeKey(archetype)}`;
+}
+
+function readPlannerPatternCounterState(baseDir) {
+  const statePath = resolve(
+    baseDir || process.cwd(),
+    PLANNER_PATTERN_COUNTER_RELATIVE_PATH,
+  );
+  if (!existsSync(statePath)) {
+    return { statePath, state: { patterns: {} } };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+    const patterns =
+      parsed?.patterns && typeof parsed.patterns === "object"
+        ? parsed.patterns
+        : {};
+    return {
+      statePath,
+      state: {
+        updatedAt: String(parsed?.updatedAt || "").trim() || null,
+        patterns,
+      },
+    };
+  } catch {
+    return { statePath, state: { patterns: {} } };
+  }
+}
+
+function writePlannerPatternCounterState(statePath, state) {
+  try {
+    mkdirSync(dirname(statePath), { recursive: true });
+    writeFileSync(
+      statePath,
+      JSON.stringify(
+        {
+          updatedAt: new Date().toISOString(),
+          patterns:
+            state?.patterns && typeof state.patterns === "object"
+              ? state.patterns
+              : {},
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+  } catch {
+    // best effort
+  }
+}
+
 function buildPlannerFeedback() {
   const tasks = Array.isArray(getAllInternalTasks?.()) ? getAllInternalTasks() : [];
   const statusCounts = {
@@ -858,9 +1019,71 @@ function buildPlannerFeedback() {
   };
   const blockedReasonCounts = new Map();
   const hotTasks = [];
+  const patternObservations = new Map();
+  const taskDebtWeightById = new Map();
   let attemptedCount = 0;
   let noCommitCount = 0;
 
+  let debtEntries = [];
+  try {
+    debtEntries = readTaskDebtEntries({ baseDir: repoRoot, limit: 300 });
+  } catch {
+    debtEntries = [];
+  }
+
+  const now = Date.now();
+  const recentWindowMs = 7 * 24 * 60 * 60 * 1000;
+  const previousWindowMs = 14 * 24 * 60 * 60 * 1000;
+  const recentDebtEntries = debtEntries.filter((entry) => {
+    const ts = Date.parse(String(entry?.recordedAt || ""));
+    return Number.isFinite(ts) && now - ts <= recentWindowMs;
+  });
+  const previousDebtEntries = debtEntries.filter((entry) => {
+    const ts = Date.parse(String(entry?.recordedAt || ""));
+    return Number.isFinite(ts) && now - ts > recentWindowMs && now - ts <= previousWindowMs;
+  });
+  const debtSeverityCounts = { critical: 0, high: 0, medium: 0, low: 0 };
+  const previousDebtSeverityCounts = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const entry of recentDebtEntries) {
+    for (const item of Array.isArray(entry?.debtItems) ? entry.debtItems : []) {
+      const severity = String(item?.severity || "").trim().toLowerCase();
+      if (Object.prototype.hasOwnProperty.call(debtSeverityCounts, severity)) {
+        debtSeverityCounts[severity] += 1;
+        const taskId = String(entry?.taskId || "").trim();
+        if (taskId) {
+          const severityWeight = severity === "critical"
+            ? 2
+            : severity === "high"
+              ? 1.5
+              : severity === "medium"
+                ? 1
+                : 0.5;
+          taskDebtWeightById.set(
+            taskId,
+            (taskDebtWeightById.get(taskId) || 0) + severityWeight,
+          );
+        }
+      }
+    }
+  }
+  for (const entry of previousDebtEntries) {
+    for (const item of Array.isArray(entry?.debtItems) ? entry.debtItems : []) {
+      const severity = String(item?.severity || "").trim().toLowerCase();
+      if (Object.prototype.hasOwnProperty.call(previousDebtSeverityCounts, severity)) {
+        previousDebtSeverityCounts[severity] += 1;
+      }
+    }
+  }
+
+  const weightedDebtSeverity = (counts) =>
+    (counts.critical * 2) + (counts.high * 1.5) + counts.medium + (counts.low * 0.5);
+  const recentDebtWeighted = weightedDebtSeverity(debtSeverityCounts);
+  const previousDebtWeighted = weightedDebtSeverity(previousDebtSeverityCounts);
+  const debtTrendDelta = recentDebtWeighted - previousDebtWeighted;
+  const debtTrendPenalty = debtTrendDelta > 0
+    ? Math.min(2, (debtTrendDelta / 8) * PLANNER_FAILURE_SIGNAL_WEIGHTS.debtTrend)
+    : 0;
+
   for (const task of tasks) {
     const status = String(task?.status || "").trim().toLowerCase();
     if (Object.prototype.hasOwnProperty.call(statusCounts, status)) {
@@ -869,6 +1092,7 @@ function buildPlannerFeedback() {
       statusCounts.other += 1;
     }
 
+    const taskId = String(task?.id || "").trim();
     const agentAttempts = Number(task?.agentAttempts || 0);
     const consecutiveNoCommits = Number(task?.consecutiveNoCommits || 0);
     const blockedReason = String(task?.blockedReason || "").trim();
@@ -881,6 +1105,57 @@ function buildPlannerFeedback() {
       );
     }
 
+    const attemptPenalty =
+      Math.min(Math.max(0, agentAttempts), 6) * PLANNER_FAILURE_SIGNAL_WEIGHTS.agentAttempts;
+    const noCommitPenalty =
+      Math.min(Math.max(0, consecutiveNoCommits), 4) * PLANNER_FAILURE_SIGNAL_WEIGHTS.consecutiveNoCommits;
+    const blockedPenalty = blockedReason ? PLANNER_FAILURE_SIGNAL_WEIGHTS.blockedReason : 0;
+    const taskDebtPenalty =
+      Math.min(2, (taskDebtWeightById.get(taskId) || 0) * PLANNER_FAILURE_SIGNAL_WEIGHTS.taskDebt);
+    const failureSignal =
+      attemptPenalty +
+      noCommitPenalty +
+      blockedPenalty +
+      taskDebtPenalty +
+      debtTrendPenalty;
+    const terminalSuccess = ["done", "completed", "closed"].includes(status);
+    const successSignal =
+      terminalSuccess &&
+      agentAttempts > 0 &&
+      consecutiveNoCommits <= 0 &&
+      !blockedReason
+        ? 1
+        : 0;
+    const archetype = inferPlannerTaskArchetype(task);
+    const areas = resolvePlannerTaskPatternAreas(task);
+
+    for (const area of areas) {
+      const key = buildPlannerPatternKey(area, archetype);
+      let entry = patternObservations.get(key);
+      if (!entry) {
+        entry = {
+          key,
+          repoArea: area,
+          archetype,
+          failures: 0,
+          successes: 0,
+          failureSignalTotal: 0,
+          successSignalTotal: 0,
+        };
+        patternObservations.set(key, entry);
+      }
+      if (failureSignal > 0) {
+        entry.failureSignalTotal += failureSignal;
+      }
+      if (failureSignal >= 0.75) {
+        entry.failures += 1;
+      }
+      if (successSignal > 0) {
+        entry.successSignalTotal += successSignal;
+        entry.successes += 1;
+      }
+    }
+
     if (
       agentAttempts > 0 ||
       consecutiveNoCommits > 0 ||
@@ -888,17 +1163,23 @@ function buildPlannerFeedback() {
       status === "blocked"
     ) {
       hotTasks.push({
-        taskId: String(task?.id || "").trim(),
+        taskId,
         title: String(task?.title || "").trim(),
         status: status || null,
         agentAttempts: agentAttempts || 0,
         consecutiveNoCommits: consecutiveNoCommits || 0,
         blockedReason: blockedReason || null,
+        failureSignal: Number(failureSignal.toFixed(2)),
+        archetype,
+        repoAreas: areas,
       });
     }
   }
 
   hotTasks.sort((a, b) => {
+    if ((b.failureSignal || 0) !== (a.failureSignal || 0)) {
+      return (b.failureSignal || 0) - (a.failureSignal || 0);
+    }
     if ((b.consecutiveNoCommits || 0) !== (a.consecutiveNoCommits || 0)) {
       return (b.consecutiveNoCommits || 0) - (a.consecutiveNoCommits || 0);
     }
@@ -908,28 +1189,80 @@ function buildPlannerFeedback() {
     return String(a.taskId || "").localeCompare(String(b.taskId || ""));
   });
 
-  let debtEntries = [];
-  try {
-    debtEntries = readTaskDebtEntries({ baseDir: repoRoot, limit: 300 });
-  } catch {
-    debtEntries = [];
+  const persistedCounter = readPlannerPatternCounterState(repoRoot);
+  const previousPatternState =
+    persistedCounter?.state?.patterns && typeof persistedCounter.state.patterns === "object"
+      ? persistedCounter.state.patterns
+      : {};
+  const nextPatternState = {};
+  const observedKeys = new Set(patternObservations.keys());
+
+  for (const [key, observation] of patternObservations.entries()) {
+    const previous = previousPatternState[key] || {};
+    const previousCounter = Number(previous.failureCounter || 0);
+    const nextCounter = Math.max(
+      0,
+      (previousCounter * PLANNER_FAILURE_COUNTER_DECAY) +
+        observation.failureSignalTotal -
+        (observation.successSignalTotal * 1.1),
+    );
+    nextPatternState[key] = {
+      key,
+      repoArea: observation.repoArea,
+      archetype: observation.archetype,
+      observations: Number(previous.observations || 0) + 1,
+      failures: Number(previous.failures || 0) + observation.failures,
+      successes: Number(previous.successes || 0) + observation.successes,
+      failureSignal: Number(observation.failureSignalTotal.toFixed(2)),
+      successSignal: Number(observation.successSignalTotal.toFixed(2)),
+      failureCounter: Number(nextCounter.toFixed(3)),
+      lastUpdatedAt: new Date().toISOString(),
+    };
   }
 
-  const now = Date.now();
-  const recentWindowMs = 7 * 24 * 60 * 60 * 1000;
-  const recentDebtEntries = debtEntries.filter((entry) => {
-    const ts = Date.parse(String(entry?.recordedAt || ""));
-    return Number.isFinite(ts) && now - ts <= recentWindowMs;
+  for (const [key, previous] of Object.entries(previousPatternState)) {
+    if (observedKeys.has(key)) continue;
+    const previousCounter = Number(previous?.failureCounter || 0);
+    if (previousCounter <= 0) continue;
+    nextPatternState[key] = {
+      ...previous,
+      failureCounter: Number(
+        Math.max(0, previousCounter * PLANNER_FAILURE_COUNTER_IDLE_DECAY).toFixed(3),
+      ),
+      lastUpdatedAt: new Date().toISOString(),
+    };
+  }
+
+  writePlannerPatternCounterState(persistedCounter.statePath, {
+    patterns: nextPatternState,
   });
-  const debtSeverityCounts = { critical: 0, high: 0, medium: 0, low: 0 };
-  for (const entry of recentDebtEntries) {
-    for (const item of Array.isArray(entry?.debtItems) ? entry.debtItems : []) {
-      const severity = String(item?.severity || "").trim().toLowerCase();
-      if (Object.prototype.hasOwnProperty.call(debtSeverityCounts, severity)) {
-        debtSeverityCounts[severity] += 1;
+
+  const rankedPatternCounters = Object.values(nextPatternState)
+    .map((entry) => {
+      const failureCounter = Number(entry?.failureCounter || 0);
+      const negativePrior = failureCounter > PLANNER_FAILURE_THRESHOLD
+        ? Number(((failureCounter - PLANNER_FAILURE_THRESHOLD) * 0.6).toFixed(3))
+        : 0;
+      return {
+        key: String(entry?.key || "").trim(),
+        repoArea: String(entry?.repoArea || "").trim() || "global",
+        archetype: normalizePlannerArchetypeKey(entry?.archetype),
+        failureCounter,
+        failures: Number(entry?.failures || 0),
+        successes: Number(entry?.successes || 0),
+        negativePrior,
+      };
+    })
+    .sort((a, b) => {
+      if ((b.negativePrior || 0) !== (a.negativePrior || 0)) {
+        return (b.negativePrior || 0) - (a.negativePrior || 0);
       }
-    }
-  }
+      if ((b.failureCounter || 0) !== (a.failureCounter || 0)) {
+        return (b.failureCounter || 0) - (a.failureCounter || 0);
+      }
+      return String(a.key || "").localeCompare(String(b.key || ""));
+    })
+    .slice(0, 50);
 
   const blockedTop = [...blockedReasonCounts.entries()]
     .sort((a, b) => b[1] - a[1])
@@ -947,6 +1280,8 @@ function buildPlannerFeedback() {
     `noCommitHot=${noCommitCount}`,
     `debtRecent7d=${recentDebtEntries.length}`,
     `debtCriticalHigh=${debtSeverityCounts.critical + debtSeverityCounts.high}`,
+    `debtTrendDelta=${Number(debtTrendDelta.toFixed(2))}`,
+    `penalizedPatterns=${rankedPatternCounters.filter((entry) => entry.negativePrior > 0).length}`,
   ];
   const blockedSummary = blockedTop.length > 0
     ? blockedTop.map((item) => `${item.reason}(${item.count})`).join(", ")
@@ -970,6 +1305,15 @@ function buildPlannerFeedback() {
       totalEntries: debtEntries.length,
       recentEntries7d: recentDebtEntries.length,
       severityCounts7d: debtSeverityCounts,
+      previousSeverityCounts7d: previousDebtSeverityCounts,
+      trendDelta: Number(debtTrendDelta.toFixed(2)),
+    },
+    rankingSignals: {
+      failureThreshold: PLANNER_FAILURE_THRESHOLD,
+      debtTrendDelta: Number(debtTrendDelta.toFixed(2)),
+      debtTrendPenalty: Number(debtTrendPenalty.toFixed(3)),
+      weights: PLANNER_FAILURE_SIGNAL_WEIGHTS,
+      patterns: rankedPatternCounters,
     },
   };
 }
@@ -1610,34 +1954,243 @@ const WORKSPACE_SYNC_INTERVAL_MS = parseEnvInteger(
   { min: 60 * 1000, max: 120 * 60 * 1000 },
 ); // 1m..120m (default 30m)
 const WORKSPACE_SYNC_INITIAL_DELAY_MS = parseEnvInteger(
-  process.env.BOSUN_WORKSPACE_SYNC_INITIAL_DELAY_MS,
-  20 * 1000,
-  { min: 0, max: 5 * 60 * 1000 },
-); // 0s..5m (default 20s)
+  isDevMode()
+    ? process.env.DEVMODE_WORKSPACE_SYNC_INITIAL_DELAY_MS
+    : process.env.BOSUN_WORKSPACE_SYNC_INITIAL_DELAY_MS,
+  60 * 1000,
+  { min: 0, max: 10 * 60 * 1000 },
+); // 0s..5m (default 60s)
 const WORKSPACE_SYNC_INITIAL_JITTER_MS = parseEnvInteger(
   process.env.BOSUN_WORKSPACE_SYNC_INITIAL_JITTER_MS,
   5 * 1000,
   { min: 0, max: 60 * 1000 },
 ); // 0s..60s (default 5s)
 const WORKSPACE_SYNC_WARN_THROTTLE_MS = parseEnvInteger(
-  process.env.BOSUN_WORKSPACE_SYNC_WARN_THROTTLE_MS,
-  6 * 60 * 60 * 1000,
-  { min: 60 * 1000, max: 24 * 60 * 60 * 1000 },
-); // 1m..24h (default 6h)
+  isDevMode()
+    ? process.env.DEVMODE_WORKSPACE_SYNC_WARN_THROTTLE_MS
+    : process.env.BOSUN_WORKSPACE_SYNC_WARN_THROTTLE_MS,
+  isDevMode() ? 30 * 60 * 1000 : 6 * 60 * 60 * 1000,
+  { min: 10 * 1000, max: 24 * 60 * 60 * 1000 },
+); // 10s..24h (default dev 30m, prod 6h)
 const WORKSPACE_SYNC_SLOW_WARN_MS = parseEnvInteger(
-  process.env.BOSUN_WORKSPACE_SYNC_SLOW_WARN_MS,
-  90 * 1000,
+  isDevMode()
+    ? process.env.DEVMODE_WORKSPACE_SYNC_SLOW_WARN_MS
+    : process.env.BOSUN_WORKSPACE_SYNC_SLOW_WARN_MS,
+  isDevMode() ? 30 * 1000 : 90 * 1000,
   { min: 5 * 1000, max: 10 * 60 * 1000 },
-); // 5s..10m (default 90s)
+); // 5s..10m (default dev 30s, prod 90s)
 const WORKSPACE_SYNC_WARN_MAX_KEYS = parseEnvInteger(
-  process.env.BOSUN_WORKSPACE_SYNC_WARN_MAX_KEYS,
+  isDevMode()
+    ? process.env.DEVMODE_WORKSPACE_SYNC_WARN_MAX_KEYS
+    : process.env.BOSUN_WORKSPACE_SYNC_WARN_MAX_KEYS,
   500,
-  { min: 50, max: 5000 },
-); // 50..5000 (default 500)
+  { min: 10, max: 5000 },
+); // 10..5000 (default 500)
+const WORKSPACE_SYNC_WARN_STATE_FILE = "ve-workspace-sync-warn-state.json";
+const WORKSPACE_SYNC_WARN_STATE_TMP_FILE = "ve-workspace-sync-warn-state.json.tmp";
+const WORKSPACE_SYNC_WARN_STATE_WRITE_GAP_MS = isDevMode()
+  ? parseEnvInteger(
+      process.env.DEVMODE_WORKSPACE_SYNC_WARN_STATE_WRITE_GAP_MS,
+      2 * 1000,
+      { min: 200, max: 60 * 1000 },
+    )
+  : parseEnvInteger(
+      process.env.BOSUN_WORKSPACE_SYNC_WARN_STATE_WRITE_GAP_MS,
+      5 * 1000,
+      { min: 200, max: 60 * 1000 },
+    );
+const WORKSPACE_SYNC_WARN_STALE_EXPIRY_MS = 24 * 60 * 60 * 1000;
+const WORKSPACE_SYNC_WARN_ARCHIVE_MAX_FILES = 5;
+const WORKSPACE_SYNC_WARN_ARCHIVE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
 let workspaceSyncTimer = null;
 let workspaceSyncInitialTimer = null;
 let workspaceSyncInFlight = false;
+let workspaceSyncWarnStateWriteTimer = null;
+let workspaceSyncWarnStateWriteConfigDir = null;
 const workspaceSyncWarnSeen = new Map();
+function resolveWorkspaceSyncWarnStatePaths(configDir) {
+  const cacheDir = resolve(configDir || process.cwd(), ".cache");
+  const statePath = resolve(cacheDir, WORKSPACE_SYNC_WARN_STATE_FILE);
+  const tmpPath = resolve(cacheDir, WORKSPACE_SYNC_WARN_STATE_TMP_FILE);
+  return { cacheDir, statePath, tmpPath };
+}
+function pruneWorkspaceSyncWarnSeen(now = Date.now()) {
+  let changed = false;
+  for (const [seenKey, seenAt] of workspaceSyncWarnSeen.entries()) {
+    const updatedAt = Number(seenAt || 0);
+    if (now - updatedAt >= WORKSPACE_SYNC_WARN_STALE_EXPIRY_MS) {
+      workspaceSyncWarnSeen.delete(seenKey);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function evictWorkspaceSyncWarnSeenOverflow() {
+  let changed = false;
+  // Evict oldest entries so warn state remains bounded.
+  while (workspaceSyncWarnSeen.size > WORKSPACE_SYNC_WARN_MAX_KEYS) {
+    const oldestKey = workspaceSyncWarnSeen.keys().next().value;
+    if (!oldestKey) break;
+    workspaceSyncWarnSeen.delete(oldestKey);
+    changed = true;
+  }
+  return changed;
+}
+function cleanupWorkspaceSyncWarnStateArchives(configDir, now = Date.now()) {
+  const { cacheDir, statePath } = resolveWorkspaceSyncWarnStatePaths(configDir);
+  const archivePrefix = `${WORKSPACE_SYNC_WARN_STATE_FILE}.archive.`;
+  let entries = [];
+  try {
+    entries = readdirSync(cacheDir)
+      .filter((name) => name.startsWith(archivePrefix))
+      .map((name) => {
+        const path = resolve(cacheDir, name);
+        let mtimeMs = 0;
+        try {
+          mtimeMs = Number(statSync(path).mtimeMs || 0);
+        } catch {
+          // Ignore files that disappear during cleanup.
+        }
+        return { name, path, mtimeMs };
+      });
+  } catch {
+    return;
+  }
+  const keep = [];
+  for (const entry of entries) {
+    if (!entry.mtimeMs || now - entry.mtimeMs > WORKSPACE_SYNC_WARN_ARCHIVE_MAX_AGE_MS) {
+      try {
+        unlinkSync(entry.path);
+      } catch {
+        // Ignore cleanup failures; best effort.
+      }
+      continue;
+    }
+    keep.push(entry);
+  }
+  keep.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const entry of keep.slice(WORKSPACE_SYNC_WARN_ARCHIVE_MAX_FILES)) {
+    try {
+      unlinkSync(entry.path);
+    } catch {
+      // Ignore cleanup failures; best effort.
+    }
+  }
+  if (keep.length > WORKSPACE_SYNC_WARN_ARCHIVE_MAX_FILES) {
+    console.log(
+      `[monitor] workspace sync warn archive cleanup: kept ${WORKSPACE_SYNC_WARN_ARCHIVE_MAX_FILES} newest archives for ${basename(statePath)}`,
+    );
+  }
+}
+function archiveWorkspaceSyncWarnStateFile(configDir, reason = "corrupt") {
+  const { cacheDir, statePath } = resolveWorkspaceSyncWarnStatePaths(configDir);
+  if (!existsSync(statePath)) return;
+  const timestamp = new Date().toISOString().replaceAll(":", "-");
+  const archiveName = `${WORKSPACE_SYNC_WARN_STATE_FILE}.archive.${timestamp}.${reason}.json`;
+  const archivePath = resolve(cacheDir, archiveName);
+  try {
+    renameSync(statePath, archivePath);
+    console.warn(
+      `[monitor] workspace sync warn state archived (${reason}): ${basename(archivePath)}`,
+    );
+  } catch (err) {
+    console.warn(
+      `[monitor] workspace sync warn state archive failed (${reason}): ${err?.message || err}`,
+    );
+  }
+}
+function persistWorkspaceSyncWarnState(configDir) {
+  const { cacheDir, statePath, tmpPath } = resolveWorkspaceSyncWarnStatePaths(configDir);
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+  } catch (err) {
+    console.warn(
+      `[monitor] workspace sync warn state: unable to create cache dir: ${err?.message || err}`,
+    );
+    return;
+  }
+  const now = Date.now();
+  pruneWorkspaceSyncWarnSeen(now);
+  evictWorkspaceSyncWarnSeenOverflow();
+  const entries = [];
+  for (const [key, value] of workspaceSyncWarnSeen.entries()) {
+    entries.push({ key, updatedAt: Number(value || 0) });
+  }
+  const payload = JSON.stringify(
+    {
+      version: 1,
+      updatedAt: now,
+      entries,
+    },
+    null,
+    2,
+  );
+  let tmpWritten = false;
+  try {
+    writeFileSync(tmpPath, payload, "utf8");
+    tmpWritten = true;
+    renameSync(tmpPath, statePath);
+  } catch (err) {
+    console.warn(
+      `[monitor] workspace sync warn state persist failed: ${err?.message || err}`,
+    );
+    if (tmpWritten || existsSync(tmpPath)) {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+        // Ignore temp cleanup failures.
+      }
+    }
+  }
+}
+function scheduleWorkspaceSyncWarnStatePersist(configDir, { immediate = false } = {}) {
+  workspaceSyncWarnStateWriteConfigDir = configDir || workspaceSyncWarnStateWriteConfigDir || process.cwd();
+  if (immediate || WORKSPACE_SYNC_WARN_STATE_WRITE_GAP_MS <= 0) {
+    if (workspaceSyncWarnStateWriteTimer) {
+      clearTimeout(workspaceSyncWarnStateWriteTimer);
+      workspaceSyncWarnStateWriteTimer = null;
+    }
+    persistWorkspaceSyncWarnState(workspaceSyncWarnStateWriteConfigDir);
+    return;
+  }
+  if (workspaceSyncWarnStateWriteTimer) {
+    clearTimeout(workspaceSyncWarnStateWriteTimer);
+    workspaceSyncWarnStateWriteTimer = null;
+  }
+  workspaceSyncWarnStateWriteTimer = safeSetTimeout("workspace-sync-warn-state-persist", () => {
+    workspaceSyncWarnStateWriteTimer = null;
+    persistWorkspaceSyncWarnState(workspaceSyncWarnStateWriteConfigDir);
+  }, WORKSPACE_SYNC_WARN_STATE_WRITE_GAP_MS);
+  if (workspaceSyncWarnStateWriteTimer?.unref) workspaceSyncWarnStateWriteTimer.unref();
+}
+function loadWorkspaceSyncWarnState(configDir) {
+  const { statePath } = resolveWorkspaceSyncWarnStatePaths(configDir);
+  // Run archive cleanup during monitor startup initialization.
+  cleanupWorkspaceSyncWarnStateArchives(configDir);
+  if (!existsSync(statePath)) return;
+  try {
+    const raw = readFileSync(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = Array.isArray(parsed?.entries)
+      ? parsed.entries
+      : Object.entries(parsed || {}).map(([key, updatedAt]) => ({ key, updatedAt }));
+    workspaceSyncWarnSeen.clear();
+    for (const entry of entries) {
+      const key = String(entry?.key || "").trim();
+      const updatedAt = Number(entry?.updatedAt || entry?.timestamp || 0);
+      if (!key || !Number.isFinite(updatedAt) || updatedAt <= 0) continue;
+      workspaceSyncWarnSeen.set(key, updatedAt);
+    }
+    const now = Date.now();
+    const changed = pruneWorkspaceSyncWarnSeen(now) || evictWorkspaceSyncWarnSeenOverflow();
+    if (changed) scheduleWorkspaceSyncWarnStatePersist(configDir, { immediate: true });
+  } catch (err) {
+    console.warn(
+      `[monitor] workspace sync warn state load failed; archiving corrupt file: ${err?.message || err}`,
+    );
+    archiveWorkspaceSyncWarnStateFile(configDir, "corrupt");
+  }
+}
 function stopWorkspaceSyncTimers() {
   if (workspaceSyncInitialTimer) {
     clearTimeout(workspaceSyncInitialTimer);
@@ -1647,30 +2200,48 @@ function stopWorkspaceSyncTimers() {
     clearInterval(workspaceSyncTimer);
     workspaceSyncTimer = null;
   }
+  if (workspaceSyncWarnStateWriteTimer) {
+    clearTimeout(workspaceSyncWarnStateWriteTimer);
+    workspaceSyncWarnStateWriteTimer = null;
+    scheduleWorkspaceSyncWarnStatePersist(
+      workspaceSyncWarnStateWriteConfigDir || config?.configDir || process.cwd(),
+      { immediate: true },
+    );
+  }
 }
 function shouldEmitWorkspaceSyncWarn(key, now = Date.now()) {
+  const stateConfigDir = config?.configDir || process.cwd();
+  let changed = false;
   for (const [seenKey, seenAt] of workspaceSyncWarnSeen.entries()) {
     if (now - Number(seenAt || 0) >= WORKSPACE_SYNC_WARN_THROTTLE_MS) {
       workspaceSyncWarnSeen.delete(seenKey);
+      changed = true;
     }
   }
+  changed = pruneWorkspaceSyncWarnSeen(now) || changed;
   const last = Number(workspaceSyncWarnSeen.get(key) || 0);
   if (last > 0 && now - last < WORKSPACE_SYNC_WARN_THROTTLE_MS) return false;
+  // Refresh key insertion order so oldest eviction works predictably.
+  workspaceSyncWarnSeen.delete(key);
   workspaceSyncWarnSeen.set(key, now);
+  changed = true;
   // keep memory bounded
-  if (workspaceSyncWarnSeen.size > WORKSPACE_SYNC_WARN_MAX_KEYS) {
-    const oldestKey = workspaceSyncWarnSeen.keys().next().value;
-    if (oldestKey) workspaceSyncWarnSeen.delete(oldestKey);
-  }
+  changed = evictWorkspaceSyncWarnSeenOverflow() || changed;
+  if (changed) scheduleWorkspaceSyncWarnStatePersist(stateConfigDir);
   return true;
 }
 function clearWorkspaceSyncWarnForWorkspace(workspaceId) {
+  let changed = false;
   const prefix = `${workspaceId}:`;
   for (const key of workspaceSyncWarnSeen.keys()) {
     if (String(key).startsWith(prefix)) {
       workspaceSyncWarnSeen.delete(key);
+      changed = true;
     }
   }
+  if (changed) {
+    scheduleWorkspaceSyncWarnStatePersist(config?.configDir || process.cwd());
+  }
 }
 function isBenignWorkspaceSyncFailure(errorText) {
   const text = String(errorText || "").toLowerCase();
@@ -1695,6 +2266,7 @@ function isBenignWorkspaceSyncFailure(errorText) {
 {
   const wsArray = config.repositories?.filter((r) => r.workspace) || [];
   if (wsArray.length > 0) {
+    loadWorkspaceSyncWarnState(config?.configDir || process.cwd());
     const workspaceIds = [...new Set(wsArray.map((r) => r.workspace).filter(Boolean))];
     const doWorkspaceSync = () => {
       if (shuttingDown) return;
@@ -2147,6 +2719,10 @@ const SELF_RESTART_QUIET_MS = Math.max(
   90_000,
   Number(process.env.SELF_RESTART_QUIET_MS || "90000"),
 );
+const ENV_RELOAD_DELAY_MS = Math.max(
+  500,
+  Number(process.env.ENV_RELOAD_DELAY_MS || "5000") || 5000,
+);
 const SELF_RESTART_RETRY_MS = Math.max(
   15_000,
   Number(process.env.SELF_RESTART_RETRY_MS || "30000"),
@@ -13283,7 +13859,6 @@ async function startWatcher(force = false) {
     stopWatcher();
   }
   let targetPath = watchPath;
-  let missingWatchPath = false;
   try {
     const stats = await (await import("node:fs/promises")).stat(watchPath);
     if (stats.isFile()) {
@@ -13291,21 +13866,15 @@ async function startWatcher(force = false) {
       targetPath = watchPath.split(/[\\/]/).slice(0, -1).join("/") || ".";
     }
   } catch {
-    // The configured path may not exist yet (common for stale ORCHESTRATOR_SCRIPT paths).
-    // Fall back to watching its parent directory if present; otherwise watch repoRoot.
-    missingWatchPath = true;
-    const candidateFile = watchPath.split(/[\\/]/).pop() || null;
-    const candidateDir = watchPath.split(/[\\/]/).slice(0, -1).join("/") || ".";
-    if (existsSync(candidateDir)) {
-      targetPath = candidateDir;
-      watchFileName = candidateFile;
-    } else if (existsSync(repoRoot)) {
-      targetPath = repoRoot;
-      watchFileName = null;
-    } else {
-      targetPath = process.cwd();
-      watchFileName = null;
-    }
+    // The configured path does not exist.  Previous behaviour fell back to
+    // watching the parent directory, which could be extremely broad (e.g. the
+    // entire AppData/Roaming tree) and trigger spurious restarts.  Disable the
+    // watcher entirely instead — the auto-update loop handles updates in
+    // npm/prod mode, and in dev mode the source-dir watcher covers restarts.
+    console.warn(
+      `[monitor] watcher disabled — configured watch path does not exist: ${watchPath}`,
+    );
+    return;
   }
 
   if (!existsSync(targetPath)) {
@@ -13314,11 +13883,6 @@ async function startWatcher(force = false) {
     );
     return;
   }
-  if (missingWatchPath) {
-    console.warn(
-      `[monitor] watch path not found: ${watchPath} — watching ${targetPath} instead`,
-    );
-  }
 
   try {
     watcher = watch(targetPath, { persistent: true }, (_event, filename) => {
@@ -13360,7 +13924,7 @@ function scheduleEnvReload(reason) {
     runDetached("config-reload:env-change", () =>
       reloadConfig(reason || "env-change"),
     );
-  }, 400);
+  }, ENV_RELOAD_DELAY_MS);
 }
 
 function startEnvWatchers() {
@@ -14943,6 +15507,73 @@ if (isExecutorDisabled()) {
             console.warn(`[monitor] supervisor continue: no active session for ${taskId}`);
           }
         },
+        dispatchFixTask: (taskId, issues) => {
+          const normalizedTaskId = String(taskId || "").trim();
+          if (!normalizedTaskId) return;
+          const task = getInternalTask(normalizedTaskId);
+          const issueList = Array.isArray(issues) ? issues : [];
+          const issueCount = issueList.length;
+          const status = String(task?.status || "").trim().toLowerCase();
+
+          if (status && status !== "inreview") {
+            console.warn(
+              `[monitor] supervisor dispatch-fix skipped for ${normalizedTaskId}: status=${status}`,
+            );
+            return;
+          }
+
+          if (hasActiveSession(normalizedTaskId)) {
+            const issueSummary = issueList
+              .slice(0, 5)
+              .map((issue) => {
+                const severity = String(issue?.severity || "major");
+                const category = String(issue?.category || "review");
+                const file = String(issue?.file || "(unknown)");
+                const line = Number.isFinite(Number(issue?.line))
+                  ? `:${Number(issue.line)}`
+                  : "";
+                const description = String(issue?.description || "").trim();
+                return `- [${severity}/${category}] ${file}${line}${description ? ` - ${description}` : ""}`;
+              })
+              .join("\n");
+            const prompt = [
+              `Review requested changes for task "${task?.title || normalizedTaskId}".`,
+              issueSummary
+                ? `Fix these review issues first:\n${issueSummary}`
+                : "Fix the reported review issues first.",
+              "Stay on the current branch, run relevant tests, commit the fixes, and continue toward PR update.",
+            ].join("\n\n");
+            console.log(
+              `[monitor] supervisor dispatch-fix steering active session for ${normalizedTaskId}`,
+            );
+            steerActiveThread(normalizedTaskId, prompt);
+            return;
+          }
+
+          console.warn(
+            `[monitor] supervisor dispatch-fix: no active session for ${normalizedTaskId}; resetting task to todo`,
+          );
+          try {
+            setInternalTaskStatus(
+              normalizedTaskId,
+              "todo",
+              "review-fix-redispatch",
+            );
+          } catch {
+            /* best-effort */
+          }
+          void updateTaskStatus(normalizedTaskId, "todo", {
+            source: "review-fix-redispatch",
+            workflowEvent: "task.review_fix_requested",
+            workflowData: {
+              reviewIssueCount: issueCount,
+            },
+          }).catch((err) => {
+            console.warn(
+              `[monitor] supervisor dispatch-fix transition failed for ${normalizedTaskId}: ${err?.message || err}`,
+            );
+          });
+        },
       });
       agentSupervisor.start();
 
@@ -15383,8 +16014,3 @@ export {
   // Workflow event bridge — for fleet/kanban modules to emit events
   queueWorkflowEvent,
 };
-
-
-
-
-