bosun 0.41.8 → 0.41.10

package/shell/claude-shell.mjs

@@ -437,9 +437,22 @@ async function saveState() {
 }
 
 function extractTaskHeading(msg) {
-  // Prompt first line is "# TASKID — Task Title" (from _buildTaskPrompt).
+  // Prompt first line is "# Task: Task Title" (or legacy "# TASKID — Task Title").
   // Return just the task title portion, or a short fallback.
   const firstLine = msg.split(/\r?\n/)[0].replace(/^#+\s*/, '').trim();
+  if (!firstLine) return 'Execute Task';
+  const lowerLine = firstLine.toLowerCase();
+  if (lowerLine.startsWith('task')) {
+    let index = 4;
+    while (index < firstLine.length && /\s/.test(firstLine[index])) index += 1;
+    const separator = firstLine[index];
+    if (separator === ':' || separator === '-' || separator === '\u2014') {
+      index += 1;
+      while (index < firstLine.length && /\s/.test(firstLine[index])) index += 1;
+      const heading = firstLine.slice(index).trim();
+      if (heading) return heading;
+    }
+  }
   const dashIdx = firstLine.indexOf(' \u2014 ');
   const heading = dashIdx !== -1 ? firstLine.slice(dashIdx + 3).trim() : firstLine;
   return heading || 'Execute Task';

package/shell/codex-config.mjs

@@ -1345,7 +1345,7 @@ function ensureModelProviderSectionsFromEnv(toml, env = process.env) {
       try {
         const parsed = new URL(String(activeBaseUrl || ""));
         const host = String(parsed.hostname || "").toLowerCase();
-        return host === "openai.azure.com" || host.endsWith(".openai.azure.com");
+        return host === "openai.azure.com" || host.endsWith(".openai.azure.com") || host.endsWith(".cognitiveservices.azure.com");
       } catch {
         return false;
       }

package/shell/codex-model-profiles.mjs

@@ -9,6 +9,33 @@ function clean(value) {
   return String(value ?? "").trim();
 }
 
+function isAzureOpenAIBaseUrl(value) {
+  try {
+    const parsed = value instanceof URL ? value : new URL(String(value || ""));
+    const host = String(parsed.hostname || "").toLowerCase();
+    return host === "openai.azure.com" || host.endsWith(".openai.azure.com") || host.endsWith(".cognitiveservices.azure.com");
+  } catch {
+    return false;
+  }
+}
+
+function normalizeAzureOpenAIBaseUrl(value) {
+  const raw = clean(value);
+  if (!raw) return "";
+  try {
+    const parsed = new URL(raw);
+    if (!isAzureOpenAIBaseUrl(parsed)) {
+      return raw;
+    }
+    parsed.pathname = "/openai/v1";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString().replace(/\/+$/, "");
+  } catch {
+    return raw;
+  }
+}
+
 function normalizeProfileName(value, fallback = DEFAULT_ACTIVE_PROFILE) {
   const raw = clean(value).toLowerCase();
   if (!raw) return fallback;
@@ -19,20 +46,6 @@ function profilePrefix(name) {
   return `CODEX_MODEL_PROFILE_${name.toUpperCase()}_`;
 }
 
-function inferGlobalProvider(env) {
-  const baseUrl = clean(env.OPENAI_BASE_URL).toLowerCase();
-  if ((() => {
-        try {
-          const parsed = new URL(baseUrl);
-          const host = String(parsed.hostname || "").toLowerCase();
-          return host === "openai.azure.com" || host.endsWith(".openai.azure.com");
-        } catch {
-          return false;
-        }
-      })()) return "azure";
-  return "openai";
-}
-
 function normalizeProvider(value, fallback) {
   const raw = clean(value).toLowerCase();
   if (!raw) return fallback;
@@ -48,6 +61,17 @@ function normalizeProvider(value, fallback) {
   return fallback;
 }
 
+function hasEnvValue(env, key) {
+  return Boolean(key && clean(env?.[key]));
+}
+
+function inferProviderKindFromSection(name, section, fallback = "openai") {
+  if (isAzureOpenAIBaseUrl(section?.baseUrl)) return "azure";
+  const normalized = normalizeProvider(name, "");
+  if (normalized) return normalized;
+  return fallback;
+}
+
 function readProfileField(env, profileName, field) {
   return clean(env[`${profilePrefix(profileName)}${field}`]);
 }
@@ -57,8 +81,9 @@ function profileRecord(env, profileName, globalProvider) {
     readProfileField(env, profileName, "PROVIDER"),
     globalProvider,
   );
+  const explicitModel = readProfileField(env, profileName, "MODEL");
   const model =
-    readProfileField(env, profileName, "MODEL") ||
+    explicitModel ||
     (profileName === "xl" ? "gpt-5.3-codex" : profileName === "m" ? "gpt-5.1-codex-mini" : "");
   const baseUrl = readProfileField(env, profileName, "BASE_URL");
   const apiKey = readProfileField(env, profileName, "API_KEY");
@@ -68,6 +93,7 @@ function profileRecord(env, profileName, globalProvider) {
     name: profileName,
     provider,
     model,
+    modelIsExplicit: Boolean(explicitModel),
     baseUrl,
     apiKey,
     apiKeyEnv,
@@ -75,19 +101,101 @@ function profileRecord(env, profileName, globalProvider) {
   };
 }
 
-function readCodexConfigTopLevelModel() {
+function readCodexConfigRuntimeDefaults() {
   try {
     const configPath = resolve(homedir(), ".codex", "config.toml");
-    if (!existsSync(configPath)) return "";
+    if (!existsSync(configPath)) {
+      return { model: "", modelProvider: "", providers: {} };
+    }
     const content = readFileSync(configPath, "utf8");
     const head = content.split(/\n\[/)[0] || "";
-    const match = head.match(/^\s*model\s*=\s*"([^"]+)"/m);
-    return match ? match[1].trim() : "";
+    const modelMatch = head.match(/^\s*model\s*=\s*"([^"]+)"/m);
+    const modelProviderMatch = head.match(/^\s*model_provider\s*=\s*"([^"]+)"/m);
+    const providers = {};
+    const providerSectionRegex = /^\[model_providers\.([^\]]+)\]\s*([\s\S]*?)(?=^\[[^\]]+\]|$(?![\s\S]))/gm;
+    for (const match of content.matchAll(providerSectionRegex)) {
+      const [, rawName = "", body = ""] = match;
+      const name = clean(rawName);
+      if (!name) continue;
+      const baseUrlMatch = body.match(/^\s*base_url\s*=\s*"([^"]+)"/m);
+      const envKeyMatch = body.match(/^\s*env_key\s*=\s*"([^"]+)"/m);
+      providers[name] = {
+        name,
+        baseUrl: clean(baseUrlMatch?.[1]),
+        envKey: clean(envKeyMatch?.[1]),
+      };
+    }
+    return {
+      model: clean(modelMatch?.[1]),
+      modelProvider: clean(modelProviderMatch?.[1]),
+      providers,
+    };
   } catch {
-    return "";
+    return { model: "", modelProvider: "", providers: {} };
   }
 }
 
