bosun 0.42.0 → 0.42.2

package/shell/codex-config.mjs

@@ -1329,10 +1329,40 @@ function buildModelProviderSection(providerName, config = {}) {
   return lines.join("\n");
 }
 
+/**
+ * Codex CLI built-in provider IDs that cannot be used in [model_providers.*].
+ * Declaring these in config.toml causes a fatal "reserved built-in provider"
+ * error on Codex CLI >=0.x (March 2026+).
+ */
+const CODEX_RESERVED_PROVIDER_IDS = new Set(["openai"]);
+
+/**
+ * Migrate legacy [model_providers.openai] sections that Bosun previously
+ * generated.  Newer Codex CLI versions reject this ID as a reserved built-in.
+ * We rename it to "openai-direct" so existing timeout / retry settings
+ * are preserved without triggering the error.
+ */
+function migrateReservedProviderIds(toml) {
+  const migrated = [];
+  for (const reserved of CODEX_RESERVED_PROVIDER_IDS) {
+    const header = `[model_providers.${reserved}]`;
+    if (toml.includes(header)) {
+      const replacement = `[model_providers.${reserved}-direct]`;
+      toml = toml.replace(header, replacement);
+      migrated.push({ from: reserved, to: `${reserved}-direct` });
+    }
+  }
+  return { toml, migrated };
+}
+
 function ensureModelProviderSectionsFromEnv(toml, env = process.env) {
   const added = [];
   const { env: resolvedEnv, active } = resolveCodexProfileRuntime(env);
 
+  // Migrate any legacy reserved provider IDs before adding new sections
+  const migration = migrateReservedProviderIds(toml);
+  toml = migration.toml;
+
   const activeProvider = String(active?.provider || "").toLowerCase();
   const activeBaseUrl =
     active?.baseUrl ||
@@ -1363,15 +1393,11 @@ function ensureModelProviderSectionsFromEnv(toml, env = process.env) {
     }
   }
 
-  if (!hasModelProviderSection(toml, "openai")) {
-    toml += buildModelProviderSection("openai", {
-      name: "OpenAI",
-      envKey: "OPENAI_API_KEY",
-    });
-    added.push("openai");
-  }
+  // NOTE: Do NOT add [model_providers.openai] — it is a Codex built-in.
+  // The built-in already handles OPENAI_API_KEY.  Declaring it causes:
+  //   "model_providers contains reserved built-in provider IDs: openai"
 
-  return { toml, added };
+  return { toml, added, migrated: migration.migrated };
 }
 
 /**

package/task/task-cli.mjs

@@ -25,11 +25,15 @@
  *   taskStats()           — Programmatic stats
  */
 
-import { resolve, dirname } from "node:path";
+import { resolve, dirname, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { readFileSync, existsSync, statSync } from "node:fs";
 import { randomUUID } from "node:crypto";
+import {
+  normalizeWorkspaceStorageKey,
+  normalizeWorkspaceStorageKeys,
+} from "./task-store.mjs";
 import { getTaskLifetimeTotals } from "../infra/runtime-accumulator.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -56,6 +60,20 @@ function normalizeStorePath(pathLike) {
     : resolvedPath;
 }
 
