bosun 0.33.10 → 0.34.2

package/.env.example

@@ -39,6 +39,15 @@ TELEGRAM_CHAT_ID=
 # TELEGRAM_ALLOWED_CHAT_IDS=
 # Minutes between periodic status summaries (default: 10)
 TELEGRAM_INTERVAL_MIN=10
+# Weekly report scheduler (default: disabled)
+# Sends the same report as /weekly automatically on a UTC schedule.
+# TELEGRAM_WEEKLY_REPORT_ENABLED=false
+# Day of week in UTC: 0=Sunday ... 6=Saturday (default: 0)
+# TELEGRAM_WEEKLY_REPORT_DAY=0
+# Hour in UTC (0-23) when weekly report is sent (default: 9)
+# TELEGRAM_WEEKLY_REPORT_HOUR=9
+# Lookback window in days for weekly report generation (default: 7)
+# TELEGRAM_WEEKLY_REPORT_DAYS=7
 # Long-poll timeout for getUpdates in seconds (default: 20)
 TELEGRAM_COMMAND_POLL_TIMEOUT_SEC=20
 # Agent execution timeout for Telegram-triggered SDK runs (ms).
@@ -497,7 +506,7 @@ TELEGRAM_MINIAPP_ENABLED=false
 # Controls which Codex CLI features are enabled in config.toml during setup.
 # All default to "true" (enabled). Set to "false" to disable a specific feature.
 # CODEX_FEATURES_CHILD_AGENTS_MD=true     # Sub-agent discovery via CODEX.md (KEY for sub-agents)
-# CODEX_FEATURES_MEMORY_TOOL=true         # Persistent memory across sessions
+# CODEX_FEATURES_MEMORIES=true         # Persistent memory across sessions
 # CODEX_FEATURES_UNDO=true                # Undo/rollback support
 # CODEX_FEATURES_MULTI_AGENT=true         # Multi Agent mode
 # CODEX_FEATURES_COLLABORATION_MODES=true # Mode selection for collaboration
@@ -1033,6 +1042,9 @@ COPILOT_CLOUD_DISABLED=true
 # AGENT_WORK_LOGGING_ENABLED=true
 # Enable/disable live stream analyzer (default: true)
 # AGENT_WORK_ANALYZER_ENABLED=true
+# Enrich missing task metadata from VK for agent work logs (default: true)
+# AGENT_WORK_LOGGING_ENRICH_VK=true
+# Task metadata cache (auto-managed): .cache/agent-work-logs/task-metadata.json
 # Log directory (default: .cache/agent-work-logs)
 # AGENT_WORK_LOG_DIR=.cache/agent-work-logs
 # Session log retention count - keep last N session transcripts (default: 100)

package/README.md

@@ -54,6 +54,12 @@ Requires:
 
 ---
 
+## Telegram weekly report
+
+- Run `/weekly` to generate the operator weekly agent-work report on demand.
+- Use `/report weekly` as an alias.
+- Optional scheduler knobs in `.env`: `TELEGRAM_WEEKLY_REPORT_ENABLED`, `TELEGRAM_WEEKLY_REPORT_DAY`, `TELEGRAM_WEEKLY_REPORT_HOUR` (UTC), and `TELEGRAM_WEEKLY_REPORT_DAYS`.
+
 ## Documentation
 
 **Published docs (website):** https://bosun.virtengine.com/docs/
@@ -89,13 +95,13 @@ Local commands you can run any time:
 
 ```bash
 # Syntax + tests for bosun package
-npm -C scripts/bosun test
+npm test
 
 # Prepublish safety checks
-npm -C scripts/bosun run prepublishOnly
+npm run prepublishOnly
 
 # Install local git hooks (pre-commit + pre-push)
-npm -C scripts/bosun run hooks:install
+npm run hooks:install
 ```
 
 ---

package/agent-event-bus.mjs

