@fro.bot/systematic 2.10.0 → 2.11.0

package/README.md

@@ -338,6 +338,8 @@ Systematic separates config-source precedence from overlay precedence. Config fi
 
 Source category model defaults are primary model choices only — they are not fallback chains. Systematic does not support `fallback_models`, inherited retry semantics, runtime fallback behavior, or fallback to the parent model when a source model is unavailable. Explicit and source model IDs are structurally validated and may still fail at OpenCode runtime if the provider or model is unavailable.
 
+Source category model defaults are now ordered preference arrays per category rather than single strings. At plugin load, Systematic reads OpenCode's authentication state from `auth.json` and selects the first array entry whose provider is authenticated. For example, the `review` category defaults to `['anthropic/claude-opus-4.7', 'openai/gpt-5.5']` — a user authenticated only to OpenAI receives `openai/gpt-5.5` (first match), while a user authenticated to Anthropic (or both) receives the more preferred `anthropic/claude-opus-4.7`. If no array entry's provider is authenticated, the first entry is used as the default. The arrays are an ordered preference list, not a runtime fallback chain — `fallback_models` is still not supported.
+
 If you want to restore OpenCode parent-model inheritance for a bundled agent or category (opting out of the source default), set `"model": null` in high-trust user or `$OPENCODE_CONFIG_DIR/systematic.json` config. Project config cannot use `model: null` — project config cannot set, erase, or shadow `model` at any value.
 
 The source defaults are:

package/dist/index.js

@@ -78,14 +78,15 @@ ${toolMapping}
 
 // src/lib/agent-overlays.ts
 import fs2 from "fs";
