bosun 0.42.0 → 0.42.1

package/.env.example

@@ -1039,6 +1039,18 @@ COPILOT_CLOUD_DISABLED=true
 # WORKFLOW_AUTOMATION_ENABLED=true
 # Optional dedup window to avoid event storms (milliseconds).
 # WORKFLOW_EVENT_DEDUP_WINDOW_MS=15000
+# Monitor self-healing retry policy for startup unstick operations
+# (stale dispatch polling and workflow-history resume).
+# Max bounded retry attempts before terminal escalation.
+# WORKFLOW_RECOVERY_MAX_ATTEMPTS=5
+# Escalation warning threshold for repeated failures (must be <= max attempts).
+# WORKFLOW_RECOVERY_ESCALATION_THRESHOLD=3
+# Exponential backoff base delay in ms.
+# WORKFLOW_RECOVERY_BACKOFF_BASE_MS=5000
+# Exponential backoff maximum delay in ms.
+# WORKFLOW_RECOVERY_BACKOFF_MAX_MS=60000
+# Random jitter ratio (0.0-0.9) applied to backoff to prevent retry storms.
+# WORKFLOW_RECOVERY_BACKOFF_JITTER_RATIO=0.2
 
 # ─── GitHub Issue Reconciler ─────────────────────────────────────────────────
 # Periodically reconciles open GitHub issues against open/merged PRs.

package/README.md

@@ -144,6 +144,8 @@ Set `primaryAgent` in `.bosun/bosun.config.json` or choose an executor preset du
 - `bosun --daemon --sentinel` starts daemon + sentinel together (recommended for unattended operation).
 - `bosun --terminate` is the clean reset command when you suspect stale/ghost processes.
 
+Telegram operators can pull the weekly agent work summary with `/weekly [days]` or `/report weekly [days]`. To post it automatically once per week, set `TELEGRAM_WEEKLY_REPORT_ENABLED=true` together with `TELEGRAM_WEEKLY_REPORT_DAY`, `TELEGRAM_WEEKLY_REPORT_HOUR`, and optional `TELEGRAM_WEEKLY_REPORT_DAYS`.
+
 ## Documentation
 
 **Published docs (website):** https://bosun.engineer/docs/

package/agent/agent-pool.mjs

@@ -2871,6 +2871,19 @@ function sdkSupportsPersistentThreads(sdkName) {
 
 /** @type {Map<string, ActiveSession>} */
 const activeSessions = new Map();
+const ACTIVE_SESSION_LISTENERS = new Set();
+
+function notifyActiveSessionListeners(reason = "update", taskKey = null) {
+  if (ACTIVE_SESSION_LISTENERS.size === 0) return;
+  const snapshot = getActiveSessions();
+  for (const listener of ACTIVE_SESSION_LISTENERS) {
+    try {
+      listener(snapshot, { reason, taskKey });
+    } catch {
+      /* best effort */
+    }
+  }
+}
 
 /** Threshold for approaching-exhaustion warning (80% of MAX_THREAD_TURNS). */
 const THREAD_EXHAUSTION_WARNING_THRESHOLD = Math.floor(MAX_THREAD_TURNS * 0.8);
@@ -2892,6 +2905,7 @@ function registerActiveSession(taskKey, sdk, threadId, sendFn) {
     send: sendFn,
     registeredAt: Date.now(),
   });
+  notifyActiveSessionListeners("start", taskKey);
 }
 
 /**
@@ -2900,6 +2914,7 @@ function registerActiveSession(taskKey, sdk, threadId, sendFn) {
  */
 function unregisterActiveSession(taskKey) {
   activeSessions.delete(taskKey);
+  notifyActiveSessionListeners("end", taskKey);
 }
 
 /**
@@ -2949,15 +2964,31 @@ export function hasActiveSession(taskKey) {
  * Get info about which tasks have active (steerable) sessions.
  * @returns {Array<{ taskKey: string, sdk: string, threadId: string|null, age: number }>}
  */
