@fro.bot/systematic 3.9.0 → 3.10.0

package/dist/index.js

@@ -14,125 +14,18 @@ import {
   loadConfig,
   loadConfigWithSources,
   parseFrontmatter
-} from "./index-hjbt4p5s.js";
+} from "./index-y8nc60tz.js";
 
 // src/index.ts
-import { createHash as createHash5 } from "crypto";
-import fs11 from "fs";
-import path10 from "path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
+import { createHash as createHash4 } from "crypto";
+import fs10 from "fs";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 
 // src/lib/bootstrap.ts
-import fs3 from "fs";
-import os from "os";
-import path2 from "path";
-
-// src/lib/skill-catalog.ts
-import { pathToFileURL } from "url";
-
-// src/lib/skill-loader.ts
 import fs2 from "fs";
+import os from "os";
 import path from "path";
-var SKILL_PREFIX = "systematic:";
-var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
-function formatSkillCommandName(name2) {
-  if (name2.includes(":")) {
-    return name2;
-  }
-  return `${SKILL_PREFIX}${name2}`;
-}
-function formatSkillDescription(description, fallbackName) {
-  const desc = description || `${fallbackName} skill`;
-  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
-    return desc;
-  }
-  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
-}
-function wrapSkillTemplate(skillPath, body2) {
-  const skillDir = path.dirname(skillPath);
-  return `<skill-instruction>
-Base directory for this skill: ${skillDir}/
-File references (@path) in this skill are relative to this directory.
-
-${body2.trim()}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`;
-}
-function extractSkillBody(wrappedTemplate) {
-  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
-  return match ? match[1].trim() : wrappedTemplate;
-}
-function loadSkill(skillInfo) {
-  try {
-    const content = fs2.readFileSync(skillInfo.skillFile, "utf8");
-    const { body: body2 } = parseFrontmatter(content);
-    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body2);
-    return {
-      name: skillInfo.name,
-      prefixedName: formatSkillCommandName(skillInfo.name),
-      description: formatSkillDescription(skillInfo.description, skillInfo.name),
-      path: skillInfo.path,
-      skillFile: skillInfo.skillFile,
-      wrappedTemplate,
-      disableModelInvocation: skillInfo.disableModelInvocation,
-      userInvocable: skillInfo.userInvocable,
-      subtask: skillInfo.subtask,
-      agent: skillInfo.agent,
-      model: skillInfo.model,
-      argumentHint: skillInfo.argumentHint
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/skill-catalog.ts
-function escapeXml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildCatalogEntries(options) {
-  const { bundledSkillsDir, disabledSkills } = options;
-  return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name)).map((s) => ({
-    name: s.name,
-    prefixedName: formatSkillCommandName(s.name),
-    description: s.description,
-    path: s.path,
-    skillFile: s.skillFile
-  }));
-}
-function renderCatalogVerbose(options) {
-  const entries = buildCatalogEntries(options);
-  if (entries.length === 0)
-    return "";
-  const skillLines = entries.flatMap((entry) => [
-    "  <skill>",
-    `    <name>${escapeXml(entry.prefixedName)}</name>`,
-    `    <description>${escapeXml(entry.description)}</description>`,
-    `    <location>${pathToFileURL(entry.path).href}</location>`,
-    "  </skill>"
-  ]);
-  return ["<available_skills>", ...skillLines, "</available_skills>"].join(`
-`);
-}
-function renderCatalogCompact(options) {
-  const entries = buildCatalogEntries(options);
-  const heading = "## Available Systematic Skills";
-  if (entries.length === 0) {
-    return `${heading}
-
-No Systematic skills are currently available.`;
-  }
-  const bullets = entries.map((entry) => `- ${entry.prefixedName}: ${entry.description}`).join(`
-`);
-  return `${heading}
-
-${bullets}`;
-}
-
-// src/lib/bootstrap.ts
 var INTERNAL_AGENT_SIGNATURES = [
   "You are a title generator",
   "You are a helpful AI assistant tasked with summarizing conversations",
@@ -190,9 +83,9 @@ var applyBootstrapContent = (output, content) => {
 ${content}` : content;
 };
 function readHarnessProfile(bundledSkillsDir, name2) {
-  const profilePath = path2.join(bundledSkillsDir, "using-systematic/references", `${name2}-profile.md`);
+  const profilePath = path.join(bundledSkillsDir, "using-systematic/references", `${name2}-profile.md`);
   try {
-    return fs3.readFileSync(profilePath, "utf8");
+    return fs2.readFileSync(profilePath, "utf8");
   } catch (error) {
     console.error(`Failed to read harness profile ${profilePath}: ${error instanceof Error ? error.message : String(error)}`);
     return null;
@@ -216,25 +109,18 @@ function getBootstrapContent(config, deps) {
   if (!config.bootstrap.enabled)
     return null;
   if (config.bootstrap.file) {
-    const customPath = config.bootstrap.file.startsWith("~/") ? path2.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
-    if (fs3.existsSync(customPath)) {
-      return fs3.readFileSync(customPath, "utf8");
+    const customPath = config.bootstrap.file.startsWith("~/") ? path.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    if (fs2.existsSync(customPath)) {
+      return fs2.readFileSync(customPath, "utf8");
     }
   }
-  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs3.existsSync(usingSystematicPath))
+  const usingSystematicPath = path.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs2.existsSync(usingSystematicPath))
     return null;
-  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
+  const fullContent = fs2.readFileSync(usingSystematicPath, "utf8");
   const { body: body2 } = parseFrontmatter(fullContent);
   const content = body2.trim();
   const skillUsage = usageTemplate ?? getSkillUsageTemplate();
-  const catalog = renderCatalogVerbose({
-    bundledSkillsDir,
-    disabledSkills: config.disabled_skills
-  });
-  const catalogSection = catalog.length > 0 ? `
-
-${catalog}` : "";
   const profileSection = profileBlock === undefined ? "" : `
 
 ${profileBlock}`;
@@ -245,222 +131,32 @@ You have access to structured engineering workflows via the Systematic plugin.
 
 ${content}
 
-${skillUsage}${profileSection}${catalogSection}
+${skillUsage}${profileSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
 // src/lib/config-handler.ts
-import fs6 from "fs";
-import os3 from "os";
-import path6 from "path";
-
-// src/lib/agent-overlays.ts
-import fs4 from "fs";
+import fs5 from "fs";
+import os2 from "os";
 import path4 from "path";
 
-// src/lib/source-model-defaults.ts
-import * as path3 from "path";
-import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-var packageRoot = path3.resolve(__dirname2, "..", "..");
-var bundledAgentsDir = path3.join(packageRoot, "agents");
-var ProviderID = exports_external.union([
-  exports_external.literal("vercel"),
-  exports_external.literal("opencode"),
-  exports_external.literal("github-copilot"),
-  exports_external.literal("opencode-go"),
-  exports_external.literal("openai"),
-  exports_external.literal("anthropic"),
-  exports_external.literal("google")
-]);
-var variantSchema = exports_external.string().min(1, "variant must be a non-empty string").max(128, "variant must be at most 128 characters").regex(/^\S+$/, "variant must not contain whitespace");
-var tableCellSchema = exports_external.string().min(1, "must be a non-empty string").regex(/^[^|\r\n]+$/, "must not contain pipe (|) or newline characters \u2014 these break Markdown table generation");
-var ModelEntrySchema = exports_external.object({
-  model: exports_external.string().min(1, "model must be a non-empty string"),
-  variant: variantSchema.optional()
-}).strict();
-var ProviderEntrySchema = exports_external.object({
-  provider: ProviderID,
-  models: exports_external.array(ModelEntrySchema).min(1, "models must be non-empty \u2014 every provider entry must list at least one model")
-}).strict().refine((entry) => {
-  const seen = new Set;
-  for (const m of entry.models) {
-    const key = `${m.model}::${m.variant ?? ""}`;
-    if (seen.has(key))
-      return false;
-    seen.add(key);
-  }
-  return true;
-}, {
-  message: "duplicate (model, variant) pair within a provider entry \u2014 each model+variant combination must be unique"
-});
-var CategoryDefaultSchema = exports_external.object({
-  rationale: tableCellSchema,
-  whenToOverride: tableCellSchema.optional(),
-  providers: exports_external.array(ProviderEntrySchema).min(1, "providers must be non-empty \u2014 every category must list at least one provider")
-}).strict().refine((cat) => {
-  const seen = new Set;
-  for (const p of cat.providers) {
-    if (seen.has(p.provider))
-      return false;
-    seen.add(p.provider);
-  }
-  return true;
-}, {
-  message: "duplicate provider ID within a category \u2014 each provider must appear at most once per category"
-});
-var SourceCategoryDefaultsSchema = exports_external.record(exports_external.string(), CategoryDefaultSchema);
-var SOURCE_CATEGORY_MODEL_DEFAULTS = {
-  design: {
-    rationale: "High-judgment UX, product, and design work benefits from a strong general reasoning model with broad creative capability.",
-    whenToOverride: "Override to a faster/cheaper model when design tasks are primarily templating or low-stakes layout work.",
-    providers: [
-      {
-        provider: "github-copilot",
-        models: [{ model: "gemini-3.1-pro-preview" }]
-      },
-      {
-        provider: "openai",
-        models: [{ model: "gpt-5.5", variant: "high" }]
-      },
-      {
-        provider: "anthropic",
-        models: [{ model: "claude-opus-4-7", variant: "max" }]
-      },
-      {
-        provider: "vercel",
-        models: [{ model: "v0-1.5-md" }]
-      }
-    ]
-  },
-  "document-review": {
-    rationale: "Requirements and plan critique benefit from the strongest nuanced reasoning to surface non-obvious gaps and contradictions.",
-    providers: [
-      {
-        provider: "anthropic",
-        models: [{ model: "claude-opus-4-7", variant: "max" }]
-      },
-      {
-        provider: "openai",
-        models: [{ model: "gpt-5.5", variant: "high" }]
-      },
-      {
-        provider: "github-copilot",
-        models: [{ model: "gemini-3.1-pro-preview" }]
-      },
-      {
-        provider: "opencode",
-        models: [{ model: "claude-sonnet-4-6" }]
-      }
-    ]
-  },
-  research: {
-    rationale: "Tool-heavy synthesis and source evaluation benefit from a strong general reasoning model with broad knowledge.",
-    providers: [
-      {
-        provider: "openai",
-        models: [{ model: "gpt-5.4-mini" }]
-      },
-      {
-        provider: "anthropic",
-        models: [{ model: "claude-sonnet-4-6" }]
-      },
-      {
-        provider: "github-copilot",
-        models: [{ model: "gemini-3.1-pro-preview" }]
-      },
-      {
-        provider: "opencode",
-        models: [{ model: "claude-sonnet-4-6" }]
-      }
-    ]
-  },
-  review: {
-    rationale: "Code, security, and adversarial review benefits from the strongest reasoning to catch subtle bugs and security issues.",
-    whenToOverride: "Override to a faster model when review tasks are primarily style or formatting checks rather than correctness or security analysis.",
-    providers: [
-      {
-        provider: "anthropic",
-        models: [{ model: "claude-sonnet-4-6" }]
-      },
-      {
-        provider: "openai",
-        models: [{ model: "gpt-5.3-codex" }]
-      },
-      {
-        provider: "github-copilot",
-        models: [{ model: "gemini-3.1-pro-preview" }]
-      },
-      {
-        provider: "opencode",
-        models: [{ model: "claude-sonnet-4-6" }]
-      }
-    ]
-  },
-  workflow: {
-    rationale: "Orchestration and bounded implementation tasks should default cheaper and faster; strong reasoning is rarely needed for routing decisions.",
-    providers: [
-      {
-        provider: "openai",
-        models: [{ model: "gpt-5.4-mini" }]
-      },
-      {
-        provider: "anthropic",
-        models: [{ model: "claude-sonnet-4-6" }]
-      },
-      {
-        provider: "opencode",
-        models: [{ model: "claude-haiku-4-5" }]
-      },
-      {
-        provider: "opencode-go",
-        models: [{ model: "claude-haiku-4-5" }]
-      }
-    ]
-  }
-};
-function resolveSourceModel(category, availabilitySet) {
-  const categoryDefault = SOURCE_CATEGORY_MODEL_DEFAULTS[category];
-  if (!categoryDefault) {
-    throw new Error(`resolveSourceModel: unknown category "${category}". Valid categories: ${Object.keys(SOURCE_CATEGORY_MODEL_DEFAULTS).join(", ")}`);
-  }
-  for (const providerEntry of categoryDefault.providers) {
-    for (const modelEntry of providerEntry.models) {
-      const key = `${providerEntry.provider}/${modelEntry.model}`;
-      if (availabilitySet.has(key)) {
-        return {
-          provider: providerEntry.provider,
-          model: modelEntry.model,
-          variant: modelEntry.variant
-        };
-      }
-    }
-  }
-  const firstProvider = categoryDefault.providers[0];
-  const firstModel = firstProvider.models[0];
-  return {
-    provider: firstProvider.provider,
-    model: firstModel.model,
-    variant: firstModel.variant
-  };
-}
-
 // src/lib/agent-overlays.ts
+import fs3 from "fs";
+import path2 from "path";
 function buildBundledAgentInventory(agentsDir, disabledAgents) {
   const categories = readCategoryDirs(agentsDir);
   const agentsByQualifiedId = {};
   const stemCategories = new Map;
   const disabledSet = new Set(disabledAgents);
   for (const category of categories) {
-    for (const fileName of readMarkdownFiles(path4.join(agentsDir, category))) {
+    for (const fileName of readMarkdownFiles(path2.join(agentsDir, category))) {
       const key = fileName.replace(/\.md$/, "");
       const id = `${category}/${key}`;
       agentsByQualifiedId[id] = {
         id,
         key,
         category,
-        file: path4.join(agentsDir, category, fileName),
+        file: path2.join(agentsDir, category, fileName),
         disabled: disabledSet.has(key) || disabledSet.has(id)
       };
       const existing = stemCategories.get(key) ?? [];
@@ -497,12 +193,6 @@ function resolveAgentOverlaySet(overlays) {
     categoriesByKey: new Map(overlays.categories.map((overlay) => [overlay.key, overlay]))
   };
 }
-function assertSourceCategoryModelCoverage(categories) {
-  const missingCategories = categories.filter((category) => !Object.hasOwn(SOURCE_CATEGORY_MODEL_DEFAULTS, category));
-  if (missingCategories.length > 0) {
-    throw new Error(`Source category model defaults missing intentional coverage for: ${missingCategories.join(", ")}`);
-  }
-}
 function validateExactAgentOverlays(inventory, overlays, nativeAgents, enabledSkills) {
   const result = [];
   const seenTargets = new Map;
@@ -585,14 +275,14 @@ function validateOverlaySkills(overlay, skills, enabledSkills) {
 }
 function readCategoryDirs(agentsDir) {
   try {
-    return fs4.readdirSync(agentsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return fs3.readdirSync(agentsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   } catch {
     return [];
   }
 }
 function readMarkdownFiles(categoryDir) {
   try {
-    return fs4.readdirSync(categoryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
+    return fs3.readdirSync(categoryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
   } catch {
     return [];
   }
@@ -604,169 +294,63 @@ function throwConfigError(sourcePath, keyPath, message) {
   throw new Error(`Invalid Systematic config in ${sourcePath}: ${keyPath} ${message}`);
 }
 
-// src/lib/model-availability.ts
-import { createHash } from "crypto";
-import fs5 from "fs";
-import os2 from "os";
-import path5 from "path";
-function emptyAvailability() {
-  return { status: "unknown", models: new Set };
-}
-var MAX_CACHE_FILE_BYTES = 16 * 1024 * 1024;
-var DEFAULT_API_TIMEOUT_MS = 1500;
-var MODELS_JSON_FILENAME = "models.json";
-var availabilityCache = new WeakMap;
-function resolveCacheDir() {
-  const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim();
-  const cacheBase = xdgCacheHome && path5.isAbsolute(xdgCacheHome) ? xdgCacheHome : path5.join(os2.homedir(), ".cache");
-  return path5.join(cacheBase, "opencode");
-}
-function fastHash(input) {
-  return createHash("sha1").update(input).digest("hex");
-}
-function isProviderRecord(value) {
-  if (!isRecord(value))
-    return false;
-  for (const entry of Object.values(value)) {
-    if (!isRecord(entry))
-      return false;
-    if (!isRecord(entry.models))
-      return false;
+// src/lib/skill-loader.ts
+import fs4 from "fs";
+import path3 from "path";
+var SKILL_PREFIX = "systematic:";
+var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
+function formatSkillCommandName(name2) {
+  if (name2.includes(":")) {
+    return name2;
   }
-  return true;
+  return `${SKILL_PREFIX}${name2}`;
 }
-function readModelsFromCache(filePath) {
-  let fd;
-  try {
-    fd = fs5.openSync(filePath, "r");
-  } catch {
-    return null;
-  }
-  let raw;
-  try {
-    let stat;
-    try {
-      stat = fs5.fstatSync(fd);
-    } catch {
-      return null;
-    }
-    if (!stat.isFile())
-      return null;
-    if (stat.size === 0)
-      return null;
-    if (stat.size > MAX_CACHE_FILE_BYTES) {
-      console.warn(`[systematic] models.json at ${filePath} is ${stat.size} bytes (>${MAX_CACHE_FILE_BYTES}); treating as cache miss.`);
-      return null;
-    }
-    const buffer = Buffer.alloc(stat.size);
-    let bytesRead;
-    try {
-      bytesRead = fs5.readSync(fd, buffer, 0, stat.size, 0);
-    } catch {
-      return null;
-    }
-    if (bytesRead !== stat.size)
-      return null;
-    raw = buffer.toString("utf8");
-  } finally {
-    try {
-      fs5.closeSync(fd);
-    } catch {}
-  }
-  if (raw.trim().length === 0)
-    return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return null;
-  }
-  if (!isProviderRecord(parsed)) {
-    console.warn(`[systematic] models.json schema mismatch at ${filePath}; treating as cache miss. Upstream shape may have drifted.`);
-    return null;
-  }
-  const result = new Set;
-  for (const [providerId, providerData] of Object.entries(parsed)) {
-    for (const modelId of Object.keys(providerData.models)) {
-      result.add(`${providerId}/${modelId}`);
-    }
+function formatSkillDescription(description, fallbackName) {
+  const desc = description || `${fallbackName} skill`;
+  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
+    return desc;
   }
-  return result;
+  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
 }
-function readFallbackCache() {
-  const cacheDir = resolveCacheDir();
-  const openCodeModelsUrl = process.env.OPENCODE_MODELS_URL?.trim();
-  if (openCodeModelsUrl) {
-    const urlDerivedPath = path5.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
-    const urlResult = readModelsFromCache(urlDerivedPath);
-    if (urlResult !== null && urlResult.size > 0) {
-      return { status: "cache", models: urlResult };
-    }
-    return emptyAvailability();
-  }
-  const defaultPath = path5.join(cacheDir, MODELS_JSON_FILENAME);
-  const defaultResult = readModelsFromCache(defaultPath);
-  if (defaultResult !== null && defaultResult.size > 0) {
-    return { status: "cache", models: defaultResult };
-  }
-  return emptyAvailability();
+function wrapSkillTemplate(skillPath, body2) {
+  const skillDir = path3.dirname(skillPath);
+  return `<skill-instruction>
+Base directory for this skill: ${skillDir}/
+File references (@path) in this skill are relative to this directory.
+
+${body2.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
 }
-function buildSetFromProviders(providers) {
-  const result = new Set;
-  for (const provider of providers) {
-    for (const modelId of Object.keys(provider.models)) {
-      result.add(`${provider.id}/${modelId}`);
-    }
-  }
-  return result;
+function extractSkillBody(wrappedTemplate) {
+  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
+  return match ? match[1].trim() : wrappedTemplate;
 }
-async function getAvailableModels(client, options = {}) {
-  const cached = availabilityCache.get(client);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const cacheAndReturn = (envelope) => {
-    if (envelope.status !== "unknown") {
-      availabilityCache.set(client, envelope);
-    }
-    return envelope;
-  };
-  const timeoutMs = options.apiTimeoutMs === undefined ? DEFAULT_API_TIMEOUT_MS : options.apiTimeoutMs;
-  if (typeof client.config?.providers !== "function") {
-    return cacheAndReturn(readFallbackCache());
-  }
-  const apiCall = client.config.providers();
-  let response;
+function loadSkill(skillInfo) {
   try {
-    if (timeoutMs === null) {
-      response = await apiCall;
-    } else {
-      const TIMEOUT_SENTINEL = Symbol("timeout");
-      const timeoutPromise = new Promise((resolve2) => {
-        const timer = setTimeout(() => resolve2(TIMEOUT_SENTINEL), timeoutMs);
-        timer.unref?.();
-      });
-      const raced = await Promise.race([apiCall, timeoutPromise]);
-      if (raced === TIMEOUT_SENTINEL) {
-        console.warn(`[systematic] client.config.providers() exceeded ${timeoutMs}ms; falling back to models.json cache.`);
-        return cacheAndReturn(readFallbackCache());
-      }
-      response = raced;
-    }
+    const content = fs4.readFileSync(skillInfo.skillFile, "utf8");
+    const { body: body2 } = parseFrontmatter(content);
+    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body2);
+    return {
+      name: skillInfo.name,
+      prefixedName: formatSkillCommandName(skillInfo.name),
+      description: formatSkillDescription(skillInfo.description, skillInfo.name),
+      path: skillInfo.path,
+      skillFile: skillInfo.skillFile,
+      wrappedTemplate,
+      disableModelInvocation: skillInfo.disableModelInvocation,
+      userInvocable: skillInfo.userInvocable,
+      subtask: skillInfo.subtask,
+      agent: skillInfo.agent,
+      model: skillInfo.model,
+      argumentHint: skillInfo.argumentHint
+    };
   } catch {
-    return cacheAndReturn(readFallbackCache());
-  }
-  if (response.error !== undefined || response.data === undefined) {
-    return cacheAndReturn(readFallbackCache());
-  }
-  const models = buildSetFromProviders(response.data.providers);
-  if (models.size === 0) {
-    return cacheAndReturn(emptyAvailability());
+    return null;
   }
-  return cacheAndReturn({
-    status: "api",
-    models
-  });
 }
 
 // src/lib/config-handler.ts
@@ -805,7 +389,7 @@ function formatAgentDescription(name2, description) {
 }
 function loadAgentAsConfig(agentInfo) {
   try {
-    const content = fs6.readFileSync(agentInfo.file, "utf8");
+    const content = fs5.readFileSync(agentInfo.file, "utf8");
     const {
       description,
       prompt,
@@ -854,7 +438,7 @@ function loadAgentAsConfig(agentInfo) {
 }
 function loadCommandAsConfig(commandInfo) {
   try {
-    const content = fs6.readFileSync(commandInfo.file, "utf8");
+    const content = fs5.readFileSync(commandInfo.file, "utf8");
     const { name: name2, description, agent, model, subtask } = extractCommandFrontmatter(content);
     const { body: body2 } = parseFrontmatter(content);
     const cleanName = commandInfo.name.replace(/^\//, "");
@@ -894,7 +478,7 @@ function loadSkillAsCommand(loaded) {
     config.subtask = loaded.subtask;
   return config;
 }
-function collectAgents(dir, disabledAgents, nativeAgents, overlays, availabilitySet) {
+function collectAgents(dir, disabledAgents, nativeAgents, overlays) {
   const agents = {};
   const agentList = findAgentsInDir(dir);
   const disabledSet = new Set(disabledAgents);
@@ -909,12 +493,12 @@ function collectAgents(dir, disabledAgents, nativeAgents, overlays, availability
       continue;
     const config = loadAgentAsConfig(agentInfo);
     if (config) {
-      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays, availabilitySet);
+      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays);
     }
   }
   return agents;
 }
-function applyAgentOverlays(config, agentInfo, overlays, availabilitySet) {
+function applyAgentOverlays(config, agentInfo, overlays) {
   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);
@@ -924,23 +508,11 @@ function applyAgentOverlays(config, agentInfo, overlays, availabilitySet) {
   if (hasPermissionOverlay && isRecord(config.permission)) {
     addPermissionRules(permissionRules, config.permission);
   }
-  applySourceModelDefault(result, agentInfo, availabilitySet);
   applyAgentOverlay(result, categoryOverlay?.value, permissionRules);
   applyAgentOverlay(result, exactOverlay?.value, permissionRules);
   applyPermissionOverlay(result, permissionRules, hasPermissionOverlay);
   return result;
 }
-function applySourceModelDefault(target, agentInfo, availabilitySet) {
-  if (!agentInfo.category || availabilitySet === undefined)
-    return;
-  const resolved = resolveSourceModel(agentInfo.category, availabilitySet);
-  target.model = `${resolved.provider}/${resolved.model}`;
-  if (resolved.variant !== undefined) {
-    target.variant = resolved.variant;
-  } else {
-    delete target.variant;
-  }
-}
 function applyAgentOverlay(target, overlay, permissionRules) {
   if (overlay === undefined)
     return;
@@ -1113,9 +685,9 @@ function collectEnabledSkillNames(dir, disabledSkills) {
   return findSkillsInDir(dir).filter((skillInfo) => !disabledSet.has(skillInfo.name)).map((skillInfo) => skillInfo.name);
 }
 function createConfigHandler(deps) {
-  const { directory, bundledSkillsDir, bundledAgentsDir: bundledAgentsDir2, bundledCommandsDir } = deps;
-  const homeDir = deps.homeDir ?? os3.homedir();
-  const opencodeConfigDir = deps.opencodeConfigDir ?? path6.join(homeDir, ".config/opencode");
+  const { directory, bundledSkillsDir, bundledAgentsDir, bundledCommandsDir } = deps;
+  const homeDir = deps.homeDir ?? os2.homedir();
+  const opencodeConfigDir = deps.opencodeConfigDir ?? path4.join(homeDir, ".config/opencode");
   const opencodeConfigDirOverride = process.env.OPENCODE_CONFIG_DIR?.trim() ? process.env.OPENCODE_CONFIG_DIR : undefined;
   return async (config) => {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
@@ -1124,10 +696,7 @@ function createConfigHandler(deps) {
     const nativeAgents = Object.fromEntries(Object.entries(existingAgents).filter(([, agent]) => !isSystematicAgentConfig(agent)));
     const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, systematicConfig.disabled_skills);
     const enabledSkillNames = collectEnabledSkillNames(bundledSkillsDir, systematicConfig.disabled_skills);
-    const inventory = buildBundledAgentInventory(bundledAgentsDir2, systematicConfig.disabled_agents);
-    const availability = deps.client ? await getAvailableModels(deps.client) : undefined;
-    const availabilitySet = availability && availability.status !== "unknown" ? availability.models : undefined;
-    assertSourceCategoryModelCoverage(inventory.categories);
+    const inventory = buildBundledAgentInventory(bundledAgentsDir, systematicConfig.disabled_agents);
     const validatedOverlays = validateAgentOverlays({
       inventory,
       overlays,
@@ -1135,7 +704,7 @@ function createConfigHandler(deps) {
       enabledSkills: enabledSkillNames
     });
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
-    const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays, availabilitySet);
+    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
     const discoveredSkillCommands = systematicConfig.skills_as_commands !== false ? collectDiscoveredSkillsAsCommands(directory, homeDir, opencodeConfigDir, opencodeConfigDirOverride, systematicConfig.disabled_commands) : {};
     const bundledAgentKeys = new Set(Object.keys(bundledAgents));
@@ -1161,21 +730,21 @@ function registerSkillsPaths(config, skillsDir) {
   };
 }
 function removeSystematicSkillPaths(paths) {
-  return paths.filter((path7) => !isSystematicSkillPath(path7));
+  return paths.filter((path5) => !isSystematicSkillPath(path5));
 }
-function isSystematicSkillPath(path7) {
-  const normalizedPath = normalizePath(path7);
+function isSystematicSkillPath(path5) {
+  const normalizedPath = normalizePath(path5);
   return normalizedPath.endsWith("/.config/opencode/systematic/skills") || normalizedPath.endsWith("/.cache/opencode/systematic/skills") || normalizedPath.endsWith("/.local/share/opencode/systematic/skills") || normalizedPath.endsWith("/.opencode/systematic/skills") || /(?:^|\/)\.cache\/opencode\/packages\/@fro\.bot\/systematic@[^/]+\/node_modules\/@fro\.bot\/systematic\/skills(?:$|\/)/u.test(normalizedPath);
 }
-function normalizePath(path7) {
-  return path7.replaceAll("\\", "/").replace(/\/+$/u, "");
+function normalizePath(path5) {
+  return path5.replaceAll("\\", "/").replace(/\/+$/u, "");
 }
 
 // src/lib/opencode-operation-observer.ts
 import { spawnSync } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import fs7 from "fs";
-import path7 from "path";
+import { createHash } from "crypto";
+import fs6 from "fs";
+import path5 from "path";
 var DEFAULT_LIMITS = {
   maxCommandOutputBytes: 1048576,
   maxCommandTimeoutMs: 5000,
@@ -1196,7 +765,7 @@ function unavailable(result) {
   return { status: "unavailable", reasonCode: result.reasonCode };
 }
 function digest(domain, facts) {
-  const hash = createHash2("sha256");
+  const hash = createHash("sha256");
   hash.update(`systematic:opencode-observer:${domain}:v1\x00`);
   for (const fact of facts) {
     hash.update(fact);
@@ -1287,11 +856,11 @@ function parseStageEntries(output, maxPathBytes) {
   return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 function safePath(root, relativePath) {
-  if (path7.isAbsolute(relativePath))
+  if (path5.isAbsolute(relativePath))
     return;
-  const absolutePath = path7.resolve(root, relativePath);
-  const relative = path7.relative(root, absolutePath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path7.sep}`)) {
+  const absolutePath = path5.resolve(root, relativePath);
+  const relative = path5.relative(root, absolutePath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path5.sep}`)) {
     return;
   }
   return absolutePath;
@@ -1314,25 +883,25 @@ function runCommand(runner, args2, cwd, limits) {
   }
   return { status: "ok", output: { stdout: result.stdout } };
 }
-function canonicalPath(filePath, realPath = fs7.realpathSync) {
+function canonicalPath(filePath, realPath = fs6.realpathSync) {
   try {
     return realPath(filePath);
   } catch {
     return;
   }
 }
-function requiredGitPath(runner, args2, cwd, limits, realPath = fs7.realpathSync) {
+function requiredGitPath(runner, args2, cwd, limits, realPath = fs6.realpathSync) {
   const result = runCommand(runner, args2, cwd, limits);
   if (result.status === "error")
     return result;
   const rawValue = result.output.stdout.trim();
-  if (!path7.isAbsolute(rawValue)) {
+  if (!path5.isAbsolute(rawValue)) {
     return { status: "error", reasonCode: "target-unavailable" };
   }
   const value = canonicalPath(rawValue, realPath);
   return value === undefined ? { status: "error", reasonCode: "target-unavailable" } : { status: "ok", value };
 }
-function captureParentIdentity(targetDirectory, runner, limits, realPath = fs7.realpathSync) {
+function captureParentIdentity(targetDirectory, runner, limits, realPath = fs6.realpathSync) {
   const targetRoot = requiredGitPath(runner, ["rev-parse", "--show-toplevel"], targetDirectory, limits, realPath);
   if (targetRoot.status === "error")
     return targetRoot;
@@ -1360,53 +929,53 @@ function captureParentIdentity(targetDirectory, runner, limits, realPath = fs7.r
     }
   } : { status: "error", reasonCode: "target-unavailable" };
 }
-function readGitfileTarget(gitfilePath, realPath = fs7.realpathSync) {
+function readGitfileTarget(gitfilePath, realPath = fs6.realpathSync) {
   let contents;
   try {
-    contents = fs7.readFileSync(gitfilePath, "utf8");
+    contents = fs6.readFileSync(gitfilePath, "utf8");
   } catch {
     return;
   }
   const match = /^gitdir:\s*(.+?)\s*$/im.exec(contents);
   if (!match)
     return;
-  const target = path7.isAbsolute(match[1]) ? match[1] : path7.resolve(path7.dirname(gitfilePath), match[1]);
+  const target = path5.isAbsolute(match[1]) ? match[1] : path5.resolve(path5.dirname(gitfilePath), match[1]);
   return canonicalPath(target, realPath);
 }
 function readGitdirBacklink(backlinkPath, realPath) {
   let contents;
   try {
-    contents = fs7.readFileSync(backlinkPath, "utf8").trim();
+    contents = fs6.readFileSync(backlinkPath, "utf8").trim();
   } catch {
     return;
   }
   if (contents.length === 0)
     return;
-  const target = path7.isAbsolute(contents) ? contents : path7.resolve(path7.dirname(backlinkPath), contents);
+  const target = path5.isAbsolute(contents) ? contents : path5.resolve(path5.dirname(backlinkPath), contents);
   return canonicalPath(target, realPath);
 }
 function isPathWithin(root, candidate) {
-  const relative = path7.relative(root, candidate);
-  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
+  const relative = path5.relative(root, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
 }
 function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
-  const dotGit = path7.join(targetRoot, ".git");
+  const dotGit = path5.join(targetRoot, ".git");
   let dotGitStat;
   try {
-    dotGitStat = fs7.lstatSync(dotGit);
+    dotGitStat = fs6.lstatSync(dotGit);
   } catch {
     return false;
   }
   if (dotGitStat.isDirectory()) {
     return gitDir === commonDir && canonicalPath(dotGit, realPath) === commonDir;
   }
-  if (!dotGitStat.isFile() || dotGitStat.isSymbolicLink() || !isPathWithin(path7.join(commonDir, "worktrees"), gitDir) || readGitfileTarget(dotGit, realPath) !== gitDir) {
+  if (!dotGitStat.isFile() || dotGitStat.isSymbolicLink() || !isPathWithin(path5.join(commonDir, "worktrees"), gitDir) || readGitfileTarget(dotGit, realPath) !== gitDir) {
     return false;
   }
-  const backlinkPath = path7.join(gitDir, "gitdir");
+  const backlinkPath = path5.join(gitDir, "gitdir");
   let backlinkStat;
   try {
-    backlinkStat = fs7.lstatSync(backlinkPath);
+    backlinkStat = fs6.lstatSync(backlinkPath);
   } catch {
     return false;
   }
@@ -1415,7 +984,7 @@ function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
 function validateRegisteredWorktree(candidateDirectory, parentIdentity, options = {}) {
   const runner = options.commandRunner ?? defaultCommandRunner;
   const limits = mergeLimits(options.limits);
-  const realPath = options.realPath ?? fs7.realpathSync;
+  const realPath = options.realPath ?? fs6.realpathSync;
   const candidateRoot = canonicalPath(candidateDirectory, realPath);
   if (candidateRoot === undefined) {
     return { status: "error", reasonCode: "target-unavailable" };
@@ -1582,7 +1151,7 @@ function readWorktreeRevisionV2(runner, fileReader, symlinkReader, statReader, c
   if (paths.length > limits.maxFiles) {
     return { status: "error", reasonCode: "file-limit" };
   }
-  const hash = createHash2("sha256");
+  const hash = createHash("sha256");
   hash.update("systematic:opencode-observer:worktree:v2\x00");
   let totalBytes = 0;
   for (const relativePath of paths) {
@@ -1800,19 +1369,19 @@ function createOpencodeOperationObserver(options) {
   const limits = mergeLimits(options.limits);
   let targetDirectory;
   try {
-    targetDirectory = (options.realPath ?? fs7.realpathSync)(options.targetDirectory);
+    targetDirectory = (options.realPath ?? fs6.realpathSync)(options.targetDirectory);
   } catch {
-    targetDirectory = path7.resolve(options.targetDirectory);
+    targetDirectory = path5.resolve(options.targetDirectory);
   }
   const runner = options.commandRunner ?? defaultCommandRunner;
   const remoteRunner = options.remoteCommandRunner ?? defaultRemoteCommandRunner;
-  const realPath = options.realPath ?? fs7.realpathSync;
+  const realPath = options.realPath ?? fs6.realpathSync;
   const parentIdentityResult = captureParentIdentity(targetDirectory, runner, limits, realPath);
   const targetDigest = digest("target", [targetDirectory]);
-  const fileReader = options.fileReader ?? fs7.readFileSync;
-  const symlinkReader = options.symlinkReader ?? fs7.readlinkSync;
+  const fileReader = options.fileReader ?? fs6.readFileSync;
+  const symlinkReader = options.symlinkReader ?? fs6.readlinkSync;
   const statReader = options.statReader ?? ((filePath) => {
-    const stat = fs7.lstatSync(filePath);
+    const stat = fs6.lstatSync(filePath);
     return {
       isFile: stat.isFile(),
       isSymbolicLink: stat.isSymbolicLink(),
@@ -1875,11 +1444,11 @@ function createOpencodeOperationObserver(options) {
 
 // src/lib/opencode-workflow-guard.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import fs9 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path6 from "path";
 
 // src/lib/question-attestation.ts
-import { createHash as createHash3, randomBytes } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 var CANONICAL_QUESTION_WORDING = "Confirm the requested guarded transition.";
 var MAX_ID_LENGTH = 128;
 var MAX_RESOURCE_LENGTH = 512;
@@ -1910,7 +1479,7 @@ function isQuestionPurpose(value) {
   return value === "transition" || value === "session-disablement";
 }
 function digestResource(resource) {
-  return `sha256:${createHash3("sha256").update(`systematic-question-attestation:v1:resource:${resource}`, "utf8").digest("hex")}`;
+  return `sha256:${createHash2("sha256").update(`systematic-question-attestation:v1:resource:${resource}`, "utf8").digest("hex")}`;
 }
 function bindingKey(input, resourceDigest) {
   return [
@@ -2396,7 +1965,7 @@ function createQuestionAttestation(options = {}) {
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/lib/receipt-readback.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var RECEIPT_READBACK_SCHEMA_VERSION = 2;
 var RECEIPT_READBACK_PROTOCOL_VERSION = 2;
 var LEGACY_RECEIPT_READBACK_SCHEMA_VERSION = 1;
@@ -2567,7 +2136,7 @@ function sessionSaltHex(value) {
 }
 function digestReceiptIdentity(domain, identity, sessionSalt) {
   const salt = sessionSaltHex(sessionSalt) ?? "invalid-salt";
-  return createHash4("sha256").update(`systematic/receipt-ledger/${domain}/v1/${salt}/${identity}`).digest("hex");
+  return createHash3("sha256").update(`systematic/receipt-ledger/${domain}/v1/${salt}/${identity}`).digest("hex");
 }
 function decodeSessionSalt(value) {
   return Uint8Array.from(Buffer.from(value, "hex"));
@@ -2730,7 +2299,7 @@ function serializeEnvelope(envelope) {
   });
 }
 function hashIntegrity(scope, value) {
-  return createHash4("sha256").update(`systematic/receipt-readback/${scope}/v1/${value}`).digest("hex");
+  return createHash3("sha256").update(`systematic/receipt-readback/${scope}/v1/${value}`).digest("hex");
 }
 function mintIntegrity(envelope, sessionSalt) {
   return hashIntegrity("mint", `${sessionSalt}/${serializeEnvelope(envelope)}`);
@@ -4416,8 +3985,8 @@ function normalizeCapabilities(input) {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/lib/receipt-classifier.ts
-import fs8 from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import fs7 from "fs";
+import { fileURLToPath } from "url";
 
 // node_modules/.bun/web-tree-sitter@0.25.10/node_modules/web-tree-sitter/tree-sitter.js
 var __defProp = Object.defineProperty;
@@ -5853,8 +5422,8 @@ var Module2 = (() => {
     var moduleRtn;
     var Module = moduleArg;
     var readyPromiseResolve, readyPromiseReject;
-    var readyPromise = new Promise((resolve2, reject) => {
-      readyPromiseResolve = resolve2;
+    var readyPromise = new Promise((resolve, reject) => {
+      readyPromiseResolve = resolve;
       readyPromiseReject = reject;
     });
     var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -5876,11 +5445,11 @@ var Module2 = (() => {
       throw toThrow;
     }, "quit_");
     var scriptDirectory = "";
-    function locateFile(path8) {
+    function locateFile(path6) {
       if (Module["locateFile"]) {
-        return Module["locateFile"](path8, scriptDirectory);
+        return Module["locateFile"](path6, scriptDirectory);
       }
-      return scriptDirectory + path8;
+      return scriptDirectory + path6;
     }
     __name(locateFile, "locateFile");
     var readAsync, readBinary;
@@ -5934,13 +5503,13 @@ var Module2 = (() => {
         }
         readAsync = /* @__PURE__ */ __name(async (url) => {
           if (isFileURI(url)) {
-            return new Promise((resolve2, reject) => {
+            return new Promise((resolve, reject) => {
               var xhr = new XMLHttpRequest;
               xhr.open("GET", url, true);
               xhr.responseType = "arraybuffer";
               xhr.onload = () => {
                 if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                  resolve2(xhr.response);
+                  resolve(xhr.response);
                   return;
                 }
                 reject(xhr.status);
@@ -6160,10 +5729,10 @@ var Module2 = (() => {
       __name(receiveInstantiationResult, "receiveInstantiationResult");
       var info2 = getWasmImports();
       if (Module["instantiateWasm"]) {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve, reject) => {
           Module["instantiateWasm"](info2, (mod, inst) => {
             receiveInstance(mod, inst);
-            resolve2(mod.exports);
+            resolve(mod.exports);
           });
         });
       }
@@ -7954,7 +7523,7 @@ function matchesToolIdentity(tool, executable) {
 async function initializeParserAssets(options) {
   const treeSitterWasmPath = options.treeSitterWasmPath ?? resolveAsset("web-tree-sitter/tree-sitter.wasm");
   const bashWasmPath = options.bashWasmPath ?? resolveAsset("tree-sitter-bash/tree-sitter-bash.wasm");
-  if (!fs8.existsSync(treeSitterWasmPath) || !fs8.existsSync(bashWasmPath)) {
+  if (!fs7.existsSync(treeSitterWasmPath) || !fs7.existsSync(bashWasmPath)) {
     throw new Error("parser-asset-unavailable");
   }
   try {
@@ -7975,7 +7544,7 @@ async function initializeParserAssets(options) {
 }
 function resolveAsset(specifier) {
   const resolved = import.meta.resolve(specifier);
-  return resolved.startsWith("file://") ? fileURLToPath2(resolved) : resolved;
+  return resolved.startsWith("file://") ? fileURLToPath(resolved) : resolved;
 }
 function classifyParserFailure(error) {
   if (error instanceof Error && error.message === "grammar-incompatible") {
@@ -10832,16 +10401,16 @@ function canonicalFileTarget(filePath, realPath) {
   const existing = canonicalExistingPath(filePath, realPath);
   if (existing)
     return existing;
-  const parent = canonicalExistingPath(path8.dirname(filePath), realPath);
-  const basename = path8.basename(filePath);
-  return parent && basename && basename !== "." && basename !== ".." ? path8.join(parent, basename) : undefined;
+  const parent = canonicalExistingPath(path6.dirname(filePath), realPath);
+  const basename = path6.basename(filePath);
+  return parent && basename && basename !== "." && basename !== ".." ? path6.join(parent, basename) : undefined;
 }
 function pathWithinOrEqual(root, candidate) {
-  const relative = path8.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+  const relative = path6.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
 }
 function targetIsGitAdminStorage(targetPath, validation) {
-  return pathWithinOrEqual(path8.join(validation.targetRoot, ".git"), targetPath) || pathWithinOrEqual(validation.gitDir, targetPath) || pathWithinOrEqual(validation.commonDir, targetPath);
+  return pathWithinOrEqual(path6.join(validation.targetRoot, ".git"), targetPath) || pathWithinOrEqual(validation.gitDir, targetPath) || pathWithinOrEqual(validation.commonDir, targetPath);
 }
 function targetResultFromValidation(candidatePath, validation) {
   if (validation.status === "error")
@@ -10857,7 +10426,7 @@ function targetResultFromValidation(candidatePath, validation) {
 function trustedParentTarget(parentTargetRoot, candidatePath) {
   if (!pathWithinOrEqual(parentTargetRoot, candidatePath))
     return;
-  if (pathWithinOrEqual(path8.join(parentTargetRoot, ".git"), candidatePath)) {
+  if (pathWithinOrEqual(path6.join(parentTargetRoot, ".git"), candidatePath)) {
     return unavailableOperationTarget();
   }
   return { status: "available", targetRoot: parentTargetRoot };
@@ -10870,14 +10439,14 @@ function validationForCandidate(candidatePath, options, targetPath = candidatePa
   }
 }
 function deriveFileTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath, allowParentFastPath = true) {
-  const resolvedPath = path8.resolve(baseDirectory, rawPath);
+  const resolvedPath = path6.resolve(baseDirectory, rawPath);
   const canonicalPath2 = canonicalFileTarget(resolvedPath, realPath);
   if (!canonicalPath2)
     return unavailableOperationTarget();
-  const parentResult = allowParentFastPath && !path8.isAbsolute(rawPath) ? trustedParentTarget(parentTargetRoot, canonicalPath2) : undefined;
+  const parentResult = allowParentFastPath && !path6.isAbsolute(rawPath) ? trustedParentTarget(parentTargetRoot, canonicalPath2) : undefined;
   if (parentResult)
     return parentResult;
-  return validationForCandidate(path8.dirname(canonicalPath2), options, canonicalPath2);
+  return validationForCandidate(path6.dirname(canonicalPath2), options, canonicalPath2);
 }
 function sharedTargetRoot(targets, extraRoots = []) {
   const roots = [...extraRoots];
@@ -10890,10 +10459,10 @@ function sharedTargetRoot(targets, extraRoots = []) {
   return targetRoot && roots.every((root) => root === targetRoot) ? targetRoot : undefined;
 }
 function deriveDirectoryTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath) {
-  const resolvedPath = canonicalExistingPath(path8.resolve(baseDirectory, rawPath), realPath);
+  const resolvedPath = canonicalExistingPath(path6.resolve(baseDirectory, rawPath), realPath);
   if (!resolvedPath)
     return { status: "unavailable" };
-  const parentResult = path8.isAbsolute(rawPath) ? undefined : trustedParentTarget(parentTargetRoot, resolvedPath);
+  const parentResult = path6.isAbsolute(rawPath) ? undefined : trustedParentTarget(parentTargetRoot, resolvedPath);
   if (parentResult?.status === "unavailable") {
     return { status: "unavailable" };
   }
@@ -11001,14 +10570,14 @@ function deriveBashTarget(args2, sessionLocation, parentTargetRoot, options, rea
   if (typeof args2.workdir !== "string" || args2.workdir.length === 0) {
     return unavailableOperationTarget();
   }
-  const candidatePath = canonicalExistingPath(path8.resolve(sessionLocation, args2.workdir), realPath);
+  const candidatePath = canonicalExistingPath(path6.resolve(sessionLocation, args2.workdir), realPath);
   if (!candidatePath)
     return unavailableOperationTarget();
-  const parentResult = path8.isAbsolute(args2.workdir) ? undefined : trustedParentTarget(parentTargetRoot, candidatePath);
+  const parentResult = path6.isAbsolute(args2.workdir) ? undefined : trustedParentTarget(parentTargetRoot, candidatePath);
   return parentResult ?? validationForCandidate(candidatePath, options);
 }
 function deriveOpencodeOperationTarget(tool, args2, options) {
-  const realPath = options.realPath ?? fs9.realpathSync;
+  const realPath = options.realPath ?? fs8.realpathSync;
   const parentTargetRoot = canonicalExistingPath(options.parentTargetRoot, realPath);
   if (!parentTargetRoot)
     return unavailableOperationTarget();
@@ -11085,7 +10654,7 @@ function canonicalPatchText(patchText, sessionLocation) {
     const filePath = line.slice(prefix.length).trim();
     if (!filePath)
       return;
-    segments[index] = `${prefix}${path8.resolve(sessionLocation, filePath)}`;
+    segments[index] = `${prefix}${path6.resolve(sessionLocation, filePath)}`;
   }
   return segments.join("");
 }
@@ -11099,13 +10668,13 @@ function canonicalHunks(value, sessionLocation) {
     }
     const canonical = {
       ...hunk,
-      path: path8.resolve(sessionLocation, hunk.path)
+      path: path6.resolve(sessionLocation, hunk.path)
     };
     if (hunk.move_path !== undefined) {
       if (typeof hunk.move_path !== "string" || !hunk.move_path) {
         return;
       }
-      canonical.move_path = path8.resolve(sessionLocation, hunk.move_path);
+      canonical.move_path = path6.resolve(sessionLocation, hunk.move_path);
     }
     hunks.push(canonical);
   }
@@ -11394,7 +10963,7 @@ function createSessionRuntime(options, operationObservers, recoveredOperationCon
   function parentObserverRegistration() {
     if (!options.observer)
       return;
-    const targetRoot = canonicalExistingPath(options.targetDirectory ?? process.cwd(), fs9.realpathSync);
+    const targetRoot = canonicalExistingPath(options.targetDirectory ?? process.cwd(), fs8.realpathSync);
     if (!targetRoot)
       return;
     let validation;
@@ -12343,7 +11912,7 @@ function createSessionRuntime(options, operationObservers, recoveredOperationCon
       markUnavailable();
       return;
     }
-    const canonicalParentTargetRoot = canonicalExistingPath(parentTargetRoot, fs9.realpathSync);
+    const canonicalParentTargetRoot = canonicalExistingPath(parentTargetRoot, fs8.realpathSync);
     if (!canonicalParentTargetRoot) {
       markUnavailable();
       return;
@@ -13379,9 +12948,35 @@ function createOpencodeWorkflowGuard(options) {
 }
 
 // src/lib/skill-resolver.ts
-import fs10 from "fs";
-import path9 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+import fs9 from "fs";
+import path7 from "path";
+import { pathToFileURL } from "url";
+
+// src/lib/skill-catalog.ts
+function buildCatalogEntries(options) {
+  const { bundledSkillsDir, disabledSkills } = options;
+  return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name)).map((s) => ({
+    name: s.name,
+    prefixedName: formatSkillCommandName(s.name),
+    description: s.description
+  }));
+}
+function renderCatalogCompact(options) {
+  const entries = buildCatalogEntries(options);
+  const heading = "## Available Systematic Skills";
+  if (entries.length === 0) {
+    return `${heading}
+
+No Systematic skills are currently available.`;
+  }
+  const bullets = entries.map((entry) => `- ${entry.prefixedName}: ${entry.description}`).join(`
+`);
+  return `${heading}
+
+${bullets}`;
+}
+
+// src/lib/skill-resolver.ts
 function getAllSkills(options) {
   const { bundledSkillsDir, disabledSkills } = options;
   return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).map((skillInfo) => loadSkill(skillInfo)).filter((s) => s !== null).sort((a, b) => a.name.localeCompare(b.name));
@@ -13416,8 +13011,8 @@ function buildSkillToolParameterHint(options) {
 }
 function buildSkillContentOutput(matchedSkill) {
   const body2 = extractSkillBody(matchedSkill.wrappedTemplate);
-  const dir = path9.dirname(matchedSkill.skillFile);
-  const base = pathToFileURL2(dir).href;
+  const dir = path7.dirname(matchedSkill.skillFile);
+  const base = pathToFileURL(dir).href;
   const files = discoverSkillFiles(dir);
   const lines = [
     `<skill_content name="${matchedSkill.prefixedName}">`,
@@ -13447,17 +13042,17 @@ function discoverSkillFiles(dir, limit = 10) {
   function handleEntry(entry, currentDir) {
     if (entry.isDirectory()) {
       if (!shouldSkipDirectory(entry.name)) {
-        recurse(path9.resolve(currentDir, entry.name));
+        recurse(path7.resolve(currentDir, entry.name));
       }
     } else if (shouldIncludeFile(entry.name)) {
-      files.push(path9.resolve(currentDir, entry.name));
+      files.push(path7.resolve(currentDir, entry.name));
     }
   }
   function recurse(currentDir) {
     if (files.length >= limit)
       return;
     try {
-      const entries = fs10.readdirSync(currentDir, { withFileTypes: true });
+      const entries = fs9.readdirSync(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= limit)
           break;
@@ -13469,6 +13064,7 @@ function discoverSkillFiles(dir, limit = 10) {
   return files.map((file) => `  <file>${file}</file>`).join(`
 `);
 }
+
 // src/lib/skill-tool.ts
 function createSkillTool(options) {
   const { bundledSkillsDir, disabledSkills } = options;
@@ -13514,19 +13110,19 @@ function createSkillTool(options) {
 }
 
 // src/index.ts
-var __dirname3 = path10.dirname(fileURLToPath3(import.meta.url));
-var packageRoot2 = path10.resolve(__dirname3, "..");
-var bundledSkillsDir = path10.join(packageRoot2, "skills");
-var bundledAgentsDir2 = path10.join(packageRoot2, "agents");
-var bundledCommandsDir = path10.join(packageRoot2, "commands");
-var packageJsonPath = path10.join(packageRoot2, "package.json");
-var canonicalPackageSource = pathToFileURL3(fs11.realpathSync(packageRoot2)).href;
-var registrationSourceIdentity = createHash5("sha256").update(`systematic/opencode-registration-source/v1/${canonicalPackageSource}`).digest("hex");
+var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
+var packageRoot = path8.resolve(__dirname2, "..");
+var bundledSkillsDir = path8.join(packageRoot, "skills");
+var bundledAgentsDir = path8.join(packageRoot, "agents");
+var bundledCommandsDir = path8.join(packageRoot, "commands");
+var packageJsonPath = path8.join(packageRoot, "package.json");
+var canonicalPackageSource = pathToFileURL2(fs10.realpathSync(packageRoot)).href;
+var registrationSourceIdentity = createHash4("sha256").update(`systematic/opencode-registration-source/v1/${canonicalPackageSource}`).digest("hex");
 var getPackageVersion = () => {
   try {
-    if (!fs11.existsSync(packageJsonPath))
+    if (!fs10.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs11.readFileSync(packageJsonPath, "utf8");
+    const content = fs10.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {
@@ -13547,9 +13143,8 @@ var initializePlugin = async ({
   const configHandler = createConfigHandler({
     directory,
     bundledSkillsDir,
-    bundledAgentsDir: bundledAgentsDir2,
-    bundledCommandsDir,
-    client
+    bundledAgentsDir,
+    bundledCommandsDir
   });
   const observer = createOpencodeOperationObserver({
     targetDirectory: typeof worktree === "string" ? worktree : directory