+import os2 from "os";
 import path2 from "path";
 var SOURCE_CATEGORY_MODEL_DEFAULTS = {
-  design: "openai/gpt-5.5",
-  docs: "openai/gpt-5.4-mini",
-  "document-review": "anthropic/claude-opus-4.7",
-  research: "openai/gpt-5.5",
-  review: "anthropic/claude-opus-4.7",
-  workflow: "openai/gpt-5.4-mini"
+  design: ["openai/gpt-5.5", "anthropic/claude-opus-4.7"],
+  docs: ["openai/gpt-5.4-mini", "anthropic/claude-haiku-4-5"],
+  "document-review": ["anthropic/claude-opus-4.7", "openai/gpt-5.5"],
+  research: ["openai/gpt-5.5", "anthropic/claude-opus-4.7"],
+  review: ["anthropic/claude-opus-4.7", "openai/gpt-5.5"],
+  workflow: ["openai/gpt-5.4-mini", "anthropic/claude-haiku-4-5"]
 };
 var ALLOWED_OVERLAY_FIELDS = new Set([
   "model",
@@ -166,10 +167,51 @@ function inferBuiltInTemperature(name, description) {
   }
   return 0.3;
 }
-function getSourceCategoryModel(category) {
+function getAuthenticatedProviders(rootDirOverride) {
+  const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+  const rootDir = rootDirOverride || (xdgDataHome && path2.isAbsolute(xdgDataHome) ? xdgDataHome : path2.join(os2.homedir(), ".local/share"));
+  const authPath = path2.join(rootDir, "opencode", "auth.json");
+  let raw;
+  try {
+    raw = fs2.readFileSync(authPath, "utf8");
+  } catch (err) {
+    if (isSystemError(err) && err.code === "ENOENT") {
+      return new Set;
+    }
+    console.warn(`[systematic] auth.json unreadable at ${authPath}; ignoring`);
+    return new Set;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.warn(`[systematic] auth.json malformed at ${authPath}; ignoring`);
+    return new Set;
+  }
+  if (!isRecord(parsed)) {
+    console.warn(`[systematic] auth.json malformed at ${authPath}; ignoring`);
+    return new Set;
+  }
+  return new Set(Object.keys(parsed));
+}
+function getSourceCategoryModel(category, authedProviders) {
   if (!category)
     return;
-  return SOURCE_CATEGORY_MODEL_DEFAULTS[category];
+  const candidates = SOURCE_CATEGORY_MODEL_DEFAULTS[category];
+  if (!candidates || candidates.length === 0)
+    return;
+  if (!authedProviders || authedProviders.size === 0)
+    return candidates[0];
+  for (const entry of candidates) {
+    const slashIndex = entry.indexOf("/");
+    if (slashIndex <= 0)
+      continue;
+    const providerId = entry.slice(0, slashIndex);
+    if (authedProviders.has(providerId)) {
+      return entry;
+    }
+  }
+  return candidates[0];
 }
 function assertSourceCategoryModelCoverage(categories) {
   validateSourceCategoryModelDefaults();
@@ -179,8 +221,16 @@ function assertSourceCategoryModelCoverage(categories) {
   }
 }
 function validateSourceCategoryModelDefaults(defaults = SOURCE_CATEGORY_MODEL_DEFAULTS) {
-  for (const [category, model] of Object.entries(defaults)) {
-    validateModel("source category model defaults", `source category model defaults.${category}`, model);
+  for (const [category, value] of Object.entries(defaults)) {
+    if (!Array.isArray(value)) {
+      throw new Error(`Source category model defaults: ${category} must be a non-empty array of provider/model strings`);
+    }
+    if (value.length === 0) {
+      throw new Error(`Source category model defaults: ${category} must be a non-empty array of provider/model strings`);
+    }
+    for (const [index, model] of value.entries()) {
+      validateModel("source category model defaults", `source category model defaults.${category}[${index}]`, model);
+    }
   }
 }
 function validateExactAgentOverlays(inventory, overlays, nativeAgents, enabledSkills) {
@@ -398,6 +448,9 @@ function validAgentKeys(inventory) {
 function throwConfigError(sourcePath, keyPath, message) {
   throw new Error(`Invalid Systematic config in ${sourcePath}: ${keyPath} ${message}`);
 }
+function isSystemError(err) {
+  return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string";
+}
 
 // src/lib/skill-loader.ts
 import path3 from "path";
@@ -567,7 +620,7 @@ function loadSkillAsCommand(loaded) {
     config.subtask = loaded.subtask;
   return config;
 }
-function collectAgents(dir, disabledAgents, nativeAgents, overlays) {
+function collectAgents(dir, disabledAgents, nativeAgents, overlays, authedProviders) {
   const agents = {};
   const agentList = findAgentsInDir(dir);
   const disabledSet = new Set(disabledAgents);
@@ -582,12 +635,12 @@ function collectAgents(dir, disabledAgents, nativeAgents, overlays) {
       continue;
     const config = loadAgentAsConfig(agentInfo);
     if (config) {
-      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays);
+      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays, authedProviders);
     }
   }
   return agents;
 }
-function applyAgentOverlays(config, agentInfo, overlays) {
+function applyAgentOverlays(config, agentInfo, overlays, authedProviders) {
   const id = agentInfo.category ? `${agentInfo.category}/${agentInfo.name}` : agentInfo.name;
   const categoryOverlay = agentInfo.category ? overlays.categoriesByKey.get(agentInfo.category) : undefined;
   const exactOverlay = overlays.agentsByTargetId.get(id);
@@ -599,7 +652,7 @@ function applyAgentOverlays(config, agentInfo, overlays) {
   }
   result.temperature = inferBuiltInTemperature(agentInfo.name, result.description);
   if (agentInfo.category) {
-    const sourceModel = getSourceCategoryModel(agentInfo.category);
+    const sourceModel = getSourceCategoryModel(agentInfo.category, authedProviders);
     if (sourceModel) {
       result.model = sourceModel;
     }
@@ -729,6 +782,7 @@ function collectEnabledSkillNames(dir, disabledSkills) {
 }
 function createConfigHandler(deps) {
   const { directory, bundledSkillsDir, bundledAgentsDir, bundledCommandsDir } = deps;
+  const readAuthProviders = deps.getAuthenticatedProviders ?? getAuthenticatedProviders;
   return async (config) => {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
     const existingAgents = { ...config.agent ?? {} };
@@ -744,7 +798,8 @@ function createConfigHandler(deps) {
       enabledSkills: enabledSkillNames
     });
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
-    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents, existingAgents, resolvedOverlays);
+    const authedProviders = readAuthProviders();
+    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents, existingAgents, resolvedOverlays, authedProviders);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
     config.agent = {
       ...bundledAgents,

package/dist/lib/agent-overlays.d.ts

@@ -42,6 +42,27 @@ export declare function buildBundledAgentInventory(agentsDir: string, disabledAg
 export declare function validateAgentOverlays({ inventory, overlays, nativeAgents, enabledSkills, }: ValidateAgentOverlaysOptions): ValidatedAgentOverlays;
 export declare function resolveAgentOverlaySet(overlays: ValidatedAgentOverlays): ResolvedAgentOverlaySet;
 export declare function inferBuiltInTemperature(name: string, description?: string): number;
-export declare function getSourceCategoryModel(category: string | undefined): string | undefined;
+/**
+ * Read which providers are authenticated from OpenCode's auth.json.
+ *
+ * Reads only top-level keys (provider IDs). Nested values are NEVER
+ * inspected, logged, persisted, or transmitted. This is a hard contract:
+ * the auth file holds API keys and OAuth tokens, and Systematic must
+ * never expose them via stderr, telemetry, or any other channel.
+ *
+ * Intended for one invocation per plugin config(cfg) cycle. Repeated
+ * calls trigger repeated file reads and, on malformed input, repeated
+ * stderr diagnostics.
+ *
+ * @param rootDirOverride - Optional path override for tests. When
+ *   non-empty, the auth file is resolved as
+ *   `path.join(rootDirOverride, 'opencode', 'auth.json')`. When
+ *   omitted, resolution follows XDG_DATA_HOME -> ~/.local/share
+ *   convention.
+ * @returns A readonly set of authenticated provider IDs (empty set on
+ *   any failure).
+ */
+export declare function getAuthenticatedProviders(rootDirOverride?: string): ReadonlySet<string>;
+export declare function getSourceCategoryModel(category: string | undefined, authedProviders?: ReadonlySet<string>): string | undefined;
 export declare function assertSourceCategoryModelCoverage(categories: string[]): void;
 export declare function validateSourceCategoryModelDefaults(defaults?: Record<string, unknown>): void;

package/dist/lib/config-handler.d.ts

@@ -4,6 +4,8 @@ export interface ConfigHandlerDeps {
     bundledSkillsDir: string;
     bundledAgentsDir: string;
     bundledCommandsDir: string;
+    /** Override for authenticated provider reader; for testing. */
+    getAuthenticatedProviders?: (rootDirOverride?: string) => ReadonlySet<string>;
 }
 export declare function toTitleCase(name: string): string;
 export declare function formatAgentDescription(name: string, description: string | undefined): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "homepage": "https://fro.bot/systematic",