bosun 0.29.3 → 0.29.5

package/agent-pool.mjs

@@ -307,8 +307,26 @@ const SDK_ADAPTERS = {
   },
 };
 
-/** Ordered fallback chain for SDK resolution */
-const SDK_FALLBACK_ORDER = ["codex", "copilot", "claude"];
+/**
+ * Ordered fallback chain for SDK resolution.
+ * Configurable via bosun.config.json → agentPool.fallbackOrder
+ */
+let SDK_FALLBACK_ORDER = ["codex", "copilot", "claude"];
+
+// Attempt to load custom fallback order from config
+try {
+  const cfg = loadConfig();
+  const customOrder = cfg?.agentPool?.fallbackOrder;
+  if (Array.isArray(customOrder) && customOrder.length > 0) {
+    // Validate: only accept known SDK names
+    const valid = customOrder
+      .map((s) => String(s).trim().toLowerCase())
+      .filter((s) => SDK_ADAPTERS[s]);
+    if (valid.length > 0) SDK_FALLBACK_ORDER = valid;
+  }
+} catch {
+  // loadConfig not available or no custom order — use default
+}
 
 // ---------------------------------------------------------------------------
 // SDK Resolution & Cache

package/agent-sdk.mjs

@@ -21,12 +21,12 @@ const DEFAULT_CAPABILITIES_BY_PRIMARY = {
   },
   copilot: {
     steering: false,
-    subagents: false,
+    subagents: true,
     vscodeTools: true,
   },
   claude: {
     steering: false,
-    subagents: false,
+    subagents: true,
     vscodeTools: false,
   },
 };

package/codex-config.mjs

@@ -9,6 +9,16 @@
  *   5. Sandbox permissions and shell environment policy
  *   6. Common MCP servers (context7, microsoft-docs)
  *
+ * SCOPE: This manages the GLOBAL ~/.codex/config.toml which contains:
+ *   - Model provider configs (API keys, base URLs) — MUST be global
+ *   - Stream timeouts & retry settings — per-provider, global
+ *   - Sandbox workspace-write (writable_roots) — spans multiple repos, global
+ *   - Feature flags, MCP servers, agent_sdk — kept as FALLBACK defaults
+ *     (prefer repo-level .codex/config.toml via repo-config.mjs)
+ *
+ * For project-scoped settings, see repo-config.mjs which generates
+ * .codex/config.toml at the repo level.
+ *
  * Uses string-based TOML manipulation (no parser dependency) — we only
  * append or patch well-known sections rather than rewriting the whole file.
  */
@@ -55,25 +65,38 @@ const AGENT_SDK_CAPS_HEADER = "[agent_sdk.capabilities]";
 const AGENTS_HEADER = "[agents]";
 const DEFAULT_AGENT_MAX_THREADS = 12;
 