@@ -114,6 +114,7 @@ export class AgentEventBus {
       options.staleCheckIntervalMs || DEFAULTS.staleCheckIntervalMs;
     this._maxAutoRetries =
       options.maxAutoRetries ?? DEFAULTS.maxAutoRetries;
+    this._dedupeWindowMs = options.dedupeWindowMs || DEFAULTS.dedupeWindowMs;
 
     /** @type {Array<{type: string, taskId: string, payload: object, ts: number}>} ring buffer */
     this._eventLog = [];
@@ -202,11 +203,11 @@ export class AgentEventBus {
 
     // ── Dedup
     const key = `${type}:${taskId}`;
-    const last = this._recentEmits.get(key) || 0;
-    if (ts - last < DEFAULTS.dedupeWindowMs) return;
+    const last = this._recentEmits.get(key);
+    if (typeof last === "number" && ts - last < this._dedupeWindowMs) return;
     this._recentEmits.set(key, ts);
     if (this._recentEmits.size > 200) {
-      const cutoff = ts - DEFAULTS.dedupeWindowMs * 2;
+      const cutoff = ts - this._dedupeWindowMs * 2;
       for (const [k, v] of this._recentEmits) {
         if (v < cutoff) this._recentEmits.delete(k);
       }

package/agent-pool.mjs

@@ -110,6 +110,57 @@ function buildCopilotPermissionHandler() {
   return async () => ({ kind: "approved" });
 }
 
+/**
+ * Build a per-attempt abort controller that preserves external abort semantics.
+ *
+ * Internal attempt timeouts must not abort the caller-provided controller.
+ * Otherwise retries are immediately pre-aborted and treated as external kills.
+ *
+ * @param {AbortController|null|undefined} externalAC
+ * @param {number} timeoutMs
+ * @returns {{ controller: AbortController, cleanup: () => void }}
+ */
+function createScopedAbortController(externalAC, timeoutMs) {
+  const controller = new AbortController();
+  const externalSignal = externalAC?.signal || null;
+  const forwardExternalAbort = () => {
+    if (!controller.signal.aborted) {
+      controller.abort(externalSignal?.reason || "external_abort");
+    }
+  };
+
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      forwardExternalAbort();
+    } else {
+      externalSignal.addEventListener("abort", forwardExternalAbort, {
+        once: true,
+      });
+    }
+  }
+
+  const timeoutHandle = setTimeout(() => {
+    if (!controller.signal.aborted) {
+      controller.abort("timeout");
+    }
+  }, timeoutMs);
+  if (timeoutHandle && typeof timeoutHandle.unref === "function") {
+    timeoutHandle.unref();
+  }
+
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    clearTimeout(timeoutHandle);
+    if (externalSignal) {
+      externalSignal.removeEventListener("abort", forwardExternalAbort);
+    }
+  };
+
+  return { controller, cleanup };
+}
+
 function shouldFallbackForSdkError(error) {
   if (!error) return false;
   const message = String(error).toLowerCase();
@@ -127,13 +178,42 @@ function shouldFallbackForSdkError(error) {
   if (message.includes("invalid model")) return true;
   // Auth / key errors — SDK isn't properly configured
   if (message.includes("unauthorized") || message.includes("401")) return true;
-  if (message.includes("api key") && (message.includes("invalid") || message.includes("missing") || message.includes("required"))) return true;
-  if (message.includes("authentication") && (message.includes("failed") || message.includes("required") || message.includes("error"))) return true;
+  if (
+    message.includes("api key") &&
+    (message.includes("invalid") ||
+      message.includes("missing") ||
+      message.includes("required"))
+  ) {
+    return true;
+  }
+  if (
+    message.includes("authentication") &&
+    (message.includes("failed") ||
+      message.includes("required") ||
+      message.includes("error"))
+  ) {
+    return true;
+  }
   if (message.includes("forbidden") || message.includes("403")) return true;
   // Connection errors — SDK endpoint is unreachable
   if (message.includes("econnrefused")) return true;
   if (message.includes("enotfound")) return true;
   if (message.includes("connection refused")) return true;
+  if (message.includes("connection reset")) return true;
+  if (message.includes("etimedout")) return true;
+  // Runtime/provider instability: fail over to next SDK immediately.
+  if (message.includes("timeout")) return true;
+  if (message.includes("rate limit") || message.includes("429")) return true;
+  if (message.includes("service unavailable") || message.includes("503")) {
+    return true;
+  }
+  if (message.includes("bad gateway") || message.includes("502")) return true;
+  if (message.includes("gateway timeout") || message.includes("504")) {
+    return true;
+  }
+  if (message.includes("overloaded") || message.includes("server error")) {
+    return true;
+  }
   return false;
 }
 
@@ -349,6 +429,64 @@ function isDisabled(name) {
   return envFlagEnabled(process.env[adapter.envDisableKey]);
 }
 
+const DEFAULT_SDK_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
+const sdkFailureCooldownUntil = new Map();
+
+function getSdkFailureCooldownMs() {
+  const parsed = Number(process.env.AGENT_POOL_SDK_FAILURE_COOLDOWN_MS);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_SDK_FAILURE_COOLDOWN_MS;
+  }
+  return Math.trunc(parsed);
+}
+
+function getSdkCooldownRemainingMs(name, nowMs = Date.now()) {
+  const untilMs = Number(sdkFailureCooldownUntil.get(name) || 0);
+  if (!untilMs || untilMs <= nowMs) {
+    sdkFailureCooldownUntil.delete(name);
+    return 0;
+  }
+  return untilMs - nowMs;
+}
+
+function shouldApplySdkCooldown(error) {
+  if (!error) return false;
+  const message = String(error).toLowerCase();
+  if (!message) return false;
+  if (message.includes("timeout")) return true;
+  if (message.includes("rate limit") || message.includes("429")) return true;
+  if (message.includes("service unavailable") || message.includes("503")) {
+    return true;
+  }
+  if (message.includes("bad gateway") || message.includes("502")) return true;
+  if (message.includes("gateway timeout") || message.includes("504")) {
+    return true;
+  }
+  if (message.includes("overloaded") || message.includes("server error")) {
+    return true;
+  }
+  if (message.includes("econnrefused")) return true;
+  if (message.includes("enotfound")) return true;
+  if (message.includes("connection reset")) return true;
+  if (message.includes("etimedout")) return true;
+  return false;
+}
+
+function applySdkFailureCooldown(name, error, nowMs = Date.now()) {
+  if (!name || !SDK_ADAPTERS[name]) return;
+  if (!shouldApplySdkCooldown(error)) return;
+  const cooldownMs = getSdkFailureCooldownMs();
+  if (cooldownMs <= 0) return;
+  const untilMs = nowMs + cooldownMs;
+  const previous = Number(sdkFailureCooldownUntil.get(name) || 0);
+  if (untilMs <= previous) return;
+  sdkFailureCooldownUntil.set(name, untilMs);
+  const roundedSec = Math.max(1, Math.ceil(cooldownMs / 1000));
+  console.warn(
+    `${TAG} SDK "${name}" entering failure cooldown for ${roundedSec}s after fallback-worthy error: ${error}`,
+  );
+}
+
 const MONITOR_MONITOR_TASK_KEY = "monitor-monitor";
 let monitorMonitorTimeoutBoundsWarningKey = "";
 let monitorMonitorTimeoutAdjustmentKey = "";