+function readCodexConfigTopLevelModel() {
+  return readCodexConfigRuntimeDefaults().model;
+}
+
+function selectConfigProviderForRuntime(configDefaults, env, preferredProvider = "") {
+  const providers = configDefaults?.providers || {};
+  const preferred = clean(preferredProvider).toLowerCase();
+  const entries = Object.values(providers).map((section) => ({
+    ...section,
+    provider: inferProviderKindFromSection(section.name, section, preferred || "openai"),
+  }));
+  const matchingEntries = preferred
+    ? entries.filter((section) => section.provider === preferred)
+    : entries;
+  const envBackedEntries = matchingEntries.filter(
+    (section) => !section.envKey || hasEnvValue(env, section.envKey),
+  );
+  const preferredNames = preferred === "azure"
+    ? ["azure"]
+    : preferred === "openai"
+      ? ["openai"]
+      : [];
+  const findNamed = (sections) => preferredNames
+    .map((name) => sections.find((section) => section.name === name))
+    .find(Boolean);
+
+  const configuredName = clean(configDefaults?.modelProvider);
+  if (configuredName) {
+    const configuredSection = providers[configuredName];
+    if (configuredSection) {
+      const configured = {
+        ...configuredSection,
+        provider: inferProviderKindFromSection(
+          configuredSection.name,
+          configuredSection,
+          preferred || "openai",
+        ),
+      };
+      const preferredMatches = !preferred || configured.provider === preferred;
+      if (preferredMatches && (!configured.envKey || hasEnvValue(env, configured.envKey))) {
+        return configured;
+      }
+    }
+  }
+
+  return (
+    findNamed(envBackedEntries) ||
+    envBackedEntries[0] ||
+    findNamed(matchingEntries) ||
+    matchingEntries[0] ||
+    null
+  );
+}
+
+function inferGlobalProvider(env, configDefaults = null) {
+  const baseUrl = clean(env.OPENAI_BASE_URL).toLowerCase();
+  if (isAzureOpenAIBaseUrl(baseUrl)) return "azure";
+  const configured = selectConfigProviderForRuntime(configDefaults, env);
+  return configured?.provider || "openai";
+}
+
 /**
  * Resolve codex model/provider profile configuration from env vars.
  * Applies active profile values onto runtime env keys (`CODEX_MODEL`,
@@ -96,6 +204,7 @@ function readCodexConfigTopLevelModel() {
  */
 export function resolveCodexProfileRuntime(envInput = process.env) {
   const sourceEnv = { ...envInput };
+  const configDefaults = readCodexConfigRuntimeDefaults();
   const activeProfile = normalizeProfileName(
     sourceEnv.CODEX_MODEL_PROFILE,
     DEFAULT_ACTIVE_PROFILE,
@@ -105,7 +214,7 @@ export function resolveCodexProfileRuntime(envInput = process.env) {
     DEFAULT_SUBAGENT_PROFILE,
   );
 
-  const globalProvider = inferGlobalProvider(sourceEnv);
+  const globalProvider = inferGlobalProvider(sourceEnv, configDefaults);
   const active = profileRecord(sourceEnv, activeProfile, globalProvider);
   const sub = profileRecord(sourceEnv, subagentProfile, globalProvider);
 
@@ -116,24 +225,51 @@ export function resolveCodexProfileRuntime(envInput = process.env) {
   if (active.model) {
     env.CODEX_MODEL = active.model;
   }
-  if (active.baseUrl) {
-    env.OPENAI_BASE_URL = active.baseUrl;
-  }
 
   const profileApiKey = active.apiKey;
   const resolvedProvider = active.provider || globalProvider;
+  const configProvider = selectConfigProviderForRuntime(
+    configDefaults,
+    sourceEnv,
+    resolvedProvider,
+  );
+  const runtimeBaseUrl =
+    clean(active.baseUrl) ||
+    clean(env.OPENAI_BASE_URL) ||
+    clean(configProvider?.baseUrl);
+  if (runtimeBaseUrl) {
+    const normalizedBaseUrl =
+      resolvedProvider === "azure"
+        ? normalizeAzureOpenAIBaseUrl(runtimeBaseUrl)
+        : runtimeBaseUrl;
+    env.OPENAI_BASE_URL = normalizedBaseUrl;
+    active.baseUrl = normalizedBaseUrl;
+  }
+
+  if (!profileApiKey && configProvider?.envKey && hasEnvValue(sourceEnv, configProvider.envKey)) {
+    const configuredApiKey = clean(sourceEnv[configProvider.envKey]);
+    if (resolvedProvider === "azure") {
+      env.AZURE_OPENAI_API_KEY = configuredApiKey;
+      if (!env.OPENAI_API_KEY) {
+        env.OPENAI_API_KEY = configuredApiKey;
+      }
+    } else {
+      env.OPENAI_API_KEY = configuredApiKey;
+    }
+  }
 
   // Azure deployments often differ from default model names.
   // If the env is using Azure and the model is still the default,
   // prefer the top-level ~/.codex/config.toml model when present.
-  const activeModelExplicit =
-    Boolean(readProfileField(sourceEnv, activeProfile, "MODEL")) ||
-    Boolean(clean(sourceEnv.CODEX_MODEL));
-  if (
+  // The hardcoded profile fallback (e.g. "gpt-5.3-codex" for xl) should NOT
+  // block the config.toml override — only explicit env or profile fields should.
+  const runtimeModelExplicit = Boolean(clean(sourceEnv.CODEX_MODEL));
+  const shouldPreferAzureConfigModel =
     resolvedProvider === "azure" &&
     configModel &&
-    (!activeModelExplicit || clean(env.CODEX_MODEL) === "gpt-5.3-codex")
-  ) {
+    !active.modelIsExplicit &&
+    !runtimeModelExplicit;
+  if (shouldPreferAzureConfigModel) {
     env.CODEX_MODEL = configModel;
     active.model = configModel;
   }
@@ -173,5 +309,9 @@ export function resolveCodexProfileRuntime(envInput = process.env) {
     active,
     subagent: sub,
     provider: resolvedProvider,
+    /** The config.toml provider section selected for this runtime. */
+    configProvider: configProvider
+      ? { name: configProvider.name, envKey: configProvider.envKey, baseUrl: configProvider.baseUrl }
+      : null,
   };
 }

package/shell/codex-shell.mjs

@@ -78,6 +78,63 @@ function normalizeTimeoutMs(value, { fallback = DEFAULT_TIMEOUT_MS, label = "tim
   return normalized;
 }
 
+function isAzureOpenAIBaseUrl(value) {
+  try {
+    const parsed = new URL(String(value || ""));
+    const host = String(parsed.hostname || "").toLowerCase();
+    return host === "openai.azure.com" || host.endsWith(".openai.azure.com") || host.endsWith(".cognitiveservices.azure.com");
+  } catch {
+    return false;
+  }
+}
+
+function buildCodexSdkRuntime(streamProviderOverrides, envInput = process.env) {
+  const resolved = resolveCodexProfileRuntime(envInput);
+  const { env: resolvedEnv, configProvider } = resolved;
+  const baseUrl = resolvedEnv.OPENAI_BASE_URL || "";
+  const isAzure = isAzureOpenAIBaseUrl(baseUrl);
+  const env = { ...resolvedEnv };
+
+  delete env.OPENAI_BASE_URL;
+
+  // Use the config.toml provider section name and env_key when available,
+  // so Bosun's config override is consistent with the user's config.toml
+  // instead of hardcoding "azure" / "AZURE_OPENAI_API_KEY".
+  const providerSectionName = (isAzure && configProvider?.name) || (isAzure ? "azure" : "openai");
+  const providerEnvKey = (isAzure && configProvider?.envKey) || (isAzure ? "AZURE_OPENAI_API_KEY" : "OPENAI_API_KEY");
+
+  if (isAzure && env.OPENAI_API_KEY && !env.AZURE_OPENAI_API_KEY) {
+    env.AZURE_OPENAI_API_KEY = env.OPENAI_API_KEY;
+  }
+
+  const providerName = isAzure ? "azure" : "openai";
+  const config = {
+    model_providers: {
+      [providerSectionName]: isAzure
+        ? {
+            name: "Azure OpenAI",
+            base_url: baseUrl,
+            env_key: providerEnvKey,
+            wire_api: "responses",
+            ...streamProviderOverrides,
+          }
+        : streamProviderOverrides,
+    },
+  };
+
+  if (isAzure && env.CODEX_MODEL) {
+    config.model_provider = providerSectionName;
+    config.model = env.CODEX_MODEL;
+  }
+
+  return {
+    env,
+    config,
+    providerName,
+    streamIdleTimeoutMs: streamProviderOverrides.stream_idle_timeout_ms,
+  };
+}
+
 function getInternalExecutorStreamConfig() {
   try {
     const cfg = loadConfig();
@@ -443,9 +500,6 @@ async function getThread() {
   if (activeThread) return activeThread;
   const threadOptions = buildThreadOptions();
 
-  const { env: resolvedEnv } = resolveCodexProfileRuntime(process.env);
-  Object.assign(process.env, resolvedEnv);
-
   if (!codexInstance) {
     const Cls = await loadCodexSdk();
     if (!Cls) throw new Error("Codex SDK not available");
@@ -454,23 +508,16 @@ async function getThread() {
     // even if config.toml hasn't been patched by codex-config.mjs yet.
     // This is the most reliable path for Azure/Foundry deployments where
     // dropped SSE streams ("response.failed") are the dominant failure mode.
-    const providerName = (() => {
-      try {
-        const parsed = new URL(String(resolvedEnv.OPENAI_BASE_URL || ""));
-        const host = String(parsed.hostname || "").toLowerCase();
-        return host === "openai.azure.com" || host.endsWith(".openai.azure.com")
-          ? "azure"
-          : "openai";
-      } catch {
-        return "openai";
-      }
-    })();
     const STREAM_IDLE_TIMEOUT_MS = 3_600_000; // 60 min — matches Azure max stream lifetime
     const streamProviderOverrides = {
       stream_idle_timeout_ms: STREAM_IDLE_TIMEOUT_MS,
       stream_max_retries: 15,
       request_max_retries: 6,
     };
+    const runtime = buildCodexSdkRuntime(streamProviderOverrides, process.env);
+
+    Object.assign(process.env, runtime.env);
+    delete process.env.OPENAI_BASE_URL;
 
     codexInstance = new Cls({
       config: {
@@ -481,13 +528,11 @@ async function getThread() {
           undo: true,
           steer: true,
         },
-        model_providers: {
-          [providerName]: streamProviderOverrides,
-        },
+        ...runtime.config,
       },
     });
 
-    console.log(`[codex-shell] created Codex instance (provider=${providerName}, stream_idle_timeout=${STREAM_IDLE_TIMEOUT_MS}ms, stream_max_retries=${streamProviderOverrides.stream_max_retries})`);
+    console.log(`[codex-shell] created Codex instance (provider=${runtime.providerName}, stream_idle_timeout=${runtime.streamIdleTimeoutMs}ms, stream_max_retries=${streamProviderOverrides.stream_max_retries})`);
   }
 
   const transport = resolveCodexTransport();

package/shell/opencode-providers.mjs

@@ -91,22 +91,33 @@ async function discoverViaSDK(existingClient = null) {
     // Try to connect to an already-running server
     try {
       const port = Number(process.env.OPENCODE_PORT || "4096");
-      const result = sdk.createOpencodeClient({
-        hostname: "127.0.0.1",
-        port,
-        timeout: 5_000,
-      });
-      client = result;
+      try {
+        client = sdk.createOpencodeClient({
+          baseUrl: `http://127.0.0.1:${port}`,
+          timeout: 5_000,
+        });
+      } catch {
+        client = sdk.createOpencodeClient({
+          hostname: "127.0.0.1",
+          port,
+          timeout: 5_000,
+        });
+      }
     } catch {
       return null;
     }
   }
 
   try {
+    const directory = process.cwd();
+    const requestOptions = directory
+      ? { query: { directory } }
+      : undefined;
+
     // Fetch provider list + auth methods in parallel
     const [providerRes, authRes] = await Promise.all([
-      client.provider.list().catch(() => null),
-      client.provider.auth().catch(() => null),
+      client.provider.list(requestOptions).catch(() => null),
+      client.provider.auth(requestOptions).catch(() => null),
     ]);
 
     if (!providerRes?.data) return null;
@@ -481,3 +492,4 @@ export function buildExecutorEntry(providerID, modelFullId, overrides = {}) {
 export function invalidateCache() {
   _providerCache = { data: null, ts: 0 };
 }
+

package/task/task-executor.mjs

@@ -4278,6 +4278,34 @@ class TaskExecutor {
     };
   }
 
+  resetTaskThrottleState(taskId, options = {}) {
+    const key = normalizeTaskIdKey(taskId);
+    if (!key) return false;
+
+    let changed = false;
+    if (options.clearNoCommit !== false && this._noCommitCounts.delete(key)) {
+      changed = true;
+    }
+    if (options.clearSkipUntil !== false && this._skipUntil.delete(key)) {
+      changed = true;
+    }
+    if (options.clearCooldowns !== false && this._taskCooldowns.delete(key)) {
+      changed = true;
+    }
+    if (this._idleContinueCounts.delete(key)) {
+      changed = true;
+    }
+    if (this._repoAreaBlockedTasks.has(key)) {
+      this._repoAreaBlockedTasks.delete(key);
+      changed = true;
+    }
+
+    if (changed) {
+      this._saveNoCommitState();
+    }
+    return changed;
+  }
+
   setBacklogReplenishmentConfig(patch = {}) {
     if (!patch || typeof patch !== "object") {
       return this.getBacklogReplenishmentConfig();

package/task/task-store.mjs

@@ -101,15 +101,25 @@ function resolveBosunHomeDir() {
   return resolve(base, "bosun");
 }
 
+function resolveExplicitRepoRoot() {
+  const explicit = String(process.env.REPO_ROOT || "").trim();
+  if (!explicit) return null;
+  return resolve(explicit);
+}
+
 function resolvePersistentStorePath() {
-  const repoRoot = inferRepoRoot(process.cwd());
-  if (repoRoot) {
-    return resolve(repoRoot, ".bosun", ".cache", "kanban-state.json");
+  const explicitRepoRoot = resolveExplicitRepoRoot();
+  if (explicitRepoRoot) {
+    return resolve(explicitRepoRoot, ".bosun", ".cache", "kanban-state.json");
   }
   const bosunHome = resolveBosunHomeDir();
   if (bosunHome) {
     return resolve(bosunHome, ".cache", "kanban-state.json");
   }
+  const repoRoot = inferRepoRoot(process.cwd());
+  if (repoRoot) {
+    return resolve(repoRoot, ".bosun", ".cache", "kanban-state.json");
+  }
   return resolve(__dirname, "..", ".cache", "kanban-state.json");
 }
 
@@ -2831,4 +2841,3 @@ export function getStaleInReviewTasks(maxAgeMs) {
     (t) => t.status === "inreview" && t.lastActivityAt < cutoff,
   );
 }
-

package/telegram/telegram-sentinel.mjs

@@ -41,7 +41,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { readFile, writeFile, unlink } from "node:fs/promises";
-import { resolve, dirname } from "node:path";
+import { resolve, dirname, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import os from "node:os";
@@ -61,7 +61,55 @@ import {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const repoRoot = resolveRepoRoot();
+
+// Resolve repo root from BOSUN_HOME config first, then fall back to git detection.
+// This avoids depending on cwd being inside a git repo (daemon/sentinel may start
+// from homedir or any arbitrary directory).
+function _resolveSentinelRepoRoot() {
+  // 1. Explicit env
+  if (process.env.REPO_ROOT) {
+    const r = resolve(process.env.REPO_ROOT);
+    if (existsSync(r)) return r;
+  }
+  // 2. Check BOSUN_HOME workspace config for a primary repo
+  const bosunDir = resolveBosunConfigDir();
+  if (bosunDir) {
+    for (const cfgName of ["bosun.config.json", ".bosun.json", "bosun.json"]) {
+      const cfgPath = resolve(bosunDir, cfgName);
+      if (!existsSync(cfgPath)) continue;
+      try {
+        const cfg = JSON.parse(readFileSync(cfgPath, "utf8"));
+        // Check workspace repos
+        const workspaces = Array.isArray(cfg.workspaces) ? cfg.workspaces : [];
+        for (const ws of workspaces) {
+          const repos = ws?.repos || ws?.repositories || [];
+          if (!Array.isArray(repos)) continue;
+          for (const repo of repos) {
+            const name = typeof repo === "string" ? repo.split("/").pop() : (repo?.name || repo?.id || "");
+            if (!name) continue;
+            const wsId = ws?.id || "default";
+            const repoPath = resolve(bosunDir, "workspaces", wsId, name);
+            if (existsSync(resolve(repoPath, ".git"))) return repoPath;
+          }
+        }
+        // Check flat repositories
+        const repos = cfg.repositories || cfg.repos || [];
+        if (Array.isArray(repos)) {
+          for (const repo of repos) {
+            const repoPath = typeof repo === "string" ? repo : (repo?.path || repo?.repoRoot);
+            if (!repoPath) continue;
+            const resolved = resolve(isAbsolute(repoPath) ? repoPath : resolve(bosunDir, repoPath));
+            if (existsSync(resolve(resolved, ".git"))) return resolved;
+          }
+        }
+      } catch { /* invalid config */ }
+    }
+  }
+  // 3. Fall back to standard repo-root resolution (git detection)
+  return resolveRepoRoot();
+}
+
+const repoRoot = _resolveSentinelRepoRoot();
 const cacheDir = resolve(repoRoot, ".cache");
 
 function resolveBosunConfigDir() {
@@ -1654,8 +1702,11 @@ async function startAndWaitForMonitor(reason) {
     {
       detached: true,
       stdio: "ignore",
+      windowsHide: process.platform === "win32",
       env: spawnEnv,
-      cwd: repoRoot,
+      // Use repoRoot if it has a .git dir; otherwise use homedir so spawn
+      // never inherits a non-existent or non-repo cwd.
+      cwd: existsSync(resolve(repoRoot, ".git")) ? repoRoot : os.homedir(),
     },
   );
 

package/tools/list-todos.mjs

@@ -2,9 +2,10 @@
 /**
  * list-todos — Scan codebase for TODO/FIXME/HACK/XXX/BUG comment markers
  *
- * Usage: node list-todos.mjs [rootDir] [--json]
+ * Usage: node list-todos.mjs [rootDir] [--json] [--help]
  *   rootDir  defaults to cwd
  *   --json   emit JSON array instead of human-readable output
+ *   --help   show usage and exit without scanning
  *
  * Exit 0 always (informational tool).
  */
@@ -12,6 +13,11 @@ import { readdirSync, readFileSync } from "node:fs";
 import { resolve, relative, extname } from "node:path";
 
 const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h") || args.includes("help")) {
+  console.log("Usage: node list-todos.mjs [rootDir] [--json] [--help]");
+  console.log("Scans for TODO/FIXME/HACK/XXX/TEMP/BUG comment markers.");
+  process.exit(0);
+}
 const jsonMode = args.includes("--json");
 const ROOT = args.find((a) => !a.startsWith("-")) || process.cwd();
 

package/ui/app.js

@@ -314,7 +314,7 @@ import { LogsTab } from "./tabs/logs.js";
 import { TelemetryTab } from "./tabs/telemetry.js";
 import { SettingsTab } from "./tabs/settings.js";
 import { WorkflowsTab } from "./tabs/workflows.js";
-import { LibraryTab } from "./tabs/library.js";
+import { LibraryTab, LibraryMarketplaceTab } from "./tabs/library.js";
 import { ManualFlowsTab } from "./tabs/manual-flows.js";
 
 /* ── Shared components ── */
@@ -603,6 +603,7 @@ const TAB_COMPONENTS = {
   workflows: WorkflowsTab,
   "manual-flows": ManualFlowsTab,
   library: LibraryTab,
+  marketplace: LibraryMarketplaceTab,
   settings: SettingsTab,
 };
 
@@ -1228,7 +1229,7 @@ function InspectorPanel({ onResizeStart, onResizeReset, showResizer }) {
  *  Bottom Navigation
  * ═══════════════════════════════════════════════ */
 const PRIMARY_NAV_TABS = ["dashboard", "chat", "tasks", "agents"];
-const MORE_NAV_TABS = ["control", "infra", "logs", "telemetry", "library", "workflows", "manual-flows", "settings"];
+const MORE_NAV_TABS = ["control", "infra", "logs", "telemetry", "library", "marketplace", "workflows", "manual-flows", "settings"];
 
 function getTabsById(ids) {
   return ids