orionfold-relay 0.17.0 → 0.18.0

package/dist/cli.js

@@ -1177,14 +1177,16 @@ var init_detect = __esm({
 var types_exports = {};
 __export(types_exports, {
   CAPABILITY_VALUES: () => CAPABILITY_VALUES,
+  CURRENT_PLUGIN_API_VERSION: () => CURRENT_PLUGIN_API_VERSION,
   ORIGIN_VALUES: () => ORIGIN_VALUES,
   PluginManifestSchema: () => PluginManifestSchema
 });
 import { z } from "zod";
-var CAPABILITY_VALUES, ORIGIN_VALUES, PrimitivesBundleManifestSchema, ChatToolsPluginManifestSchema, PluginManifestSchema;
+var CURRENT_PLUGIN_API_VERSION, CAPABILITY_VALUES, ORIGIN_VALUES, PrimitivesBundleManifestSchema, ChatToolsPluginManifestSchema, PluginManifestSchema;
 var init_types = __esm({
   "src/lib/plugins/sdk/types.ts"() {
     "use strict";
+    CURRENT_PLUGIN_API_VERSION = "0.17";
     CAPABILITY_VALUES = ["fs", "net", "child_process", "env"];
     ORIGIN_VALUES = ["ainative-internal", "third-party"];
     PrimitivesBundleManifestSchema = z.object({
@@ -1230,16 +1232,16 @@ function computeHash(content) {
 function safePreview(content) {
   return content.slice(0, MAX_PREVIEW_CHARS).trim();
 }
-function safeStat(path20) {
+function safeStat(path21) {
   try {
-    return statSync2(path20);
+    return statSync2(path21);
   } catch {
     return null;
   }
 }
-function safeReadFile(path20) {
+function safeReadFile(path21) {
   try {
-    return readFileSync4(path20, "utf-8");
+    return readFileSync4(path21, "utf-8");
   } catch {
     return null;
   }
@@ -3717,6 +3719,14 @@ var init_format = __esm({
        * The string is the unit of entitlement, version- and pack-id-agnostic.
        */
       entitlement: z3.string().min(1).optional(),
+      /**
+       * Premium display copy (D6). Offline strings rendered on the locked
+       * gallery card — the Website still owns actual pricing. Meaningful only
+       * alongside `entitlement`; harmless on a free pack.
+       */
+      price: z3.string().min(1).optional(),
+      /** Get-license CTA target on the locked card. */
+      purchaseUrl: z3.url().optional(),
       /** Customer slugs seeded via ensureCustomer at install. */
       customers: z3.array(z3.string()).default([])
     }).strict();
@@ -3731,6 +3741,82 @@ var init_format = __esm({
   }
 });
 
+// src/lib/packs/catalog.ts
+var catalog_exports = {};
+__export(catalog_exports, {
+  UnknownPackNameError: () => UnknownPackNameError,
+  findPackTemplate: () => findPackTemplate,
+  listPackTemplates: () => listPackTemplates,
+  packTemplatesDir: () => packTemplatesDir,
+  resolvePackSource: () => resolvePackSource
+});
+import fs4 from "fs";
+import path4 from "path";
+function packTemplatesDir(opts2 = {}) {
+  return opts2.templatesDir ?? path4.join(
+    getAppRoot(import.meta.dirname, 3),
+    "src",
+    "lib",
+    "packs",
+    "templates"
+  );
+}
+function listPackTemplates(opts2 = {}) {
+  const dir = packTemplatesDir(opts2);
+  if (!fs4.existsSync(dir)) return [];
+  const out = [];
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const templateDir = path4.join(dir, entry.name);
+    try {
+      const pack = parsePack(templateDir);
+      out.push({
+        id: pack.meta.id,
+        dir: templateDir,
+        meta: pack.meta,
+        primitivesSummary: buildPrimitivesSummary(pack.manifest)
+      });
+    } catch (err2) {
+      out.push({
+        id: entry.name,
+        dir: templateDir,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
+  }
+  return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function findPackTemplate(id, opts2 = {}) {
+  const match = listPackTemplates(opts2).find((t) => t.id === id);
+  return match && !match.error ? match : null;
+}
+function resolvePackSource(source, opts2 = {}) {
+  if (fs4.existsSync(path4.resolve(source))) return source;
+  if (!BARE_NAME.test(source)) return source;
+  const template = findPackTemplate(source, opts2);
+  if (template) return template.dir;
+  const ids = listPackTemplates(opts2).filter((t) => !t.error).map((t) => t.id);
+  throw new UnknownPackNameError(
+    `Unknown pack "${source}". Bundled packs: ${ids.length ? ids.join(", ") : "(none)"}. Otherwise pass a folder path or git URL.`
+  );
+}
+var UnknownPackNameError, BARE_NAME;
+var init_catalog = __esm({
+  "src/lib/packs/catalog.ts"() {
+    "use strict";
+    init_app_root();
+    init_registry();
+    init_format();
+    UnknownPackNameError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "UnknownPackNameError";
+      }
+    };
+    BARE_NAME = /^[a-z0-9][a-z0-9-]*$/;
+  }
+});
+
 // src/lib/licensing/canonicalize.ts
 function canonicalize(v) {
   if (Array.isArray(v)) {
@@ -3914,7 +4000,7 @@ __export(load_exports, {
   LicenseLoadError: () => LicenseLoadError,
   loadLicense: () => loadLicense
 });
-import fs4 from "fs";
+import fs5 from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function assertEnvelope(value, origin) {
   if (!value || typeof value !== "object") {
@@ -3962,7 +4048,7 @@ async function loadLicense(urlOrPath) {
   const filePath = urlOrPath.startsWith("file://") ? fileURLToPath3(urlOrPath) : urlOrPath;
   let text2;
   try {
-    text2 = fs4.readFileSync(filePath, "utf-8");
+    text2 = fs5.readFileSync(filePath, "utf-8");
   } catch (err2) {
     throw new LicenseLoadError(
       `Could not read license file at ${filePath}.`,
@@ -3997,10 +4083,10 @@ __export(store_exports, {
   removeLicense: () => removeLicense,
   saveLicense: () => saveLicense
 });
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 function licensesDir(opts2 = {}) {
-  return opts2.dir ?? path4.join(getAinativeDataDir(), "licenses");
+  return opts2.dir ?? path5.join(getAinativeDataDir(), "licenses");
 }
 function readIdentity(payload) {
   const raw = payload.issued_to && typeof payload.issued_to === "object" ? payload.issued_to : {};
@@ -4012,7 +4098,7 @@ function readIdentity(payload) {
 }
 function buildInfo(payload, filePath, valid, reason) {
   return {
-    licenseId: String(payload.license_id ?? path4.basename(filePath, FILE_SUFFIX)),
+    licenseId: String(payload.license_id ?? path5.basename(filePath, FILE_SUFFIX)),
     filePath,
     valid,
     ...reason ? { reason } : {},
@@ -4051,14 +4137,14 @@ function saveLicense(envelope, opts2 = {}) {
     throw new LicenseStoreError(`License not saved: ${term.detail}`);
   }
   const dir = licensesDir(opts2);
-  const filePath = path4.join(dir, `${licenseId}${FILE_SUFFIX}`);
+  const filePath = path5.join(dir, `${licenseId}${FILE_SUFFIX}`);
   try {
-    fs5.mkdirSync(dir, { recursive: true });
-    const tmp = path4.join(dir, `.${licenseId}.${process.pid}.tmp`);
-    fs5.writeFileSync(tmp, JSON.stringify(envelope, null, 2) + "\n", {
+    fs6.mkdirSync(dir, { recursive: true });
+    const tmp = path5.join(dir, `.${licenseId}.${process.pid}.tmp`);
+    fs6.writeFileSync(tmp, JSON.stringify(envelope, null, 2) + "\n", {
       mode: 384
     });
-    fs5.renameSync(tmp, filePath);
+    fs6.renameSync(tmp, filePath);
   } catch (err2) {
     throw new LicenseStoreError(
       `Could not write license to ${filePath}: ${err2 instanceof Error ? err2.message : String(err2)}`,
@@ -4070,7 +4156,7 @@ function saveLicense(envelope, opts2 = {}) {
 function readEnvelope(filePath) {
   let text2;
   try {
-    text2 = fs5.readFileSync(filePath, "utf-8");
+    text2 = fs6.readFileSync(filePath, "utf-8");
   } catch (err2) {
     return {
       error: `unreadable: ${err2 instanceof Error ? err2.message : String(err2)}`
@@ -4089,11 +4175,11 @@ function readEnvelope(filePath) {
 function listLicenses(opts2 = {}) {
   const dir = licensesDir(opts2);
   const now = opts2.now ?? /* @__PURE__ */ new Date();
-  if (!fs5.existsSync(dir)) return [];
+  if (!fs6.existsSync(dir)) return [];
   const out = [];
-  for (const file of fs5.readdirSync(dir).sort()) {
+  for (const file of fs6.readdirSync(dir).sort()) {
     if (!file.endsWith(FILE_SUFFIX)) continue;
-    const filePath = path4.join(dir, file);
+    const filePath = path5.join(dir, file);
     const read = readEnvelope(filePath);
     if ("error" in read) {
       out.push(buildInfo({}, filePath, false, read.error));
@@ -4120,10 +4206,10 @@ function listLicenses(opts2 = {}) {
 function findEntitledLicense(entitlement, opts2 = {}) {
   const dir = licensesDir(opts2);
   const now = opts2.now ?? /* @__PURE__ */ new Date();
-  if (!fs5.existsSync(dir)) return null;
-  for (const file of fs5.readdirSync(dir).sort()) {
+  if (!fs6.existsSync(dir)) return null;
+  for (const file of fs6.readdirSync(dir).sort()) {
     if (!file.endsWith(FILE_SUFFIX)) continue;
-    const filePath = path4.join(dir, file);
+    const filePath = path5.join(dir, file);
     const read = readEnvelope(filePath);
     if ("error" in read) continue;
     try {
@@ -4149,10 +4235,10 @@ function findEntitledLicense(entitlement, opts2 = {}) {
 }
 function removeLicense(licenseId, opts2 = {}) {
   if (!SAFE_ID.test(licenseId)) return false;
-  const filePath = path4.join(licensesDir(opts2), `${licenseId}${FILE_SUFFIX}`);
-  if (!fs5.existsSync(filePath)) return false;
+  const filePath = path5.join(licensesDir(opts2), `${licenseId}${FILE_SUFFIX}`);
+  if (!fs6.existsSync(filePath)) return false;
   try {
-    fs5.rmSync(filePath);
+    fs6.rmSync(filePath);
   } catch (err2) {
     throw new LicenseStoreError(
       `Could not remove license ${licenseId}: ${err2 instanceof Error ? err2.message : String(err2)}`,
@@ -4211,8 +4297,8 @@ __export(compose_integration_exports, {
   extractAppIdFromArtifactId: () => extractAppIdFromArtifactId,
   upsertAppManifest: () => upsertAppManifest
 });
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import yaml3 from "js-yaml";
 import { eq as eq3 } from "drizzle-orm";
 function titleCase(slug) {
@@ -4233,10 +4319,10 @@ async function ensureAppProject(appId, appsDir = getAinativeAppsDir()) {
   return { projectId: appId, created: true };
 }
 function resolveAppName(appId, appsDir) {
-  const manifestPath = path5.join(appsDir, appId, "manifest.yaml");
-  if (fs6.existsSync(manifestPath)) {
+  const manifestPath = path6.join(appsDir, appId, "manifest.yaml");
+  if (fs7.existsSync(manifestPath)) {
     try {
-      const parsed = yaml3.load(fs6.readFileSync(manifestPath, "utf-8"));
+      const parsed = yaml3.load(fs7.readFileSync(manifestPath, "utf-8"));
       const result = AppManifestSchema.safeParse(parsed);
       if (result.success) return result.data.name;
     } catch {
@@ -4245,13 +4331,13 @@ function resolveAppName(appId, appsDir) {
   return titleCase(appId);
 }
 function upsertAppManifest(appId, artifact, displayName, appsDir = getAinativeAppsDir()) {
-  const appDir2 = path5.join(appsDir, appId);
-  const manifestPath = path5.join(appDir2, "manifest.yaml");
-  fs6.mkdirSync(appDir2, { recursive: true });
+  const appDir2 = path6.join(appsDir, appId);
+  const manifestPath = path6.join(appDir2, "manifest.yaml");
+  fs7.mkdirSync(appDir2, { recursive: true });
   let manifest = emptyManifest(appId, displayName);
-  if (fs6.existsSync(manifestPath)) {
+  if (fs7.existsSync(manifestPath)) {
     try {
-      const parsed = yaml3.load(fs6.readFileSync(manifestPath, "utf-8"));
+      const parsed = yaml3.load(fs7.readFileSync(manifestPath, "utf-8"));
       const result = AppManifestSchema.safeParse(parsed);
       if (result.success) manifest = result.data;
     } catch {
@@ -4266,7 +4352,7 @@ function upsertAppManifest(appId, artifact, displayName, appsDir = getAinativeAp
     if (artifact.runs) entry.runs = artifact.runs;
     arr.push(entry);
   }
-  fs6.writeFileSync(manifestPath, yaml3.dump(manifest));
+  fs7.writeFileSync(manifestPath, yaml3.dump(manifest));
   invalidateAppsCache();
   return manifest;
 }
@@ -4622,8 +4708,8 @@ var init_blueprint = __esm({
 });
 
 // src/lib/agents/runtime/catalog.ts
-var catalog_exports = {};
-__export(catalog_exports, {
+var catalog_exports2 = {};
+__export(catalog_exports2, {
   DEFAULT_AGENT_RUNTIME: () => DEFAULT_AGENT_RUNTIME,
   SUPPORTED_AGENT_RUNTIMES: () => SUPPORTED_AGENT_RUNTIMES,
   getRuntimeCapabilities: () => getRuntimeCapabilities,
@@ -4655,7 +4741,7 @@ function listRuntimeCatalog() {
   return SUPPORTED_AGENT_RUNTIMES.map((runtimeId) => RUNTIME_CATALOG[runtimeId]);
 }
 var SUPPORTED_AGENT_RUNTIMES, DEFAULT_AGENT_RUNTIME, RUNTIME_CATALOG;
-var init_catalog = __esm({
+var init_catalog2 = __esm({
   "src/lib/agents/runtime/catalog.ts"() {
     "use strict";
     SUPPORTED_AGENT_RUNTIMES = [
@@ -4869,7 +4955,7 @@ var runtimeIdSchema, profileTestsSchema, canUseToolPolicySchema, profileRuntimeO
 var init_profile = __esm({
   "src/lib/validators/profile.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     runtimeIdSchema = z5.enum(SUPPORTED_AGENT_RUNTIMES);
     profileTestsSchema = z5.array(
       z5.object({
@@ -4991,29 +5077,29 @@ function resolveProfileRuntimePayload(profile, runtimeId) {
 var init_compatibility = __esm({
   "src/lib/agents/profiles/compatibility.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
   }
 });
 
 // src/lib/agents/profiles/project-profiles.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 import yaml4 from "js-yaml";
 function getProjectSkillsSignature(skillsDir) {
-  if (!fs7.existsSync(skillsDir)) return "missing";
-  const entries = fs7.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  if (!fs8.existsSync(skillsDir)) return "missing";
+  const entries = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   const parts = [];
   for (const entry of entries) {
-    const dir = path6.join(skillsDir, entry.name);
+    const dir = path7.join(skillsDir, entry.name);
     parts.push(entry.name);
-    const yamlPath = path6.join(dir, "profile.yaml");
-    if (fs7.existsSync(yamlPath)) {
-      const s = fs7.statSync(yamlPath);
+    const yamlPath = path7.join(dir, "profile.yaml");
+    if (fs8.existsSync(yamlPath)) {
+      const s = fs8.statSync(yamlPath);
       parts.push(`yaml:${s.mtimeMs}:${s.size}`);
     }
-    const skillPath = path6.join(dir, "SKILL.md");
-    if (fs7.existsSync(skillPath)) {
-      const s = fs7.statSync(skillPath);
+    const skillPath = path7.join(dir, "SKILL.md");
+    if (fs8.existsSync(skillPath)) {
+      const s = fs8.statSync(skillPath);
       parts.push(`skill:${s.mtimeMs}:${s.size}`);
     }
   }
@@ -5034,8 +5120,8 @@ function parseFrontmatter(content) {
   return fm;
 }
 function generateMinimalProfile(skillDir, dirName, projectDir) {
-  const skillPath = path6.join(skillDir, "SKILL.md");
-  const skillMd = fs7.readFileSync(skillPath, "utf-8");
+  const skillPath = path7.join(skillDir, "SKILL.md");
+  const skillMd = fs8.readFileSync(skillPath, "utf-8");
   const fm = parseFrontmatter(skillMd);
   return {
     id: dirName,
@@ -5052,20 +5138,20 @@ function generateMinimalProfile(skillDir, dirName, projectDir) {
   };
 }
 function scanProjectProfiles(projectDir) {
-  const skillsDir = path6.join(projectDir, ".claude", "skills");
-  if (!fs7.existsSync(skillsDir)) return [];
+  const skillsDir = path7.join(projectDir, ".claude", "skills");
+  if (!fs8.existsSync(skillsDir)) return [];
   const signature = getProjectSkillsSignature(skillsDir);
   const cached = projectProfileCache.get(projectDir);
   if (cached && cached.signature === signature) return cached.profiles;
   const profiles = [];
-  for (const entry of fs7.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs8.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const dir = path6.join(skillsDir, entry.name);
-    const yamlPath = path6.join(dir, "profile.yaml");
-    const skillPath = path6.join(dir, "SKILL.md");
-    if (fs7.existsSync(yamlPath) && fs7.existsSync(skillPath)) {
+    const dir = path7.join(skillsDir, entry.name);
+    const yamlPath = path7.join(dir, "profile.yaml");
+    const skillPath = path7.join(dir, "SKILL.md");
+    if (fs8.existsSync(yamlPath) && fs8.existsSync(skillPath)) {
       try {
-        const rawYaml = fs7.readFileSync(yamlPath, "utf-8");
+        const rawYaml = fs8.readFileSync(yamlPath, "utf-8");
         const parsed = yaml4.load(rawYaml);
         const result = ProfileConfigSchema.safeParse(parsed);
         if (!result.success) {
@@ -5076,7 +5162,7 @@ function scanProjectProfiles(projectDir) {
           continue;
         }
         const config = result.data;
-        const skillMd = fs7.readFileSync(skillPath, "utf-8");
+        const skillMd = fs8.readFileSync(skillPath, "utf-8");
         const descMatch = skillMd.match(
           /^---\s*\n[\s\S]*?description:\s*(.+?)\s*\n[\s\S]*?---/
         );
@@ -5110,7 +5196,7 @@ function scanProjectProfiles(projectDir) {
           err2
         );
       }
-    } else if (fs7.existsSync(skillPath)) {
+    } else if (fs8.existsSync(skillPath)) {
       try {
         profiles.push(generateMinimalProfile(dir, entry.name, projectDir));
       } catch (err2) {
@@ -5136,7 +5222,7 @@ var init_project_profiles = __esm({
 
 // src/lib/environment/profile-linker.ts
 import { eq as eq6, and as and2, isNull } from "drizzle-orm";
-import path7 from "path";
+import path8 from "path";
 var init_profile_linker = __esm({
   "src/lib/environment/profile-linker.ts"() {
     "use strict";
@@ -5187,23 +5273,23 @@ var init_data = __esm({
 });
 
 // src/lib/agents/profiles/app-manifest-source.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 import yaml5 from "js-yaml";
 function titleCase2(slug) {
   return slug.split("-").filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(" ");
 }
 function loadAppManifestProfiles(appsDir, profilesDir, builtinsDir) {
-  if (!fs8.existsSync(appsDir)) return [];
+  if (!fs9.existsSync(appsDir)) return [];
   const synthesized = /* @__PURE__ */ new Map();
-  for (const entry of fs8.readdirSync(appsDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(appsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const appId = entry.name;
-    const manifestPath = path8.join(appsDir, appId, "manifest.yaml");
-    if (!fs8.existsSync(manifestPath)) continue;
+    const manifestPath = path9.join(appsDir, appId, "manifest.yaml");
+    if (!fs9.existsSync(manifestPath)) continue;
     let manifest;
     try {
-      const parsed = yaml5.load(fs8.readFileSync(manifestPath, "utf-8"));
+      const parsed = yaml5.load(fs9.readFileSync(manifestPath, "utf-8"));
       manifest = AppManifestSchema.safeParse(parsed);
     } catch (err2) {
       console.warn(`[app-manifest-source] Malformed manifest for ${appId}:`, err2);
@@ -5215,9 +5301,9 @@ function loadAppManifestProfiles(appsDir, profilesDir, builtinsDir) {
     }
     for (const profileRef of manifest.data.profiles ?? []) {
       const profileId = profileRef.id;
-      const userYaml = path8.join(profilesDir, profileId, "profile.yaml");
-      const builtinYaml = path8.join(builtinsDir, profileId, "profile.yaml");
-      if (fs8.existsSync(userYaml) || fs8.existsSync(builtinYaml)) continue;
+      const userYaml = path9.join(profilesDir, profileId, "profile.yaml");
+      const builtinYaml = path9.join(builtinsDir, profileId, "profile.yaml");
+      if (fs9.existsSync(userYaml) || fs9.existsSync(builtinYaml)) continue;
       const existing = synthesized.get(profileId);
       if (existing) {
         if (!existing.tags.includes(appId)) {
@@ -5248,7 +5334,7 @@ function loadAppManifestProfiles(appsDir, profilesDir, builtinsDir) {
 var init_app_manifest_source = __esm({
   "src/lib/agents/profiles/app-manifest-source.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     init_registry();
   }
 });
@@ -5273,29 +5359,29 @@ __export(registry_exports2, {
   scanProfilesIntoMap: () => scanProfilesIntoMap,
   updateProfile: () => updateProfile
 });
-import fs9 from "fs";
+import fs10 from "fs";
 import { homedir as homedir3 } from "os";
-import path9 from "path";
+import path10 from "path";
 import yaml6 from "js-yaml";
 import { eq as eq8, and as and4 } from "drizzle-orm";
 function getBuiltinsDir() {
   return BUILTINS_DIR;
 }
 function getDirectorySignatureParts(baseDir) {
-  if (!fs9.existsSync(baseDir)) return [];
-  const entries = fs9.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  if (!fs10.existsSync(baseDir)) return [];
+  const entries = fs10.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   const parts = [];
   for (const entry of entries) {
-    const dir = path9.join(baseDir, entry.name);
-    const yamlPath = path9.join(dir, "profile.yaml");
-    const skillPath = path9.join(dir, "SKILL.md");
+    const dir = path10.join(baseDir, entry.name);
+    const yamlPath = path10.join(dir, "profile.yaml");
+    const skillPath = path10.join(dir, "SKILL.md");
     parts.push(entry.name);
-    if (fs9.existsSync(yamlPath)) {
-      const stats = fs9.statSync(yamlPath);
+    if (fs10.existsSync(yamlPath)) {
+      const stats = fs10.statSync(yamlPath);
       parts.push(`yaml:${stats.mtimeMs}:${stats.size}`);
     }
-    if (fs9.existsSync(skillPath)) {
-      const stats = fs9.statSync(skillPath);
+    if (fs10.existsSync(skillPath)) {
+      const stats = fs10.statSync(skillPath);
       parts.push(`skill:${stats.mtimeMs}:${stats.size}`);
     }
   }
@@ -5303,14 +5389,14 @@ function getDirectorySignatureParts(baseDir) {
 }
 function getAppsDirectorySignature() {
   const appsDir = getAinativeAppsDir();
-  if (!fs9.existsSync(appsDir)) return "no-apps";
+  if (!fs10.existsSync(appsDir)) return "no-apps";
   const parts = [];
-  const entries = fs9.readdirSync(appsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = fs10.readdirSync(appsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const manifestPath = path9.join(appsDir, entry.name, "manifest.yaml");
+    const manifestPath = path10.join(appsDir, entry.name, "manifest.yaml");
     parts.push(entry.name);
-    if (fs9.existsSync(manifestPath)) {
-      const stats = fs9.statSync(manifestPath);
+    if (fs10.existsSync(manifestPath)) {
+      const stats = fs10.statSync(manifestPath);
       parts.push(`manifest:${stats.mtimeMs}:${stats.size}`);
     }
   }
@@ -5333,17 +5419,17 @@ function getSkillsDirectorySignature() {
 }
 function ensureBuiltins() {
   const builtinsDir = getBuiltinsDir();
-  if (!fs9.existsSync(builtinsDir)) return;
-  fs9.mkdirSync(SKILLS_DIR, { recursive: true });
-  for (const entry of fs9.readdirSync(builtinsDir, { withFileTypes: true })) {
+  if (!fs10.existsSync(builtinsDir)) return;
+  fs10.mkdirSync(SKILLS_DIR, { recursive: true });
+  for (const entry of fs10.readdirSync(builtinsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const targetDir = path9.join(SKILLS_DIR, entry.name);
-    const targetYaml = path9.join(targetDir, "profile.yaml");
-    const srcYaml = path9.join(builtinsDir, entry.name, "profile.yaml");
-    if (fs9.existsSync(targetYaml)) {
+    const targetDir = path10.join(SKILLS_DIR, entry.name);
+    const targetYaml = path10.join(targetDir, "profile.yaml");
+    const srcYaml = path10.join(builtinsDir, entry.name, "profile.yaml");
+    if (fs10.existsSync(targetYaml)) {
       try {
-        const source = yaml6.load(fs9.readFileSync(srcYaml, "utf-8")) ?? {};
-        const target = yaml6.load(fs9.readFileSync(targetYaml, "utf-8")) ?? {};
+        const source = yaml6.load(fs10.readFileSync(srcYaml, "utf-8")) ?? {};
+        const target = yaml6.load(fs10.readFileSync(targetYaml, "utf-8")) ?? {};
         let changed = false;
         if (source.supportedRuntimes !== void 0 && target.supportedRuntimes === void 0) {
           target.supportedRuntimes = source.supportedRuntimes;
@@ -5362,29 +5448,29 @@ function ensureBuiltins() {
           changed = true;
         }
         if (changed) {
-          fs9.writeFileSync(targetYaml, yaml6.dump(target));
+          fs10.writeFileSync(targetYaml, yaml6.dump(target));
         }
       } catch {
       }
       continue;
     }
-    fs9.mkdirSync(targetDir, { recursive: true });
-    const srcDir = path9.join(builtinsDir, entry.name);
-    for (const file of fs9.readdirSync(srcDir)) {
-      fs9.copyFileSync(path9.join(srcDir, file), path9.join(targetDir, file));
+    fs10.mkdirSync(targetDir, { recursive: true });
+    const srcDir = path10.join(builtinsDir, entry.name);
+    for (const file of fs10.readdirSync(srcDir)) {
+      fs10.copyFileSync(path10.join(srcDir, file), path10.join(targetDir, file));
     }
   }
 }
 function scanProfilesFromDir(baseDir, profiles, options = {}) {
-  if (!fs9.existsSync(baseDir)) return;
-  for (const entry of fs9.readdirSync(baseDir, { withFileTypes: true })) {
+  if (!fs10.existsSync(baseDir)) return;
+  for (const entry of fs10.readdirSync(baseDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const dir = path9.join(baseDir, entry.name);
-    const yamlPath = path9.join(dir, "profile.yaml");
-    const skillPath = path9.join(dir, "SKILL.md");
-    if (!fs9.existsSync(yamlPath)) continue;
+    const dir = path10.join(baseDir, entry.name);
+    const yamlPath = path10.join(dir, "profile.yaml");
+    const skillPath = path10.join(dir, "SKILL.md");
+    if (!fs10.existsSync(yamlPath)) continue;
     try {
-      const rawYaml = fs9.readFileSync(yamlPath, "utf-8");
+      const rawYaml = fs10.readFileSync(yamlPath, "utf-8");
       const parsed = yaml6.load(rawYaml);
       const result = ProfileConfigSchema.safeParse(parsed);
       if (!result.success) {
@@ -5395,7 +5481,7 @@ function scanProfilesFromDir(baseDir, profiles, options = {}) {
         continue;
       }
       const config = result.data;
-      const skillMd = fs9.existsSync(skillPath) ? fs9.readFileSync(skillPath, "utf-8") : "";
+      const skillMd = fs10.existsSync(skillPath) ? fs10.readFileSync(skillPath, "utf-8") : "";
       const descMatch = skillMd.match(
         /^---\s*\n[\s\S]*?description:\s*(.+?)\s*\n[\s\S]*?---/
       );
@@ -5485,20 +5571,20 @@ function reloadProfiles() {
   profileCacheSignature = null;
 }
 function isBuiltin(id) {
-  return fs9.existsSync(path9.join(getBuiltinsDir(), id, "profile.yaml"));
+  return fs10.existsSync(path10.join(getBuiltinsDir(), id, "profile.yaml"));
 }
 function createProfile(config, skillMd) {
   const result = ProfileConfigSchema.safeParse(config);
   if (!result.success) {
     throw new Error(`Invalid profile: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
-  const dir = path9.join(SKILLS_DIR, config.id);
-  if (fs9.existsSync(path9.join(dir, "profile.yaml"))) {
+  const dir = path10.join(SKILLS_DIR, config.id);
+  if (fs10.existsSync(path10.join(dir, "profile.yaml"))) {
     throw new Error(`Profile "${config.id}" already exists`);
   }
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(path9.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs9.writeFileSync(path9.join(dir, "SKILL.md"), skillMd);
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
+  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5507,13 +5593,13 @@ function createPromotedProfile(config, skillMd) {
   if (!result.success) {
     throw new Error(`Invalid profile: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
-  const dir = path9.join(PROMOTED_PROFILES_DIR, config.id);
-  if (fs9.existsSync(path9.join(dir, "profile.yaml"))) {
+  const dir = path10.join(PROMOTED_PROFILES_DIR, config.id);
+  if (fs10.existsSync(path10.join(dir, "profile.yaml"))) {
     throw new Error(`Profile "${config.id}" already exists`);
   }
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(path9.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs9.writeFileSync(path9.join(dir, "SKILL.md"), skillMd);
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
+  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5525,14 +5611,14 @@ function updateProfile(id, config, skillMd) {
   if (!result.success) {
     throw new Error(`Invalid profile: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
-  const skillsDir = path9.join(SKILLS_DIR, id);
-  const promotedDir = path9.join(PROMOTED_PROFILES_DIR, id);
-  const dir = fs9.existsSync(skillsDir) ? skillsDir : fs9.existsSync(promotedDir) ? promotedDir : null;
+  const skillsDir = path10.join(SKILLS_DIR, id);
+  const promotedDir = path10.join(PROMOTED_PROFILES_DIR, id);
+  const dir = fs10.existsSync(skillsDir) ? skillsDir : fs10.existsSync(promotedDir) ? promotedDir : null;
   if (!dir) {
     throw new Error(`Profile "${id}" not found`);
   }
-  fs9.writeFileSync(path9.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs9.writeFileSync(path9.join(dir, "SKILL.md"), skillMd);
+  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
+  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5540,13 +5626,13 @@ function deleteProfile(id) {
   if (isBuiltin(id)) {
     throw new Error("Cannot delete built-in profiles");
   }
-  const skillsDir = path9.join(SKILLS_DIR, id);
-  const promotedDir = path9.join(PROMOTED_PROFILES_DIR, id);
-  const dir = fs9.existsSync(skillsDir) ? skillsDir : fs9.existsSync(promotedDir) ? promotedDir : null;
+  const skillsDir = path10.join(SKILLS_DIR, id);
+  const promotedDir = path10.join(PROMOTED_PROFILES_DIR, id);
+  const dir = fs10.existsSync(skillsDir) ? skillsDir : fs10.existsSync(promotedDir) ? promotedDir : null;
   if (!dir) {
     throw new Error(`Profile "${id}" not found`);
   }
-  fs9.rmSync(dir, { recursive: true, force: true });
+  fs10.rmSync(dir, { recursive: true, force: true });
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5630,7 +5716,7 @@ var init_registry2 = __esm({
     init_ainative_paths();
     init_app_manifest_source();
     init_app_root();
-    BUILTINS_DIR = path9.resolve(
+    BUILTINS_DIR = path10.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -5638,7 +5724,7 @@ var init_registry2 = __esm({
       "profiles",
       "builtins"
     );
-    SKILLS_DIR = path9.join(
+    SKILLS_DIR = path10.join(
       process.env.HOME ?? process.env.USERPROFILE ?? homedir3(),
       ".claude",
       "skills"
@@ -5666,16 +5752,16 @@ __export(registry_exports3, {
   reloadBlueprints: () => reloadBlueprints,
   validateBlueprintRefs: () => validateBlueprintRefs
 });
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import yaml7 from "js-yaml";
 function scanDirectory(dir, isBuiltin2) {
   const blueprints = /* @__PURE__ */ new Map();
-  if (!fs10.existsSync(dir)) return blueprints;
-  for (const file of fs10.readdirSync(dir)) {
+  if (!fs11.existsSync(dir)) return blueprints;
+  for (const file of fs11.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      const content = fs10.readFileSync(path10.join(dir, file), "utf-8");
+      const content = fs11.readFileSync(path11.join(dir, file), "utf-8");
       const parsed = yaml7.load(content);
       const result = BlueprintSchema.safeParse(parsed);
       if (!result.success) {
@@ -5729,12 +5815,12 @@ function createBlueprint(yamlContent) {
       `Invalid blueprint: ${result.error.issues.map((i) => i.message).join(", ")}`
     );
   }
-  fs10.mkdirSync(USER_BLUEPRINTS_DIR, { recursive: true });
-  const filePath = path10.join(USER_BLUEPRINTS_DIR, `${result.data.id}.yaml`);
-  if (fs10.existsSync(filePath)) {
+  fs11.mkdirSync(USER_BLUEPRINTS_DIR, { recursive: true });
+  const filePath = path11.join(USER_BLUEPRINTS_DIR, `${result.data.id}.yaml`);
+  if (fs11.existsSync(filePath)) {
     throw new Error(`Blueprint "${result.data.id}" already exists`);
   }
-  fs10.writeFileSync(filePath, yamlContent);
+  fs11.writeFileSync(filePath, yamlContent);
   reloadBlueprints();
   return { ...result.data, isBuiltin: false };
 }
@@ -5742,11 +5828,11 @@ function deleteBlueprint(id) {
   if (isBuiltinBlueprint(id)) {
     throw new Error("Cannot delete built-in blueprints");
   }
-  const filePath = path10.join(USER_BLUEPRINTS_DIR, `${id}.yaml`);
-  if (!fs10.existsSync(filePath)) {
+  const filePath = path11.join(USER_BLUEPRINTS_DIR, `${id}.yaml`);
+  if (!fs11.existsSync(filePath)) {
     throw new Error(`Blueprint "${id}" not found`);
   }
-  fs10.unlinkSync(filePath);
+  fs11.unlinkSync(filePath);
   reloadBlueprints();
 }
 function getUserBlueprintsDir() {
@@ -5805,7 +5891,7 @@ var init_registry3 = __esm({
     init_ainative_paths();
     init_app_root();
     init_registry2();
-    BUILTINS_DIR2 = path10.resolve(
+    BUILTINS_DIR2 = path11.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -6667,18 +6753,18 @@ var init_processor = __esm({
 });
 
 // src/lib/documents/output-scanner.ts
-import path11 from "path";
-import fs11 from "fs/promises";
+import path12 from "path";
+import fs12 from "fs/promises";
 import { and as and6, eq as eq14 } from "drizzle-orm";
 function getTaskOutputDirectory(taskId) {
-  return path11.join(TASK_OUTPUTS_DIR, taskId);
+  return path12.join(TASK_OUTPUTS_DIR, taskId);
 }
 async function prepareTaskOutputDirectory(taskId, options = {}) {
   const outputDir = getTaskOutputDirectory(taskId);
   if (options.clearExisting) {
-    await fs11.rm(outputDir, { recursive: true, force: true });
+    await fs12.rm(outputDir, { recursive: true, force: true });
   }
-  await fs11.mkdir(outputDir, { recursive: true });
+  await fs12.mkdir(outputDir, { recursive: true });
   return outputDir;
 }
 function buildTaskOutputInstructions(taskId) {
@@ -6691,10 +6777,10 @@ function buildTaskOutputInstructions(taskId) {
   ].join("\n");
 }
 async function listFilesRecursively(rootDir) {
-  const entries = await fs11.readdir(rootDir, { withFileTypes: true });
+  const entries = await fs12.readdir(rootDir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map(async (entry) => {
-      const resolved = path11.join(rootDir, entry.name);
+      const resolved = path12.join(rootDir, entry.name);
       if (entry.isDirectory()) {
         return listFilesRecursively(resolved);
       }
@@ -6704,13 +6790,13 @@ async function listFilesRecursively(rootDir) {
   return files.flat();
 }
 function resolveOutputMimeType(filename) {
-  return OUTPUT_MIME_TYPES[path11.extname(filename).toLowerCase()] ?? null;
+  return OUTPUT_MIME_TYPES[path12.extname(filename).toLowerCase()] ?? null;
 }
 function normalizeRelativePath(value) {
-  return value.split(path11.sep).join("/");
+  return value.split(path12.sep).join("/");
 }
 function buildArchivedFilename(relativePath, version) {
-  const parsed = path11.parse(relativePath);
+  const parsed = path12.parse(relativePath);
   const sanitizedBase = parsed.name.replace(/[^a-zA-Z0-9._-]+/g, "-");
   const nestedPrefix = parsed.dir ? `${parsed.dir.replace(/[\\/]+/g, "__")}__` : "";
   return `${nestedPrefix}${sanitizedBase || "output"}-v${version}${parsed.ext}`;
@@ -6722,7 +6808,7 @@ async function scanTaskOutputDocuments(taskId) {
     throw new Error(`Task ${taskId} not found`);
   }
   try {
-    await fs11.access(outputDir);
+    await fs12.access(outputDir);
   } catch {
     return [];
   }
@@ -6742,22 +6828,22 @@ async function scanTaskOutputDocuments(taskId) {
   const discoveredFiles = await listFilesRecursively(outputDir);
   const registeredDocumentIds = [];
   for (const sourcePath of discoveredFiles) {
-    const relativePath = normalizeRelativePath(path11.relative(outputDir, sourcePath));
+    const relativePath = normalizeRelativePath(path12.relative(outputDir, sourcePath));
     const mimeType = resolveOutputMimeType(relativePath);
     if (!mimeType) {
       continue;
     }
-    const stats = await fs11.stat(sourcePath);
+    const stats = await fs12.stat(sourcePath);
     if (!stats.isFile()) {
       continue;
     }
     const nextVersion = (versionMap.get(relativePath) ?? 0) + 1;
     versionMap.set(relativePath, nextVersion);
-    const archiveDir = path11.join(OUTPUT_ARCHIVE_DIR, taskId);
-    await fs11.mkdir(archiveDir, { recursive: true });
+    const archiveDir = path12.join(OUTPUT_ARCHIVE_DIR, taskId);
+    await fs12.mkdir(archiveDir, { recursive: true });
     const archivedFilename = buildArchivedFilename(relativePath, nextVersion);
-    const archivedPath = path11.join(archiveDir, archivedFilename);
-    await fs11.copyFile(sourcePath, archivedPath);
+    const archivedPath = path12.join(archiveDir, archivedFilename);
+    await fs12.copyFile(sourcePath, archivedPath);
     const documentId = crypto.randomUUID();
     const now = /* @__PURE__ */ new Date();
     await db.insert(documents).values({
@@ -6788,8 +6874,8 @@ var init_output_scanner = __esm({
     init_schema();
     init_env();
     init_processor();
-    TASK_OUTPUTS_DIR = path11.join(dataDir(), "outputs");
-    OUTPUT_ARCHIVE_DIR = path11.join(dataDir(), "documents", "output");
+    TASK_OUTPUTS_DIR = path12.join(dataDir(), "outputs");
+    OUTPUT_ARCHIVE_DIR = path12.join(dataDir(), "documents", "output");
     OUTPUT_MIME_TYPES = {
       ".md": "text/markdown",
       ".txt": "text/plain",
@@ -6849,7 +6935,7 @@ var CHAT_MODELS;
 var init_types2 = __esm({
   "src/lib/chat/types.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     CHAT_MODELS = [
       // Anthropic — uses SDK short names
       { id: "haiku", label: "Haiku", provider: "anthropic", tier: "Fast", costLabel: "$" },
@@ -6861,7 +6947,7 @@ var init_types2 = __esm({
       { id: "gpt-5.4", label: "GPT-5.4", provider: "openai", tier: "Best", costLabel: "$$$" }
     ];
     try {
-      const { listRuntimeCatalog: listRuntimeCatalog2 } = (init_catalog(), __toCommonJS(catalog_exports));
+      const { listRuntimeCatalog: listRuntimeCatalog2 } = (init_catalog2(), __toCommonJS(catalog_exports2));
       const allSupportedModels = /* @__PURE__ */ new Set();
       for (const runtime of listRuntimeCatalog2()) {
         for (const model of runtime.models.supported) {
@@ -7920,7 +8006,7 @@ var init_ledger = __esm({
 });
 
 // src/lib/plugins/classify-trust.ts
-import path12 from "path";
+import path13 from "path";
 import os from "os";
 function classifyPluginTrust(manifest, rootDir, opts2 = {}) {
   if (manifest.kind === "primitives-bundle") return "self";
@@ -7934,9 +8020,9 @@ function classifyPluginTrust(manifest, rootDir, opts2 = {}) {
     if (manifest.author === currentUser) return "self";
   }
   const appsBase = opts2.appsBaseDir ?? getAinativeAppsDir();
-  const normalizedRoot = path12.resolve(rootDir);
-  const normalizedApps = path12.resolve(appsBase);
-  const sep = path12.sep;
+  const normalizedRoot = path13.resolve(rootDir);
+  const normalizedApps = path13.resolve(appsBase);
+  const sep = path13.sep;
   if (normalizedRoot === normalizedApps || normalizedRoot.startsWith(normalizedApps + sep)) {
     return "self";
   }
@@ -7957,15 +8043,15 @@ __export(transport_dispatch_exports, {
   validateStdioMcp: () => validateStdioMcp
 });
 import { spawn } from "child_process";
-import fs12 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path14 from "path";
 import readline from "readline";
 function logToFile2(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs12.mkdirSync(logsDir, { recursive: true });
-    fs12.appendFileSync(
-      path13.join(logsDir, "plugins.log"),
+    fs13.mkdirSync(logsDir, { recursive: true });
+    fs13.appendFileSync(
+      path14.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -8100,14 +8186,14 @@ async function validateInProcessSdk(config, pluginId, serverName) {
     };
   }
   const absPath = config.entry;
-  if (!path13.isAbsolute(absPath)) {
+  if (!path14.isAbsolute(absPath)) {
     return {
       ok: false,
       reason: "sdk_invalid_export",
       detail: `entry must be absolute path, got: ${absPath}`
     };
   }
-  const ext = path13.extname(absPath);
+  const ext = path14.extname(absPath);
   if (ext === ".ts") {
     return {
       ok: false,
@@ -8226,8 +8312,8 @@ __export(mcp_loader_exports, {
   loadPluginMcpServers: () => loadPluginMcpServers,
   reloadPluginMcpRegistrations: () => reloadPluginMcpRegistrations
 });
-import fs13 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path15 from "path";
 import os2 from "os";
 import yaml8 from "js-yaml";
 function __resetDockerBootSweepForTests() {
@@ -8236,9 +8322,9 @@ function __resetDockerBootSweepForTests() {
 function logToFile3(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs13.mkdirSync(logsDir, { recursive: true });
-    fs13.appendFileSync(
-      path14.join(logsDir, "plugins.log"),
+    fs14.mkdirSync(logsDir, { recursive: true });
+    fs14.appendFileSync(
+      path15.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -8263,10 +8349,10 @@ function isRelativeCommand(command) {
 }
 async function scanPlugin(pluginDir, pluginId) {
   const registrations = [];
-  const pluginYamlPath = path14.join(pluginDir, "plugin.yaml");
+  const pluginYamlPath = path15.join(pluginDir, "plugin.yaml");
   let pluginYamlContent;
   try {
-    pluginYamlContent = fs13.readFileSync(pluginYamlPath, "utf-8");
+    pluginYamlContent = fs14.readFileSync(pluginYamlPath, "utf-8");
   } catch {
     return { registrations };
   }
@@ -8288,7 +8374,7 @@ async function scanPlugin(pluginDir, pluginId) {
   if (manifest.kind !== "chat-tools") {
     return { registrations };
   }
-  const mcpJsonPath = path14.join(pluginDir, ".mcp.json");
+  const mcpJsonPath = path15.join(pluginDir, ".mcp.json");
   const mcpServers = parseMcpConfigFile(mcpJsonPath);
   if (mcpServers === null) {
     logToFile3(
@@ -8392,8 +8478,8 @@ async function scanPlugin(pluginDir, pluginId) {
       const resolvedEnv = resolveEnvTemplates(rawEntry.env, context);
       let resolvedCommand;
       if (isRelativeCommand(rawCommand)) {
-        const absCommand = path14.resolve(pluginDir, rawCommand);
-        if (!fs13.existsSync(absCommand)) {
+        const absCommand = path15.resolve(pluginDir, rawCommand);
+        if (!fs14.existsSync(absCommand)) {
           logToFile3(
             `[mcp-loader] plugin ${pluginId} server "${serverName}": command "${rawCommand}" not found at ${absCommand} (server_not_found)`
           );
@@ -8487,8 +8573,8 @@ async function scanPlugin(pluginDir, pluginId) {
         });
         continue;
       }
-      const absEntry = path14.resolve(pluginDir, entryField);
-      if (!fs13.existsSync(absEntry)) {
+      const absEntry = path15.resolve(pluginDir, entryField);
+      if (!fs14.existsSync(absEntry)) {
         logToFile3(
           `[mcp-loader] plugin ${pluginId} server "${serverName}": entry "${entryField}" not found at ${absEntry} (sdk_entry_not_found)`
         );
@@ -8557,9 +8643,9 @@ async function listPluginMcpRegistrations(opts2) {
     const features = getRuntimeFeatures(opts2.runtime);
     if (!features.supportsPluginMcpServers) {
       const pluginsDir2 = getAinativePluginsDir();
-      if (fs13.existsSync(pluginsDir2)) {
+      if (fs14.existsSync(pluginsDir2)) {
         try {
-          for (const entry of fs13.readdirSync(pluginsDir2).sort()) {
+          for (const entry of fs14.readdirSync(pluginsDir2).sort()) {
             const logKey = `${entry}@${opts2.runtime}@${pluginsDir2}`;
             if (!ollamaSkipLogged.has(logKey)) {
               ollamaSkipLogged.add(logKey);
@@ -8582,22 +8668,22 @@ async function listPluginMcpRegistrations(opts2) {
     }
   }
   const pluginsDir = getAinativePluginsDir();
-  if (!fs13.existsSync(pluginsDir)) {
+  if (!fs14.existsSync(pluginsDir)) {
     return [];
   }
   let pluginDirEntries;
   try {
-    pluginDirEntries = fs13.readdirSync(pluginsDir).sort();
+    pluginDirEntries = fs14.readdirSync(pluginsDir).sort();
   } catch {
     logToFile3(`[mcp-loader] could not read plugins directory: ${pluginsDir}`);
     return [];
   }
   const allRegistrations = [];
   for (const entry of pluginDirEntries) {
-    const pluginDir = path14.join(pluginsDir, entry);
+    const pluginDir = path15.join(pluginsDir, entry);
     let stat2;
     try {
-      stat2 = fs13.statSync(pluginDir);
+      stat2 = fs14.statSync(pluginDir);
     } catch {
       continue;
     }
@@ -8622,18 +8708,18 @@ async function loadPluginMcpServers(opts2) {
 }
 function hasAnyDockerConfinedPlugin() {
   const pluginsDir = getAinativePluginsDir();
-  if (!fs13.existsSync(pluginsDir)) return false;
+  if (!fs14.existsSync(pluginsDir)) return false;
   let entries;
   try {
-    entries = fs13.readdirSync(pluginsDir);
+    entries = fs14.readdirSync(pluginsDir);
   } catch {
     return false;
   }
   for (const entry of entries) {
-    const pluginYamlPath = path14.join(pluginsDir, entry, "plugin.yaml");
+    const pluginYamlPath = path15.join(pluginsDir, entry, "plugin.yaml");
     let content;
     try {
-      content = fs13.readFileSync(pluginYamlPath, "utf-8");
+      content = fs14.readFileSync(pluginYamlPath, "utf-8");
     } catch {
       continue;
     }
@@ -8653,26 +8739,26 @@ function hasAnyDockerConfinedPlugin() {
 function buildSafeModeRegistrations() {
   const out = [];
   const pluginsDir = getAinativePluginsDir();
-  if (!fs13.existsSync(pluginsDir)) return out;
+  if (!fs14.existsSync(pluginsDir)) return out;
   let entries;
   try {
-    entries = fs13.readdirSync(pluginsDir).sort();
+    entries = fs14.readdirSync(pluginsDir).sort();
   } catch {
     return out;
   }
   for (const entry of entries) {
-    const pluginDir = path14.join(pluginsDir, entry);
+    const pluginDir = path15.join(pluginsDir, entry);
     let stat2;
     try {
-      stat2 = fs13.statSync(pluginDir);
+      stat2 = fs14.statSync(pluginDir);
     } catch {
       continue;
     }
     if (!stat2.isDirectory()) continue;
-    const pluginYamlPath = path14.join(pluginDir, "plugin.yaml");
+    const pluginYamlPath = path15.join(pluginDir, "plugin.yaml");
     let content;
     try {
-      content = fs13.readFileSync(pluginYamlPath, "utf-8");
+      content = fs14.readFileSync(pluginYamlPath, "utf-8");
     } catch {
       continue;
     }
@@ -8739,7 +8825,7 @@ var init_mcp_loader = __esm({
     init_types();
     init_capability_check();
     init_mcp_config();
-    init_catalog();
+    init_catalog2();
     init_ainative_paths();
     init_transport_dispatch();
     init_wrap();
@@ -8765,17 +8851,17 @@ __export(capability_check_exports, {
   writePluginsLock: () => writePluginsLock
 });
 import crypto3 from "crypto";
-import fs14 from "fs";
+import fs15 from "fs";
 import os3 from "os";
-import path15 from "path";
+import path16 from "path";
 import yaml9 from "js-yaml";
 import { z as z6 } from "zod";
 function logToFile4(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs14.mkdirSync(logsDir, { recursive: true });
-    fs14.appendFileSync(
-      path15.join(logsDir, "plugins.log"),
+    fs15.mkdirSync(logsDir, { recursive: true });
+    fs15.appendFileSync(
+      path16.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -8815,12 +8901,12 @@ function deriveManifestHash(pluginYamlContent) {
 }
 function readPluginsLock() {
   const lockPath = getAinativePluginsLockPath();
-  if (!fs14.existsSync(lockPath)) {
+  if (!fs15.existsSync(lockPath)) {
     return { version: 1, accepted: {} };
   }
   let raw;
   try {
-    raw = yaml9.load(fs14.readFileSync(lockPath, "utf-8"));
+    raw = yaml9.load(fs15.readFileSync(lockPath, "utf-8"));
   } catch (err2) {
     logToFile4(
       `[capability-check] WARN: plugins.lock is not valid YAML \u2014 treating as empty. Error: ${err2 instanceof Error ? err2.message : String(err2)}`
@@ -8839,31 +8925,31 @@ function readPluginsLock() {
 function writePluginsLock(pluginId, entry) {
   const lockPath = getAinativePluginsLockPath();
   const bakPath = lockPath + ".bak";
-  const lockDir = path15.dirname(lockPath);
-  fs14.mkdirSync(lockDir, { recursive: true });
+  const lockDir = path16.dirname(lockPath);
+  fs15.mkdirSync(lockDir, { recursive: true });
   const current = readPluginsLock();
   current.accepted[pluginId] = entry;
   const newContent = yaml9.dump(current, { lineWidth: -1 });
-  if (fs14.existsSync(lockPath)) {
-    fs14.copyFileSync(lockPath, bakPath);
+  if (fs15.existsSync(lockPath)) {
+    fs15.copyFileSync(lockPath, bakPath);
     try {
-      fs14.chmodSync(bakPath, 384);
+      fs15.chmodSync(bakPath, 384);
     } catch {
     }
   }
   const tmpPath = `${lockPath}.tmp-${crypto3.randomBytes(6).toString("hex")}`;
   try {
-    fs14.writeFileSync(tmpPath, newContent, { mode: 384 });
-    fs14.renameSync(tmpPath, lockPath);
+    fs15.writeFileSync(tmpPath, newContent, { mode: 384 });
+    fs15.renameSync(tmpPath, lockPath);
   } catch (err2) {
     try {
-      fs14.unlinkSync(tmpPath);
+      fs15.unlinkSync(tmpPath);
     } catch {
     }
     throw err2;
   }
   try {
-    fs14.chmodSync(lockPath, 384);
+    fs15.chmodSync(lockPath, 384);
   } catch {
   }
 }
@@ -8874,28 +8960,28 @@ function removePluginsLockEntry(pluginId) {
   if (!(pluginId in current.accepted)) return;
   delete current.accepted[pluginId];
   const newContent = yaml9.dump(current, { lineWidth: -1 });
-  const lockDir = path15.dirname(lockPath);
-  fs14.mkdirSync(lockDir, { recursive: true });
-  if (fs14.existsSync(lockPath)) {
-    fs14.copyFileSync(lockPath, bakPath);
+  const lockDir = path16.dirname(lockPath);
+  fs15.mkdirSync(lockDir, { recursive: true });
+  if (fs15.existsSync(lockPath)) {
+    fs15.copyFileSync(lockPath, bakPath);
     try {
-      fs14.chmodSync(bakPath, 384);
+      fs15.chmodSync(bakPath, 384);
     } catch {
     }
   }
   const tmpPath = `${lockPath}.tmp-${crypto3.randomBytes(6).toString("hex")}`;
   try {
-    fs14.writeFileSync(tmpPath, newContent, { mode: 384 });
-    fs14.renameSync(tmpPath, lockPath);
+    fs15.writeFileSync(tmpPath, newContent, { mode: 384 });
+    fs15.renameSync(tmpPath, lockPath);
   } catch (err2) {
     try {
-      fs14.unlinkSync(tmpPath);
+      fs15.unlinkSync(tmpPath);
     } catch {
     }
     throw err2;
   }
   try {
-    fs14.chmodSync(lockPath, 384);
+    fs15.chmodSync(lockPath, 384);
   } catch {
   }
 }
@@ -8981,9 +9067,9 @@ function getPluginToolApprovalMode(pluginId, toolName, defaultFromManifest) {
 }
 function readManifestDefaultApproval(pluginId) {
   try {
-    const pluginYamlPath = path15.join(getAinativePluginsDir(), pluginId, "plugin.yaml");
-    if (!fs14.existsSync(pluginYamlPath)) return void 0;
-    const content = fs14.readFileSync(pluginYamlPath, "utf-8");
+    const pluginYamlPath = path16.join(getAinativePluginsDir(), pluginId, "plugin.yaml");
+    if (!fs15.existsSync(pluginYamlPath)) return void 0;
+    const content = fs15.readFileSync(pluginYamlPath, "utf-8");
     const raw = yaml9.load(content);
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
     const record = raw;
@@ -9075,13 +9161,13 @@ async function revokePluginCapabilities(pluginId) {
 }
 async function grantPluginCapabilities(pluginId, opts2) {
   const { getAinativePluginsDir: getDir } = await Promise.resolve().then(() => (init_ainative_paths(), ainative_paths_exports));
-  const pluginYamlPath = path15.join(getDir(), pluginId, "plugin.yaml");
-  if (!fs14.existsSync(pluginYamlPath)) {
+  const pluginYamlPath = path16.join(getDir(), pluginId, "plugin.yaml");
+  if (!fs15.existsSync(pluginYamlPath)) {
     return { granted: false, reason: "not_found" };
   }
   let content;
   try {
-    content = fs14.readFileSync(pluginYamlPath, "utf-8");
+    content = fs15.readFileSync(pluginYamlPath, "utf-8");
   } catch (err2) {
     return {
       granted: false,
@@ -9472,7 +9558,7 @@ var RetryableRuntimeLaunchError;
 var init_launch_failure = __esm({
   "src/lib/agents/runtime/launch-failure.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     RetryableRuntimeLaunchError = class extends Error {
       runtimeId;
       cause;
@@ -9764,7 +9850,7 @@ var init_router = __esm({
     "use strict";
     init_registry2();
     init_compatibility();
-    init_catalog();
+    init_catalog2();
     init_task_dispatch();
     RUNTIME_KEYWORD_SIGNALS = {
       // File/code operations → claude-code (needs filesystem)
@@ -10094,7 +10180,7 @@ var init_task_tools = __esm({
     init_db();
     init_schema();
     init_helpers2();
-    init_catalog();
+    init_catalog2();
     init_registry2();
     VALID_TASK_STATUSES = [
       "planned",
@@ -10325,7 +10411,7 @@ function workflowTools(ctx) {
           args.definition = JSON.stringify(parsedDef);
           let runtimeId = null;
           if (args.runtime) {
-            const { isAgentRuntimeId: isAgentRuntimeId2 } = await Promise.resolve().then(() => (init_catalog(), catalog_exports));
+            const { isAgentRuntimeId: isAgentRuntimeId2 } = await Promise.resolve().then(() => (init_catalog2(), catalog_exports2));
             if (!isAgentRuntimeId2(args.runtime)) {
               return err(`Invalid runtime "${args.runtime}". Use list_runtimes to see available options.`);
             }
@@ -11848,9 +11934,9 @@ function buildPermissionSummary(toolName, input) {
     }
   }
   if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "read" || toolName === "write" || toolName === "edit") {
-    const path20 = input.file_path ?? input.path;
-    if (typeof path20 === "string" && path20.trim().length > 0) {
-      return truncate(path20.trim());
+    const path21 = input.file_path ?? input.path;
+    if (typeof path21 === "string" && path21.trim().length > 0) {
+      return truncate(path21.trim());
     }
   }
   if (toolName?.startsWith("mcp__")) {
@@ -11884,9 +11970,9 @@ function getPermissionDetailEntries(toolName, input) {
     }
   }
   if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "read" || toolName === "write" || toolName === "edit") {
-    const path20 = input.file_path ?? input.path;
-    if (typeof path20 === "string") {
-      return [{ label: "Path", value: path20 }];
+    const path21 = input.file_path ?? input.path;
+    if (typeof path21 === "string") {
+      return [{ label: "Path", value: path21 }];
     }
   }
   return Object.entries(input).slice(0, 6).map(([key, value]) => ({
@@ -12174,16 +12260,16 @@ __export(registry_exports4, {
   reloadSchedules: () => reloadSchedules,
   validateScheduleRefs: () => validateScheduleRefs
 });
-import fs15 from "fs";
-import path16 from "path";
+import fs16 from "fs";
+import path17 from "path";
 import yaml10 from "js-yaml";
 function scanDirectory2(dir) {
   const schedules2 = /* @__PURE__ */ new Map();
-  if (!fs15.existsSync(dir)) return schedules2;
-  for (const file of fs15.readdirSync(dir)) {
+  if (!fs16.existsSync(dir)) return schedules2;
+  for (const file of fs16.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      const content = fs15.readFileSync(path16.join(dir, file), "utf-8");
+      const content = fs16.readFileSync(path17.join(dir, file), "utf-8");
       const parsed = yaml10.load(content);
       const result = ScheduleSpecSchema.safeParse(parsed);
       if (!result.success) {
@@ -12239,12 +12325,12 @@ function createScheduleFromYaml(yamlContent) {
       `Invalid schedule: ${result.error.issues.map((i) => i.message).join(", ")}`
     );
   }
-  fs15.mkdirSync(USER_DIR, { recursive: true });
-  const filePath = path16.join(USER_DIR, `${result.data.id}.yaml`);
-  if (fs15.existsSync(filePath)) {
+  fs16.mkdirSync(USER_DIR, { recursive: true });
+  const filePath = path17.join(USER_DIR, `${result.data.id}.yaml`);
+  if (fs16.existsSync(filePath)) {
     throw new Error(`Schedule "${result.data.id}" already exists`);
   }
-  fs15.writeFileSync(filePath, yamlContent);
+  fs16.writeFileSync(filePath, yamlContent);
   reloadSchedules();
   return result.data;
 }
@@ -12296,11 +12382,11 @@ function deleteSchedule(id) {
   if (isBuiltinSchedule(id)) {
     throw new Error("Cannot delete built-in schedules");
   }
-  const filePath = path16.join(USER_DIR, `${id}.yaml`);
-  if (!fs15.existsSync(filePath)) {
+  const filePath = path17.join(USER_DIR, `${id}.yaml`);
+  if (!fs16.existsSync(filePath)) {
     throw new Error(`Schedule "${id}" not found`);
   }
-  fs15.unlinkSync(filePath);
+  fs16.unlinkSync(filePath);
   reloadSchedules();
 }
 var BUILTINS_DIR3, USER_DIR, scheduleCache, builtinIdsCache, pluginScheduleIndex;
@@ -12310,7 +12396,7 @@ var init_registry5 = __esm({
     init_schedule_spec();
     init_ainative_paths();
     init_app_root();
-    BUILTINS_DIR3 = path16.resolve(
+    BUILTINS_DIR3 = path17.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -12444,8 +12530,8 @@ __export(registry_exports5, {
   reloadPlugins: () => reloadPlugins,
   scanBundleSection: () => scanBundleSection
 });
-import fs16 from "fs";
-import path17 from "path";
+import fs17 from "fs";
+import path18 from "path";
 import yaml11 from "js-yaml";
 import { z as z16 } from "zod";
 function isSupportedApiVersion(apiVersion) {
@@ -12454,9 +12540,9 @@ function isSupportedApiVersion(apiVersion) {
 function logToFile5(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs16.mkdirSync(logsDir, { recursive: true });
-    fs16.appendFileSync(
-      path17.join(logsDir, "plugins.log"),
+    fs17.mkdirSync(logsDir, { recursive: true });
+    fs17.appendFileSync(
+      path18.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -12464,11 +12550,11 @@ function logToFile5(line) {
   }
 }
 function readManifest(rootDir) {
-  const manifestPath = path17.join(rootDir, "plugin.yaml");
-  if (!fs16.existsSync(manifestPath)) return { error: "missing plugin.yaml" };
+  const manifestPath = path18.join(rootDir, "plugin.yaml");
+  if (!fs17.existsSync(manifestPath)) return { error: "missing plugin.yaml" };
   let raw;
   try {
-    raw = yaml11.load(fs16.readFileSync(manifestPath, "utf-8"));
+    raw = yaml11.load(fs17.readFileSync(manifestPath, "utf-8"));
   } catch (err2) {
     return { error: `yaml_parse: ${err2 instanceof Error ? err2.message : String(err2)}` };
   }
@@ -12480,16 +12566,16 @@ function readManifest(rootDir) {
 }
 function discoverBundleRoots() {
   const baseDir = getAinativePluginsDir();
-  if (!fs16.existsSync(baseDir)) return [];
-  return fs16.readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path17.join(baseDir, e.name)).sort();
+  if (!fs17.existsSync(baseDir)) return [];
+  return fs17.readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path18.join(baseDir, e.name)).sort();
 }
 function scanBundleSection(opts2) {
-  const dir = path17.join(opts2.rootDir, opts2.section);
-  if (!fs16.existsSync(dir)) return [];
+  const dir = path18.join(opts2.rootDir, opts2.section);
+  if (!fs17.existsSync(dir)) return [];
   const out = [];
-  for (const file of fs16.readdirSync(dir)) {
+  for (const file of fs17.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-    const filePath = path17.join(dir, file);
+    const filePath = path18.join(dir, file);
     try {
       const result = opts2.parseFile(filePath);
       if (result !== null) out.push(result);
@@ -12500,8 +12586,8 @@ function scanBundleSection(opts2) {
   return out;
 }
 function scanBundleProfiles(rootDir, pluginId) {
-  const profilesDir = path17.join(rootDir, "profiles");
-  if (!fs16.existsSync(profilesDir)) return [];
+  const profilesDir = path18.join(rootDir, "profiles");
+  if (!fs17.existsSync(profilesDir)) return [];
   const tmp = /* @__PURE__ */ new Map();
   scanProfilesIntoMap(profilesDir, tmp, { namespace: pluginId });
   return Array.from(tmp.entries()).map(([id, profile]) => ({
@@ -12514,9 +12600,9 @@ function scanBundleBlueprints(rootDir, pluginId, siblingProfileIds) {
     rootDir,
     section: "blueprints",
     parseFile: (filePath) => {
-      const file = path17.basename(filePath);
+      const file = path18.basename(filePath);
       try {
-        const raw = yaml11.load(fs16.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
         const parsed = BlueprintSchema.safeParse(raw);
         if (!parsed.success) {
           logToFile5(`skip blueprint ${pluginId}/${file}: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
@@ -12542,9 +12628,9 @@ function scanBundleTables(rootDir, pluginId) {
     rootDir,
     section: "tables",
     parseFile: (filePath) => {
-      const file = path17.basename(filePath);
+      const file = path18.basename(filePath);
       try {
-        const raw = yaml11.load(fs16.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
         const parsed = PluginTableSchema.safeParse(raw);
         if (!parsed.success) {
           logToFile5(`skip table ${pluginId}/${file}: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
@@ -12563,9 +12649,9 @@ function scanBundleSchedules(rootDir, pluginId) {
     rootDir,
     section: "schedules",
     parseFile: (filePath) => {
-      const file = path17.basename(filePath);
+      const file = path18.basename(filePath);
       try {
-        const raw = yaml11.load(fs16.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
         const parsed = ScheduleSpecSchema.safeParse(raw);
         if (!parsed.success) {
           logToFile5(`skip schedule ${pluginId}/${file}: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
@@ -12652,7 +12738,7 @@ async function scanPlugins() {
   for (const rootDir of discoverBundleRoots()) {
     const { manifest, error } = readManifest(rootDir);
     if (!manifest) {
-      const fallbackId = path17.basename(rootDir);
+      const fallbackId = path18.basename(rootDir);
       result.push({
         id: fallbackId,
         manifest: { id: fallbackId, version: "0.0.0", apiVersion: "0.0", kind: "primitives-bundle" },
@@ -12776,7 +12862,7 @@ var init_registry6 = __esm({
     init_registry5();
     init_installer();
     init_schedule_spec();
-    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set(["0.14", "0.13", "0.12"]);
+    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PLUGIN_API_VERSION, "0.16"]);
     pluginCache = null;
     lastLoadedPluginIds = /* @__PURE__ */ new Set();
     PluginTableSchema = z16.object({
@@ -12819,8 +12905,8 @@ function pluginTools(_ctx) {
             Promise.resolve().then(() => (init_ainative_paths(), ainative_paths_exports)),
             Promise.resolve().then(() => (init_types(), types_exports))
           ]);
-          const fs19 = await import("fs");
-          const path20 = await import("path");
+          const fs20 = await import("fs");
+          const path21 = await import("path");
           const yaml13 = await import("js-yaml");
           const kind5 = listPlugins2();
           const registrations = await listPluginMcpRegistrations2();
@@ -12837,13 +12923,13 @@ function pluginTools(_ctx) {
               let manifestHash;
               let capabilityAcceptStatus = "pending";
               try {
-                const pluginYamlPath = path20.join(
+                const pluginYamlPath = path21.join(
                   pluginsDir,
                   pluginId,
                   "plugin.yaml"
                 );
-                if (fs19.existsSync(pluginYamlPath)) {
-                  const content = fs19.readFileSync(pluginYamlPath, "utf-8");
+                if (fs20.existsSync(pluginYamlPath)) {
+                  const content = fs20.readFileSync(pluginYamlPath, "utf-8");
                   const rawManifest = yaml13.load(content);
                   if (rawManifest !== null && typeof rawManifest === "object" && !Array.isArray(rawManifest)) {
                     const record = rawManifest;
@@ -12856,7 +12942,7 @@ function pluginTools(_ctx) {
                   try {
                     manifestHash = deriveManifestHash2(content);
                     const parsed = PluginManifestSchema2.safeParse(rawManifest);
-                    const pluginRootDir = path20.join(pluginsDir, pluginId);
+                    const pluginRootDir = path21.join(pluginsDir, pluginId);
                     const check = isCapabilityAccepted2(
                       pluginId,
                       manifestHash,
@@ -15576,7 +15662,7 @@ var init_runtime_tools = __esm({
     "use strict";
     init_tool_registry();
     init_helpers2();
-    init_catalog();
+    init_catalog2();
   }
 });
 
@@ -16690,7 +16776,7 @@ async function activateSkill(args) {
       return { kind: "error", message: `Conversation not found: ${conversationId}` };
     }
     if (mode === "add") {
-      const { getRuntimeFeatures: getRuntimeFeatures2 } = await Promise.resolve().then(() => (init_catalog(), catalog_exports));
+      const { getRuntimeFeatures: getRuntimeFeatures2 } = await Promise.resolve().then(() => (init_catalog2(), catalog_exports2));
       let features;
       try {
         features = getRuntimeFeatures2(
@@ -17011,8 +17097,8 @@ var init_schedule_spec_tools = __esm({
 
 // src/lib/chat/tools/plugin-spec-tools.ts
 import { z as z27 } from "zod";
-import * as fs17 from "fs";
-import * as path18 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 function validateId(id) {
   if (id.length < 2) {
     throw new PluginSpecInvalidIdError(id, "must be at least 2 chars");
@@ -17040,7 +17126,7 @@ function renderPluginYaml(input) {
     ``,
     `id: ${input.id}`,
     `version: 0.1.0`,
-    `apiVersion: "0.14"`,
+    `apiVersion: "${CURRENT_PLUGIN_API_VERSION}"`,
     `kind: chat-tools`,
     `name: ${JSON.stringify(input.name)}`,
     `description: ${JSON.stringify(input.description)}`,
@@ -17275,20 +17361,20 @@ directory at load time \u2014 you do not need to edit that path.
 function scaffoldPluginSpec(input) {
   validateId(input.id);
   const pluginsDir = getAinativePluginsDir();
-  const pluginDir = path18.join(pluginsDir, input.id);
-  const tmpDir = path18.join(pluginsDir, `${input.id}.tmp-${Date.now()}`);
-  if (fs17.existsSync(pluginDir)) {
+  const pluginDir = path19.join(pluginsDir, input.id);
+  const tmpDir = path19.join(pluginsDir, `${input.id}.tmp-${Date.now()}`);
+  if (fs18.existsSync(pluginDir)) {
     throw new PluginSpecAlreadyExistsError(pluginDir);
   }
   try {
-    fs17.mkdirSync(tmpDir, { recursive: true });
-    fs17.writeFileSync(
-      path18.join(tmpDir, "plugin.yaml"),
+    fs18.mkdirSync(tmpDir, { recursive: true });
+    fs18.writeFileSync(
+      path19.join(tmpDir, "plugin.yaml"),
       renderPluginYaml(input),
       "utf-8"
     );
-    fs17.writeFileSync(
-      path18.join(tmpDir, ".mcp.json"),
+    fs18.writeFileSync(
+      path19.join(tmpDir, ".mcp.json"),
       renderMcpJson({
         id: input.id,
         transport: input.transport,
@@ -17296,8 +17382,8 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs17.writeFileSync(
-      path18.join(tmpDir, "server.py"),
+    fs18.writeFileSync(
+      path19.join(tmpDir, "server.py"),
       renderServerPy({
         id: input.id,
         tools: input.tools,
@@ -17306,8 +17392,8 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs17.writeFileSync(
-      path18.join(tmpDir, "README.md"),
+    fs18.writeFileSync(
+      path19.join(tmpDir, "README.md"),
       renderReadme({
         id: input.id,
         name: input.name,
@@ -17315,11 +17401,11 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs17.renameSync(tmpDir, pluginDir);
+    fs18.renameSync(tmpDir, pluginDir);
   } catch (cause) {
     try {
-      if (fs17.existsSync(tmpDir)) {
-        fs17.rmSync(tmpDir, { recursive: true, force: true });
+      if (fs18.existsSync(tmpDir)) {
+        fs18.rmSync(tmpDir, { recursive: true, force: true });
       }
     } catch {
     }
@@ -17330,10 +17416,10 @@ function scaffoldPluginSpec(input) {
     id: input.id,
     pluginDir,
     files: {
-      pluginYaml: path18.join(pluginDir, "plugin.yaml"),
-      mcpJson: path18.join(pluginDir, ".mcp.json"),
-      serverPy: path18.join(pluginDir, "server.py"),
-      readme: path18.join(pluginDir, "README.md")
+      pluginYaml: path19.join(pluginDir, "plugin.yaml"),
+      mcpJson: path19.join(pluginDir, ".mcp.json"),
+      serverPy: path19.join(pluginDir, "server.py"),
+      readme: path19.join(pluginDir, "README.md")
     },
     tools: input.tools.map((t) => t.name),
     message: `Scaffolded ${input.id}. Reload ainative to register.`
@@ -17399,6 +17485,7 @@ var init_plugin_spec_tools = __esm({
     init_tool_registry();
     init_helpers2();
     init_ainative_paths();
+    init_types();
     PluginSpecAlreadyExistsError = class extends Error {
       constructor(pluginDir) {
         super(
@@ -18864,7 +18951,7 @@ var init_claude = __esm({
     init_registry2();
     init_compatibility();
     init_claude_agent();
-    init_catalog();
+    init_catalog2();
     init_claude_sdk();
     init_workspace_context();
     init_helpers();
@@ -19271,13 +19358,13 @@ var init_codex_app_server_client = __esm({
           await syncPluginMcpToCodex2();
         } catch (err2) {
           try {
-            const fs19 = await import("fs");
-            const path20 = await import("path");
+            const fs20 = await import("fs");
+            const path21 = await import("path");
             const { getAinativeLogsDir: getAinativeLogsDir2 } = await Promise.resolve().then(() => (init_ainative_paths(), ainative_paths_exports));
             const dir = getAinativeLogsDir2();
-            fs19.mkdirSync(dir, { recursive: true });
-            fs19.appendFileSync(
-              path20.join(dir, "plugins.log"),
+            fs20.mkdirSync(dir, { recursive: true });
+            fs20.appendFileSync(
+              path21.join(dir, "plugins.log"),
               `${(/* @__PURE__ */ new Date()).toISOString()} codex-sync-failed: ${err2 instanceof Error ? err2.message : String(err2)}
 `
             );
@@ -20403,7 +20490,7 @@ var init_openai_codex = __esm({
     init_context_builder();
     init_output_scanner();
     init_permissions();
-    init_catalog();
+    init_catalog2();
     init_workspace_context();
     init_openai_codex_auth();
     init_launch_failure();
@@ -21016,7 +21103,7 @@ var init_anthropic_direct = __esm({
     init_ainative_tools();
     init_tool_permissions();
     init_agentic_loop();
-    init_catalog();
+    init_catalog2();
     init_registry2();
     init_ledger();
     init_output_scanner();
@@ -21450,7 +21537,7 @@ var init_openai_direct = __esm({
     init_ainative_tools();
     init_tool_permissions();
     init_agentic_loop();
-    init_catalog();
+    init_catalog2();
     init_registry2();
     init_ledger();
     init_output_scanner();
@@ -21757,7 +21844,7 @@ var init_ollama_adapter = __esm({
     init_schema();
     init_execution_manager();
     init_claude_agent();
-    init_catalog();
+    init_catalog2();
     init_registry2();
     init_ledger();
     DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
@@ -21794,7 +21881,7 @@ var updateAuthSettingsSchema, updateOpenAISettingsSchema, nullablePositiveNumber
 var init_settings3 = __esm({
   "src/lib/validators/settings.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     updateAuthSettingsSchema = z29.object({
       method: z29.enum(["api_key", "oauth"]).optional(),
       apiKey: z29.string().startsWith("sk-ant-", "API key must start with sk-ant-").optional(),
@@ -21897,7 +21984,7 @@ function listConfiguredRuntimeIds(states) {
 var init_runtime_setup = __esm({
   "src/lib/settings/runtime-setup.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     init_auth();
     init_openai_auth();
   }
@@ -22317,7 +22404,7 @@ var init_budget_guardrails = __esm({
     init_db();
     init_schema();
     init_settings();
-    init_catalog();
+    init_catalog2();
     init_helpers();
     init_settings3();
     init_ledger();
@@ -22372,7 +22459,7 @@ var runtimeRegistry;
 var init_runtime = __esm({
   "src/lib/agents/runtime/index.ts"() {
     "use strict";
-    init_catalog();
+    init_catalog2();
     init_claude();
     init_openai_codex();
     init_anthropic_direct();
@@ -22647,7 +22734,7 @@ var init_execution_target = __esm({
     init_registry2();
     init_compatibility();
     init_router();
-    init_catalog();
+    init_catalog2();
     init_runtime();
     init_routing();
     init_runtime_setup();
@@ -22829,7 +22916,7 @@ var init_task_dispatch = __esm({
     init_runtime();
     init_execution_target();
     init_launch_failure();
-    init_catalog();
+    init_catalog2();
   }
 });
 
@@ -22869,14 +22956,14 @@ function resolvePostAction(action, row, itemVariable) {
 function substituteRowPath(template, row, itemVariable) {
   const escaped = itemVariable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const pattern = new RegExp(`\\{\\{\\s*${escaped}\\.([\\w.]+)\\s*\\}\\}`, "g");
-  return template.replace(pattern, (_match, path20) => {
-    const value = readPath(row, path20);
+  return template.replace(pattern, (_match, path21) => {
+    const value = readPath(row, path21);
     if (value === void 0 || value === null) return "";
     return String(value);
   });
 }
-function readPath(obj, path20) {
-  const parts = path20.split(".");
+function readPath(obj, path21) {
+  const parts = path21.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -23063,14 +23150,14 @@ ${resolvedTemplate}`);
   return parts.join("");
 }
 function resolveRowTemplate(template, context) {
-  return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, path20) => {
-    const value = readContextPath(context, path20.trim());
+  return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, path21) => {
+    const value = readContextPath(context, path21.trim());
     if (value === void 0 || value === null) return "";
     return typeof value === "string" ? value : JSON.stringify(value);
   });
 }
-function readContextPath(value, path20) {
-  const parts = path20.split(".");
+function readContextPath(value, path21) {
+  const parts = path21.split(".");
   let current = value;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -24803,7 +24890,7 @@ var init_engine = __esm({
     init_learning_session();
     init_context_builder();
     init_cost_estimator();
-    init_catalog();
+    init_catalog2();
     init_helpers();
     init_execution_stats();
   }
@@ -25435,20 +25522,20 @@ var install_exports = {};
 __export(install_exports, {
   installPack: () => installPack
 });
-import fs18 from "fs";
-import path19 from "path";
+import fs19 from "fs";
+import path20 from "path";
 import os4 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import yaml12 from "js-yaml";
 import semver from "semver";
 function relayCoreVersion() {
-  if (semver.valid("0.17.0")) {
-    return "0.17.0";
+  if (semver.valid("0.18.0")) {
+    return "0.18.0";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
     const pkg2 = JSON.parse(
-      fs18.readFileSync(path19.join(root, "package.json"), "utf-8")
+      fs19.readFileSync(path20.join(root, "package.json"), "utf-8")
     );
     if (pkg2.version && semver.valid(pkg2.version)) return pkg2.version;
   } catch {
@@ -25460,7 +25547,11 @@ async function installPack(source, options = {}) {
   const profilesDir = options.profilesDir ?? getAinativeProfilesDir();
   const blueprintsDir = options.blueprintsDir ?? getAinativeBlueprintsDir();
   const coreVersion = options.coreVersion ?? relayCoreVersion();
-  const { dir: packDir, cleanup } = acquirePack(source);
+  const { resolvePackSource: resolvePackSource2 } = await Promise.resolve().then(() => (init_catalog(), catalog_exports));
+  const resolvedSource = resolvePackSource2(source, {
+    templatesDir: options.templatesDir
+  });
+  const { dir: packDir, cleanup } = acquirePack(resolvedSource);
   try {
     const pack = parsePack(packDir);
     if (pack.meta.relayCore) {
@@ -25565,25 +25656,25 @@ function isGitUrl(source) {
 }
 function acquirePack(source) {
   if (!isGitUrl(source)) {
-    const resolved = path19.resolve(source);
-    if (!fs18.existsSync(resolved)) {
+    const resolved = path20.resolve(source);
+    if (!fs19.existsSync(resolved)) {
       throw new PackValidationError(`Pack path does not exist: ${resolved}`);
     }
     return { dir: resolved, cleanup: () => {
     } };
   }
-  const tmp = fs18.mkdtempSync(path19.join(os4.tmpdir(), "ainative-pack-clone-"));
+  const tmp = fs19.mkdtempSync(path20.join(os4.tmpdir(), "ainative-pack-clone-"));
   try {
     execFileSync3("git", ["clone", "--depth", "1", source, tmp], {
       stdio: "pipe"
     });
   } catch (err2) {
-    fs18.rmSync(tmp, { recursive: true, force: true });
+    fs19.rmSync(tmp, { recursive: true, force: true });
     throw new PackValidationError(`git clone failed for ${source}`, err2);
   }
   return {
     dir: tmp,
-    cleanup: () => fs18.rmSync(tmp, { recursive: true, force: true })
+    cleanup: () => fs19.rmSync(tmp, { recursive: true, force: true })
   };
 }
 function findResolved(files, relPath) {
@@ -25592,7 +25683,7 @@ function findResolved(files, relPath) {
 function readCustomerSeed(resolved) {
   const file = findResolved(resolved.files, "seed/customers.yaml");
   if (!file) return [];
-  const parsed = yaml12.load(fs18.readFileSync(file.absPath, "utf-8"));
+  const parsed = yaml12.load(fs19.readFileSync(file.absPath, "utf-8"));
   if (!Array.isArray(parsed)) {
     throw new PackValidationError(
       "seed/customers.yaml must be a YAML list of { slug, name, ... }"
@@ -25604,7 +25695,7 @@ function readTableSeed(resolved, logicalId) {
   for (const ext of ["json", "yaml", "yml"]) {
     const file = findResolved(resolved.files, `seed/tables/${logicalId}.${ext}`);
     if (!file) continue;
-    const text2 = fs18.readFileSync(file.absPath, "utf-8");
+    const text2 = fs19.readFileSync(file.absPath, "utf-8");
     const parsed = ext === "json" ? JSON.parse(text2) : yaml12.load(text2);
     if (!Array.isArray(parsed)) {
       throw new PackValidationError(
@@ -25649,7 +25740,7 @@ function rewriteViewTableRefs(view, logicalToReal) {
   return view;
 }
 function writeManifest(appsDir, appId, manifest) {
-  fs18.mkdirSync(path19.join(appsDir, appId), { recursive: true });
+  fs19.mkdirSync(path20.join(appsDir, appId), { recursive: true });
   writeAppManifest(appId, manifest, appsDir);
 }
 function dropArtifacts(files, profilesDir, blueprintsDir) {
@@ -25657,18 +25748,18 @@ function dropArtifacts(files, profilesDir, blueprintsDir) {
   let blueprintsDropped = 0;
   for (const file of files) {
     if (file.relPath.startsWith("profiles/")) {
-      const dest = path19.join(profilesDir, file.relPath.slice("profiles/".length));
-      fs18.mkdirSync(path19.dirname(dest), { recursive: true });
-      fs18.copyFileSync(file.absPath, dest);
+      const dest = path20.join(profilesDir, file.relPath.slice("profiles/".length));
+      fs19.mkdirSync(path20.dirname(dest), { recursive: true });
+      fs19.copyFileSync(file.absPath, dest);
       const top = file.relPath.split("/")[1];
       if (top) profileDirs.add(top);
     } else if (file.relPath.startsWith("blueprints/") && file.relPath.endsWith(".yaml")) {
-      const dest = path19.join(
+      const dest = path20.join(
         blueprintsDir,
         file.relPath.slice("blueprints/".length)
       );
-      fs18.mkdirSync(path19.dirname(dest), { recursive: true });
-      fs18.copyFileSync(file.absPath, dest);
+      fs19.mkdirSync(path20.dirname(dest), { recursive: true });
+      fs19.copyFileSync(file.absPath, dest);
       blueprintsDropped += 1;
     }
   }
@@ -25729,7 +25820,7 @@ async function runPackCommand(argv, io) {
 }
 async function runAdd(source, licenseUrl, io) {
   if (!source) {
-    io.error("Missing pack path. Usage: relay pack add <path|git-url>");
+    io.error("Missing pack source. Usage: relay pack add <name|path|git-url>");
     return 1;
   }
   try {
@@ -25815,7 +25906,7 @@ var init_cli = __esm({
     init_ainative_paths();
     USAGE = [
       "Usage: relay pack <action>",
-      "  add <path|git-url> [--license-url=<path|url>]   install a pack",
+      "  add <name|path|git-url> [--license-url=<path|url>]   install a pack",
       "  list                 list installed packs",
       "  remove <id>          uninstall a pack",
       "  update <id>          (v1 stub \u2014 editable-seed; edit in place)"
@@ -26288,10 +26379,10 @@ import { existsSync as existsSync4, renameSync, cpSync, rmSync as rmSync2, readF
 import { join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 import Database from "better-sqlite3";
-function hasSqliteHeader(path20) {
+function hasSqliteHeader(path21) {
   const SQLITE_MAGIC = "SQLite format 3\0";
   try {
-    const header = readFileSync3(path20, { encoding: null });
+    const header = readFileSync3(path21, { encoding: null });
     return header.length >= 16 && header.subarray(0, 16).toString("binary") === SQLITE_MAGIC;
   } catch {
     return false;