+function rethrowKeyCollision(err) {
+  if (err?.code === "TASK_STORE_KEY_COLLISION") {
+    throw err;
+  }
+}
+
+function normalizeStoreScopeKey(value) {
+  return normalizeWorkspaceStorageKey(value);
+}
+
+function assertNoStoreKeyCollisions(values, kind) {
+  normalizeWorkspaceStorageKeys(values, { kind });
+}
+
 function ensureStore() {
   if (_storeReady) return;
   // Import is sync-cached after first call
@@ -115,16 +133,42 @@ function resolveKanbanStorePath() {
       if (existsSync(configPath)) {
         const cfg = JSON.parse(readFileSync(configPath, "utf8"));
         const workspacesDir = cfg.workspacesDir || resolve(bosunHome, "workspaces");
-        const activeWs = cfg.activeWorkspace;
+        const activeWs = String(cfg?.activeWorkspace || "").trim();
+        const workspaceEntries = Array.isArray(cfg?.workspaces) ? cfg.workspaces : [];
+        assertNoStoreKeyCollisions(
+          workspaceEntries.map((entry) => entry?.id),
+          "bosun.config.workspaces",
+        );
         if (activeWs && workspacesDir) {
-          const ws = (cfg.workspaces || []).find((w) => w.id === activeWs);
-          const primaryRepoName =
-            ws?.activeRepo ||
-            (cfg.repos || []).find((r) => r.primary)?.name;
+          const activeWorkspaceKey = normalizeStoreScopeKey(activeWs);
+          const ws =
+            workspaceEntries.find(
+              (entry) => normalizeStoreScopeKey(entry?.id) === activeWorkspaceKey,
+            ) || null;
+          const repos = Array.isArray(ws?.repos) ? ws.repos : [];
+          assertNoStoreKeyCollisions(
+            repos.map((repo) => repo?.slug || repo?.name),
+            "bosun.config.repos",
+          );
+          const activeRepoKey = normalizeStoreScopeKey(ws?.activeRepo);
+          const selectedRepo =
+            (activeRepoKey
+              ? repos.find(
+                  (repo) =>
+                    normalizeStoreScopeKey(repo?.slug || repo?.name)
+                    === activeRepoKey,
+                )
+              : null) ||
+            repos.find((repo) => repo?.primary) ||
+            null;
+          const fallbackRepoName = (cfg.repos || []).find((r) => r.primary)?.name;
+          const primaryRepoName = normalizeStoreScopeKey(
+            selectedRepo?.name || selectedRepo?.slug || fallbackRepoName,
+          );
           if (primaryRepoName) {
             const wsStorePath = resolve(
               workspacesDir,
-              activeWs,
+              activeWorkspaceKey,
               primaryRepoName,
               ".bosun",
               ".cache",
@@ -140,7 +184,8 @@ function resolveKanbanStorePath() {
         }
       }
     }
-  } catch {
+  } catch (err) {
+    rethrowKeyCollision(err);
     // fall through to legacy CWD-based resolution
   }
 
@@ -155,31 +200,46 @@ function resolveActiveWorkspaceDefaults() {
     const configPath = resolve(bosunHome, "bosun.config.json");
     if (!existsSync(configPath)) return { workspace: "", repository: "" };
     const cfg = JSON.parse(readFileSync(configPath, "utf8"));
-    const activeWsId = String(cfg?.activeWorkspace || "").trim();
+    const activeWsId = normalizeStoreScopeKey(cfg?.activeWorkspace);
     const workspaces = Array.isArray(cfg?.workspaces) ? cfg.workspaces : [];
+    assertNoStoreKeyCollisions(
+      workspaces.map((entry) => entry?.id),
+      "bosun.config.workspaces",
+    );
     const workspace =
       (activeWsId
-        ? workspaces.find((entry) => String(entry?.id || "").trim() === activeWsId)
+        ? workspaces.find(
+            (entry) => normalizeStoreScopeKey(entry?.id) === activeWsId,
+          )
         : null) ||
       workspaces[0] ||
       null;
     const repos = Array.isArray(workspace?.repos) ? workspace.repos : [];
-    const activeRepoName = String(workspace?.activeRepo || "").trim();
+    assertNoStoreKeyCollisions(
+      repos.map((repo) => repo?.slug || repo?.name),
+      "bosun.config.repos",
+    );
+    const activeRepoName = normalizeStoreScopeKey(workspace?.activeRepo);
     const selectedRepo =
       (activeRepoName
-        ? repos.find((repo) => String(repo?.name || "").trim() === activeRepoName)
+        ? repos.find(
+            (repo) =>
+              normalizeStoreScopeKey(repo?.slug || repo?.name)
+              === activeRepoName,
+          )
         : null) ||
       repos.find((repo) => repo?.primary) ||
       repos[0] ||
       null;
-    const repository = String(
+    const repository = normalizeStoreScopeKey(
       selectedRepo?.slug || selectedRepo?.name || "",
-    ).trim();
+    );
     return {
-      workspace: String(workspace?.id || activeWsId || "").trim(),
+      workspace: normalizeStoreScopeKey(workspace?.id || activeWsId || ""),
       repository,
     };
-  } catch {
+  } catch (err) {
+    rethrowKeyCollision(err);
     return { workspace: "", repository: "" };
   }
 }
@@ -248,6 +308,10 @@ function isDebugModeEnabled(args = []) {
  */
 export async function taskCreate(data) {
   const store = await initStore();
+  const normalizeKey = store.normalizeWorkspaceStorageKey || normalizeStoreScopeKey;
+  const normalizeKeys =
+    store.normalizeWorkspaceStorageKeys
+    || ((values, options = {}) => normalizeWorkspaceStorageKeys(values, options));
   const id = data.id || randomUUID();
   const parsedCandidateCount = Number(data?.candidateCount);
   const candidateCount = Number.isFinite(parsedCandidateCount)
@@ -268,6 +332,16 @@ export async function taskCreate(data) {
     inputMeta.execution = executionMeta;
   }
   const defaults = resolveActiveWorkspaceDefaults();
+  const rawWorkspace = data.workspace || defaults.workspace || process.cwd();
+  const workspaceKey = normalizeKey(rawWorkspace);
+  const workspaceValue = typeof rawWorkspace === "string" && isAbsolute(rawWorkspace)
+    ? rawWorkspace
+    : (workspaceKey || null);
+  const repositoryKey = normalizeKey(data.repository || defaults.repository || "");
+  const repositoryKeys = normalizeKeys(
+    [repositoryKey, ...(Array.isArray(data.repositories) ? data.repositories : [])],
+    { kind: `task-cli:create:${id}:repositories` },
+  );
   const taskData = {
     id,
     title: data.title,
@@ -277,9 +351,9 @@ export async function taskCreate(data) {
     priority: data.priority || "medium",
     tags: normalizeTags(data.tags),
     baseBranch: data.baseBranch || data.base_branch || "main",
-    workspace: data.workspace || defaults.workspace || process.cwd(),
-    repository: data.repository || defaults.repository || "",
-    repositories: data.repositories || [],
+    workspace: workspaceValue,
+    repository: repositoryKey || null,
+    repositories: repositoryKeys,
     candidateCount: candidateCount && candidateCount > 1 ? candidateCount : undefined,
     meta: inputMeta,
   };