+export function addActiveSessionListener(listener) {
+  if (typeof listener !== "function") return () => {};
+  ACTIVE_SESSION_LISTENERS.add(listener);
+  return () => ACTIVE_SESSION_LISTENERS.delete(listener);
+}
+
 export function getActiveSessions() {
   const now = Date.now();
   const result = [];
   for (const [key, session] of activeSessions) {
+    const record = threadRegistry.get(key) || null;
+    const createdAt = Number(record?.createdAt || session.registeredAt || now);
+    const lastUsedAt = Number(record?.lastUsedAt || now);
     result.push({
+      id: key,
+      taskId: key,
       taskKey: key,
       sdk: session.sdk,
       threadId: session.threadId,
-      age: now - session.registeredAt,
+      type: "task",
+      status: "active",
+      turnCount: Number(record?.turnCount || 0),
+      createdAt: new Date(createdAt).toISOString(),
+      lastActiveAt: new Date(lastUsedAt).toISOString(),
+      age: Math.max(0, now - createdAt),
     });
   }
   return result;
@@ -3973,3 +4004,5 @@ export function getActiveThreads() {
   }
   return result;
 }
+
+

package/agent/agent-work-report.mjs

@@ -1,5 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { resolveRepoRoot } from "../config/repo-root.mjs";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -89,6 +90,12 @@ function defaultLogPaths() {
   };
 }
 
+export function getWeeklyReportStatePath(options = {}) {
+  if (options?.statePath) return resolve(String(options.statePath));
+  const repoRoot = resolveRepoRoot();
+  return resolve(repoRoot, ".cache", "agent-work-logs", "weekly-report-state.json");
+}
+
 async function defaultLoadMetrics() {
   const { metricsPath } = defaultLogPaths();
   return await readJsonlFile(metricsPath);
@@ -99,6 +106,44 @@ async function defaultLoadErrors() {
   return await readJsonlFile(errorsPath);
 }
 
+export async function readWeeklyReportScheduleState(options = {}) {
+  const statePath = getWeeklyReportStatePath(options);
+  try {
+    const raw = await readFile(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const lastSentAt = String(parsed?.lastSentAt || "").trim();
+    if (!lastSentAt) {
+      return { statePath, lastSentAt: null };
+    }
+    const lastSentMs = Date.parse(lastSentAt);
+    return {
+      statePath,
+      lastSentAt: Number.isFinite(lastSentMs) ? new Date(lastSentMs).toISOString() : null,
+    };
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return { statePath, lastSentAt: null };
+    }
+    return { statePath, lastSentAt: null };
+  }
+}
+
+export async function writeWeeklyReportScheduleState(lastSentAt, options = {}) {
+  const statePath = getWeeklyReportStatePath(options);
+  const normalized = String(lastSentAt || "").trim();
+  const lastSentMs = Date.parse(normalized);
+  const payload = {
+    lastSentAt: Number.isFinite(lastSentMs) ? new Date(lastSentMs).toISOString() : null,
+    updatedAt: new Date().toISOString(),
+  };
+  await mkdir(dirname(statePath), { recursive: true });
+  await writeFile(statePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  return {
+    statePath,
+    lastSentAt: payload.lastSentAt,
+  };
+}
+
 export function buildWeeklyAgentWorkSummary(options = {}) {
   const now = toSafeDate(options.now);
   const days = toPositiveDays(options.days, DEFAULT_DAYS);
@@ -359,4 +404,45 @@ export function shouldSendWeeklyReport(options = {}) {
     return true;
   }
   return lastSentMs < scheduledThisWeek.getTime();
-}
+}
+
+export async function runWeeklyAgentWorkReportCli(options = {}) {
+  const argv = Array.isArray(options.argv) ? options.argv : process.argv.slice(2);
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  const rawDays = String(argv[0] || "").trim();
+  const parsedDays = Number.parseInt(rawDays, 10);
+  const days = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : undefined;
+
+  try {
+    const report = await generateWeeklyAgentWorkReport({
+      ...(days ? { days } : {}),
+      ...(options.now ? { now: options.now } : {}),
+      ...(typeof options.loadMetrics === "function"
+        ? { loadMetrics: options.loadMetrics }
+        : {}),
+      ...(typeof options.loadErrors === "function"
+        ? { loadErrors: options.loadErrors }
+        : {}),
+    });
+    stdout.write(`${report.text}\n`);
+    if (Array.isArray(report.warnings) && report.warnings.length > 0) {
+      stderr.write(`Warnings: ${report.warnings.join(" | ")}\n`);
+    }
+    return 0;
+  } catch (err) {
+    stderr.write(`Failed to generate weekly agent work report: ${err?.message || err}\n`);
+    return 1;
+  }
+}
+
+const isDirectRun =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+
+if (isDirectRun) {
+  const exitCode = await runWeeklyAgentWorkReportCli();
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}

package/agent/analyze-agent-work-helpers.mjs

@@ -203,8 +203,10 @@ function buildErrorCorrelationEntries(errors, taskProfiles) {
         count: 0,
         task_ids: new Set(),
         by_executor: {},
+        by_model: {},
         by_size: {},
         by_complexity: {},
+        avg_task_duration_ms: 0,
         sample_message: "",
         first_seen_ts: null,
         last_seen_ts: null,
@@ -240,13 +242,23 @@ function buildErrorCorrelationEntries(errors, taskProfiles) {
       extractSizeLabelFromTitle(error.task_title),
     );
     const executor = resolveKnownValue(profile?.executor, error.executor);
+    const model = resolveKnownValue(profile?.model, error.model);
     const complexity = resolveKnownValue(profile?.complexity);
 
     incrementCounter(entry.by_size, sizeLabel);
     incrementCounter(entry.by_executor, executor);
+    incrementCounter(entry.by_model, model);
     incrementCounter(entry.by_complexity, complexity);
   }
 
+  for (const entry of correlations.values()) {
+    const durations = [...entry.task_ids]
+      .map((taskId) => taskProfiles.get(taskId)?.avg_duration_ms || 0)
+      .filter((duration) => duration > 0);
+    entry.avg_task_duration_ms =
+      durations.length > 0 ? average(durations) : 0;
+  }
+
   return correlations;
 }
 