-const DEFAULT_AGENT_SDK_BLOCK = [
-  "",
-  "# ── Agent SDK selection (added by bosun) ──",
-  AGENT_SDK_HEADER,
-  "# Primary agent SDK used for in-process automation.",
-  '# Supported: "codex", "copilot", "claude"',
-  'primary = "codex"',
-  "# Max concurrent agent threads per Codex session.",
-  `max_threads = ${DEFAULT_AGENT_MAX_THREADS}`,
-  "",
-  AGENT_SDK_CAPS_HEADER,
-  "# Live steering updates during an active run.",
-  "steering = true",
-  "# Ability to spawn subagents/child tasks.",
-  "subagents = true",
-  "# Access to VS Code tools (Copilot extension).",
-  "vscode_tools = false",
-  "",
-].join("\n");
+/**
+ * Build the default [agent_sdk] TOML block.
+ * @param {string} [primary="codex"]  The primary SDK: "codex", "copilot", or "claude"
+ * @returns {string}
+ */
+function buildDefaultAgentSdkBlock(primary = "codex") {
+  const caps = {
+    codex:   { steering: true,  subagents: true,  vscodeTools: false },
+    copilot: { steering: false, subagents: true,  vscodeTools: true  },
+    claude:  { steering: false, subagents: true,  vscodeTools: false },
+  };
+  const c = caps[primary] || caps.codex;
+  return [
+    "",
+    "# ── Agent SDK selection (added by bosun) ──",
+    AGENT_SDK_HEADER,
+    "# Primary agent SDK used for in-process automation.",
+    '# Supported: "codex", "copilot", "claude"',
+    `primary = "${primary}"`,
+    "# Max concurrent agent threads per Codex session.",
+    `max_threads = ${DEFAULT_AGENT_MAX_THREADS}`,
+    "",
+    AGENT_SDK_CAPS_HEADER,
+    "# Live steering updates during an active run.",
+    `steering = ${c.steering}`,
+    "# Ability to spawn subagents/child tasks.",
+    `subagents = ${c.subagents}`,
+    "# Access to VS Code tools (Copilot extension).",
+    `vscode_tools = ${c.vscodeTools}`,
+    "",
+  ].join("\n");
+}
 
 /**
  * @deprecated No longer used — max_threads is now managed under [agent_sdk].
@@ -411,7 +434,7 @@ function formatTomlArray(values) {
   return `[${values.map((value) => `"${String(value).replace(/"/g, '\\"')}"`).join(", ")}]`;
 }
 
-function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
+function normalizeWritableRoots(input, { repoRoot, additionalRoots, validateExistence = false } = {}) {
   const roots = new Set();
   const addRoot = (value) => {
     const trimmed = String(value || "").trim();
@@ -420,6 +443,16 @@ function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
     // at Codex launch time and cause "writable root does not exist" errors
     // (e.g. /home/user/.codex/.git). Only accept absolute paths.
     if (!trimmed.startsWith("/")) return;
+    // When validateExistence is true, skip paths that don't exist on disk.
+    // This prevents the sandbox from failing to start with phantom roots.
+    if (validateExistence && !existsSync(trimmed)) return;
+    roots.add(trimmed);
+  };
+  // Always-add: these are primary roots (repo root, parent) that should be
+  // present even if validateExistence is true — they're the intended CWD.
+  const addPrimaryRoot = (value) => {
+    const trimmed = String(value || "").trim();
+    if (!trimmed || !trimmed.startsWith("/")) return;
     roots.add(trimmed);
   };
   if (Array.isArray(input)) {
@@ -437,15 +470,18 @@ function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
     if (!repo) return;
     const r = String(repo).trim();
     if (!r || !r.startsWith("/")) return;
-    addRoot(r);
+    // Repo root and parent are always added (they're primary working dirs)
+    addPrimaryRoot(r);
     const gitDir = resolve(r, ".git");
     // Only add .git if it actually exists (prevents phantom writable roots)
     if (existsSync(gitDir)) addRoot(gitDir);
     const cacheWorktrees = resolve(r, ".cache", "worktrees");
-    addRoot(cacheWorktrees);
-    addRoot(resolve(r, ".cache"));
+    // Only add .cache subdirs if they exist — avoid phantom roots
+    if (existsSync(cacheWorktrees)) addRoot(cacheWorktrees);
+    const cacheDir = resolve(r, ".cache");
+    if (existsSync(cacheDir)) addRoot(cacheDir);
     const parent = dirname(r);
-    if (parent && parent !== r) addRoot(parent);
+    if (parent && parent !== r) addPrimaryRoot(parent);
   };
 
   addRepoRootPaths(repoRoot);
@@ -515,13 +551,17 @@ export function ensureGitAncestor(dir) {
  * @returns {string[]} Merged writable roots
  */
 export function buildTaskWritableRoots({ worktreePath, repoRoot, existingRoots = [] } = {}) {
-  const roots = new Set(existingRoots.filter(r => r && r.startsWith("/")));
+  const roots = new Set(existingRoots.filter(r => r && r.startsWith("/") && existsSync(r)));
   const addIfExists = (p) => {
+    if (p && p.startsWith("/") && existsSync(p)) roots.add(p);
+  };
+  // Add path even if it doesn't exist yet (will be created by the task)
+  const addRoot = (p) => {
     if (p && p.startsWith("/")) roots.add(p);
   };
 
   if (worktreePath) {
-    addIfExists(worktreePath);
+    addRoot(worktreePath); // Worktree dir itself may be about to be created
     // Worktrees have a .git file pointing to main repo — resolve the actual git dir
     const ancestor = ensureGitAncestor(worktreePath);
     if (ancestor.gitDir) addIfExists(ancestor.gitDir);
@@ -531,7 +571,7 @@ export function buildTaskWritableRoots({ worktreePath, repoRoot, existingRoots =
     }
   }
   if (repoRoot) {
-    addIfExists(repoRoot);
+    addRoot(repoRoot);
     const gitDir = resolve(repoRoot, ".git");
     if (existsSync(gitDir)) addIfExists(gitDir);
     addIfExists(resolve(repoRoot, ".cache", "worktrees"));
@@ -557,7 +597,7 @@ export function ensureSandboxWorkspaceWrite(toml, options = {}) {
     excludeSlashTmp = false,
   } = options;
 
-  const desiredRoots = normalizeWritableRoots(writableRoots, { repoRoot, additionalRoots });
+  const desiredRoots = normalizeWritableRoots(writableRoots, { repoRoot, additionalRoots, validateExistence: true });
   if (!hasSandboxWorkspaceWrite(toml)) {
     if (desiredRoots.length === 0) {
       return { toml, changed: false, added: false, rootsAdded: [] };
@@ -609,13 +649,18 @@ export function ensureSandboxWorkspaceWrite(toml, options = {}) {
   const match = section.match(rootsRegex);
   if (match) {
     const existingRoots = parseTomlArrayLiteral(match[1]);
-    const merged = normalizeWritableRoots(existingRoots, { repoRoot });
+    // Filter out stale roots that no longer exist on disk
+    const validExisting = existingRoots.filter((r) => r === "/tmp" || existsSync(r));
+    const merged = normalizeWritableRoots(validExisting, { repoRoot, validateExistence: true });
     for (const root of desiredRoots) {
       if (!merged.includes(root)) {
         merged.push(root);
         rootsAdded.push(root);
       }
     }
+    // Track any roots that were removed due to non-existence
+    const staleRemoved = existingRoots.filter((r) => r !== "/tmp" && !existsSync(r));
+    if (staleRemoved.length > 0) changed = true;
     const formatted = formatTomlArray(merged);
     if (formatted !== match[1]) {
       section = section.replace(rootsRegex, `writable_roots = ${formatted}`);
@@ -642,6 +687,39 @@ export function ensureSandboxWorkspaceWrite(toml, options = {}) {
   };
 }
 
+/**
+ * Prune writable_roots in [sandbox_workspace_write] that no longer exist on disk.
+ * Returns the updated TOML and a list of removed paths.
+ * @param {string} toml
+ * @returns {{ toml: string, changed: boolean, removed: string[] }}
+ */
+export function pruneStaleSandboxRoots(toml) {
+  if (!hasSandboxWorkspaceWrite(toml)) {
+    return { toml, changed: false, removed: [] };
+  }
+  const header = "[sandbox_workspace_write]";
+  const headerIdx = toml.indexOf(header);
+  if (headerIdx === -1) return { toml, changed: false, removed: [] };
+  const afterHeader = headerIdx + header.length;
+  const nextSection = toml.indexOf("\n[", afterHeader);
+  const sectionEnd = nextSection === -1 ? toml.length : nextSection;
+  let section = toml.substring(afterHeader, sectionEnd);
+
+  const rootsRegex = /^writable_roots\s*=\s*(\[[^\]]*\])\s*$/m;
+  const match = section.match(rootsRegex);
+  if (!match) return { toml, changed: false, removed: [] };
+
+  const existing = parseTomlArrayLiteral(match[1]);
+  const valid = existing.filter((r) => r === "/tmp" || existsSync(r));
+  const removed = existing.filter((r) => r !== "/tmp" && !existsSync(r));
+  if (removed.length === 0) return { toml, changed: false, removed: [] };
+
+  section = section.replace(rootsRegex, `writable_roots = ${formatTomlArray(valid)}`);
+  const updatedToml =
+    toml.substring(0, afterHeader) + section + toml.substring(sectionEnd);
+  return { toml: updatedToml, changed: true, removed };
+}
+
 /**
  * Build the [shell_environment_policy] section.
  * Default: inherit = "all" so .NET, Go, Node etc. env vars are visible.
@@ -810,9 +888,12 @@ export function hasAgentSdkConfig(toml) {
 
 /**
  * Build the default agent SDK block.
+ * @param {object}  [opts]
+ * @param {string}  [opts.primary="codex"]  Primary SDK: "codex", "copilot", or "claude"
+ * @returns {string}
  */
-export function buildAgentSdkBlock() {
-  return DEFAULT_AGENT_SDK_BLOCK;
+export function buildAgentSdkBlock({ primary = "codex" } = {}) {
+  return buildDefaultAgentSdkBlock(primary);
 }
 
 /**
@@ -1054,12 +1135,14 @@ export function ensureRetrySettings(toml, providerName) {
  * @param {boolean} [opts.skipVk]
  * @param {boolean} [opts.dryRun]  If true, returns result without writing
  * @param {object}  [opts.env]     Environment overrides (defaults to process.env)
+ * @param {string}  [opts.primarySdk]  Primary agent SDK: "codex", "copilot", or "claude"
  */
 export function ensureCodexConfig({
   vkBaseUrl = "http://127.0.0.1:54089",
   skipVk = false,
   dryRun = false,
   env = process.env,
+  primarySdk,
 } = {}) {
   const result = {
     path: CONFIG_PATH,
@@ -1075,6 +1158,7 @@ export function ensureCodexConfig({
     sandboxWorkspaceAdded: false,
     sandboxWorkspaceUpdated: false,
     sandboxWorkspaceRootsAdded: [],
+    sandboxStaleRootsRemoved: [],
     shellEnvAdded: false,
     commonMcpAdded: false,
     profileProvidersAdded: [],
@@ -1155,8 +1239,21 @@ export function ensureCodexConfig({
 
   // ── 1b. Ensure agent SDK selection block ──────────────────
 
+  // Resolve which SDK should be primary:
+  //   1. Explicit primarySdk parameter
+  //   2. PRIMARY_AGENT env var (e.g. "copilot-sdk" → "copilot")
+  //   3. Default: "codex"
+  const resolvedPrimary = (() => {
+    if (primarySdk && ["codex", "copilot", "claude"].includes(primarySdk)) {
+      return primarySdk;
+    }
+    const envPrimary = (env.PRIMARY_AGENT || "").trim().toLowerCase().replace(/-sdk$/, "");
+    if (["codex", "copilot", "claude"].includes(envPrimary)) return envPrimary;
+    return "codex";
+  })();
+
   if (!hasAgentSdkConfig(toml)) {
-    toml += buildAgentSdkBlock();
+    toml += buildAgentSdkBlock({ primary: resolvedPrimary });
     result.agentSdkAdded = true;
   }
 
@@ -1241,6 +1338,14 @@ export function ensureCodexConfig({
       result.sandboxWorkspaceUpdated = !ensured.added;
       result.sandboxWorkspaceRootsAdded = ensured.rootsAdded || [];
     }
+
+    // Prune any writable_roots that no longer exist on disk
+    const pruned = pruneStaleSandboxRoots(toml);
+    if (pruned.changed) {
+      toml = pruned.toml;
+      result.sandboxWorkspaceUpdated = true;
+      result.sandboxStaleRootsRemoved = pruned.removed;
+    }
   }
 
   // ── 1g. Ensure shell environment policy ───────────────────
@@ -1408,6 +1513,15 @@ export function printConfigSummary(result, log = console.log) {
     );
   }
 
+  if (result.sandboxStaleRootsRemoved && result.sandboxStaleRootsRemoved.length > 0) {
+    log(
+      `  🗑️  Pruned ${result.sandboxStaleRootsRemoved.length} stale writable root(s) that no longer exist`,
+    );
+    for (const r of result.sandboxStaleRootsRemoved) {
+      log(`     - ${r}`);
+    }
+  }
+
   if (result.shellEnvAdded) {
     log("  ✅ Added shell environment policy (inherit=all)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.29.3",
+  "version": "0.29.5",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/setup.mjs

@@ -1500,6 +1500,15 @@ const EXECUTOR_PRESETS = {
       role: "primary",
     },
   ],
+  "claude-only": [
+    {
+      name: "claude-default",
+      executor: "CLAUDE",
+      variant: "CLAUDE_OPUS_4",
+      weight: 100,
+      role: "primary",
+    },
+  ],
   triple: [
     {
       name: "copilot-claude",
@@ -1817,6 +1826,16 @@ function normalizeSetupConfiguration({
     enabled: executor.enabled !== false,
   }));
 
+  // Derive PRIMARY_AGENT from executor config for SDK resolution
+  {
+    const primaryExec = configJson.executors.find((e) => e.role === "primary");
+    if (primaryExec) {
+      const sdkMap = { CODEX: "codex-sdk", COPILOT: "copilot-sdk", CLAUDE: "claude-sdk" };
+      env.PRIMARY_AGENT = env.PRIMARY_AGENT ||
+        sdkMap[String(primaryExec.executor).toUpperCase()] || "codex-sdk";
+    }
+  }
+
   configJson.failover = {
     strategy: normalizeEnum(
       configJson.failover?.strategy || env.FAILOVER_STRATEGY || "next-in-line",
@@ -2460,6 +2479,7 @@ async function main() {
           "Codex only",
           "Copilot + Codex (50/50 split)",
           "Copilot only (Claude Opus 4.6)",
+          "Claude only (direct API)",
           "Triple (Copilot Claude 40%, Codex 35%, Copilot GPT 25%)",
           "Custom — I'll define my own executors",
         ]
@@ -2467,6 +2487,7 @@ async function main() {
           "Codex only",
           "Copilot + Codex (50/50 split)",
           "Copilot only (Claude Opus 4.6)",
+          "Claude only (direct API)",
           "Triple (Copilot Claude 40%, Codex 35%, Copilot GPT 25%)",
         ];
 
@@ -2477,8 +2498,8 @@ async function main() {
     );
 
     const presetNames = isAdvancedSetup
-      ? ["codex-only", "copilot-codex", "copilot-only", "triple", "custom"]
-      : ["codex-only", "copilot-codex", "copilot-only", "triple"];
+      ? ["codex-only", "copilot-codex", "copilot-only", "claude-only", "triple", "custom"]
+      : ["codex-only", "copilot-codex", "copilot-only", "claude-only", "triple"];
     const presetKey = presetNames[presetIdx] || "codex-only";
 
     if (presetKey === "custom") {
@@ -2629,92 +2650,140 @@ async function main() {
       if (!wantCodexFallback) env.CODEX_SDK_DISABLED = "true";
     }
 
-    // ── Step 5: AI Provider ────────────────────────────────
-    headingStep(5, "AI / Codex Provider", markSetupProgress);
+    // ── Step 5: AI Provider Keys ─────────────────────────────
+    headingStep(5, "AI Provider Keys", markSetupProgress);
     console.log(
-      "  Codex Monitor uses the Codex SDK for crash analysis & autofix.\n",
+      "  Configure API keys for the agent SDKs in your executor preset.\n",
     );
 
-    const providerIdx = await prompt.choose(
-      "Select AI provider:",
-      [
-        "OpenAI (default)",
-        "Azure OpenAI",
-        "Local model (Ollama, vLLM, etc.)",
-        "Other OpenAI-compatible endpoint",
-        "None — disable AI features",
-      ],
-      0,
-    );
-
-    if (providerIdx < 4) {
-      env.OPENAI_API_KEY = await prompt.ask(
-        "API Key",
-        process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_API_KEY || "",
-      );
+    // Determine which SDK families are needed
+    const needsCodexSdk = usedSdks.has("CODEX") || env.CODEX_SDK_DISABLED !== "true";
+    const needsCopilotSdk = usedSdks.has("COPILOT") || env.COPILOT_SDK_DISABLED !== "true";
+    const needsClaudeSdk = usedSdks.has("CLAUDE") || env.CLAUDE_SDK_DISABLED !== "true";
+
+    // ── 5a. Copilot / GitHub Token ──────────────────────
+    if (needsCopilotSdk) {
+      console.log(chalk.bold("  Copilot SDK") + chalk.dim(" (uses GitHub token)\n"));
+      const existingGhToken = process.env.COPILOT_CLI_TOKEN || process.env.GITHUB_TOKEN || "";
+      if (existingGhToken) {
+        info(`GitHub token detected (${existingGhToken.slice(0, 8)}…). Copilot SDK will use it.`);
+      } else {
+        const ghToken = await prompt.ask(
+          "GitHub Token (GITHUB_TOKEN or COPILOT_CLI_TOKEN, blank to skip)",
+          "",
+        );
+        if (ghToken) env.GITHUB_TOKEN = ghToken;
+      }
+      // Copilot permission defaults
+      env.COPILOT_NO_ALLOW_ALL = env.COPILOT_NO_ALLOW_ALL || "false";
+      env.COPILOT_ENABLE_ASK_USER = env.COPILOT_ENABLE_ASK_USER || "false";
+      env.COPILOT_AGENT_MAX_REQUESTS = env.COPILOT_AGENT_MAX_REQUESTS || "500";
     }
-    if (providerIdx === 1) {
-      // Azure OpenAI also needs AZURE_OPENAI_API_KEY for adapters that check it directly
-      env.AZURE_OPENAI_API_KEY = env.OPENAI_API_KEY;
-      env.OPENAI_BASE_URL = await prompt.ask(
-        "Azure endpoint URL",
-        process.env.OPENAI_BASE_URL || "",
-      );
-      env.CODEX_MODEL = await prompt.ask(
-        "Deployment/model name",
-        process.env.CODEX_MODEL || "",
-      );
-    } else if (providerIdx === 2) {
-      env.OPENAI_API_KEY = env.OPENAI_API_KEY || "ollama";
-      env.OPENAI_BASE_URL = await prompt.ask(
-        "Local API URL",
-        "http://localhost:11434/v1",
-      );
-      env.CODEX_MODEL = await prompt.ask("Model name", "codex");
-    } else if (providerIdx === 3) {
-      env.OPENAI_BASE_URL = await prompt.ask("API Base URL", "");
-      env.CODEX_MODEL = await prompt.ask("Model name", "");
-    } else if (providerIdx === 4) {
-      env.CODEX_SDK_DISABLED = "true";
+
+    // ── 5b. Claude / Anthropic Key ──────────────────────
+    if (needsClaudeSdk) {
+      console.log(chalk.bold("\n  Claude SDK") + chalk.dim(" (uses Anthropic API key)\n"));
+      const existingAnthropicKey = process.env.ANTHROPIC_API_KEY || "";
+      if (existingAnthropicKey) {
+        info(`Anthropic API key detected (${existingAnthropicKey.slice(0, 8)}…). Claude SDK will use it.`);
+      } else {
+        const anthropicKey = await prompt.ask(
+          "Anthropic API Key (ANTHROPIC_API_KEY, blank to skip)",
+          "",
+        );
+        if (anthropicKey) env.ANTHROPIC_API_KEY = anthropicKey;
+      }
+      // Claude always runs in bypass mode under Bosun
+      env.CLAUDE_PERMISSION_MODE = env.CLAUDE_PERMISSION_MODE || "bypassPermissions";
     }
 
-    if (providerIdx < 4) {
-      const configureProfiles = await prompt.confirm(
-        "Configure model profiles (xl/m) for one-click switching?",
-        true,
+    // ── 5c. Codex / OpenAI Key ──────────────────────────
+    if (needsCodexSdk) {
+      console.log(chalk.bold("\n  Codex SDK") + chalk.dim(" (uses OpenAI API key)\n"));
+
+      const providerIdx = await prompt.choose(
+        "Select AI provider for Codex:",
+        [
+          "OpenAI (default)",
+          "Azure OpenAI",
+          "Local model (Ollama, vLLM, etc.)",
+          "Other OpenAI-compatible endpoint",
+          "None — disable Codex SDK",
+        ],
+        0,
       );
-      if (configureProfiles) {
-        const activeProfileIdx = await prompt.choose(
-          "Default active profile:",
-          ["xl (high quality)", "m (faster/cheaper)"],
-          0,
+
+      if (providerIdx < 4) {
+        env.OPENAI_API_KEY = await prompt.ask(
+          "API Key",
+          process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_API_KEY || "",
         );
-        env.CODEX_MODEL_PROFILE = activeProfileIdx === 0 ? "xl" : "m";
-        env.CODEX_MODEL_PROFILE_SUBAGENT = activeProfileIdx === 0 ? "m" : "xl";
-
-        env.CODEX_MODEL_PROFILE_XL_MODEL = await prompt.ask(
-          "XL profile model",
-          process.env.CODEX_MODEL_PROFILE_XL_MODEL ||
-            process.env.CODEX_MODEL ||
-            "gpt-5.3-codex",
+      }
+      if (providerIdx === 1) {
+        env.AZURE_OPENAI_API_KEY = env.OPENAI_API_KEY;
+        env.OPENAI_BASE_URL = await prompt.ask(
+          "Azure endpoint URL",
+          process.env.OPENAI_BASE_URL || "",
         );
-        env.CODEX_MODEL_PROFILE_M_MODEL = await prompt.ask(
-          "M profile model",
-          process.env.CODEX_MODEL_PROFILE_M_MODEL || "gpt-5.1-codex-mini",
+        env.CODEX_MODEL = await prompt.ask(
+          "Deployment/model name",
+          process.env.CODEX_MODEL || "",
         );
+      } else if (providerIdx === 2) {
+        env.OPENAI_API_KEY = env.OPENAI_API_KEY || "ollama";
+        env.OPENAI_BASE_URL = await prompt.ask(
+          "Local API URL",
+          "http://localhost:11434/v1",
+        );
+        env.CODEX_MODEL = await prompt.ask("Model name", "codex");
+      } else if (providerIdx === 3) {
+        env.OPENAI_BASE_URL = await prompt.ask("API Base URL", "");
+        env.CODEX_MODEL = await prompt.ask("Model name", "");
+      } else if (providerIdx === 4) {
+        env.CODEX_SDK_DISABLED = "true";
+      }
+
+      if (providerIdx < 4) {
+        const configureProfiles = await prompt.confirm(
+          "Configure model profiles (xl/m) for one-click switching?",
+          true,
+        );
+        if (configureProfiles) {
+          const activeProfileIdx = await prompt.choose(
+            "Default active profile:",
+            ["xl (high quality)", "m (faster/cheaper)"],
+            0,
+          );
+          env.CODEX_MODEL_PROFILE = activeProfileIdx === 0 ? "xl" : "m";
+          env.CODEX_MODEL_PROFILE_SUBAGENT = activeProfileIdx === 0 ? "m" : "xl";
+
+          env.CODEX_MODEL_PROFILE_XL_MODEL = await prompt.ask(
+            "XL profile model",
+            process.env.CODEX_MODEL_PROFILE_XL_MODEL ||
+              process.env.CODEX_MODEL ||
+              "gpt-5.3-codex",
+          );
+          env.CODEX_MODEL_PROFILE_M_MODEL = await prompt.ask(
+            "M profile model",
+            process.env.CODEX_MODEL_PROFILE_M_MODEL || "gpt-5.1-codex-mini",
+          );
 
-        const providerName =
-          providerIdx === 1 ? "azure" : providerIdx === 3 ? "compatible" : "openai";
-        env.CODEX_MODEL_PROFILE_XL_PROVIDER =
-          process.env.CODEX_MODEL_PROFILE_XL_PROVIDER || providerName;
-        env.CODEX_MODEL_PROFILE_M_PROVIDER =
-          process.env.CODEX_MODEL_PROFILE_M_PROVIDER || providerName;
+          const providerName =
+            providerIdx === 1 ? "azure" : providerIdx === 3 ? "compatible" : "openai";
+          env.CODEX_MODEL_PROFILE_XL_PROVIDER =
+            process.env.CODEX_MODEL_PROFILE_XL_PROVIDER || providerName;
+          env.CODEX_MODEL_PROFILE_M_PROVIDER =
+            process.env.CODEX_MODEL_PROFILE_M_PROVIDER || providerName;
 
-        if (!env.CODEX_SUBAGENT_MODEL) {
-          env.CODEX_SUBAGENT_MODEL =
-            env.CODEX_MODEL_PROFILE_M_MODEL || "gpt-5.1-codex-mini";
+          if (!env.CODEX_SUBAGENT_MODEL) {
+            env.CODEX_SUBAGENT_MODEL =
+              env.CODEX_MODEL_PROFILE_M_MODEL || "gpt-5.1-codex-mini";
+          }
         }
       }
+    } else {
+      // Codex not needed — skip OpenAI key prompts entirely
+      info("Codex SDK not in executor preset — skipping OpenAI configuration.");
     }
 
     // ── Step 6: Telegram ──────────────────────────────────
@@ -4568,6 +4637,13 @@ async function runNonInteractive({
   env.COPILOT_AGENT_MAX_REQUESTS =
     process.env.COPILOT_AGENT_MAX_REQUESTS || "500";
 
+  // Claude SDK: permission mode and API key passthrough
+  env.CLAUDE_PERMISSION_MODE =
+    process.env.CLAUDE_PERMISSION_MODE || "bypassPermissions";
+  if (process.env.ANTHROPIC_API_KEY) {
+    env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+  }
+
   // Parse EXECUTORS env if set, else use default preset
   if (process.env.EXECUTORS) {
     const entries = process.env.EXECUTORS.split(",").map((e) => e.trim());
@@ -4589,7 +4665,33 @@ async function runNonInteractive({
     }
   }
   if (!configJson.executors.length) {
-    configJson.executors = EXECUTOR_PRESETS["codex-only"];
+    // Smart default: pick preset based on available API keys
+    const hasOpenAI = !!process.env.OPENAI_API_KEY;
+    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
+    const hasGitHub = !!process.env.GITHUB_TOKEN || !!process.env.COPILOT_CLI_TOKEN;
+    const presetEnv = (process.env.EXECUTOR_PRESET || "").toLowerCase();
+    if (presetEnv && EXECUTOR_PRESETS[presetEnv]) {
+      configJson.executors = EXECUTOR_PRESETS[presetEnv];
+    } else if (hasGitHub) {
+      configJson.executors = hasOpenAI
+        ? EXECUTOR_PRESETS["copilot-codex"]
+        : EXECUTOR_PRESETS["copilot-only"];
+    } else if (hasAnthropic) {
+      configJson.executors = EXECUTOR_PRESETS["claude-only"];
+    } else {
+      configJson.executors = EXECUTOR_PRESETS["codex-only"];
+    }
+  }
+
+  // Derive PRIMARY_AGENT from executor preset's primary role
+  {
+    const primaryExec = (configJson.executors || []).find(
+      (e) => e.role === "primary",
+    );
+    if (primaryExec) {
+      const sdkMap = { CODEX: "codex-sdk", COPILOT: "copilot-sdk", CLAUDE: "claude-sdk" };
+      env.PRIMARY_AGENT = sdkMap[String(primaryExec.executor).toUpperCase()] || "codex-sdk";
+    }
   }
 
   configJson.projectName = env.PROJECT_NAME;
@@ -4803,6 +4905,42 @@ async function writeConfigFiles({ env, configJson, repoRoot, configDir }) {
     warn(`Could not update Copilot MCP config: ${copilotMcpResult.error}`);
   }
 
+  // ── Repo-level AI configs for all workspace repos ──────
+  heading("Repo-Level AI Configs");
+  try {
+    const { ensureRepoConfigs, printRepoConfigSummary } = await import("./repo-config.mjs");
+    // Apply to the primary repo
+    const repoResult = ensureRepoConfigs(repoRoot);
+    printRepoConfigSummary(repoResult, (msg) => console.log(msg));
+
+    // Also apply to all workspace repos under $BOSUN_DIR/workspaces/
+    const bosunDir = env.BOSUN_DIR || configDir || resolve(homedir(), "bosun");
+    const bosunConfigPath = resolve(bosunDir, "bosun.config.json");
+    if (existsSync(bosunConfigPath)) {
+      try {
+        const bosunCfg = JSON.parse(readFileSync(bosunConfigPath, "utf8"));
+        const wsDir = resolve(bosunDir, "workspaces");
+        for (const ws of bosunCfg.workspaces || []) {
+          for (const repo of ws.repos || []) {
+            const wsRepoPath = resolve(wsDir, ws.id || ws.name || "", repo.name);
+            if (wsRepoPath !== repoRoot && existsSync(wsRepoPath)) {
+              const wsResult = ensureRepoConfigs(wsRepoPath);
+              const anyChange = Object.values(wsResult).some((r) => r.created || r.updated);
+              if (anyChange) {
+                info(`Workspace repo: ${repo.name}`);
+                printRepoConfigSummary(wsResult, (msg) => console.log(msg));
+              }
+            }
+          }
+        }
+      } catch (wsErr) {
+        warn(`Could not update workspace repo configs: ${wsErr.message}`);
+      }
+    }
+  } catch (rcErr) {
+    warn(`Could not apply repo-level configs: ${rcErr.message}`);
+  }
+
   // ── Codex CLI config.toml ─────────────────────────────
   heading("Codex CLI Config");
 
@@ -4814,10 +4952,24 @@ async function writeConfigFiles({ env, configJson, repoRoot, configDir }) {
     const kanbanIsVk =
       (env.KANBAN_BACKEND || "internal").toLowerCase() === "vk" ||
       ["vk", "hybrid"].includes((env.EXECUTOR_MODE || "internal").toLowerCase());
+    // Derive primary SDK from executor configuration
+    const primaryExecutor = (configJson.executors || []).find(
+      (e) => e.role === "primary",
+    );
+    const executorToPrimarySdk = {
+      CODEX: "codex",
+      COPILOT: "copilot",
+      CLAUDE: "claude",
+    };
+    const primarySdk = primaryExecutor
+      ? executorToPrimarySdk[String(primaryExecutor.executor).toUpperCase()] || "codex"
+      : "codex";
+
     const tomlResult = ensureCodexConfig({
       vkBaseUrl,
       skipVk: !kanbanIsVk,
       dryRun: false,
+      primarySdk,
       env: {
         ...process.env,
         ...env,

package/ui/components/session-list.js

@@ -278,9 +278,9 @@ function SwipeableSessionItem({
     const x = e.clientX || e.touches?.[0]?.clientX || 0;
     currentX.current = x;
     const dx = x - startX.current;
-    // Only allow left swipe (negative), cap at -120
+    // Only allow left swipe (negative), cap at -140
     if (dx < 0) {
-      setOffset(Math.max(dx, -120));
+      setOffset(Math.max(dx, -140));
     } else {
       setOffset(0);
     }
@@ -290,7 +290,7 @@ function SwipeableSessionItem({
     swiping.current = false;
     if (offset < -50) {
       // Snap open to reveal actions
-      setOffset(-120);
+      setOffset(-140);
       if (onToggleActions) onToggleActions(s.id);
     } else {
       setOffset(0);
@@ -440,7 +440,7 @@ function SwipeableSessionItem({
               e.stopPropagation();
               if (onToggleActions) {
                 onToggleActions(s.id);
-                setOffset(-120);
+                setOffset(-140);
               }
             }}
           >

package/ui/components/shared.js

@@ -206,6 +206,8 @@ export function Modal({ title, open = true, onClose, children, contentClassName
   }, []);
 
   const handleTouchStart = useCallback((e) => {
+    // Don't intercept touches on the close button
+    if (e.target.closest?.(".modal-close-btn")) return;
     const el = contentRef.current;
     if (!el) return;
     const rect = el.getBoundingClientRect();
@@ -244,6 +246,8 @@ export function Modal({ title, open = true, onClose, children, contentClassName
 
   const handlePointerDown = useCallback((e) => {
     if (e.pointerType === "touch") return;
+    // Don't intercept clicks on the close button
+    if (e.target.closest?.(".modal-close-btn")) return;
     const el = contentRef.current;
     if (!el) return;
     const rect = el.getBoundingClientRect();

package/ui/components/workspace-switcher.js

@@ -469,19 +469,30 @@ export function WorkspaceSwitcher() {
 
   const activeWs = workspaces.value.find((ws) => ws.id === activeWorkspaceId.value);
   const wsList = workspaces.value;
+  const isLoading = workspacesLoading.value;
 
-  if (!wsList.length && !managerOpen) return null;
+  // Always render — even with no workspaces, show a manage button so users can add one
 
   return html`
     <div class="ws-switcher">
       <button
-        class="ws-switcher-btn"
-        onClick=${(e) => { e.stopPropagation(); haptic("light"); setOpen(!open); }}
-        title="Switch workspace"
+        class="ws-switcher-btn ${!wsList.length ? 'ws-switcher-btn-empty' : ''}"
+        onClick=${(e) => {
+          e.stopPropagation();
+          haptic("light");
+          if (!wsList.length) {
+            setManagerOpen(true);
+          } else {
+            setOpen(!open);
+          }
+        }}
+        title=${wsList.length ? "Switch workspace" : "Set up a workspace"}
       >
         <span class="ws-switcher-icon">⬡</span>
-        <span class="ws-switcher-name">${activeWs?.name || "Select Workspace"}</span>
-        <span class="ws-switcher-chevron ${open ? "open" : ""}">${open ? "▴" : "▾"}</span>
+        <span class="ws-switcher-name">
+          ${isLoading ? "Loading…" : (activeWs?.name || (wsList.length ? "Select Workspace" : "Set up workspace"))}
+        </span>
+        ${wsList.length ? html`<span class="ws-switcher-chevron ${open ? "open" : ""}">${open ? "▴" : "▾"}</span>` : null}
       </button>
 
       ${open && html`

package/ui/demo.html

@@ -237,6 +237,24 @@
       version: '0.26.2',
       tasks: { completed: 13, failed: 1, retried: 2, active: 2, queued: 3 },
       prs: { created: 15, merged: 11, pending: 2, ciFailures: 1 },
+      // counts consumed by dashboard metrics
+      counts: {
+        running: 2,
+        inprogress: 2,
+        inreview: 1,
+        review: 1,
+        done: 2,
+        todo: 2,
+        draft: 1,
+        error: 0,
+      },
+      backlog_remaining: 2,
+      // consumed by dashboard quality section
+      success_metrics: {
+        first_shot_rate: 72,
+        needed_fix: 3,
+        failed: 1,
+      },
     };
 
     const SEED_EXECUTORS = [
@@ -668,7 +686,7 @@
       if (route === '/api/status')
         return { data: STATE.status };
       if (route === '/api/executor')
-        return { data: { ...STATE.status, maxParallel: STATE.maxParallel, paused: STATE.paused, executors: STATE.executors } };
+        return { data: { ...STATE.status, maxParallel: STATE.maxParallel, paused: STATE.paused, executors: STATE.executors, activeSlots: STATE.executors.filter(e => e.status === 'active').length, sdk: 'auto' } };
       if (route === '/api/telemetry/summary')
         return { data: { status: 'ok', updatedAt: Date.now(), totals: { tasks: STATE.tasks.length, executors: STATE.executors.length } } };
       if (route === '/api/telemetry/errors')

package/ui/styles/sessions.css

@@ -953,7 +953,8 @@
   position: absolute;
   left: 0;
   right: 0;
-  bottom: 16px;
+  /* position above the input bar (~60px) + gap */
+  bottom: 72px;
   display: flex;
   justify-content: center;
   pointer-events: none;
@@ -1585,8 +1586,8 @@ ul.md-list li::before {
   justify-content: center;
   border: none;
   cursor: pointer;
-  padding: 0 16px;
-  min-width: 60px;
+  padding: 0 10px;
+  min-width: 68px;
   font-size: 11px;
   font-family: inherit;
   gap: 2px;
@@ -1627,6 +1628,7 @@ ul.md-list li::before {
   font-weight: 600;
   text-transform: uppercase;
   letter-spacing: 0.3px;
+  white-space: nowrap;
 }
 
 @keyframes session-pulse {

package/ui/styles/workspace-switcher.css

@@ -27,6 +27,17 @@
   border-color: var(--color-primary, #10b981);
 }
 
+.ws-switcher-btn.ws-switcher-btn-empty {
+  border-style: dashed;
+  opacity: 0.8;
+  font-style: italic;
+}
+
+.ws-switcher-btn.ws-switcher-btn-empty:hover {
+  opacity: 1;
+  font-style: normal;
+}
+
 .ws-switcher-icon {
   font-size: 14px;
   opacity: 0.7;
@@ -660,6 +671,16 @@
   to { transform: rotate(360deg); }
 }
 
+/* ── Modal toolbar (inside shared Modal body) ──────────────── */
+.ws-manager-modal-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 12px;
+  padding-bottom: 12px;
+  border-bottom: 1px solid var(--border);
+}
+
 /* ── Responsive ──────────────────────────────────────────── */
 @media (max-width: 540px) {
   .ws-manager-panel {

package/ui/tabs/dashboard.js

@@ -521,39 +521,33 @@ export function DashboardTab() {
               `,
             )}
           </div>
-        <//>
-
-        <${Card}
-          title=${html`<span class="dashboard-card-title"
-            ><span class="dashboard-title-icon">${ICONS.check}</span>Active Work</span
-          >`}
-          className="dashboard-card dashboard-active"
-        >
-          <div class="dashboard-work-layout">
-            <div class="dashboard-work-list">
-              ${workItems.map(
-                (item) => html`
-                  <div class="dashboard-work-item">
-                    <div class="dashboard-work-left">
-                      <span
-                        class="dashboard-work-dot"
-                        style="background: ${item.color}"
-                      ></span>
-                      <span class="dashboard-work-label">${item.label}</span>
+          ${segments.length > 0 && html`
+            <div class="dashboard-work-layout" style="margin-top:12px;padding-top:12px;border-top:1px solid var(--border)">
+              <div class="dashboard-work-list">
+                ${workItems.map(
+                  (item) => html`
+                    <div class="dashboard-work-item">
+                      <div class="dashboard-work-left">
+                        <span
+                          class="dashboard-work-dot"
+                          style="background: ${item.color}"
+                        ></span>
+                        <span class="dashboard-work-label">${item.label}</span>
+                      </div>
+                      <span class="dashboard-work-value">${item.value}</span>
                     </div>
-                    <span class="dashboard-work-value">${item.value}</span>
-                  </div>
-                `,
-              )}
-            </div>
-            <div class="dashboard-work-chart">
-              <${DonutChart} segments=${segments} size=${110} strokeWidth=${10} />
-              <div class="dashboard-work-meta">
-                Active progress · ${progressPct}% engaged
+                  `,
+                )}
+              </div>
+              <div class="dashboard-work-chart">
+                <${DonutChart} segments=${segments} size=${90} strokeWidth=${9} />
+                <div class="dashboard-work-meta">
+                  ${progressPct}% engaged
+                </div>
+                <${ProgressBar} percent=${progressPct} />
               </div>
-              <${ProgressBar} percent=${progressPct} />
             </div>
-          </div>
+          `}
         <//>
 
         <${Card}
@@ -683,8 +677,8 @@ export function DashboardTab() {
                           ${truncate(task.title || "(untitled)", 50)}
                         </div>
                         <div class="meta-text">
-                          ${task.id}${task.updated_at
-                            ? ` · ${formatRelative(task.updated_at)}`
+                          ${task.id}${(task.updated_at || task.updated)
+                            ? ` · ${formatRelative(task.updated_at || task.updated)}`
                             : ""}
                         </div>
                       </div>

package/ui/tabs/tasks.js

@@ -89,6 +89,15 @@ const SORT_OPTIONS = [
   { value: "title", label: "Title" },
 ];
 
+/* Maps snapshot-bar labels → tasksFilter values */
+const SNAPSHOT_STATUS_MAP = {
+  Backlog: "todo",
+  Active: "inprogress",
+  Review: "inreview",
+  Done: "done",
+  Errors: "error",
+};
+
 const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3, "": 4 };
 
 const SYSTEM_TAGS = new Set([
@@ -994,8 +1003,10 @@ export function TasksTab() {
         return dir * (av - bv);
       }
       if (listSortCol === "updated") {
-        av = a.updated_at ? new Date(a.updated_at).getTime() : 0;
-        bv = b.updated_at ? new Date(b.updated_at).getTime() : 0;
+        const tsA = a.updated_at || a.updated;
+        const tsB = b.updated_at || b.updated;
+        av = tsA ? (typeof tsA === 'number' ? tsA : new Date(tsA).getTime()) : 0;
+        bv = tsB ? (typeof tsB === 'number' ? tsB : new Date(tsB).getTime()) : 0;
         return dir * (av - bv);
       }
       if (listSortCol === "status") { av = a.status || ""; bv = b.status || ""; }
@@ -1609,11 +1620,20 @@ export function TasksTab() {
 
     <div class="snapshot-bar">
       ${summaryMetrics.map((m) => html`
-        <span key=${m.label} class="snapshot-pill">
+        <button
+          key=${m.label}
+          class="snapshot-pill snapshot-pill-btn ${!isKanban && filterVal === SNAPSHOT_STATUS_MAP[m.label] ? 'snapshot-pill-active' : ''}"
+          onClick=${() => {
+            if (isKanban) return;
+            const statusVal = SNAPSHOT_STATUS_MAP[m.label];
+            if (statusVal !== undefined) handleFilter(filterVal === statusVal ? 'all' : statusVal);
+          }}
+          title=${isKanban ? m.label : `Filter by ${m.label}`}
+        >
           <span class="snapshot-dot" style="background:${m.color};" />
           <strong class="snapshot-val">${m.value}</strong>
           <span class="snapshot-lbl">${m.label}</span>
-        </span>
+        </button>
       `)}
       <span class="snapshot-view-tag">${isKanban ? "⬛ Board" : "☰ List"}</span>
     </div>
@@ -1632,6 +1652,23 @@ export function TasksTab() {
         cursor:pointer;
       }
       .actions-dropdown-item:hover { background:var(--hover-bg, rgba(255,255,255,.08)); }
+      .snapshot-pill-btn {
+        background: none;
+        border: 1px solid transparent;
+        border-radius: 999px;
+        cursor: pointer;
+        padding: 2px 8px;
+        transition: border-color 0.15s, background 0.15s;
+        font: inherit;
+      }
+      .snapshot-pill-btn:hover {
+        border-color: var(--border);
+        background: var(--bg-card-hover, rgba(255,255,255,0.05));
+      }
+      .snapshot-pill-active {
+        border-color: var(--accent) !important;
+        background: rgba(59,130,246,0.12) !important;
+      }
       @media (max-width: 640px) {
         .actions-label { display:none; }
       }
@@ -1706,8 +1743,8 @@ export function TasksTab() {
                       : html`<span class="task-td-empty">—</span>`}
                   </td>
                   <td class="task-td task-td-updated">
-                    ${task.updated_at
-                      ? html`<span class="task-td-date">${formatRelative(task.updated_at)}</span>`
+                    ${(task.updated_at || task.updated)
+                      ? html`<span class="task-td-date">${formatRelative(task.updated_at || task.updated)}</span>`
                       : html`<span class="task-td-empty">—</span>`}
                   </td>
                 </tr>

package/workspace-manager.mjs

@@ -26,6 +26,39 @@ import { execSync, spawnSync } from "node:child_process";
 
 const TAG = "[workspace-manager]";
 
+// Lazy-loaded reference to repo-config.mjs (resolved on first use)
+let _repoConfigModule = null;
+
+/**
+ * Ensure repo-level AI executor configs exist after clone/pull.
+ * Uses synchronous import cache — repo-config.mjs is pure sync.
+ * @param {string} repoPath  Absolute path to the repo directory
+ */
+function ensureRepoAIConfigs(repoPath) {
+  try {
+    if (!_repoConfigModule) {
+      // repo-config.mjs is ESM but fully synchronous internally.
+      // We pre-populate the cache via dynamic import at module init.
+      return; // Will be populated after first async import
+    }
+    const { ensureRepoConfigs, printRepoConfigSummary } = _repoConfigModule;
+    const result = ensureRepoConfigs(repoPath);
+    // Only log if something was created/updated
+    const anyChange = Object.values(result).some((r) => r.created || r.updated);
+    if (anyChange) {
+      console.log(TAG, `Repo-level AI configs for ${basename(repoPath)}:`);
+      printRepoConfigSummary(result, (msg) => console.log(TAG, msg));
+    }
+  } catch (err) {
+    console.warn(TAG, `Could not ensure repo AI configs: ${err.message}`);
+  }
+}
+
+// Pre-load repo-config.mjs asynchronously at module init time
+import("./repo-config.mjs")
+  .then((mod) => { _repoConfigModule = mod; })
+  .catch(() => { /* repo-config not available — skip */ });
+
 // ── Path Helpers ─────────────────────────────────────────────────────────────
 
 /**
@@ -313,8 +346,12 @@ export function addRepoToWorkspace(configDir, workspaceId, { url, name, branch,
     }
     cloned = true;
     console.log(TAG, `Cloned ${repoName} successfully`);
+    // Ensure repo-level AI executor configs exist after fresh clone
+    ensureRepoAIConfigs(repoPath);
   } else {
     console.log(TAG, `Repository ${repoName} already exists at ${repoPath}`);
+    // Ensure repo-level configs are up to date even for existing repos
+    ensureRepoAIConfigs(repoPath);
   }
 
   const slug = extractSlug(url);