@fro.bot/systematic 3.9.0 → 3.10.0

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

@@ -41,4 +41,3 @@ export interface ResolvedAgentOverlaySet {
 export declare function buildBundledAgentInventory(agentsDir: string, disabledAgents: string[]): BundledAgentInventory;
 export declare function validateAgentOverlays({ inventory, overlays, nativeAgents, enabledSkills, }: ValidateAgentOverlaysOptions): ValidatedAgentOverlays;
 export declare function resolveAgentOverlaySet(overlays: ValidatedAgentOverlays): ResolvedAgentOverlaySet;
-export declare function assertSourceCategoryModelCoverage(categories: string[]): void;

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

@@ -1,12 +1,9 @@
 import type { Config } from '@opencode-ai/plugin';
-import { type OpencodeClientLike } from './model-availability.js';
 export interface ConfigHandlerDeps {
     directory: string;
     bundledSkillsDir: string;
     bundledAgentsDir: string;
     bundledCommandsDir: string;
-    /** OpenCode client for availability lookup. When omitted, availability falls back to empty set (last-resort resolution). */
-    client?: OpencodeClientLike;
     /** Home directory for discovered-skill lookups. Defaults to `os.homedir()`; inject a temp dir in tests. */
     homeDir?: string;
     /** OpenCode global config directory override for discovered-skill lookups. Defaults to `<homeDir>/.config/opencode`. */

package/dist/lib/skill-catalog.d.ts

@@ -1,15 +1,7 @@
-/**
- * Escape XML special characters (&, <, >) in text content.
- * Quotes are not escaped because catalog names and descriptions are rendered
- * as element text, not attribute values.
- */
-export declare function escapeXml(text: string): string;
 export interface CatalogEntry {
     name: string;
     prefixedName: string;
     description: string;
-    path: string;
-    skillFile: string;
 }
 export interface CatalogOptions {
     bundledSkillsDir: string;
@@ -21,11 +13,6 @@ export interface CatalogOptions {
  * Returns entries sorted by name.
  */
 export declare function buildCatalogEntries(options: CatalogOptions): CatalogEntry[];
-/**
- * Renders discoverable skills as native-style verbose XML for bootstrap content.
- * Returns empty string when no skills are available.
- */
-export declare function renderCatalogVerbose(options: CatalogOptions): string;
 /**
  * Renders discoverable skills as a compact markdown list for tool descriptions.
  * Always includes the heading; renders an explicit no-skills message when empty.

package/dist/lib/skill-tool.d.ts

@@ -1,13 +1,7 @@
 import type { ToolDefinition } from '@opencode-ai/plugin';
-import type { SkillInfo } from './skills.js';
 export { discoverSkillFiles } from './skill-resolver.js';
 export interface SkillToolOptions {
     bundledSkillsDir: string;
     disabledSkills: string[];
 }
-/**
- * Formats skills as XML for tool description.
- * Uses indented format matching OpenCode's native skill tool.
- */
-export declare function formatSkillsXml(skills: SkillInfo[]): string;
 export declare function createSkillTool(options: SkillToolOptions): ToolDefinition;

package/dist/pi.js

@@ -3316,196 +3316,13 @@ function resolveToolAllowlist(toolsSource) {
 }
 
 // src/lib/bootstrap.ts
-import fs5 from "node:fs";
-import os from "node:os";
-import path4 from "node:path";
-
-// src/lib/skill-catalog.ts
-import { pathToFileURL } from "node:url";
-
-// src/lib/skill-loader.ts
 import fs3 from "node:fs";
+import os from "node:os";
 import path2 from "node:path";
-var SKILL_PREFIX = "systematic:";
-var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
-function formatSkillCommandName(name) {
-  if (name.includes(":")) {
-    return name;
-  }
-  return `${SKILL_PREFIX}${name}`;
-}
-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, body) {
-  const skillDir = path2.dirname(skillPath);
-  return `<skill-instruction>
-Base directory for this skill: ${skillDir}/
-File references (@path) in this skill are relative to this directory.
-
-${body.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 = fs3.readFileSync(skillInfo.skillFile, "utf8");
-    const { body } = parseFrontmatter(content);
-    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body);
-    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/skills.ts
-import fs4 from "node:fs";
-import path3 from "node:path";
-function parseMetadata(data) {
-  const metadataRaw = data.metadata;
-  if (!isRecord(metadataRaw)) {
-    return;
-  }
-  const entries = Object.entries(metadataRaw);
-  if (!entries.every(([, v]) => typeof v === "string")) {
-    return;
-  }
-  return Object.fromEntries(entries);
-}
-function extractFrontmatterFromContent(content) {
-  const { data, parseError } = parseFrontmatter(content);
-  if (parseError) {
-    return { name: "", description: "" };
-  }
-  const metadata = parseMetadata(data);
-  const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
-  const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
-  return {
-    name: extractString(data, "name"),
-    description: extractString(data, "description"),
-    license: extractNonEmptyString(data, "license"),
-    compatibility: extractNonEmptyString(data, "compatibility"),
-    metadata,
-    disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
-    userInvocable: extractBoolean(data, "user-invocable"),
-    subtask: data.context === "fork" ? true : extractBoolean(data, "subtask") ?? undefined,
-    agent: extractNonEmptyString(data, "agent"),
-    model: extractNonEmptyString(data, "model"),
-    argumentHint: argumentHint !== "" ? argumentHint : undefined,
-    allowedTools: extractNonEmptyString(data, "allowed-tools")
-  };
-}
-function extractFrontmatter(filePath) {
-  try {
-    const content = fs4.readFileSync(filePath, "utf8");
-    return extractFrontmatterFromContent(content);
-  } catch {
-    return { name: "", description: "" };
-  }
-}
-function findSkillsInDir(dir, maxDepth = 3) {
-  const skills = [];
-  const entries = walkDir(dir, {
-    maxDepth,
-    filter: (e) => e.isDirectory
-  });
-  for (const entry of entries) {
-    const skillFile = path3.join(entry.path, "SKILL.md");
-    if (fs4.existsSync(skillFile)) {
-      const frontmatter = extractFrontmatter(skillFile);
-      skills.push({
-        path: entry.path,
-        skillFile,
-        name: frontmatter.name || entry.name,
-        description: frontmatter.description || "",
-        license: frontmatter.license,
-        compatibility: frontmatter.compatibility,
-        metadata: frontmatter.metadata,
-        disableModelInvocation: frontmatter.disableModelInvocation,
-        userInvocable: frontmatter.userInvocable,
-        subtask: frontmatter.subtask,
-        agent: frontmatter.agent,
-        model: frontmatter.model,
-        argumentHint: frontmatter.argumentHint,
-        allowedTools: frontmatter.allowedTools
-      });
-    }
-  }
-  return skills;
-}
-
-// 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
 function readHarnessProfile(bundledSkillsDir, name) {
-  const profilePath = path4.join(bundledSkillsDir, "using-systematic/references", `${name}-profile.md`);
+  const profilePath = path2.join(bundledSkillsDir, "using-systematic/references", `${name}-profile.md`);
   try {
-    return fs5.readFileSync(profilePath, "utf8");
+    return fs3.readFileSync(profilePath, "utf8");
   } catch (error) {
     console.error(`Failed to read harness profile ${profilePath}: ${error instanceof Error ? error.message : String(error)}`);
     return null;
@@ -3557,25 +3374,18 @@ function getBootstrapContent(config, deps) {
   if (!config.bootstrap.enabled)
     return null;
   if (config.bootstrap.file) {
-    const customPath = config.bootstrap.file.startsWith("~/") ? path4.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
-    if (fs5.existsSync(customPath)) {
-      return fs5.readFileSync(customPath, "utf8");
+    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 usingSystematicPath = path4.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs5.existsSync(usingSystematicPath))
+  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs3.existsSync(usingSystematicPath))
     return null;
-  const fullContent = fs5.readFileSync(usingSystematicPath, "utf8");
+  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
   const { body } = parseFrontmatter(fullContent);
   const content = body.trim();
   const skillUsage = usageTemplate ?? getSkillUsageTemplate();
-  const catalog = renderCatalogVerbose({
-    bundledSkillsDir,
-    disabledSkills: config.disabled_skills
-  });
-  const catalogSection = catalog.length > 0 ? `
-
-${catalog}` : "";
   const profileSection = profileBlock === undefined ? "" : `
 
 ${profileBlock}`;
@@ -3586,7 +3396,7 @@ You have access to structured engineering workflows via the Systematic plugin.
 
 ${content}
 
-${skillUsage}${profileSection}${catalogSection}
+${skillUsage}${profileSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
@@ -3920,7 +3730,168 @@ var createRealPiDelegateSession = createDelegateSessionWith(REAL_PI_DELEGATE_SES
 // src/lib/skill-resolver.ts
 import fs6 from "node:fs";
 import path5 from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { pathToFileURL } from "node:url";
+
+// src/lib/skill-loader.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+var SKILL_PREFIX = "systematic:";
+var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
+function formatSkillCommandName(name) {
+  if (name.includes(":")) {
+    return name;
+  }
+  return `${SKILL_PREFIX}${name}`;
+}
+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, body) {
+  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.
+
+${body.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 = fs4.readFileSync(skillInfo.skillFile, "utf8");
+    const { body } = parseFrontmatter(content);
+    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body);
+    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/skills.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+function parseMetadata(data) {
+  const metadataRaw = data.metadata;
+  if (!isRecord(metadataRaw)) {
+    return;
+  }
+  const entries = Object.entries(metadataRaw);
+  if (!entries.every(([, v]) => typeof v === "string")) {
+    return;
+  }
+  return Object.fromEntries(entries);
+}
+function extractFrontmatterFromContent(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  if (parseError) {
+    return { name: "", description: "" };
+  }
+  const metadata = parseMetadata(data);
+  const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
+  const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
+  return {
+    name: extractString(data, "name"),
+    description: extractString(data, "description"),
+    license: extractNonEmptyString(data, "license"),
+    compatibility: extractNonEmptyString(data, "compatibility"),
+    metadata,
+    disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
+    userInvocable: extractBoolean(data, "user-invocable"),
+    subtask: data.context === "fork" ? true : extractBoolean(data, "subtask") ?? undefined,
+    agent: extractNonEmptyString(data, "agent"),
+    model: extractNonEmptyString(data, "model"),
+    argumentHint: argumentHint !== "" ? argumentHint : undefined,
+    allowedTools: extractNonEmptyString(data, "allowed-tools")
+  };
+}
+function extractFrontmatter(filePath) {
+  try {
+    const content = fs5.readFileSync(filePath, "utf8");
+    return extractFrontmatterFromContent(content);
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function findSkillsInDir(dir, maxDepth = 3) {
+  const skills = [];
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => e.isDirectory
+  });
+  for (const entry of entries) {
+    const skillFile = path4.join(entry.path, "SKILL.md");
+    if (fs5.existsSync(skillFile)) {
+      const frontmatter = extractFrontmatter(skillFile);
+      skills.push({
+        path: entry.path,
+        skillFile,
+        name: frontmatter.name || entry.name,
+        description: frontmatter.description || "",
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        disableModelInvocation: frontmatter.disableModelInvocation,
+        userInvocable: frontmatter.userInvocable,
+        subtask: frontmatter.subtask,
+        agent: frontmatter.agent,
+        model: frontmatter.model,
+        argumentHint: frontmatter.argumentHint,
+        allowedTools: frontmatter.allowedTools
+      });
+    }
+  }
+  return skills;
+}
+
+// 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));
@@ -3956,7 +3927,7 @@ function buildSkillToolParameterHint(options) {
 function buildSkillContentOutput(matchedSkill) {
   const body = extractSkillBody(matchedSkill.wrappedTemplate);
   const dir = path5.dirname(matchedSkill.skillFile);
-  const base = pathToFileURL2(dir).href;
+  const base = pathToFileURL(dir).href;
   const files = discoverSkillFiles(dir);
   const lines = [
     `<skill_content name="${matchedSkill.prefixedName}">`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "Compound-engineering loops for OpenCode, Pi, and Claude Code",
   "type": "module",
   "homepage": "https://fro.bot/systematic",
@@ -93,8 +93,8 @@
   "devDependencies": {
     "@biomejs/biome": "2.5.8",
     "@earendil-works/pi-coding-agent": "0.83.0",
-    "@opencode-ai/plugin": "1.18.17",
-    "@opencode-ai/sdk": "1.18.17",
+    "@opencode-ai/plugin": "1.18.18",
+    "@opencode-ai/sdk": "1.18.18",
     "@semantic-release/exec": "7.1.0",
     "@tintinweb/pi-subagents": "0.14.3",
     "@types/bun": "latest",

package/dist/lib/model-availability.d.ts

@@ -1,83 +0,0 @@
-interface ConnectedProvider {
-    id: string;
-    models: Record<string, unknown>;
-}
-interface ProvidersResponse {
-    providers: ConnectedProvider[];
-    default: Record<string, string>;
-}
-interface ClientConfigApi {
-    providers: () => Promise<{
-        data: ProvidersResponse;
-        error: undefined;
-    } | {
-        data: undefined;
-        error: unknown;
-    }>;
-}
-export interface OpencodeClientLike {
-    config: ClientConfigApi;
-}
-/**
- * Outcome of model availability discovery.
- *
- * - `api`: The OpenCode server's `/config/providers` endpoint responded with
- *   a connected-providers payload AND `models` is non-empty. An authoritatively
- *   empty response (`data.providers = []`, or providers present with zero
- *   models) collapses to `'unknown'` instead — see below — because the
- *   operational consequence is identical and downstream consumers should treat
- *   both cases the same way.
- * - `cache`: The API call failed (error envelope, thrown, or timed out) and
- *   the local `models.json` cache was readable AND non-empty. `models`
- *   reflects whatever OpenCode last wrote to disk. A cache that loads
- *   successfully but produces a zero-size set collapses to `'unknown'` for
- *   the same operational reason an empty API response does.
- * - `unknown`: Either both the API call and the cache fallback failed (cache
- *   missing, unreadable, corrupt, or schema-mismatched), OR the API call
- *   succeeded with zero usable models. Resolution should degrade gracefully —
- *   callers should treat `unknown` as a signal to skip source-default model
- *   pinning so users do not get agents pinned to inaccessible models.
- *   `models` is the empty set.
- */
-export type DiscoveryStatus = 'api' | 'cache' | 'unknown';
-export interface ModelAvailability {
-    status: DiscoveryStatus;
-    /**
-     * Set of `${providerId}/${modelId}` strings. Typed `ReadonlySet` because
-     * callers must not mutate the returned collection — mutation would corrupt
-     * future calls in the same process. Each `ModelAvailability` is a fresh
-     * instance (see `emptyAvailability()`), so mutation via cast cannot
-     * propagate, but the type makes intent explicit.
-     */
-    models: ReadonlySet<string>;
-}
-interface AvailabilityOptions {
-    /**
-     * Maximum time to wait for `client.config.providers()` before falling
-     * back to the local cache. Defaults to 1500ms — a startup-budget value
-     * that prevents a slow/half-open OpenCode server from holding the plugin
-     * indefinitely.
-     *
-     * Set to `null` to disable the timeout entirely (not recommended).
-     */
-    apiTimeoutMs?: number | null;
-}
-/**
- * Discover the set of `provider/model` keys the OpenCode server considers
- * connected (or, on API failure, the set last written to the on-disk
- * `models.json` cache).
- *
- * The returned `status` lets callers distinguish three discovery outcomes:
- * - `api`: live answer; safe to pin source-default models against it
- * - `cache`: degraded but informed; the cached `provider/model` keys are
- *   plausibly still authoritative
- * - `unknown`: both the API and the cache failed; callers should fall back
- *   to OpenCode's parent-model inheritance rather than pinning a source
- *   default the user may not have access to
- *
- * The API call is bounded by `apiTimeoutMs` (default 1500ms). On timeout,
- * thrown error, error-envelope response, or undefined data, the cache
- * fallback runs. The function never rejects.
- */
-export declare function getAvailableModels(client: OpencodeClientLike, options?: AvailabilityOptions): Promise<ModelAvailability>;
-export {};