@@ -300,7 +312,9 @@ export function buildErrorCorrelationJsonPayload(summary, { now } = {}) {
       last_seen: entry.last_seen_ts
         ? new Date(entry.last_seen_ts).toISOString()
         : null,
+      avg_task_duration_ms: entry.avg_task_duration_ms || 0,
       by_executor: buildDistribution(entry.by_executor, entry.count),
+      by_model: buildDistribution(entry.by_model, entry.count),
       by_size: buildDistribution(entry.by_size, entry.count),
       by_complexity: buildDistribution(entry.by_complexity, entry.count),
     })),

package/agent/analyze-agent-work.mjs

@@ -21,7 +21,7 @@
 import { readFile, readdir } from "fs/promises";
 import { createReadStream, existsSync } from "fs";
 import { createInterface } from "readline";
-import { resolve, dirname } from "path";
+import { resolve, dirname, isAbsolute } from "path";
 import { fileURLToPath } from "url";
 import {
   buildErrorClusters,
@@ -44,8 +44,16 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const repoRoot = resolve(__dirname, "../..");
 
+function resolveAgentWorkLogDir() {
+  const configured = String(process.env.AGENT_WORK_LOG_DIR || "").trim();
+  if (!configured) {
+    return resolve(repoRoot, ".cache/agent-work-logs");
+  }
+  return isAbsolute(configured) ? configured : resolve(repoRoot, configured);
+}
+
 // ── Log Paths ───────────────────────────────────────────────────────────────
-const LOG_DIR = resolve(repoRoot, ".cache/agent-work-logs");
+const LOG_DIR = resolveAgentWorkLogDir();
 const STREAM_LOG = resolve(LOG_DIR, "agent-work-stream.jsonl");
 const ERRORS_LOG = resolve(LOG_DIR, "agent-errors.jsonl");
 const METRICS_LOG = resolve(LOG_DIR, "agent-metrics.jsonl");
@@ -339,6 +347,14 @@ function formatDistribution(counts, total, limit = 5) {
     .join(", ");
 }
 
+function formatDurationMs(durationMs) {
+  const value = Number(durationMs) || 0;
+  if (value <= 0) return "unknown";
+  if (value < 1000) return `${value.toFixed(0)}ms`;
+  if (value < 60_000) return `${(value / 1000).toFixed(1)}s`;
+  return `${(value / 60_000).toFixed(1)}m`;
+}
+
 function topN(obj, n) {
   return Object.entries(obj)
     .sort((a, b) => b[1] - a[1])
@@ -478,7 +494,7 @@ async function correlateErrors(options) {
   const errors = await loadErrors({ days: windowDays });
 
   if (errors.length === 0) {
-    const message = "No error data found";
+    const message = "No data found for selected window";
     if (useJson) {
       console.log(
         JSON.stringify(
@@ -522,10 +538,14 @@ async function correlateErrors(options) {
     console.log(
       `  Executors: ${formatDistribution(entry.by_executor, entry.count)}`,
     );
+    console.log(`  Models: ${formatDistribution(entry.by_model, entry.count)}`);
     console.log(`  Sizes: ${formatDistribution(entry.by_size, entry.count)}`);
     console.log(
       `  Complexity: ${formatDistribution(entry.by_complexity, entry.count)}`,
     );
+    console.log(
+      `  Avg task duration: ${formatDurationMs(entry.avg_task_duration_ms)}`,
+    );
     if (entry.sample_message) {
       console.log(
         `  Sample: ${entry.sample_message.slice(0, 100)}${entry.sample_message.length > 100 ? "..." : ""}`,

package/agent/primary-agent.mjs

@@ -191,6 +191,134 @@ function appendAttachmentsToPrompt(message, attachments) {
   return { message: `${message}${lines.join("\n")}`, appended: true };
 }
 
+function normalizeRepoMap(repoMap) {
+  if (!repoMap || typeof repoMap !== "object") return null;
+  const root = String(repoMap.root || repoMap.repoRoot || "").trim();
+  const files = Array.isArray(repoMap.files)
+    ? repoMap.files
+        .filter((entry) => entry && typeof entry === "object")
+        .map((entry) => ({
+          path: String(entry.path || entry.file || "").trim(),
+          summary: String(entry.summary || entry.description || "").trim(),
+          symbols: Array.isArray(entry.symbols)
+            ? entry.symbols.map((symbol) => String(symbol || "").trim()).filter(Boolean)
+            : [],
+        }))
+        .filter((entry) => entry.path)
+    : [];
+  if (!root && files.length === 0) return null;
+  return { root, files };
+}
+
+function formatRepoMap(repoMap) {
+  const normalized = normalizeRepoMap(repoMap);
+  if (!normalized) return "";
+  const lines = ["## Repo Map"];
+  if (normalized.root) lines.push(`- Root: ${normalized.root}`);
+  for (const file of normalized.files) {
+    const parts = [file.path];
+    if (file.symbols.length) parts.push(`symbols: ${file.symbols.join(", ")}`);
+    if (file.summary) parts.push(file.summary);
+    lines.push(`- ${parts.join(" — ")}`);
+  }
+  return lines.join("\n");
+}
+
+function summarizePathSegment(segment) {
+  return String(segment || "")
+    .replace(/[-_]+/g, " ")
+    .replace(/\.m?js$/i, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function inferRepoMapEntry(pathValue) {
+  const path = String(pathValue || "").trim().replace(/\\/g, "/");
+  if (!path) return null;
+  const name = path.split("/").pop() || path;
+  const stem = summarizePathSegment(name);
+  const dir = path.includes("/") ? path.split("/").slice(0, -1).join("/") : "";
+  const dirHint = dir ? summarizePathSegment(dir.split("/").pop()) : "";
+  const symbols = [];
+  const lowerStem = stem.toLowerCase();
+  if (lowerStem) {
+    const compact = lowerStem
+      .split(" ")
+      .filter(Boolean)
+      .map((part, index) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+      .join("");
+    if (compact) {
+      symbols.push(compact);
+      if (!compact.startsWith("test")) symbols.push(`test${compact.charAt(0).toUpperCase()}${compact.slice(1)}`);
+    }
+  }
+  const summaryParts = [];
+  if (dirHint) summaryParts.push(`${dirHint} module`);
+  if (stem) summaryParts.push(stem);
+  return {
+    path,
+    summary: summaryParts.join(" — "),
+    symbols: [...new Set(symbols)].slice(0, 3),
+  };
+}
+
+function deriveRepoMap(options = {}) {
+  const explicit = normalizeRepoMap(options.repoMap);
+  if (explicit) return explicit;
+  const changedFiles = Array.isArray(options.changedFiles)
+    ? options.changedFiles.map((value) => String(value || "").trim()).filter(Boolean)
+    : [];
+  if (!changedFiles.length) return null;
+  const root = String(options.repoRoot || options.cwd || resolveRepoRoot() || "").trim();
+  const files = changedFiles
+    .map((pathValue) => inferRepoMapEntry(pathValue))
+    .filter(Boolean)
+    .slice(0, Number(options.repoMapFileLimit) > 0 ? Number(options.repoMapFileLimit) : 12);
+  if (!root && files.length === 0) return null;
+  return { root, files };
+}
+
+function inferExecutionRole(options = {}, effectiveMode = "agent") {
+  const explicitRole = String(options.executionRole || "").trim().toLowerCase();
+  if (explicitRole) return explicitRole;
+  if (effectiveMode === "plan") return "architect";
+  const architectPlan = String(options.architectPlan || options.planSummary || "").trim();
+  if (architectPlan) return "editor";
+  return "";
+}
+function buildArchitectEditorFrame(options = {}, effectiveMode = "agent") {
+  const executionRole = inferExecutionRole(options, effectiveMode);
+  const repoMapBlock = formatRepoMap(deriveRepoMap(options));
+  const architectPlan = String(options.architectPlan || options.planSummary || "").trim();
+  const lines = ["## Architect/Editor Execution"];
+
+  if (executionRole === "architect") {
+    lines.push(
+      "You are the architect phase.",
+      "Do not implement code changes in this phase.",
+      "Use the repo map to produce a compact structural plan that an editor can execute and validate.",
+      "Editor handoff: include ordered implementation steps, touched files, risks, and validation guidance.",
+    );
+  } else if (executionRole === "editor") {
+    lines.push(
+      "You are the editor phase.",
+      "Implement the approved plan with focused edits and verification.",
+      "Prefer the supplied repo map over broad rediscovery unless validation reveals drift.",
+    );
+    if (architectPlan) {
+      lines.push("", "## Architect Plan", architectPlan);
+    }
+  } else {
+    return repoMapBlock;
+  }
+
+  if (repoMapBlock) {
+    lines.push("", repoMapBlock);
+  }
+
+  return lines.join("\n");
+}
+
 function summarizeContextCompressionItems(items) {
   if (!Array.isArray(items) || items.length === 0) return null;
 
@@ -1257,6 +1385,18 @@ export async function execPrimaryPrompt(userMessage, options = {}) {
               timestamp: new Date().toISOString(),
               _sessionType: sessionType,
             });
+            const compressionSummary = summarizeContextCompressionItems(retryResult?.items);
+            if (compressionSummary) {
+              tracker.recordEvent(sessionId, {
+                role: "system",
+                type: "system",
+                content: compressionSummary.content,
+                timestamp: new Date().toISOString(),
+                meta: {
+                  contextCompression: compressionSummary,
+                },
+              });
+            }
             clearAdapterFailureState(adapterName);
             return retryResult;
           } catch (retryErr) {
@@ -1538,3 +1678,5 @@ export async function execSdkCommand(command, args = "", adapterName, options =
   }
   return adapter.execSdkCommand(cmd, args, options);
 }
+
+

package/bosun-tui.mjs

@@ -14,9 +14,10 @@
 
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync } from "node:fs";
 
-const __dirname = dirname(fileURLToPath(new URL(".", import.meta.url)));
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 function showHelp() {
   const version = JSON.parse(
@@ -50,7 +51,7 @@ function showHelp() {
     Enter            Select / Execute action
     Esc              Back / Close modal
     c                Create new task (tasks screen)
-    r                Refresh data
+    r                Resume selected agent session (Agents screen)
     q                Quit
 
   EXAMPLES

package/bosun.schema.json

@@ -855,7 +855,7 @@
         },
         "defaults": {
           "type": "object",
-          "additionalProperties": false,
+          "additionalProperties": true,
           "properties": {
             "executor": {
               "type": "string"

package/config/config.mjs

@@ -454,6 +454,24 @@ function parseEnvBoolean(value, defaultValue) {
   return defaultValue;
 }
 
+function parseBoundedInteger(value, defaultValue, { min = null, max = null } = {}) {
+  const parsed = Number.parseInt(String(value ?? "").trim(), 10);
+  if (!Number.isFinite(parsed)) return defaultValue;
+  if (Number.isFinite(min) && parsed < min) return defaultValue;
+  if (Number.isFinite(max) && parsed > max) return defaultValue;
+  return parsed;
+}
+
+function parseBoundedNumber(value, defaultValue, { min = null, max = null } = {}) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) return defaultValue;
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) return defaultValue;
+  if (Number.isFinite(min) && parsed < min) return defaultValue;
+  if (Number.isFinite(max) && parsed > max) return defaultValue;
+  return parsed;
+}
+
 function isEnvEnabled(value, defaultValue = false) {
   return parseEnvBoolean(value, defaultValue);
 }
@@ -1578,6 +1596,10 @@ export function loadConfig(argv = process.argv, options = {}) {
   validateKanbanBackendConfig({ kanbanBackend, kanban, jira });
 
   const internalExecutorConfig = configData.internalExecutor || {};
+  const workflowRecoveryConfig =
+    configData.workflowRecovery && typeof configData.workflowRecovery === "object"
+      ? configData.workflowRecovery
+      : {};
   const envInternalExecutorParallel = configFileHadInvalidJson
     ? undefined
     : process.env.INTERNAL_EXECUTOR_PARALLEL;
@@ -1629,6 +1651,41 @@ export function loadConfig(argv = process.argv, options = {}) {
     String(reviewAgentToggleRaw).trim() !== ""
       ? isEnvEnabled(reviewAgentToggleRaw, true)
       : internalExecutorConfig.reviewAgentEnabled !== false;
+  const workflowRecoveryMaxAttempts = parseBoundedInteger(
+    process.env.WORKFLOW_RECOVERY_MAX_ATTEMPTS ??
+      workflowRecoveryConfig.maxAttempts,
+    5,
+    { min: 1, max: 20 },
+  );
+  const workflowRecoveryEscalationThreshold = parseBoundedInteger(
+    process.env.WORKFLOW_RECOVERY_ESCALATION_THRESHOLD ??
+      workflowRecoveryConfig.escalationWarnAfterAttempts ??
+      workflowRecoveryConfig.escalationThreshold,
+    3,
+    { min: 1, max: workflowRecoveryMaxAttempts },
+  );
+  const workflowRecovery = Object.freeze({
+    maxAttempts: workflowRecoveryMaxAttempts,
+    escalationWarnAfterAttempts: workflowRecoveryEscalationThreshold,
+    baseBackoffMs: parseBoundedInteger(
+      process.env.WORKFLOW_RECOVERY_BACKOFF_BASE_MS ??
+        workflowRecoveryConfig.baseBackoffMs,
+      5000,
+      { min: 50, max: 60_000 },
+    ),
+    maxBackoffMs: parseBoundedInteger(
+      process.env.WORKFLOW_RECOVERY_BACKOFF_MAX_MS ??
+        workflowRecoveryConfig.maxBackoffMs,
+      60_000,
+      { min: 1000, max: 30 * 60 * 1000 },
+    ),
+    jitterRatio: parseBoundedNumber(
+      process.env.WORKFLOW_RECOVERY_BACKOFF_JITTER_RATIO ??
+        workflowRecoveryConfig.jitterRatio,
+      0.2,
+      { min: 0, max: 0.9 },
+    ),
+  });
   const internalExecutor = {
     mode: ["vk", "internal", "hybrid"].includes(executorMode)
       ? executorMode
@@ -2059,6 +2116,7 @@ export function loadConfig(argv = process.argv, options = {}) {
 
     // Internal Executor
     internalExecutor,
+    workflowRecovery,
     executorMode: internalExecutor.mode,
     kanban,
     kanbanSource,

package/config/workspace-health.mjs

@@ -1,11 +1,42 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { execSync } from "node:child_process";
 import { homedir } from "node:os";
 
+export function normalizeWorkspaceHealthPath(value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return "";
+  const isWindowsDrivePath = /^[A-Za-z]:[\\/]/.test(trimmed);
+  const isUncPath = trimmed.startsWith("\\\\");
+  const normalized = (isWindowsDrivePath || isUncPath ? trimmed : resolve(trimmed))
+    .replace(/\\/g, "/");
+  if (/^[A-Z]:/.test(normalized)) {
+    return normalized[0].toLowerCase() + normalized.slice(1);
+  }
+  return normalized;
+}
+
+export function isAbsoluteWorkspaceHealthPath(value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return false;
+  if (/^[A-Za-z]:[\\/]/.test(trimmed)) return true;
+  if (trimmed.startsWith("\\\\")) return true;
+  return isAbsolute(trimmed);
+}
+
+export function writableRootContainsPath(root, candidate) {
+  const normalizedRoot = normalizeWorkspaceHealthPath(root);
+  const normalizedCandidate = normalizeWorkspaceHealthPath(candidate);
+  if (!normalizedRoot || !normalizedCandidate) return false;
+  return (
+    normalizedCandidate === normalizedRoot ||
+    normalizedCandidate.startsWith(`${normalizedRoot}/`)
+  );
+}
+
 export function runWorkspaceHealthCheck(options = {}) {
   const configDir = options.configDir || process.env.BOSUN_DIR || join(homedir(), "bosun");
-    const issues = { errors: [], warnings: [], infos: [] };
+  const issues = { errors: [], warnings: [], infos: [] };
   const workspaceResults = [];
 
   // 1. Check if workspaces are configured
@@ -128,7 +159,7 @@ export function runWorkspaceHealthCheck(options = {}) {
           for (const repo of ws.repos || []) {
             const repoPath = join(wsPath, repo.name || repo.slug || "");
             const gitPath = join(repoPath, ".git");
-            if (existsSync(gitPath) && !roots.some(r => gitPath.startsWith(r) || r === gitPath)) {
+            if (existsSync(gitPath) && !roots.some((root) => writableRootContainsPath(root, gitPath))) {
               issues.warnings.push({
                 code: "WS_SANDBOX_MISSING_ROOT",
                 message: `Workspace repo .git not in Codex writable_roots: ${gitPath}`,
@@ -140,13 +171,13 @@ export function runWorkspaceHealthCheck(options = {}) {
 
         // Check for phantom/relative writable roots
         for (const root of roots) {
-          if (!root.startsWith("/")) {
+          if (!isAbsoluteWorkspaceHealthPath(root)) {
             issues.warnings.push({
               code: "WS_SANDBOX_RELATIVE_ROOT",
               message: `Relative path in Codex writable_roots: "${root}" — may resolve incorrectly`,
               fix: `Remove "${root}" from writable_roots in ~/.codex/config.toml and run 'bosun --setup'`,
             });
-          } else if (!existsSync(root) && root !== "/tmp") {
+          } else if (!existsSync(root) && normalizeWorkspaceHealthPath(root) !== normalizeWorkspaceHealthPath("/tmp")) {
             issues.infos.push({
               code: "WS_SANDBOX_PHANTOM_ROOT",
               message: `Codex writable_root path does not exist: ${root}`,
@@ -239,4 +270,3 @@ export function formatWorkspaceHealthReport(result) {
 
   return lines.join("\n");
 }
-