orionfold-relay 0.26.0 → 0.28.0

package/dist/cli.js

@@ -1186,7 +1186,7 @@ var CURRENT_PLUGIN_API_VERSION, CAPABILITY_VALUES, ORIGIN_VALUES, PrimitivesBund
 var init_types = __esm({
   "src/lib/plugins/sdk/types.ts"() {
     "use strict";
-    CURRENT_PLUGIN_API_VERSION = "0.26";
+    CURRENT_PLUGIN_API_VERSION = "0.28";
     CAPABILITY_VALUES = ["fs", "net", "child_process", "env"];
     ORIGIN_VALUES = ["ainative-internal", "third-party"];
     PrimitivesBundleManifestSchema = z.object({
@@ -1232,16 +1232,16 @@ function computeHash(content) {
 function safePreview(content) {
   return content.slice(0, MAX_PREVIEW_CHARS).trim();
 }
-function safeStat(path24) {
+function safeStat(path25) {
   try {
-    return statSync2(path24);
+    return statSync2(path25);
   } catch {
     return null;
   }
 }
-function safeReadFile(path24) {
+function safeReadFile(path25) {
   try {
-    return readFileSync4(path24, "utf-8");
+    return readFileSync4(path25, "utf-8");
   } catch {
     return null;
   }
@@ -5134,25 +5134,47 @@ var init_compatibility = __esm({
   }
 });
 
-// src/lib/agents/profiles/project-profiles.ts
+// src/lib/agents/profiles/agent-file.ts
 import fs8 from "fs";
 import path7 from "path";
+function resolveAgentFile(dir) {
+  const agentPath = path7.join(dir, AGENT_FILENAME);
+  if (fs8.existsSync(agentPath)) return agentPath;
+  const legacyPath = path7.join(dir, LEGACY_PROFILE_FILENAME);
+  if (fs8.existsSync(legacyPath)) return legacyPath;
+  return null;
+}
+function hasAgentFile(dir) {
+  return resolveAgentFile(dir) !== null;
+}
+var AGENT_FILENAME, LEGACY_PROFILE_FILENAME;
+var init_agent_file = __esm({
+  "src/lib/agents/profiles/agent-file.ts"() {
+    "use strict";
+    AGENT_FILENAME = "agent.yaml";
+    LEGACY_PROFILE_FILENAME = "profile.yaml";
+  }
+});
+
+// src/lib/agents/profiles/project-profiles.ts
+import fs9 from "fs";
+import path8 from "path";
 import yaml4 from "js-yaml";
 function getProjectSkillsSignature(skillsDir) {
-  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));
+  if (!fs9.existsSync(skillsDir)) return "missing";
+  const entries = fs9.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 = path7.join(skillsDir, entry.name);
+    const dir = path8.join(skillsDir, entry.name);
     parts.push(entry.name);
-    const yamlPath = path7.join(dir, "profile.yaml");
-    if (fs8.existsSync(yamlPath)) {
-      const s = fs8.statSync(yamlPath);
+    const yamlPath = resolveAgentFile(dir);
+    if (yamlPath) {
+      const s = fs9.statSync(yamlPath);
       parts.push(`yaml:${s.mtimeMs}:${s.size}`);
     }
-    const skillPath = path7.join(dir, "SKILL.md");
-    if (fs8.existsSync(skillPath)) {
-      const s = fs8.statSync(skillPath);
+    const skillPath = path8.join(dir, "SKILL.md");
+    if (fs9.existsSync(skillPath)) {
+      const s = fs9.statSync(skillPath);
       parts.push(`skill:${s.mtimeMs}:${s.size}`);
     }
   }
@@ -5173,8 +5195,8 @@ function parseFrontmatter(content) {
   return fm;
 }
 function generateMinimalProfile(skillDir, dirName, projectDir) {
-  const skillPath = path7.join(skillDir, "SKILL.md");
-  const skillMd = fs8.readFileSync(skillPath, "utf-8");
+  const skillPath = path8.join(skillDir, "SKILL.md");
+  const skillMd = fs9.readFileSync(skillPath, "utf-8");
   const fm = parseFrontmatter(skillMd);
   return {
     id: dirName,
@@ -5191,31 +5213,31 @@ function generateMinimalProfile(skillDir, dirName, projectDir) {
   };
 }
 function scanProjectProfiles(projectDir) {
-  const skillsDir = path7.join(projectDir, ".claude", "skills");
-  if (!fs8.existsSync(skillsDir)) return [];
+  const skillsDir = path8.join(projectDir, ".claude", "skills");
+  if (!fs9.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 fs8.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    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)) {
+    const dir = path8.join(skillsDir, entry.name);
+    const yamlPath = resolveAgentFile(dir);
+    const skillPath = path8.join(dir, "SKILL.md");
+    if (yamlPath && fs9.existsSync(skillPath)) {
       try {
-        const rawYaml = fs8.readFileSync(yamlPath, "utf-8");
+        const rawYaml = fs9.readFileSync(yamlPath, "utf-8");
         const parsed = yaml4.load(rawYaml);
         const result = ProfileConfigSchema.safeParse(parsed);
         if (!result.success) {
           console.warn(
-            `[project-profiles] Invalid profile.yaml in ${entry.name}:`,
+            `[project-profiles] Invalid agent manifest in ${entry.name}:`,
             result.error.issues.map((i) => i.message).join(", ")
           );
           continue;
         }
         const config = result.data;
-        const skillMd = fs8.readFileSync(skillPath, "utf-8");
+        const skillMd = fs9.readFileSync(skillPath, "utf-8");
         const descMatch = skillMd.match(
           /^---\s*\n[\s\S]*?description:\s*(.+?)\s*\n[\s\S]*?---/
         );
@@ -5249,7 +5271,7 @@ function scanProjectProfiles(projectDir) {
           err2
         );
       }
-    } else if (fs8.existsSync(skillPath)) {
+    } else if (fs9.existsSync(skillPath)) {
       try {
         profiles.push(generateMinimalProfile(dir, entry.name, projectDir));
       } catch (err2) {
@@ -5269,13 +5291,14 @@ var init_project_profiles = __esm({
     "use strict";
     init_profile();
     init_compatibility();
+    init_agent_file();
     projectProfileCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/lib/environment/profile-linker.ts
 import { eq as eq6, and as and2, isNull } from "drizzle-orm";
-import path8 from "path";
+import path9 from "path";
 var init_profile_linker = __esm({
   "src/lib/environment/profile-linker.ts"() {
     "use strict";
@@ -5326,23 +5349,23 @@ var init_data = __esm({
 });
 
 // src/lib/agents/profiles/app-manifest-source.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 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 (!fs9.existsSync(appsDir)) return [];
+  if (!fs10.existsSync(appsDir)) return [];
   const synthesized = /* @__PURE__ */ new Map();
-  for (const entry of fs9.readdirSync(appsDir, { withFileTypes: true })) {
+  for (const entry of fs10.readdirSync(appsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const appId = entry.name;
-    const manifestPath = path9.join(appsDir, appId, "manifest.yaml");
-    if (!fs9.existsSync(manifestPath)) continue;
+    const manifestPath = path10.join(appsDir, appId, "manifest.yaml");
+    if (!fs10.existsSync(manifestPath)) continue;
     let manifest;
     try {
-      const parsed = yaml5.load(fs9.readFileSync(manifestPath, "utf-8"));
+      const parsed = yaml5.load(fs10.readFileSync(manifestPath, "utf-8"));
       manifest = AppManifestSchema.safeParse(parsed);
     } catch (err2) {
       console.warn(`[app-manifest-source] Malformed manifest for ${appId}:`, err2);
@@ -5354,9 +5377,8 @@ function loadAppManifestProfiles(appsDir, profilesDir, builtinsDir) {
     }
     for (const profileRef of manifest.data.profiles ?? []) {
       const profileId = profileRef.id;
-      const userYaml = path9.join(profilesDir, profileId, "profile.yaml");
-      const builtinYaml = path9.join(builtinsDir, profileId, "profile.yaml");
-      if (fs9.existsSync(userYaml) || fs9.existsSync(builtinYaml)) continue;
+      if (hasAgentFile(path10.join(profilesDir, profileId)) || hasAgentFile(path10.join(builtinsDir, profileId)))
+        continue;
       const existing = synthesized.get(profileId);
       if (existing) {
         if (!existing.tags.includes(appId)) {
@@ -5389,6 +5411,7 @@ var init_app_manifest_source = __esm({
     "use strict";
     init_catalog2();
     init_registry();
+    init_agent_file();
   }
 });
 
@@ -5412,29 +5435,29 @@ __export(registry_exports2, {
   scanProfilesIntoMap: () => scanProfilesIntoMap,
   updateProfile: () => updateProfile
 });
-import fs10 from "fs";
+import fs11 from "fs";
 import { homedir as homedir3 } from "os";
-import path10 from "path";
+import path11 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 (!fs10.existsSync(baseDir)) return [];
-  const entries = fs10.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  if (!fs11.existsSync(baseDir)) return [];
+  const entries = fs11.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 = path10.join(baseDir, entry.name);
-    const yamlPath = path10.join(dir, "profile.yaml");
-    const skillPath = path10.join(dir, "SKILL.md");
+    const dir = path11.join(baseDir, entry.name);
+    const yamlPath = resolveAgentFile(dir);
+    const skillPath = path11.join(dir, "SKILL.md");
     parts.push(entry.name);
-    if (fs10.existsSync(yamlPath)) {
-      const stats = fs10.statSync(yamlPath);
+    if (yamlPath) {
+      const stats = fs11.statSync(yamlPath);
       parts.push(`yaml:${stats.mtimeMs}:${stats.size}`);
     }
-    if (fs10.existsSync(skillPath)) {
-      const stats = fs10.statSync(skillPath);
+    if (fs11.existsSync(skillPath)) {
+      const stats = fs11.statSync(skillPath);
       parts.push(`skill:${stats.mtimeMs}:${stats.size}`);
     }
   }
@@ -5442,14 +5465,14 @@ function getDirectorySignatureParts(baseDir) {
 }
 function getAppsDirectorySignature() {
   const appsDir = getAinativeAppsDir();
-  if (!fs10.existsSync(appsDir)) return "no-apps";
+  if (!fs11.existsSync(appsDir)) return "no-apps";
   const parts = [];
-  const entries = fs10.readdirSync(appsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = fs11.readdirSync(appsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const manifestPath = path10.join(appsDir, entry.name, "manifest.yaml");
+    const manifestPath = path11.join(appsDir, entry.name, "manifest.yaml");
     parts.push(entry.name);
-    if (fs10.existsSync(manifestPath)) {
-      const stats = fs10.statSync(manifestPath);
+    if (fs11.existsSync(manifestPath)) {
+      const stats = fs11.statSync(manifestPath);
       parts.push(`manifest:${stats.mtimeMs}:${stats.size}`);
     }
   }
@@ -5472,17 +5495,19 @@ function getSkillsDirectorySignature() {
 }
 function ensureBuiltins() {
   const builtinsDir = getBuiltinsDir();
-  if (!fs10.existsSync(builtinsDir)) return;
-  fs10.mkdirSync(SKILLS_DIR, { recursive: true });
-  for (const entry of fs10.readdirSync(builtinsDir, { withFileTypes: true })) {
+  if (!fs11.existsSync(builtinsDir)) return;
+  fs11.mkdirSync(SKILLS_DIR, { recursive: true });
+  for (const entry of fs11.readdirSync(builtinsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    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)) {
+    const targetDir = path11.join(SKILLS_DIR, entry.name);
+    const existingTargetYaml = resolveAgentFile(targetDir);
+    const srcYaml = resolveAgentFile(path11.join(builtinsDir, entry.name));
+    if (!srcYaml) continue;
+    if (existingTargetYaml) {
+      const targetYamlForMerge = existingTargetYaml;
       try {
-        const source = yaml6.load(fs10.readFileSync(srcYaml, "utf-8")) ?? {};
-        const target = yaml6.load(fs10.readFileSync(targetYaml, "utf-8")) ?? {};
+        const source = yaml6.load(fs11.readFileSync(srcYaml, "utf-8")) ?? {};
+        const target = yaml6.load(fs11.readFileSync(targetYamlForMerge, "utf-8")) ?? {};
         let changed = false;
         if (source.supportedRuntimes !== void 0 && target.supportedRuntimes === void 0) {
           target.supportedRuntimes = source.supportedRuntimes;
@@ -5501,40 +5526,40 @@ function ensureBuiltins() {
           changed = true;
         }
         if (changed) {
-          fs10.writeFileSync(targetYaml, yaml6.dump(target));
+          fs11.writeFileSync(targetYamlForMerge, yaml6.dump(target));
         }
       } catch {
       }
       continue;
     }
-    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));
+    fs11.mkdirSync(targetDir, { recursive: true });
+    const srcDir = path11.join(builtinsDir, entry.name);
+    for (const file of fs11.readdirSync(srcDir)) {
+      fs11.copyFileSync(path11.join(srcDir, file), path11.join(targetDir, file));
     }
   }
 }
 function scanProfilesFromDir(baseDir, profiles, options = {}) {
-  if (!fs10.existsSync(baseDir)) return;
-  for (const entry of fs10.readdirSync(baseDir, { withFileTypes: true })) {
+  if (!fs11.existsSync(baseDir)) return;
+  for (const entry of fs11.readdirSync(baseDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) 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;
+    const dir = path11.join(baseDir, entry.name);
+    const yamlPath = resolveAgentFile(dir);
+    const skillPath = path11.join(dir, "SKILL.md");
+    if (!yamlPath) continue;
     try {
-      const rawYaml = fs10.readFileSync(yamlPath, "utf-8");
+      const rawYaml = fs11.readFileSync(yamlPath, "utf-8");
       const parsed = yaml6.load(rawYaml);
       const result = ProfileConfigSchema.safeParse(parsed);
       if (!result.success) {
         console.warn(
-          `[profiles] Invalid profile.yaml in ${entry.name}:`,
+          `[profiles] Invalid agent manifest in ${entry.name}:`,
           result.error.issues.map((i) => i.message).join(", ")
         );
         continue;
       }
       const config = result.data;
-      const skillMd = fs10.existsSync(skillPath) ? fs10.readFileSync(skillPath, "utf-8") : "";
+      const skillMd = fs11.existsSync(skillPath) ? fs11.readFileSync(skillPath, "utf-8") : "";
       const descMatch = skillMd.match(
         /^---\s*\n[\s\S]*?description:\s*(.+?)\s*\n[\s\S]*?---/
       );
@@ -5624,20 +5649,20 @@ function reloadProfiles() {
   profileCacheSignature = null;
 }
 function isBuiltin(id) {
-  return fs10.existsSync(path10.join(getBuiltinsDir(), id, "profile.yaml"));
+  return hasAgentFile(path11.join(getBuiltinsDir(), id));
 }
 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 = path10.join(SKILLS_DIR, config.id);
-  if (fs10.existsSync(path10.join(dir, "profile.yaml"))) {
+  const dir = path11.join(SKILLS_DIR, config.id);
+  if (hasAgentFile(dir)) {
     throw new Error(`Profile "${config.id}" already exists`);
   }
-  fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
+  fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(path11.join(dir, AGENT_FILENAME), yaml6.dump(config));
+  fs11.writeFileSync(path11.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5646,13 +5671,13 @@ function createPromotedProfile(config, skillMd) {
   if (!result.success) {
     throw new Error(`Invalid profile: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
-  const dir = path10.join(PROMOTED_PROFILES_DIR, config.id);
-  if (fs10.existsSync(path10.join(dir, "profile.yaml"))) {
+  const dir = path11.join(PROMOTED_PROFILES_DIR, config.id);
+  if (hasAgentFile(dir)) {
     throw new Error(`Profile "${config.id}" already exists`);
   }
-  fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
+  fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(path11.join(dir, AGENT_FILENAME), yaml6.dump(config));
+  fs11.writeFileSync(path11.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5664,14 +5689,16 @@ function updateProfile(id, config, skillMd) {
   if (!result.success) {
     throw new Error(`Invalid profile: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
-  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;
+  const skillsDir = path11.join(SKILLS_DIR, id);
+  const promotedDir = path11.join(PROMOTED_PROFILES_DIR, id);
+  const dir = fs11.existsSync(skillsDir) ? skillsDir : fs11.existsSync(promotedDir) ? promotedDir : null;
   if (!dir) {
     throw new Error(`Profile "${id}" not found`);
   }
-  fs10.writeFileSync(path10.join(dir, "profile.yaml"), yaml6.dump(config));
-  fs10.writeFileSync(path10.join(dir, "SKILL.md"), skillMd);
+  fs11.writeFileSync(path11.join(dir, AGENT_FILENAME), yaml6.dump(config));
+  const legacyPath = path11.join(dir, LEGACY_PROFILE_FILENAME);
+  if (fs11.existsSync(legacyPath)) fs11.rmSync(legacyPath);
+  fs11.writeFileSync(path11.join(dir, "SKILL.md"), skillMd);
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5679,13 +5706,13 @@ function deleteProfile(id) {
   if (isBuiltin(id)) {
     throw new Error("Cannot delete built-in profiles");
   }
-  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;
+  const skillsDir = path11.join(SKILLS_DIR, id);
+  const promotedDir = path11.join(PROMOTED_PROFILES_DIR, id);
+  const dir = fs11.existsSync(skillsDir) ? skillsDir : fs11.existsSync(promotedDir) ? promotedDir : null;
   if (!dir) {
     throw new Error(`Profile "${id}" not found`);
   }
-  fs10.rmSync(dir, { recursive: true, force: true });
+  fs11.rmSync(dir, { recursive: true, force: true });
   reloadProfiles();
   invalidateLatestScan();
 }
@@ -5768,8 +5795,9 @@ var init_registry2 = __esm({
     init_schema();
     init_ainative_paths();
     init_app_manifest_source();
+    init_agent_file();
     init_app_root();
-    BUILTINS_DIR = path10.resolve(
+    BUILTINS_DIR = path11.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -5777,7 +5805,7 @@ var init_registry2 = __esm({
       "profiles",
       "builtins"
     );
-    SKILLS_DIR = path10.join(
+    SKILLS_DIR = path11.join(
       process.env.HOME ?? process.env.USERPROFILE ?? homedir3(),
       ".claude",
       "skills"
@@ -5805,23 +5833,23 @@ __export(registry_exports3, {
   reloadBlueprints: () => reloadBlueprints,
   validateBlueprintRefs: () => validateBlueprintRefs
 });
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import yaml7 from "js-yaml";
 function userDirMtimeMs() {
   try {
-    return fs11.statSync(USER_BLUEPRINTS_DIR).mtimeMs;
+    return fs12.statSync(USER_BLUEPRINTS_DIR).mtimeMs;
   } catch {
     return null;
   }
 }
 function scanDirectory(dir, isBuiltin2) {
   const blueprints = /* @__PURE__ */ new Map();
-  if (!fs11.existsSync(dir)) return blueprints;
-  for (const file of fs11.readdirSync(dir)) {
+  if (!fs12.existsSync(dir)) return blueprints;
+  for (const file of fs12.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      const content = fs11.readFileSync(path11.join(dir, file), "utf-8");
+      const content = fs12.readFileSync(path12.join(dir, file), "utf-8");
       const parsed = yaml7.load(content);
       const result = BlueprintSchema.safeParse(parsed);
       if (!result.success) {
@@ -5880,12 +5908,12 @@ function createBlueprint(yamlContent) {
       `Invalid blueprint: ${result.error.issues.map((i) => i.message).join(", ")}`
     );
   }
-  fs11.mkdirSync(USER_BLUEPRINTS_DIR, { recursive: true });
-  const filePath = path11.join(USER_BLUEPRINTS_DIR, `${result.data.id}.yaml`);
-  if (fs11.existsSync(filePath)) {
+  fs12.mkdirSync(USER_BLUEPRINTS_DIR, { recursive: true });
+  const filePath = path12.join(USER_BLUEPRINTS_DIR, `${result.data.id}.yaml`);
+  if (fs12.existsSync(filePath)) {
     throw new Error(`Blueprint "${result.data.id}" already exists`);
   }
-  fs11.writeFileSync(filePath, yamlContent);
+  fs12.writeFileSync(filePath, yamlContent);
   reloadBlueprints();
   return { ...result.data, isBuiltin: false };
 }
@@ -5893,11 +5921,11 @@ function deleteBlueprint(id) {
   if (isBuiltinBlueprint(id)) {
     throw new Error("Cannot delete built-in blueprints");
   }
-  const filePath = path11.join(USER_BLUEPRINTS_DIR, `${id}.yaml`);
-  if (!fs11.existsSync(filePath)) {
+  const filePath = path12.join(USER_BLUEPRINTS_DIR, `${id}.yaml`);
+  if (!fs12.existsSync(filePath)) {
     throw new Error(`Blueprint "${id}" not found`);
   }
-  fs11.unlinkSync(filePath);
+  fs12.unlinkSync(filePath);
   reloadBlueprints();
 }
 function getUserBlueprintsDir() {
@@ -5961,7 +5989,7 @@ var init_registry3 = __esm({
     init_ainative_paths();
     init_app_root();
     init_registry2();
-    BUILTINS_DIR2 = path11.resolve(
+    BUILTINS_DIR2 = path12.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -6824,18 +6852,18 @@ var init_processor = __esm({
 });
 
 // src/lib/documents/output-scanner.ts
-import path12 from "path";
-import fs12 from "fs/promises";
+import path13 from "path";
+import fs13 from "fs/promises";
 import { and as and6, eq as eq14 } from "drizzle-orm";
 function getTaskOutputDirectory(taskId) {
-  return path12.join(TASK_OUTPUTS_DIR, taskId);
+  return path13.join(TASK_OUTPUTS_DIR, taskId);
 }
 async function prepareTaskOutputDirectory(taskId, options = {}) {
   const outputDir = getTaskOutputDirectory(taskId);
   if (options.clearExisting) {
-    await fs12.rm(outputDir, { recursive: true, force: true });
+    await fs13.rm(outputDir, { recursive: true, force: true });
   }
-  await fs12.mkdir(outputDir, { recursive: true });
+  await fs13.mkdir(outputDir, { recursive: true });
   return outputDir;
 }
 function buildTaskOutputInstructions(taskId) {
@@ -6848,10 +6876,10 @@ function buildTaskOutputInstructions(taskId) {
   ].join("\n");
 }
 async function listFilesRecursively(rootDir) {
-  const entries = await fs12.readdir(rootDir, { withFileTypes: true });
+  const entries = await fs13.readdir(rootDir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map(async (entry) => {
-      const resolved = path12.join(rootDir, entry.name);
+      const resolved = path13.join(rootDir, entry.name);
       if (entry.isDirectory()) {
         return listFilesRecursively(resolved);
       }
@@ -6861,13 +6889,13 @@ async function listFilesRecursively(rootDir) {
   return files.flat();
 }
 function resolveOutputMimeType(filename) {
-  return OUTPUT_MIME_TYPES[path12.extname(filename).toLowerCase()] ?? null;
+  return OUTPUT_MIME_TYPES[path13.extname(filename).toLowerCase()] ?? null;
 }
 function normalizeRelativePath(value) {
-  return value.split(path12.sep).join("/");
+  return value.split(path13.sep).join("/");
 }
 function buildArchivedFilename(relativePath, version) {
-  const parsed = path12.parse(relativePath);
+  const parsed = path13.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}`;
@@ -6879,7 +6907,7 @@ async function scanTaskOutputDocuments(taskId) {
     throw new Error(`Task ${taskId} not found`);
   }
   try {
-    await fs12.access(outputDir);
+    await fs13.access(outputDir);
   } catch {
     return [];
   }
@@ -6899,22 +6927,22 @@ async function scanTaskOutputDocuments(taskId) {
   const discoveredFiles = await listFilesRecursively(outputDir);
   const registeredDocumentIds = [];
   for (const sourcePath of discoveredFiles) {
-    const relativePath = normalizeRelativePath(path12.relative(outputDir, sourcePath));
+    const relativePath = normalizeRelativePath(path13.relative(outputDir, sourcePath));
     const mimeType = resolveOutputMimeType(relativePath);
     if (!mimeType) {
       continue;
     }
-    const stats = await fs12.stat(sourcePath);
+    const stats = await fs13.stat(sourcePath);
     if (!stats.isFile()) {
       continue;
     }
     const nextVersion = (versionMap.get(relativePath) ?? 0) + 1;
     versionMap.set(relativePath, nextVersion);
-    const archiveDir = path12.join(OUTPUT_ARCHIVE_DIR, taskId);
-    await fs12.mkdir(archiveDir, { recursive: true });
+    const archiveDir = path13.join(OUTPUT_ARCHIVE_DIR, taskId);
+    await fs13.mkdir(archiveDir, { recursive: true });
     const archivedFilename = buildArchivedFilename(relativePath, nextVersion);
-    const archivedPath = path12.join(archiveDir, archivedFilename);
-    await fs12.copyFile(sourcePath, archivedPath);
+    const archivedPath = path13.join(archiveDir, archivedFilename);
+    await fs13.copyFile(sourcePath, archivedPath);
     const documentId = crypto.randomUUID();
     const now = /* @__PURE__ */ new Date();
     await db.insert(documents).values({
@@ -6945,8 +6973,8 @@ var init_output_scanner = __esm({
     init_schema();
     init_env();
     init_processor();
-    TASK_OUTPUTS_DIR = path12.join(dataDir(), "outputs");
-    OUTPUT_ARCHIVE_DIR = path12.join(dataDir(), "documents", "output");
+    TASK_OUTPUTS_DIR = path13.join(dataDir(), "outputs");
+    OUTPUT_ARCHIVE_DIR = path13.join(dataDir(), "documents", "output");
     OUTPUT_MIME_TYPES = {
       ".md": "text/markdown",
       ".txt": "text/plain",
@@ -8114,7 +8142,7 @@ var init_ledger = __esm({
 });
 
 // src/lib/plugins/classify-trust.ts
-import path13 from "path";
+import path14 from "path";
 import os from "os";
 function classifyPluginTrust(manifest, rootDir, opts2 = {}) {
   if (manifest.kind === "primitives-bundle") return "self";
@@ -8128,9 +8156,9 @@ function classifyPluginTrust(manifest, rootDir, opts2 = {}) {
     if (manifest.author === currentUser) return "self";
   }
   const appsBase = opts2.appsBaseDir ?? getAinativeAppsDir();
-  const normalizedRoot = path13.resolve(rootDir);
-  const normalizedApps = path13.resolve(appsBase);
-  const sep = path13.sep;
+  const normalizedRoot = path14.resolve(rootDir);
+  const normalizedApps = path14.resolve(appsBase);
+  const sep = path14.sep;
   if (normalizedRoot === normalizedApps || normalizedRoot.startsWith(normalizedApps + sep)) {
     return "self";
   }
@@ -8151,15 +8179,15 @@ __export(transport_dispatch_exports, {
   validateStdioMcp: () => validateStdioMcp
 });
 import { spawn } from "child_process";
-import fs13 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path15 from "path";
 import readline from "readline";
 function logToFile2(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}
 `
     );
@@ -8294,14 +8322,14 @@ async function validateInProcessSdk(config, pluginId, serverName) {
     };
   }
   const absPath = config.entry;
-  if (!path14.isAbsolute(absPath)) {
+  if (!path15.isAbsolute(absPath)) {
     return {
       ok: false,
       reason: "sdk_invalid_export",
       detail: `entry must be absolute path, got: ${absPath}`
     };
   }
-  const ext = path14.extname(absPath);
+  const ext = path15.extname(absPath);
   if (ext === ".ts") {
     return {
       ok: false,
@@ -8420,8 +8448,8 @@ __export(mcp_loader_exports, {
   loadPluginMcpServers: () => loadPluginMcpServers,
   reloadPluginMcpRegistrations: () => reloadPluginMcpRegistrations
 });
-import fs14 from "fs";
-import path15 from "path";
+import fs15 from "fs";
+import path16 from "path";
 import os2 from "os";
 import yaml8 from "js-yaml";
 function __resetDockerBootSweepForTests() {
@@ -8430,9 +8458,9 @@ function __resetDockerBootSweepForTests() {
 function logToFile3(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}
 `
     );
@@ -8457,10 +8485,10 @@ function isRelativeCommand(command) {
 }
 async function scanPlugin(pluginDir, pluginId) {
   const registrations = [];
-  const pluginYamlPath = path15.join(pluginDir, "plugin.yaml");
+  const pluginYamlPath = path16.join(pluginDir, "plugin.yaml");
   let pluginYamlContent;
   try {
-    pluginYamlContent = fs14.readFileSync(pluginYamlPath, "utf-8");
+    pluginYamlContent = fs15.readFileSync(pluginYamlPath, "utf-8");
   } catch {
     return { registrations };
   }
@@ -8482,7 +8510,7 @@ async function scanPlugin(pluginDir, pluginId) {
   if (manifest.kind !== "chat-tools") {
     return { registrations };
   }
-  const mcpJsonPath = path15.join(pluginDir, ".mcp.json");
+  const mcpJsonPath = path16.join(pluginDir, ".mcp.json");
   const mcpServers = parseMcpConfigFile(mcpJsonPath);
   if (mcpServers === null) {
     logToFile3(
@@ -8586,8 +8614,8 @@ async function scanPlugin(pluginDir, pluginId) {
       const resolvedEnv = resolveEnvTemplates(rawEntry.env, context);
       let resolvedCommand;
       if (isRelativeCommand(rawCommand)) {
-        const absCommand = path15.resolve(pluginDir, rawCommand);
-        if (!fs14.existsSync(absCommand)) {
+        const absCommand = path16.resolve(pluginDir, rawCommand);
+        if (!fs15.existsSync(absCommand)) {
           logToFile3(
             `[mcp-loader] plugin ${pluginId} server "${serverName}": command "${rawCommand}" not found at ${absCommand} (server_not_found)`
           );
@@ -8681,8 +8709,8 @@ async function scanPlugin(pluginDir, pluginId) {
         });
         continue;
       }
-      const absEntry = path15.resolve(pluginDir, entryField);
-      if (!fs14.existsSync(absEntry)) {
+      const absEntry = path16.resolve(pluginDir, entryField);
+      if (!fs15.existsSync(absEntry)) {
         logToFile3(
           `[mcp-loader] plugin ${pluginId} server "${serverName}": entry "${entryField}" not found at ${absEntry} (sdk_entry_not_found)`
         );
@@ -8751,9 +8779,9 @@ async function listPluginMcpRegistrations(opts2) {
     const features = getRuntimeFeatures(opts2.runtime);
     if (!features.supportsPluginMcpServers) {
       const pluginsDir2 = getAinativePluginsDir();
-      if (fs14.existsSync(pluginsDir2)) {
+      if (fs15.existsSync(pluginsDir2)) {
         try {
-          for (const entry of fs14.readdirSync(pluginsDir2).sort()) {
+          for (const entry of fs15.readdirSync(pluginsDir2).sort()) {
             const logKey = `${entry}@${opts2.runtime}@${pluginsDir2}`;
             if (!ollamaSkipLogged.has(logKey)) {
               ollamaSkipLogged.add(logKey);
@@ -8776,22 +8804,22 @@ async function listPluginMcpRegistrations(opts2) {
     }
   }
   const pluginsDir = getAinativePluginsDir();
-  if (!fs14.existsSync(pluginsDir)) {
+  if (!fs15.existsSync(pluginsDir)) {
     return [];
   }
   let pluginDirEntries;
   try {
-    pluginDirEntries = fs14.readdirSync(pluginsDir).sort();
+    pluginDirEntries = fs15.readdirSync(pluginsDir).sort();
   } catch {
     logToFile3(`[mcp-loader] could not read plugins directory: ${pluginsDir}`);
     return [];
   }
   const allRegistrations = [];
   for (const entry of pluginDirEntries) {
-    const pluginDir = path15.join(pluginsDir, entry);
+    const pluginDir = path16.join(pluginsDir, entry);
     let stat2;
     try {
-      stat2 = fs14.statSync(pluginDir);
+      stat2 = fs15.statSync(pluginDir);
     } catch {
       continue;
     }
@@ -8816,18 +8844,18 @@ async function loadPluginMcpServers(opts2) {
 }
 function hasAnyDockerConfinedPlugin() {
   const pluginsDir = getAinativePluginsDir();
-  if (!fs14.existsSync(pluginsDir)) return false;
+  if (!fs15.existsSync(pluginsDir)) return false;
   let entries;
   try {
-    entries = fs14.readdirSync(pluginsDir);
+    entries = fs15.readdirSync(pluginsDir);
   } catch {
     return false;
   }
   for (const entry of entries) {
-    const pluginYamlPath = path15.join(pluginsDir, entry, "plugin.yaml");
+    const pluginYamlPath = path16.join(pluginsDir, entry, "plugin.yaml");
     let content;
     try {
-      content = fs14.readFileSync(pluginYamlPath, "utf-8");
+      content = fs15.readFileSync(pluginYamlPath, "utf-8");
     } catch {
       continue;
     }
@@ -8847,26 +8875,26 @@ function hasAnyDockerConfinedPlugin() {
 function buildSafeModeRegistrations() {
   const out = [];
   const pluginsDir = getAinativePluginsDir();
-  if (!fs14.existsSync(pluginsDir)) return out;
+  if (!fs15.existsSync(pluginsDir)) return out;
   let entries;
   try {
-    entries = fs14.readdirSync(pluginsDir).sort();
+    entries = fs15.readdirSync(pluginsDir).sort();
   } catch {
     return out;
   }
   for (const entry of entries) {
-    const pluginDir = path15.join(pluginsDir, entry);
+    const pluginDir = path16.join(pluginsDir, entry);
     let stat2;
     try {
-      stat2 = fs14.statSync(pluginDir);
+      stat2 = fs15.statSync(pluginDir);
     } catch {
       continue;
     }
     if (!stat2.isDirectory()) continue;
-    const pluginYamlPath = path15.join(pluginDir, "plugin.yaml");
+    const pluginYamlPath = path16.join(pluginDir, "plugin.yaml");
     let content;
     try {
-      content = fs14.readFileSync(pluginYamlPath, "utf-8");
+      content = fs15.readFileSync(pluginYamlPath, "utf-8");
     } catch {
       continue;
     }
@@ -8959,17 +8987,17 @@ __export(capability_check_exports, {
   writePluginsLock: () => writePluginsLock
 });
 import crypto3 from "crypto";
-import fs15 from "fs";
+import fs16 from "fs";
 import os3 from "os";
-import path16 from "path";
+import path17 from "path";
 import yaml9 from "js-yaml";
 import { z as z6 } from "zod";
 function logToFile4(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs15.mkdirSync(logsDir, { recursive: true });
-    fs15.appendFileSync(
-      path16.join(logsDir, "plugins.log"),
+    fs16.mkdirSync(logsDir, { recursive: true });
+    fs16.appendFileSync(
+      path17.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -9009,12 +9037,12 @@ function deriveManifestHash(pluginYamlContent) {
 }
 function readPluginsLock() {
   const lockPath = getAinativePluginsLockPath();
-  if (!fs15.existsSync(lockPath)) {
+  if (!fs16.existsSync(lockPath)) {
     return { version: 1, accepted: {} };
   }
   let raw;
   try {
-    raw = yaml9.load(fs15.readFileSync(lockPath, "utf-8"));
+    raw = yaml9.load(fs16.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)}`
@@ -9033,31 +9061,31 @@ function readPluginsLock() {
 function writePluginsLock(pluginId, entry) {
   const lockPath = getAinativePluginsLockPath();
   const bakPath = lockPath + ".bak";
-  const lockDir = path16.dirname(lockPath);
-  fs15.mkdirSync(lockDir, { recursive: true });
+  const lockDir = path17.dirname(lockPath);
+  fs16.mkdirSync(lockDir, { recursive: true });
   const current = readPluginsLock();
   current.accepted[pluginId] = entry;
   const newContent = yaml9.dump(current, { lineWidth: -1 });
-  if (fs15.existsSync(lockPath)) {
-    fs15.copyFileSync(lockPath, bakPath);
+  if (fs16.existsSync(lockPath)) {
+    fs16.copyFileSync(lockPath, bakPath);
     try {
-      fs15.chmodSync(bakPath, 384);
+      fs16.chmodSync(bakPath, 384);
     } catch {
     }
   }
   const tmpPath = `${lockPath}.tmp-${crypto3.randomBytes(6).toString("hex")}`;
   try {
-    fs15.writeFileSync(tmpPath, newContent, { mode: 384 });
-    fs15.renameSync(tmpPath, lockPath);
+    fs16.writeFileSync(tmpPath, newContent, { mode: 384 });
+    fs16.renameSync(tmpPath, lockPath);
   } catch (err2) {
     try {
-      fs15.unlinkSync(tmpPath);
+      fs16.unlinkSync(tmpPath);
     } catch {
     }
     throw err2;
   }
   try {
-    fs15.chmodSync(lockPath, 384);
+    fs16.chmodSync(lockPath, 384);
   } catch {
   }
 }
@@ -9068,28 +9096,28 @@ function removePluginsLockEntry(pluginId) {
   if (!(pluginId in current.accepted)) return;
   delete current.accepted[pluginId];
   const newContent = yaml9.dump(current, { lineWidth: -1 });
-  const lockDir = path16.dirname(lockPath);
-  fs15.mkdirSync(lockDir, { recursive: true });
-  if (fs15.existsSync(lockPath)) {
-    fs15.copyFileSync(lockPath, bakPath);
+  const lockDir = path17.dirname(lockPath);
+  fs16.mkdirSync(lockDir, { recursive: true });
+  if (fs16.existsSync(lockPath)) {
+    fs16.copyFileSync(lockPath, bakPath);
     try {
-      fs15.chmodSync(bakPath, 384);
+      fs16.chmodSync(bakPath, 384);
     } catch {
     }
   }
   const tmpPath = `${lockPath}.tmp-${crypto3.randomBytes(6).toString("hex")}`;
   try {
-    fs15.writeFileSync(tmpPath, newContent, { mode: 384 });
-    fs15.renameSync(tmpPath, lockPath);
+    fs16.writeFileSync(tmpPath, newContent, { mode: 384 });
+    fs16.renameSync(tmpPath, lockPath);
   } catch (err2) {
     try {
-      fs15.unlinkSync(tmpPath);
+      fs16.unlinkSync(tmpPath);
     } catch {
     }
     throw err2;
   }
   try {
-    fs15.chmodSync(lockPath, 384);
+    fs16.chmodSync(lockPath, 384);
   } catch {
   }
 }
@@ -9175,9 +9203,9 @@ function getPluginToolApprovalMode(pluginId, toolName, defaultFromManifest) {
 }
 function readManifestDefaultApproval(pluginId) {
   try {
-    const pluginYamlPath = path16.join(getAinativePluginsDir(), pluginId, "plugin.yaml");
-    if (!fs15.existsSync(pluginYamlPath)) return void 0;
-    const content = fs15.readFileSync(pluginYamlPath, "utf-8");
+    const pluginYamlPath = path17.join(getAinativePluginsDir(), pluginId, "plugin.yaml");
+    if (!fs16.existsSync(pluginYamlPath)) return void 0;
+    const content = fs16.readFileSync(pluginYamlPath, "utf-8");
     const raw = yaml9.load(content);
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
     const record = raw;
@@ -9269,13 +9297,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 = path16.join(getDir(), pluginId, "plugin.yaml");
-  if (!fs15.existsSync(pluginYamlPath)) {
+  const pluginYamlPath = path17.join(getDir(), pluginId, "plugin.yaml");
+  if (!fs16.existsSync(pluginYamlPath)) {
     return { granted: false, reason: "not_found" };
   }
   let content;
   try {
-    content = fs15.readFileSync(pluginYamlPath, "utf-8");
+    content = fs16.readFileSync(pluginYamlPath, "utf-8");
   } catch (err2) {
     return {
       granted: false,
@@ -12042,9 +12070,9 @@ function buildPermissionSummary(toolName, input) {
     }
   }
   if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "read" || toolName === "write" || toolName === "edit") {
-    const path24 = input.file_path ?? input.path;
-    if (typeof path24 === "string" && path24.trim().length > 0) {
-      return truncate(path24.trim());
+    const path25 = input.file_path ?? input.path;
+    if (typeof path25 === "string" && path25.trim().length > 0) {
+      return truncate(path25.trim());
     }
   }
   if (toolName?.startsWith("mcp__")) {
@@ -12078,9 +12106,9 @@ function getPermissionDetailEntries(toolName, input) {
     }
   }
   if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "read" || toolName === "write" || toolName === "edit") {
-    const path24 = input.file_path ?? input.path;
-    if (typeof path24 === "string") {
-      return [{ label: "Path", value: path24 }];
+    const path25 = input.file_path ?? input.path;
+    if (typeof path25 === "string") {
+      return [{ label: "Path", value: path25 }];
     }
   }
   return Object.entries(input).slice(0, 6).map(([key, value]) => ({
@@ -12168,7 +12196,7 @@ async function listPendingApprovalPayloads(limit = 20) {
       toolName: row.toolName,
       permissionLabel: isBatchProposal ? "Workflow Learning" : isContextProposal ? "Context Proposal" : getPermissionKindLabel(row.toolName),
       compactSummary: isBatchProposal ? `Batch of learned patterns from workflow execution` : isContextProposal ? `Learned patterns proposed for profile "${row.toolName}"` : buildPermissionSummary(row.toolName, parsedInput),
-      deepLink: isBatchProposal ? "/inbox" : isContextProposal ? `/profiles/${row.toolName}` : buildDeepLink(row.taskId, effectiveWorkflowId),
+      deepLink: isBatchProposal ? "/inbox" : isContextProposal ? `/agents/${row.toolName}` : buildDeepLink(row.taskId, effectiveWorkflowId),
       supportedActionIds: isContextProposal || isBatchProposal ? ["allow_once", "deny"] : [...APPROVAL_ACTION_IDS],
       title: row.title,
       body: row.body,
@@ -12368,16 +12396,16 @@ __export(registry_exports4, {
   reloadSchedules: () => reloadSchedules,
   validateScheduleRefs: () => validateScheduleRefs
 });
-import fs16 from "fs";
-import path17 from "path";
+import fs17 from "fs";
+import path18 from "path";
 import yaml10 from "js-yaml";
 function scanDirectory2(dir) {
   const schedules2 = /* @__PURE__ */ new Map();
-  if (!fs16.existsSync(dir)) return schedules2;
-  for (const file of fs16.readdirSync(dir)) {
+  if (!fs17.existsSync(dir)) return schedules2;
+  for (const file of fs17.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      const content = fs16.readFileSync(path17.join(dir, file), "utf-8");
+      const content = fs17.readFileSync(path18.join(dir, file), "utf-8");
       const parsed = yaml10.load(content);
       const result = ScheduleSpecSchema.safeParse(parsed);
       if (!result.success) {
@@ -12433,12 +12461,12 @@ function createScheduleFromYaml(yamlContent) {
       `Invalid schedule: ${result.error.issues.map((i) => i.message).join(", ")}`
     );
   }
-  fs16.mkdirSync(USER_DIR, { recursive: true });
-  const filePath = path17.join(USER_DIR, `${result.data.id}.yaml`);
-  if (fs16.existsSync(filePath)) {
+  fs17.mkdirSync(USER_DIR, { recursive: true });
+  const filePath = path18.join(USER_DIR, `${result.data.id}.yaml`);
+  if (fs17.existsSync(filePath)) {
     throw new Error(`Schedule "${result.data.id}" already exists`);
   }
-  fs16.writeFileSync(filePath, yamlContent);
+  fs17.writeFileSync(filePath, yamlContent);
   reloadSchedules();
   return result.data;
 }
@@ -12490,11 +12518,11 @@ function deleteSchedule(id) {
   if (isBuiltinSchedule(id)) {
     throw new Error("Cannot delete built-in schedules");
   }
-  const filePath = path17.join(USER_DIR, `${id}.yaml`);
-  if (!fs16.existsSync(filePath)) {
+  const filePath = path18.join(USER_DIR, `${id}.yaml`);
+  if (!fs17.existsSync(filePath)) {
     throw new Error(`Schedule "${id}" not found`);
   }
-  fs16.unlinkSync(filePath);
+  fs17.unlinkSync(filePath);
   reloadSchedules();
 }
 var BUILTINS_DIR3, USER_DIR, scheduleCache, builtinIdsCache, pluginScheduleIndex;
@@ -12504,7 +12532,7 @@ var init_registry5 = __esm({
     init_schedule_spec();
     init_ainative_paths();
     init_app_root();
-    BUILTINS_DIR3 = path17.resolve(
+    BUILTINS_DIR3 = path18.resolve(
       getAppRoot(import.meta.dirname, 4),
       "src",
       "lib",
@@ -12650,8 +12678,8 @@ __export(registry_exports5, {
   reloadPlugins: () => reloadPlugins,
   scanBundleSection: () => scanBundleSection
 });
-import fs17 from "fs";
-import path18 from "path";
+import fs18 from "fs";
+import path19 from "path";
 import yaml11 from "js-yaml";
 import { z as z16 } from "zod";
 function isSupportedApiVersion(apiVersion) {
@@ -12660,9 +12688,9 @@ function isSupportedApiVersion(apiVersion) {
 function logToFile5(line) {
   try {
     const logsDir = getAinativeLogsDir();
-    fs17.mkdirSync(logsDir, { recursive: true });
-    fs17.appendFileSync(
-      path18.join(logsDir, "plugins.log"),
+    fs18.mkdirSync(logsDir, { recursive: true });
+    fs18.appendFileSync(
+      path19.join(logsDir, "plugins.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `
     );
@@ -12670,11 +12698,11 @@ function logToFile5(line) {
   }
 }
 function readManifest(rootDir) {
-  const manifestPath = path18.join(rootDir, "plugin.yaml");
-  if (!fs17.existsSync(manifestPath)) return { error: "missing plugin.yaml" };
+  const manifestPath = path19.join(rootDir, "plugin.yaml");
+  if (!fs18.existsSync(manifestPath)) return { error: "missing plugin.yaml" };
   let raw;
   try {
-    raw = yaml11.load(fs17.readFileSync(manifestPath, "utf-8"));
+    raw = yaml11.load(fs18.readFileSync(manifestPath, "utf-8"));
   } catch (err2) {
     return { error: `yaml_parse: ${err2 instanceof Error ? err2.message : String(err2)}` };
   }
@@ -12686,16 +12714,16 @@ function readManifest(rootDir) {
 }
 function discoverBundleRoots() {
   const baseDir = getAinativePluginsDir();
-  if (!fs17.existsSync(baseDir)) return [];
-  return fs17.readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path18.join(baseDir, e.name)).sort();
+  if (!fs18.existsSync(baseDir)) return [];
+  return fs18.readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path19.join(baseDir, e.name)).sort();
 }
 function scanBundleSection(opts2) {
-  const dir = path18.join(opts2.rootDir, opts2.section);
-  if (!fs17.existsSync(dir)) return [];
+  const dir = path19.join(opts2.rootDir, opts2.section);
+  if (!fs18.existsSync(dir)) return [];
   const out = [];
-  for (const file of fs17.readdirSync(dir)) {
+  for (const file of fs18.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-    const filePath = path18.join(dir, file);
+    const filePath = path19.join(dir, file);
     try {
       const result = opts2.parseFile(filePath);
       if (result !== null) out.push(result);
@@ -12706,8 +12734,8 @@ function scanBundleSection(opts2) {
   return out;
 }
 function scanBundleProfiles(rootDir, pluginId) {
-  const profilesDir = path18.join(rootDir, "profiles");
-  if (!fs17.existsSync(profilesDir)) return [];
+  const profilesDir = path19.join(rootDir, "profiles");
+  if (!fs18.existsSync(profilesDir)) return [];
   const tmp = /* @__PURE__ */ new Map();
   scanProfilesIntoMap(profilesDir, tmp, { namespace: pluginId });
   return Array.from(tmp.entries()).map(([id, profile]) => ({
@@ -12720,9 +12748,9 @@ function scanBundleBlueprints(rootDir, pluginId, siblingProfileIds) {
     rootDir,
     section: "blueprints",
     parseFile: (filePath) => {
-      const file = path18.basename(filePath);
+      const file = path19.basename(filePath);
       try {
-        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs18.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("; ")}`);
@@ -12748,9 +12776,9 @@ function scanBundleTables(rootDir, pluginId) {
     rootDir,
     section: "tables",
     parseFile: (filePath) => {
-      const file = path18.basename(filePath);
+      const file = path19.basename(filePath);
       try {
-        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs18.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("; ")}`);
@@ -12769,9 +12797,9 @@ function scanBundleSchedules(rootDir, pluginId) {
     rootDir,
     section: "schedules",
     parseFile: (filePath) => {
-      const file = path18.basename(filePath);
+      const file = path19.basename(filePath);
       try {
-        const raw = yaml11.load(fs17.readFileSync(filePath, "utf-8"));
+        const raw = yaml11.load(fs18.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("; ")}`);
@@ -12858,7 +12886,7 @@ async function scanPlugins() {
   for (const rootDir of discoverBundleRoots()) {
     const { manifest, error } = readManifest(rootDir);
     if (!manifest) {
-      const fallbackId = path18.basename(rootDir);
+      const fallbackId = path19.basename(rootDir);
       result.push({
         id: fallbackId,
         manifest: { id: fallbackId, version: "0.0.0", apiVersion: "0.0", kind: "primitives-bundle" },
@@ -12982,7 +13010,7 @@ var init_registry6 = __esm({
     init_registry5();
     init_installer();
     init_schedule_spec();
-    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PLUGIN_API_VERSION, "0.25"]);
+    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PLUGIN_API_VERSION, "0.27"]);
     pluginCache = null;
     lastLoadedPluginIds = /* @__PURE__ */ new Set();
     PluginTableSchema = z16.object({
@@ -13025,8 +13053,8 @@ function pluginTools(_ctx) {
             Promise.resolve().then(() => (init_ainative_paths(), ainative_paths_exports)),
             Promise.resolve().then(() => (init_types(), types_exports))
           ]);
-          const fs23 = await import("fs");
-          const path24 = await import("path");
+          const fs24 = await import("fs");
+          const path25 = await import("path");
           const yaml13 = await import("js-yaml");
           const kind5 = listPlugins2();
           const registrations = await listPluginMcpRegistrations2();
@@ -13043,13 +13071,13 @@ function pluginTools(_ctx) {
               let manifestHash;
               let capabilityAcceptStatus = "pending";
               try {
-                const pluginYamlPath = path24.join(
+                const pluginYamlPath = path25.join(
                   pluginsDir,
                   pluginId,
                   "plugin.yaml"
                 );
-                if (fs23.existsSync(pluginYamlPath)) {
-                  const content = fs23.readFileSync(pluginYamlPath, "utf-8");
+                if (fs24.existsSync(pluginYamlPath)) {
+                  const content = fs24.readFileSync(pluginYamlPath, "utf-8");
                   const rawManifest = yaml13.load(content);
                   if (rawManifest !== null && typeof rawManifest === "object" && !Array.isArray(rawManifest)) {
                     const record = rawManifest;
@@ -13062,7 +13090,7 @@ function pluginTools(_ctx) {
                   try {
                     manifestHash = deriveManifestHash2(content);
                     const parsed = PluginManifestSchema2.safeParse(rawManifest);
-                    const pluginRootDir = path24.join(pluginsDir, pluginId);
+                    const pluginRootDir = path25.join(pluginsDir, pluginId);
                     const check = isCapabilityAccepted2(
                       pluginId,
                       manifestHash,
@@ -13276,7 +13304,7 @@ var list_fused_profiles_exports = {};
 __export(list_fused_profiles_exports, {
   listFusedProfiles: () => listFusedProfiles
 });
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync4, existsSync as existsSync7 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync4, existsSync as existsSync7 } from "fs";
 import { join as join12 } from "path";
 import { homedir as homedir5 } from "os";
 function parseFrontmatter2(content) {
@@ -13295,7 +13323,7 @@ function parseFrontmatter2(content) {
 function loadFilesystemSkills(skillsDir, origin, projectRootDir) {
   if (!existsSync7(skillsDir)) return [];
   const profiles = [];
-  for (const entry of readdirSync2(skillsDir)) {
+  for (const entry of readdirSync3(skillsDir)) {
     const skillPath = join12(skillsDir, entry);
     try {
       if (!statSync4(skillPath).isDirectory()) continue;
@@ -16018,7 +16046,7 @@ var init_active_skills = __esm({
 });
 
 // src/lib/environment/parsers/skill.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
 import { join as join13, basename as basename4 } from "path";
 function parseSkillDir(dirPath, tool, scope, baseDir) {
   const stat2 = safeStat(dirPath);
@@ -16028,7 +16056,7 @@ function parseSkillDir(dirPath, tool, scope, baseDir) {
   let mainFile = "";
   let content = "";
   try {
-    const files = readdirSync3(dirPath);
+    const files = readdirSync4(dirPath);
     const skillFile = files.find((f) => f === "SKILL.md") || files.find((f) => f.endsWith(".md")) || files[0];
     if (skillFile) {
       mainFile = join13(dirPath, skillFile);
@@ -16078,7 +16106,7 @@ var init_skill = __esm({
 });
 
 // src/lib/environment/parsers/settings.ts
-import { readdirSync as readdirSync4 } from "fs";
+import { readdirSync as readdirSync5 } from "fs";
 import { join as join14, basename as basename5 } from "path";
 function parseClaudeSettings(filePath, scope, baseDir) {
   const content = safeReadFile(filePath);
@@ -16182,7 +16210,7 @@ function parseOutputStyles(dirPath, tool, baseDir) {
   if (!stat2?.isDirectory()) return [];
   const artifacts = [];
   try {
-    for (const entry of readdirSync4(dirPath)) {
+    for (const entry of readdirSync5(dirPath)) {
       const fullPath = join14(dirPath, entry);
       const content = safeReadFile(fullPath);
       if (!content) continue;
@@ -16260,7 +16288,7 @@ var init_instructions = __esm({
 });
 
 // src/lib/environment/scanners/claude-code.ts
-import { readdirSync as readdirSync5, existsSync as existsSync8 } from "fs";
+import { readdirSync as readdirSync6, existsSync as existsSync8 } from "fs";
 import { join as join15 } from "path";
 function scanUserLevel(userHome) {
   const claudeDir = join15(userHome, ".claude");
@@ -16270,7 +16298,7 @@ function scanUserLevel(userHome) {
   const skillsDir = join15(claudeDir, "skills");
   if (existsSync8(skillsDir)) {
     try {
-      for (const entry of readdirSync5(skillsDir)) {
+      for (const entry of readdirSync6(skillsDir)) {
         const skillPath = join15(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "claude-code", "user", userHome);
         if (artifact) artifacts.push(artifact);
@@ -16300,7 +16328,7 @@ function scanUserLevel(userHome) {
   const projectsDir = join15(claudeDir, "projects");
   if (existsSync8(projectsDir)) {
     try {
-      for (const projEntry of readdirSync5(projectsDir)) {
+      for (const projEntry of readdirSync6(projectsDir)) {
         const memoryDir = join15(projectsDir, projEntry, "memory");
         if (!existsSync8(memoryDir)) continue;
         const memoryIndex = join15(memoryDir, "MEMORY.md");
@@ -16333,7 +16361,7 @@ function scanProjectLevel(projectDir) {
   const skillsDir = join15(claudeDir, "skills");
   if (existsSync8(skillsDir)) {
     try {
-      for (const entry of readdirSync5(skillsDir)) {
+      for (const entry of readdirSync6(skillsDir)) {
         const skillPath = join15(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "claude-code", "project", projectDir);
         if (artifact) artifacts.push(artifact);
@@ -16355,7 +16383,7 @@ function scanProjectLevel(projectDir) {
   const hooksDir = join15(claudeDir, "hooks");
   if (existsSync8(hooksDir)) {
     try {
-      for (const entry of readdirSync5(hooksDir)) {
+      for (const entry of readdirSync6(hooksDir)) {
         const hookPath = join15(hooksDir, entry);
         const content = safeReadFile(hookPath);
         if (!content) continue;
@@ -16401,7 +16429,7 @@ var init_claude_code = __esm({
 });
 
 // src/lib/environment/scanners/codex.ts
-import { readdirSync as readdirSync6, existsSync as existsSync9 } from "fs";
+import { readdirSync as readdirSync7, existsSync as existsSync9 } from "fs";
 import { join as join16 } from "path";
 function scanUserLevel2(userHome) {
   const codexDir = join16(userHome, ".codex");
@@ -16411,7 +16439,7 @@ function scanUserLevel2(userHome) {
   const skillsDir = join16(codexDir, "skills");
   if (existsSync9(skillsDir)) {
     try {
-      for (const entry of readdirSync6(skillsDir)) {
+      for (const entry of readdirSync7(skillsDir)) {
         const skillPath = join16(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "codex", "user", userHome);
         if (artifact) artifacts.push(artifact);
@@ -16428,7 +16456,7 @@ function scanUserLevel2(userHome) {
   const rulesDir = join16(codexDir, "rules");
   if (existsSync9(rulesDir)) {
     try {
-      for (const entry of readdirSync6(rulesDir)) {
+      for (const entry of readdirSync7(rulesDir)) {
         const rulePath = join16(rulesDir, entry);
         const content = safeReadFile(rulePath);
         if (!content) continue;
@@ -16455,7 +16483,7 @@ function scanUserLevel2(userHome) {
   const memoriesDir = join16(codexDir, "memories");
   if (existsSync9(memoriesDir)) {
     try {
-      for (const entry of readdirSync6(memoriesDir)) {
+      for (const entry of readdirSync7(memoriesDir)) {
         const memPath = join16(memoriesDir, entry);
         const content = safeReadFile(memPath);
         if (!content) continue;
@@ -16668,7 +16696,7 @@ __export(list_skills_exports, {
   listSkills: () => listSkills,
   listSkillsEnriched: () => listSkillsEnriched
 });
-import { readFileSync as readFileSync8, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync8, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
 import { join as join18 } from "path";
 function listSkills(options = {}) {
   const projectDir = options.projectDir ?? getLaunchCwd();
@@ -16716,7 +16744,7 @@ function resolveSkillFile(dirPath) {
     }
   }
   try {
-    const fallback = readdirSync7(dirPath).find((f) => f.toLowerCase().endsWith(".md"));
+    const fallback = readdirSync8(dirPath).find((f) => f.toLowerCase().endsWith(".md"));
     if (fallback) return join18(dirPath, fallback);
   } catch {
   }
@@ -17218,8 +17246,8 @@ var init_schedule_spec_tools = __esm({
 
 // src/lib/chat/tools/plugin-spec-tools.ts
 import { z as z27 } from "zod";
-import * as fs18 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 function validateId(id) {
   if (id.length < 2) {
     throw new PluginSpecInvalidIdError(id, "must be at least 2 chars");
@@ -17482,20 +17510,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 = path19.join(pluginsDir, input.id);
-  const tmpDir = path19.join(pluginsDir, `${input.id}.tmp-${Date.now()}`);
-  if (fs18.existsSync(pluginDir)) {
+  const pluginDir = path20.join(pluginsDir, input.id);
+  const tmpDir = path20.join(pluginsDir, `${input.id}.tmp-${Date.now()}`);
+  if (fs19.existsSync(pluginDir)) {
     throw new PluginSpecAlreadyExistsError(pluginDir);
   }
   try {
-    fs18.mkdirSync(tmpDir, { recursive: true });
-    fs18.writeFileSync(
-      path19.join(tmpDir, "plugin.yaml"),
+    fs19.mkdirSync(tmpDir, { recursive: true });
+    fs19.writeFileSync(
+      path20.join(tmpDir, "plugin.yaml"),
       renderPluginYaml(input),
       "utf-8"
     );
-    fs18.writeFileSync(
-      path19.join(tmpDir, ".mcp.json"),
+    fs19.writeFileSync(
+      path20.join(tmpDir, ".mcp.json"),
       renderMcpJson({
         id: input.id,
         transport: input.transport,
@@ -17503,8 +17531,8 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs18.writeFileSync(
-      path19.join(tmpDir, "server.py"),
+    fs19.writeFileSync(
+      path20.join(tmpDir, "server.py"),
       renderServerPy({
         id: input.id,
         tools: input.tools,
@@ -17513,8 +17541,8 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs18.writeFileSync(
-      path19.join(tmpDir, "README.md"),
+    fs19.writeFileSync(
+      path20.join(tmpDir, "README.md"),
       renderReadme({
         id: input.id,
         name: input.name,
@@ -17522,11 +17550,11 @@ function scaffoldPluginSpec(input) {
       }),
       "utf-8"
     );
-    fs18.renameSync(tmpDir, pluginDir);
+    fs19.renameSync(tmpDir, pluginDir);
   } catch (cause) {
     try {
-      if (fs18.existsSync(tmpDir)) {
-        fs18.rmSync(tmpDir, { recursive: true, force: true });
+      if (fs19.existsSync(tmpDir)) {
+        fs19.rmSync(tmpDir, { recursive: true, force: true });
       }
     } catch {
     }
@@ -17537,10 +17565,10 @@ function scaffoldPluginSpec(input) {
     id: input.id,
     pluginDir,
     files: {
-      pluginYaml: path19.join(pluginDir, "plugin.yaml"),
-      mcpJson: path19.join(pluginDir, ".mcp.json"),
-      serverPy: path19.join(pluginDir, "server.py"),
-      readme: path19.join(pluginDir, "README.md")
+      pluginYaml: path20.join(pluginDir, "plugin.yaml"),
+      mcpJson: path20.join(pluginDir, ".mcp.json"),
+      serverPy: path20.join(pluginDir, "server.py"),
+      readme: path20.join(pluginDir, "README.md")
     },
     tools: input.tools.map((t) => t.name),
     message: `Scaffolded ${input.id}. Reload ainative to register.`
@@ -19501,13 +19529,13 @@ var init_codex_app_server_client = __esm({
           await syncPluginMcpToCodex2();
         } catch (err2) {
           try {
-            const fs23 = await import("fs");
-            const path24 = await import("path");
+            const fs24 = await import("fs");
+            const path25 = await import("path");
             const { getAinativeLogsDir: getAinativeLogsDir2 } = await Promise.resolve().then(() => (init_ainative_paths(), ainative_paths_exports));
             const dir = getAinativeLogsDir2();
-            fs23.mkdirSync(dir, { recursive: true });
-            fs23.appendFileSync(
-              path24.join(dir, "plugins.log"),
+            fs24.mkdirSync(dir, { recursive: true });
+            fs24.appendFileSync(
+              path25.join(dir, "plugins.log"),
               `${(/* @__PURE__ */ new Date()).toISOString()} codex-sync-failed: ${err2 instanceof Error ? err2.message : String(err2)}
 `
             );
@@ -23169,14 +23197,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, path24) => {
-    const value = readPath(row, path24);
+  return template.replace(pattern, (_match, path25) => {
+    const value = readPath(row, path25);
     if (value === void 0 || value === null) return "";
     return String(value);
   });
 }
-function readPath(obj, path24) {
-  const parts = path24.split(".");
+function readPath(obj, path25) {
+  const parts = path25.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -23363,14 +23391,14 @@ ${resolvedTemplate}`);
   return parts.join("");
 }
 function resolveRowTemplate(template, context) {
-  return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, path24) => {
-    const value = readContextPath(context, path24.trim());
+  return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, path25) => {
+    const value = readContextPath(context, path25.trim());
     if (value === void 0 || value === null) return "";
     return typeof value === "string" ? value : JSON.stringify(value);
   });
 }
-function readContextPath(value, path24) {
-  const parts = path24.split(".");
+function readContextPath(value, path25) {
+  const parts = path25.split(".");
   let current = value;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -25859,16 +25887,16 @@ __export(install_state_exports, {
   readInstallState: () => readInstallState,
   writeInstallState: () => writeInstallState
 });
-import fs19 from "fs";
-import path20 from "path";
+import fs20 from "fs";
+import path21 from "path";
 import { createHash as createHash5 } from "crypto";
 import { z as z30 } from "zod";
 function installStatePath(appsDir, appId) {
-  return path20.join(appsDir, appId, "install-state.json");
+  return path21.join(appsDir, appId, "install-state.json");
 }
 function readInstallState(appsDir, appId) {
   try {
-    const raw = fs19.readFileSync(installStatePath(appsDir, appId), "utf-8");
+    const raw = fs20.readFileSync(installStatePath(appsDir, appId), "utf-8");
     const parsed = InstallStateSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : null;
   } catch {
@@ -25876,14 +25904,14 @@ function readInstallState(appsDir, appId) {
   }
 }
 function writeInstallState(appsDir, appId, state) {
-  const dir = path20.join(appsDir, appId);
-  fs19.mkdirSync(dir, { recursive: true });
-  const tmp = path20.join(dir, `.install-state.${process.pid}.tmp`);
-  fs19.writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
-  fs19.renameSync(tmp, installStatePath(appsDir, appId));
+  const dir = path21.join(appsDir, appId);
+  fs20.mkdirSync(dir, { recursive: true });
+  const tmp = path21.join(dir, `.install-state.${process.pid}.tmp`);
+  fs20.writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
+  fs20.renameSync(tmp, installStatePath(appsDir, appId));
 }
 function hashFileSha256(absPath) {
-  return createHash5("sha256").update(fs19.readFileSync(absPath)).digest("hex");
+  return createHash5("sha256").update(fs20.readFileSync(absPath)).digest("hex");
 }
 var InstallStateSchema;
 var init_install_state = __esm({
@@ -25906,20 +25934,20 @@ __export(install_exports, {
   installPack: () => installPack,
   relayCoreVersion: () => relayCoreVersion
 });
-import fs20 from "fs";
-import path21 from "path";
+import fs21 from "fs";
+import path22 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.26.0")) {
-    return "0.26.0";
+  if (semver.valid("0.28.0")) {
+    return "0.28.0";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
     const pkg2 = JSON.parse(
-      fs20.readFileSync(path21.join(root, "package.json"), "utf-8")
+      fs21.readFileSync(path22.join(root, "package.json"), "utf-8")
     );
     if (pkg2.version && semver.valid(pkg2.version)) return pkg2.version;
   } catch {
@@ -26117,25 +26145,25 @@ function isGitUrl(source) {
 }
 function acquirePack(source) {
   if (!isGitUrl(source)) {
-    const resolved = path21.resolve(source);
-    if (!fs20.existsSync(resolved)) {
+    const resolved = path22.resolve(source);
+    if (!fs21.existsSync(resolved)) {
       throw new PackValidationError(`Pack path does not exist: ${resolved}`);
     }
     return { dir: resolved, cleanup: () => {
     } };
   }
-  const tmp = fs20.mkdtempSync(path21.join(os4.tmpdir(), "ainative-pack-clone-"));
+  const tmp = fs21.mkdtempSync(path22.join(os4.tmpdir(), "ainative-pack-clone-"));
   try {
     execFileSync3("git", ["clone", "--depth", "1", source, tmp], {
       stdio: "pipe"
     });
   } catch (err2) {
-    fs20.rmSync(tmp, { recursive: true, force: true });
+    fs21.rmSync(tmp, { recursive: true, force: true });
     throw new PackValidationError(`git clone failed for ${source}`, err2);
   }
   return {
     dir: tmp,
-    cleanup: () => fs20.rmSync(tmp, { recursive: true, force: true })
+    cleanup: () => fs21.rmSync(tmp, { recursive: true, force: true })
   };
 }
 function findResolved(files, relPath) {
@@ -26144,7 +26172,7 @@ function findResolved(files, relPath) {
 function readCustomerSeed(resolved) {
   const file = findResolved(resolved.files, "seed/customers.yaml");
   if (!file) return [];
-  const parsed = yaml12.load(fs20.readFileSync(file.absPath, "utf-8"));
+  const parsed = yaml12.load(fs21.readFileSync(file.absPath, "utf-8"));
   if (!Array.isArray(parsed)) {
     throw new PackValidationError(
       "seed/customers.yaml must be a YAML list of { slug, name, ... }"
@@ -26156,7 +26184,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 = fs20.readFileSync(file.absPath, "utf-8");
+    const text2 = fs21.readFileSync(file.absPath, "utf-8");
     const parsed = ext === "json" ? JSON.parse(text2) : yaml12.load(text2);
     if (!Array.isArray(parsed)) {
       throw new PackValidationError(
@@ -26214,15 +26242,15 @@ function rewriteViewRefs(view, maps) {
   return view;
 }
 function writeManifest(appsDir, appId, manifest) {
-  fs20.mkdirSync(path21.join(appsDir, appId), { recursive: true });
+  fs21.mkdirSync(path22.join(appsDir, appId), { recursive: true });
   writeAppManifest(appId, manifest, appsDir);
 }
 function artifactDestPath(relPath, profilesDir, blueprintsDir) {
   if (relPath.startsWith("profiles/")) {
-    return path21.join(profilesDir, relPath.slice("profiles/".length));
+    return path22.join(profilesDir, relPath.slice("profiles/".length));
   }
   if (relPath.startsWith("blueprints/") && relPath.endsWith(".yaml")) {
-    return path21.join(blueprintsDir, relPath.slice("blueprints/".length));
+    return path22.join(blueprintsDir, relPath.slice("blueprints/".length));
   }
   return null;
 }
@@ -26233,8 +26261,8 @@ function dropArtifacts(files, profilesDir, blueprintsDir) {
   for (const file of files) {
     const dest = artifactDestPath(file.relPath, profilesDir, blueprintsDir);
     if (!dest) continue;
-    fs20.mkdirSync(path21.dirname(dest), { recursive: true });
-    fs20.copyFileSync(file.absPath, dest);
+    fs21.mkdirSync(path22.dirname(dest), { recursive: true });
+    fs21.copyFileSync(file.absPath, dest);
     dropped.push({ relPath: file.relPath, destPath: dest });
     if (file.relPath.startsWith("profiles/")) {
       const top = file.relPath.split("/")[1];
@@ -26264,8 +26292,8 @@ __export(recap_exports, {
   changelogWindow: () => changelogWindow,
   entitledPackRecaps: () => entitledPackRecaps
 });
-import fs21 from "fs";
-import path22 from "path";
+import fs22 from "fs";
+import path23 from "path";
 import semver2 from "semver";
 function changelogWindow(changelog, fromExclusive, toInclusive) {
   if (!changelog || !toInclusive || !semver2.valid(toInclusive)) return [];
@@ -26282,7 +26310,7 @@ function entitledPackRecaps(entitlements, opts2 = {}) {
     for (const tpl of listPackTemplates({ templatesDir: opts2.templatesDir })) {
       if (tpl.error || !tpl.meta?.entitlement) continue;
       if (!covered.has(tpl.meta.entitlement)) continue;
-      if (!fs21.existsSync(path22.join(appsDir, tpl.id))) continue;
+      if (!fs22.existsSync(path23.join(appsDir, tpl.id))) continue;
       const avail = packUpdateAvailability(tpl.id, {
         appsDir,
         templatesDir: opts2.templatesDir
@@ -26327,8 +26355,8 @@ __export(update_exports, {
   packUpdateAvailability: () => packUpdateAvailability,
   updatePack: () => updatePack
 });
-import fs22 from "fs";
-import path23 from "path";
+import fs23 from "fs";
+import path24 from "path";
 import semver3 from "semver";
 function packUpdateAvailability(appId, opts2 = {}) {
   const appsDir = opts2.appsDir ?? getAinativeAppsDir();
@@ -26416,7 +26444,7 @@ async function updatePack(id, options = {}) {
       }
     }
     const resolved = resolvePackLayer(pack);
-    const backupRoot = path23.join(
+    const backupRoot = path24.join(
       appsDir,
       id,
       "backup",
@@ -26425,12 +26453,12 @@ async function updatePack(id, options = {}) {
     const backedUp = [];
     for (const file of resolved.files) {
       const dest = artifactDestPath(file.relPath, profilesDir, blueprintsDir);
-      if (!dest || !fs22.existsSync(dest)) continue;
+      if (!dest || !fs23.existsSync(dest)) continue;
       const recorded = state?.files[file.relPath];
       if (recorded !== void 0 && hashFileSha256(dest) === recorded) continue;
-      const backupPath = path23.join(backupRoot, file.relPath);
-      fs22.mkdirSync(path23.dirname(backupPath), { recursive: true });
-      fs22.copyFileSync(dest, backupPath);
+      const backupPath = path24.join(backupRoot, file.relPath);
+      fs23.mkdirSync(path24.dirname(backupPath), { recursive: true });
+      fs23.copyFileSync(dest, backupPath);
       backedUp.push(file.relPath);
     }
     const install = await installPack(packDir, {
@@ -27149,14 +27177,21 @@ init_ainative_paths();
 init_bootstrap();
 
 // src/lib/utils/migrate-to-ainative.ts
-import { existsSync as existsSync4, renameSync, cpSync, rmSync as rmSync2, readFileSync as readFileSync3 } from "fs";
+import {
+  existsSync as existsSync4,
+  renameSync,
+  cpSync,
+  rmSync as rmSync2,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2
+} from "fs";
 import { join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 import Database from "better-sqlite3";
-function hasSqliteHeader(path24) {
+function hasSqliteHeader(path25) {
   const SQLITE_MAGIC = "SQLite format 3\0";
   try {
-    const header = readFileSync3(path24, { encoding: null });
+    const header = readFileSync3(path25, { encoding: null });
     return header.length >= 16 && header.subarray(0, 16).toString("binary") === SQLITE_MAGIC;
   } catch {
     return false;
@@ -27166,6 +27201,33 @@ var MIGRATION_CHAIN = [
   { fromDir: ".stagent", toDir: ".ainative", fromDb: "stagent.db", toDb: "ainative.db" },
   { fromDir: ".ainative", toDir: ".relay", fromDb: "ainative.db", toDb: "relay.db" }
 ];
+function renameProfileFilesInRoot(root, log, errors) {
+  if (!existsSync4(root)) return 0;
+  let renamed = 0;
+  let entries;
+  try {
+    entries = readdirSync2(root, { withFileTypes: true });
+  } catch (err2) {
+    errors.push(`agent-file scan failed in ${root}: ${String(err2)}`);
+    return 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = join6(root, entry.name);
+    const legacy = join6(dir, "profile.yaml");
+    const next = join6(dir, "agent.yaml");
+    if (existsSync4(legacy) && !existsSync4(next)) {
+      try {
+        renameSync(legacy, next);
+        renamed++;
+      } catch (err2) {
+        errors.push(`agent-file rename failed in ${dir}: ${String(err2)}`);
+      }
+    }
+  }
+  if (renamed > 0) log(`renamed ${renamed} profile.yaml -> agent.yaml in ${root}`);
+  return renamed;
+}
 async function migrateLegacyData(options = {}) {
   const home = options.home ?? homedir2();
   const gitDir = options.gitDir ?? join6(process.cwd(), ".git");
@@ -27176,6 +27238,7 @@ async function migrateLegacyData(options = {}) {
     sqlRowsUpdated: 0,
     sentinelRenamed: false,
     keychainMigrated: false,
+    agentFilesRenamed: 0,
     errors: []
   };
   const finalDir = join6(home, MIGRATION_CHAIN[MIGRATION_CHAIN.length - 1].toDir);
@@ -27281,6 +27344,13 @@ async function migrateLegacyData(options = {}) {
       report.errors.push(`keychain migration failed: ${String(err2)}`);
     }
   }
+  const profileRoots = [
+    join6(finalDir, "profiles"),
+    join6(home, ".claude", "skills")
+  ];
+  for (const root of profileRoots) {
+    report.agentFilesRenamed += renameProfileFilesInRoot(root, log, report.errors);
+  }
   return report;
 }