@@ -604,7 +742,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
     features: {
       child_agents_md: true,
       multi_agent: true,
-      memory_tool: true,
+      memories: true,
       undo: true,
       steer: true,
     },
@@ -642,8 +780,10 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
   }
 
   // ── 3. Timeout / abort wiring ────────────────────────────────────────────
-  const controller = externalAC || new AbortController();
-  const timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  const { controller, cleanup: clearAbortScope } = createScopedAbortController(
+    externalAC,
+    timeoutMs,
+  );
 
   // Hard timeout: safety net if the SDK's async iterator ignores AbortSignal.
   // Fires HARD_TIMEOUT_BUFFER_MS after the soft timeout to forcibly break the loop.
@@ -692,7 +832,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
 
     await Promise.race([iterateEvents(), hardTimeoutPromise]);
     clearTimeout(hardTimer);
-    clearTimeout(timer);
+    clearAbortScope();
 
     const output =
       finalResponse.trim() || "(Agent completed with no text output)";
@@ -706,7 +846,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
       threadId: thread.id || null,
     };
   } catch (err) {
-    clearTimeout(timer);
+    clearAbortScope();
     if (hardTimer) clearTimeout(hardTimer);
     if (steerKey) unregisterActiveSession(steerKey);
     const isTimeout =
@@ -841,8 +981,10 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
   const sessionMode = (process.env.COPILOT_SESSION_MODE || "local").trim().toLowerCase();
   const cliUrl = process.env.COPILOT_CLI_URL || undefined;
 
-  const controller = externalAC || new AbortController();
-  const timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  const { controller, cleanup: clearAbortScope } = createScopedAbortController(
+    externalAC,
+    timeoutMs,
+  );
 
   let client;
   let unsubscribe = null;
@@ -884,7 +1026,7 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
       await client.start();
     });
   } catch (err) {
-    clearTimeout(timer);
+    clearAbortScope();
     return {
       success: false,
       output: "",
@@ -1131,7 +1273,7 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
       threadId: resumeThreadId,
     };
   } finally {
-    clearTimeout(timer);
+    clearAbortScope();
     if (steerKey) unregisterActiveSession(steerKey);
     try {
       if (typeof unsubscribe === "function") unsubscribe();
@@ -1221,10 +1363,13 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
     undefined;
 
   // ── 3. Build message queue ───────────────────────────────────────────────
-  const controller = externalAC || new AbortController();
-  const softTimer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  const { controller, cleanup: clearAbortScope } = createScopedAbortController(
+    externalAC,
+    timeoutMs,
+  );
   // Hard timeout: force-break Promise.race if SDK ignores abort signal
   const hardTimeoutMs = timeoutMs + HARD_TIMEOUT_BUFFER_MS;
+  let hardTimer = null;
 
   /**
    * Minimal async message queue for the Claude SDK streaming interface.
@@ -1416,13 +1561,17 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
       }
     })();
 
-    const hardTimeout = new Promise((_, reject) =>
-      setTimeout(() => reject(new Error("hard-timeout")), hardTimeoutMs),
-    );
+    const hardTimeout = new Promise((_, reject) => {
+      hardTimer = setTimeout(() => reject(new Error("hard-timeout")), hardTimeoutMs);
+      if (hardTimer && typeof hardTimer.unref === "function") {
+        hardTimer.unref();
+      }
+    });
 
     await Promise.race([sdkExecution, hardTimeout]);
+    if (hardTimer) clearTimeout(hardTimer);
 
-    clearTimeout(softTimer);
+    clearAbortScope();
     msgQueue.close();
     if (steerKey) unregisterActiveSession(steerKey);
 
@@ -1437,7 +1586,8 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
       threadId: activeClaudeSessionId,
     };
   } catch (err) {
-    clearTimeout(softTimer);
+    clearAbortScope();
+    if (hardTimer) clearTimeout(hardTimer);
     if (steerKey) unregisterActiveSession(steerKey);
     const isTimeout =
       err.name === "AbortError" ||
@@ -1555,71 +1705,124 @@ export async function launchEphemeralThread(
       ? requestedSdk
       : resolvePoolSdkName();
 
-  const primaryAdapter = SDK_ADAPTERS[primaryName];
-
-  // ── Try primary SDK ──────────────────────────────────────────────────────
-  if (primaryAdapter && !isDisabled(primaryName)) {
-    const prereq = hasSdkPrerequisites(primaryName);
-    if (!prereq.ok) {
-      console.warn(
-        `${TAG} primary SDK "${primaryName}" missing prerequisites: ${prereq.reason}; trying fallback chain`,
-      );
-    } else {
-      const launcher = await primaryAdapter.load();
-      const result = await launcher(prompt, cwd, timeoutMs, extra);
-
-      // If it succeeded, or if the error isn't fallback-worthy, return as-is
-      if (result.success || !shouldFallbackForSdkError(result.error)) {
-        return result;
-      }
+  const attemptOrder = extra?.disableFallback
+    ? [primaryName]
+    : [
+        primaryName,
+        ...SDK_FALLBACK_ORDER.filter((name) => name !== primaryName),
+      ];
 
-      // Primary SDK not installed — fall through to fallback chain
-      console.warn(
-        `${TAG} primary SDK "${primaryName}" failed (${result.error}); trying fallback chain`,
-      );
-    }
-  }
-
-  // ── Fallback chain ───────────────────────────────────────────────────────
-  for (const name of SDK_FALLBACK_ORDER) {
-    if (name === primaryName) continue; // already tried
-    if (isDisabled(name)) continue;
+  let lastAttemptResult = null;
+  const triedSdkNames = [];
+  const missingPrereqSdks = [];
+  const cooledDownSdks = [];
+  const ignoreSdkCooldown = extra?.ignoreSdkCooldown === true;
 
+  for (const name of attemptOrder) {
     const adapter = SDK_ADAPTERS[name];
     if (!adapter) continue;
+    if (isDisabled(name)) continue;
+
+    const cooldownRemainingMs = ignoreSdkCooldown
+      ? 0
+      : getSdkCooldownRemainingMs(name);
+    if (cooldownRemainingMs > 0) {
+      cooledDownSdks.push({ name, cooldownRemainingMs });
+      const remainingSec = Math.max(1, Math.ceil(cooldownRemainingMs / 1000));
+      if (name === primaryName) {
+        console.warn(
+          `${TAG} primary SDK "${name}" cooling down (${remainingSec}s remaining); trying fallback chain`,
+        );
+      } else {
+        console.log(
+          `${TAG} skipping fallback SDK "${name}" due to cooldown (${remainingSec}s remaining)`,
+        );
+      }
+      continue;
+    }
 
     // Check prerequisites before wasting time trying an unconfigured SDK
     const prereq = hasSdkPrerequisites(name);
     if (!prereq.ok) {
-      console.log(
-        `${TAG} skipping fallback SDK "${name}": ${prereq.reason}`,
-      );
+      missingPrereqSdks.push({ name, reason: prereq.reason });
+      if (name === primaryName) {
+        console.warn(
+          `${TAG} primary SDK "${name}" missing prerequisites: ${prereq.reason}; not attempting fallback`,
+        );
+        return {
+          success: false,
+          output: "",
+          items: [],
+          error: `${TAG} ${name} unavailable: ${prereq.reason}`,
+          sdk: primaryName,
+          threadId: null,
+        };
+      } else {
+        console.log(`${TAG} skipping fallback SDK "${name}": ${prereq.reason}`);
+      }
       continue;
     }
 
-    console.log(`${TAG} trying fallback SDK: ${name}`);
+    if (name !== primaryName) {
+      console.log(`${TAG} trying fallback SDK: ${name}`);
+    }
+
+    triedSdkNames.push(name);
     const launcher = await adapter.load();
     const result = await launcher(prompt, cwd, timeoutMs, extra);
+    lastAttemptResult = result;
 
-    if (result.success || !shouldFallbackForSdkError(result.error)) {
+    if (result.success) {
       return result;
     }
+
+    if (!shouldFallbackForSdkError(result.error)) {
+      return result;
+    }
+
+    applySdkFailureCooldown(name, result.error);
+
+    if (name === primaryName) {
+      console.warn(
+        `${TAG} primary SDK "${primaryName}" failed (${result.error}); trying fallback chain`,
+      );
+    } else {
+      console.warn(
+        `${TAG} fallback SDK "${name}" failed (${result.error}); trying next fallback`,
+      );
+    }
   }
 
   // ── All SDKs exhausted ───────────────────────────────────────────────────
-  const triedSdks = SDK_FALLBACK_ORDER.filter((n) => !isDisabled(n));
-  const configuredSdks = triedSdks.filter((n) => hasSdkPrerequisites(n).ok);
-  const skippedSdks = triedSdks.filter((n) => !hasSdkPrerequisites(n).ok);
-  let errorMsg = `${TAG} no SDK available.`;
-  if (configuredSdks.length > 0) {
-    errorMsg += ` Tried: ${configuredSdks.join(", ")}.`;
+  if (lastAttemptResult) {
+    return lastAttemptResult;
   }
-  if (skippedSdks.length > 0) {
-    errorMsg += ` Skipped (missing credentials): ${skippedSdks.map((n) => `${n} (${hasSdkPrerequisites(n).reason})`).join(", ")}.`;
-  }
-  if (triedSdks.length === 0) {
+
+  const eligibleSdks = Array.from(
+    new Set(attemptOrder.filter((name) => SDK_ADAPTERS[name] && !isDisabled(name))),
+  );
+
+  let errorMsg = `${TAG} no SDK available.`;
+  if (triedSdkNames.length > 0) {
+    errorMsg += ` Tried: ${triedSdkNames.join(", ")}.`;
+  }
+  if (missingPrereqSdks.length > 0) {
+    errorMsg += ` Skipped (missing credentials): ${missingPrereqSdks
+      .map((entry) => `${entry.name} (${entry.reason})`)
+      .join(", ")}.`;
+  }
+  if (cooledDownSdks.length > 0) {
+    errorMsg += ` Cooling down: ${cooledDownSdks
+      .map(
+        (entry) =>
+          `${entry.name} (${Math.max(1, Math.ceil(entry.cooldownRemainingMs / 1000))}s remaining)`,
+      )
+      .join(", ")}.`;
+  }
+  if (eligibleSdks.length === 0) {
     errorMsg += " All SDKs are disabled.";
   }
+
   return {
     success: false,
     output: "",
@@ -2027,8 +2230,10 @@ async function resumeCodexThread(threadId, prompt, cwd, timeoutMs, extra = {}) {
     };
   }
 
-  const controller = externalAC || new AbortController();
-  const timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  const { controller, cleanup: clearAbortScope } = createScopedAbortController(
+    externalAC,
+    timeoutMs,
+  );
   let hardTimer;
 
   try {
@@ -2066,7 +2271,7 @@ async function resumeCodexThread(threadId, prompt, cwd, timeoutMs, extra = {}) {
 
     await Promise.race([iterateEvents(), hardTimeoutPromise]);
     clearTimeout(hardTimer);
-    clearTimeout(timer);
+    clearAbortScope();
 
     const newThreadId = thread.id || threadId;
     return {
@@ -2078,7 +2283,7 @@ async function resumeCodexThread(threadId, prompt, cwd, timeoutMs, extra = {}) {
       threadId: newThreadId,
     };
   } catch (err) {
-    clearTimeout(timer);
+    clearAbortScope();
     if (hardTimer) clearTimeout(hardTimer);
     const isTimeout =
       err.name === "AbortError" ||
@@ -2163,6 +2368,10 @@ export async function launchOrResumeThread(
   const { taskKey, ...restExtra } = extra;
   // Pass taskKey through as steer key so SDK launchers can register active sessions
   restExtra.taskKey = taskKey;
+  if (restExtra.sdk) {
+    // Task-bound runs with an explicit SDK should stay pinned to that SDK.
+    restExtra.disableFallback = true;
+  }
   timeoutMs = clampMonitorMonitorTimeout(timeoutMs, taskKey);
 
   // No taskKey — pure ephemeral (backward compatible)
@@ -2564,6 +2773,7 @@ export async function execWithRetry(prompt, options = {}) {
       model,
       onEvent,
       abortController,
+      ignoreSdkCooldown: attempt > 1,
     });
 
     // Check post-launch if aborted with idle_continue (race: abort fired during execution)

package/agent-prompts.mjs

@@ -760,7 +760,10 @@ function asPathCandidates(pathValue, configDir, repoRoot) {
   const candidates = [];
   if (repoRoot) candidates.push(resolve(repoRoot, raw));
   if (configDir) candidates.push(resolve(configDir, raw));
-  candidates.push(resolve(process.cwd(), raw));
+  // Only fall back to cwd when no explicit roots were provided.
+  if (candidates.length === 0) {
+    candidates.push(resolve(process.cwd(), raw));
+  }
 
   return candidates.filter((p, idx, arr) => p && arr.indexOf(p) === idx);
 }