@lumerahq/cli 0.29.1 → 0.30.0

package/dist/{chunk-QPVRRJFJ.js → chunk-FLFEF2BN.js}

@@ -4,7 +4,7 @@ import { existsSync } from "fs";
 import { join, resolve } from "path";
 import pc from "picocolors";
 var SUPPORTED_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "inspect", "invoke", "test"]);
-var FUNCTIONS_SDK_REQUIREMENT = "lumera[functions]>=0.32.0,<0.33.0";
+var FUNCTIONS_SDK_REQUIREMENT = "lumera[functions]>=0.33.0,<0.34.0";
 var FUNCTIONS_RUNNER_PROTOCOL_VERSION = 1;
 function errorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;

package/dist/{chunk-KC3VBP6R.js → chunk-LVIIWE44.js}

@@ -1,6 +1,6 @@
 import {
   userContextHeaders
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   fetchWithRetry
 } from "./chunk-FJFIWC7G.js";

package/dist/{chunk-FHHWIV4C.js → chunk-U3ZLIXGD.js}

@@ -299,6 +299,38 @@ var ApiClient = class {
       method: "DELETE"
     });
   }
+  // Project skills
+  async listAgentSkills(opts) {
+    const params = new URLSearchParams({ limit: "100" });
+    if (opts?.project_id) params.set("project_id", opts.project_id);
+    if (opts?.include_global) params.set("include_global", "true");
+    const all = [];
+    let offset = 0;
+    for (; ; ) {
+      params.set("offset", String(offset));
+      const result = await this.request(`/api/lm_agent_skills?${params}`);
+      const skills = result.skills || [];
+      all.push(...skills);
+      if (!result.has_more || skills.length === 0) break;
+      offset += skills.length;
+    }
+    return all;
+  }
+  async createAgentSkill(def) {
+    return this.request("/api/lm_agent_skills", {
+      method: "POST",
+      body: JSON.stringify(def)
+    });
+  }
+  async updateAgentSkill(id, def) {
+    return this.request(`/api/lm_agent_skills/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(def)
+    });
+  }
+  async deleteAgentSkill(id) {
+    await this.request(`/api/lm_agent_skills/${id}`, { method: "DELETE" });
+  }
   // Resolve a list of refs (slugs or IDs) to skill records. Chunks
   // requests so callers don't have to think about the server-side
   // per-request cap.

package/dist/{chunk-7ZTCXKII.js → chunk-YMWDIAUG.js}

@@ -4,7 +4,7 @@ import {
 import {
   createApiClient,
   isApiErrorStatus
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   findProjectRoot,
   getAppName

package/dist/{deps-IYUORT55.js → deps-NHVL4DMD.js}

@@ -1,9 +1,9 @@
 import {
   deps,
   syncDeps
-} from "./chunk-7ZTCXKII.js";
+} from "./chunk-YMWDIAUG.js";
 import "./chunk-2CR762KB.js";
-import "./chunk-FHHWIV4C.js";
+import "./chunk-U3ZLIXGD.js";
 import "./chunk-JLVVHTBY.js";
 import "./chunk-FJFIWC7G.js";
 import "./chunk-PNKVD2UK.js";

package/dist/{dev-OJEV76DA.js → dev-IWTA5G5M.js}

@@ -1,15 +1,15 @@
 import {
   dev
-} from "./chunk-KC3VBP6R.js";
+} from "./chunk-LVIIWE44.js";
 import {
   syncDeps
-} from "./chunk-7ZTCXKII.js";
+} from "./chunk-YMWDIAUG.js";
 import {
   loadEnv
 } from "./chunk-2CR762KB.js";
 import {
   createApiClient
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   findProjectRoot,
   getApiUrl,

package/dist/{functions-KP2NO4RC.js → functions-55J6E2RF.js}

@@ -4,7 +4,7 @@ import {
   findFunctionsProjectRoot,
   functions,
   runFunctionRunner
-} from "./chunk-QPVRRJFJ.js";
+} from "./chunk-FLFEF2BN.js";
 import "./chunk-PNKVD2UK.js";
 export {
   buildFunctionRunnerArgs,

package/dist/index.js

@@ -240,49 +240,49 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-P4VA2JPE.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-P4VA2JPE.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-P4VA2JPE.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-P4VA2JPE.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-P4VA2JPE.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-P4VA2JPE.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-P4VA2JPE.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-5YWEX6DG.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-OJEV76DA.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-IWTA5G5M.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
-        await import("./run-WHVUVIYB.js").then((m) => m.run(args.slice(1)));
+        await import("./run-SLLDX3RF.js").then((m) => m.run(args.slice(1)));
         break;
       case "functions":
-        await import("./functions-KP2NO4RC.js").then(
+        await import("./functions-55J6E2RF.js").then(
           (m) => m.functions(subcommand, args.slice(2))
         );
         break;
       case "project":
-        await import("./project-OPA5UUMQ.js").then(
+        await import("./project-6POVRBZL.js").then(
           (m) => m.project(subcommand, args.slice(2))
         );
         break;
       // Project
       case "init":
-        await import("./init-ZR2SLJ3K.js").then((m) => m.init(args.slice(1)));
+        await import("./init-I4FECTEL.js").then((m) => m.init(args.slice(1)));
         break;
       case "register":
-        await import("./register-HRLBT4FI.js").then((m) => m.register(args.slice(1)));
+        await import("./register-OBQZPOGC.js").then((m) => m.register(args.slice(1)));
         break;
       case "templates":
         await import("./templates-LNUOTNLN.js").then((m) => m.templates(subcommand, args.slice(2)));
@@ -299,7 +299,7 @@ async function main() {
         break;
       // Dependencies
       case "deps":
-        await import("./deps-IYUORT55.js").then((m) => m.deps(args.slice(1)));
+        await import("./deps-NHVL4DMD.js").then((m) => m.deps(args.slice(1)));
         break;
       // Feature flags (read the in-sandbox snapshot)
       case "flags":

package/dist/{init-ZR2SLJ3K.js → init-I4FECTEL.js}

@@ -12,7 +12,7 @@ import {
 import {
   createApiClient,
   validateProjectNameLength
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   getToken,
   init_auth,

package/dist/{project-OPA5UUMQ.js → project-6POVRBZL.js}

@@ -1,12 +1,12 @@
 import {
   findFunctionsProjectRoot
-} from "./chunk-QPVRRJFJ.js";
+} from "./chunk-FLFEF2BN.js";
 import "./chunk-PNKVD2UK.js";
 
 // src/commands/project.ts
 import { spawn } from "child_process";
 import pc from "picocolors";
-var RELEASE_SDK_REQUIREMENT = "lumera[release]>=0.32.0,<0.33.0";
+var RELEASE_SDK_REQUIREMENT = "lumera[release]>=0.33.0,<0.34.0";
 var RELEASE_PROTOCOL_VERSION = 1;
 var RELEASE_COMMANDS = /* @__PURE__ */ new Set([
   "build",

package/dist/{register-HRLBT4FI.js → register-OBQZPOGC.js}

@@ -7,7 +7,7 @@ import {
 import {
   createApiClient,
   validateProjectExternalId
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   findProjectRoot,
   getAppName,

package/dist/{resources-P4VA2JPE.js → resources-5YWEX6DG.js}

@@ -1,9 +1,9 @@
 import {
   deploy
-} from "./chunk-KC3VBP6R.js";
+} from "./chunk-LVIIWE44.js";
 import {
   syncDeps
-} from "./chunk-7ZTCXKII.js";
+} from "./chunk-YMWDIAUG.js";
 import {
   loadEnv
 } from "./chunk-2CR762KB.js";
@@ -12,7 +12,7 @@ import {
   createApiClient,
   isApiErrorStatus,
   validateCollectionNameLength
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   findProjectRoot,
   getApiUrl,
@@ -1287,6 +1287,8 @@ ${pc2.dim("Resources:")}
   hooks               Plan only hooks
   agents              Plan only agents
   agents/<name>       Plan single agent
+  skills              Plan only project skills
+  skills/<slug>       Plan single project skill
   mailboxes           Plan only mailboxes
   mailboxes/<slug>    Plan single mailbox
   app                 Plan app deployment
@@ -1315,6 +1317,8 @@ ${pc2.dim("Resources:")}
   hooks               Apply only hooks
   agents              Apply only agents
   agents/<name>       Apply single agent
+  skills              Apply only project skills
+  skills/<slug>       Apply single project skill
   mailboxes           Apply only mailboxes
   mailboxes/<slug>    Apply single mailbox
   app                 Deploy the frontend app
@@ -1359,6 +1363,8 @@ ${pc2.dim("Resources:")}
   hooks               Pull only hooks
   agents              Pull only agents
   agents/<name>       Pull single agent
+  skills              Pull only project skills
+  skills/<slug>       Pull single project skill
   mailboxes           Pull only mailboxes
   mailboxes/<slug>    Pull single mailbox
 
@@ -1386,6 +1392,8 @@ ${pc2.dim("Resources:")}
   hooks               Destroy only hooks
   agents              Destroy only agents
   agents/<name>       Destroy single agent
+  skills              Destroy only project skills
+  skills/<slug>       Destroy single project skill
   app                 Delete app registration
 
 ${pc2.dim("Options:")}
@@ -1412,6 +1420,7 @@ ${pc2.dim("Types:")}
   automations         List only automations
   hooks               List only hooks
   agents              List only agents
+  skills              List only project skills
   mailboxes           List only mailboxes
 
 ${pc2.dim("Options:")}
@@ -1436,6 +1445,7 @@ ${pc2.dim("Resources:")}
   automations/<name>  Show automation details
   hooks/<name>        Show hook details
   agents/<name>       Show agent details
+  skills/<slug>       Show project skill details
   mailboxes/<slug>    Show mailbox details
   app                 Show app details
 
@@ -1452,7 +1462,7 @@ function parseResource(resourcePath) {
   const parts = resourcePath.split("/");
   const type = parts[0];
   const name = parts.slice(1).join("/") || null;
-  const validTypes = ["collections", "automations", "hooks", "agents", "mailboxes", "app"];
+  const validTypes = ["collections", "automations", "hooks", "agents", "skills", "mailboxes", "app"];
   if (!validTypes.includes(type)) {
     console.log(pc2.red(`  Unknown resource type "${type}". Valid types: ${validTypes.join(", ")}`));
     process.exit(1);
@@ -2475,6 +2485,246 @@ ${hook.script.split("\n").map((line) => "  " + line).join("\n")}
     console.log(pc2.green("  \u2713"), `${hook.name} \u2192 hooks/${fileName}`);
   }
 }
+var SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 100;
+var SKILL_SLUG_MAX_LENGTH = 100;
+var SKILL_SUMMARY_MAX_LENGTH = 500;
+function loadLocalSkills(platformDir, filterName) {
+  const skillsDir = join2(platformDir, "skills");
+  if (!existsSync2(skillsDir)) return [];
+  const skills = [];
+  const errors = [];
+  for (const entry of readdirSync2(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    if (filterName && entry.name !== filterName) continue;
+    if (!SKILL_SLUG_RE.test(entry.name)) {
+      errors.push(`${entry.name}: directory name must be a lowercase slug`);
+      continue;
+    }
+    const path = join2(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync2(path)) {
+      errors.push(`${entry.name}: missing SKILL.md`);
+      continue;
+    }
+    const content = readFileSync2(path, "utf-8");
+    const separator = /\r?\n---\r?\n/.exec(content);
+    const parts = separator ? [content.slice(0, separator.index), content.slice(separator.index + separator[0].length)] : [content];
+    if (parts.length !== 2) {
+      errors.push(`${entry.name}: SKILL.md must separate the summary and instructions with ---`);
+      continue;
+    }
+    const headerLines = parts[0].trim().split(/\r?\n/);
+    const titleLine = headerLines[0]?.trim().startsWith("# ") ? headerLines[0] : "";
+    const name = titleLine.trim().slice(2).trim();
+    const summaryLines = [];
+    for (const line of headerLines.slice(1)) {
+      const trimmed = line.trim();
+      if (summaryLines.length === 0 && trimmed === "") continue;
+      if (summaryLines.length > 0 && trimmed === "") break;
+      summaryLines.push(trimmed);
+    }
+    const summary = summaryLines.join(" ");
+    const instructions = parts[1].trim();
+    if (!name) errors.push(`${entry.name}: SKILL.md must start with a # Title`);
+    if (name.length > SKILL_NAME_MAX_LENGTH) errors.push(`${entry.name}: title must be at most ${SKILL_NAME_MAX_LENGTH} characters`);
+    if (!summary) errors.push(`${entry.name}: SKILL.md must include a one-paragraph summary`);
+    if (summary.length > SKILL_SUMMARY_MAX_LENGTH) errors.push(`${entry.name}: summary must be at most ${SKILL_SUMMARY_MAX_LENGTH} characters`);
+    if (!instructions) errors.push(`${entry.name}: SKILL.md must include instructions after ---`);
+    if (name && name.length <= SKILL_NAME_MAX_LENGTH && summary && summary.length <= SKILL_SUMMARY_MAX_LENGTH && instructions) {
+      skills.push({ slug: entry.name, name, summary, instructions });
+    }
+  }
+  if (errors.length > 0) {
+    console.log(pc2.red("  Skill errors:"));
+    for (const error3 of errors) console.log(pc2.red(`    \u2717 ${error3}`));
+    throw new Error(`Found ${errors.length} skill error(s)`);
+  }
+  return skills;
+}
+function requireProjectSkillsProjectID(projectId) {
+  if (!projectId) {
+    throw new Error("Project skills require lumera.project_id in package.json. Register the project before applying skills.");
+  }
+  return projectId;
+}
+function skillMarkdown(skill) {
+  return `# ${skill.name}
+
+${skill.summary}
+
+---
+
+${skill.instructions}
+`;
+}
+function scopedProjectSkillSlug(appName, localSlug) {
+  return appName ? `${appName}:${localSlug}` : localSlug;
+}
+function localProjectSkillSlug(appName, storedSlug) {
+  const prefix = appName ? `${appName}:` : "";
+  return prefix && storedSlug.startsWith(prefix) ? storedSlug.slice(prefix.length) : storedSlug;
+}
+function remoteSkillsByLocalSlug(remoteSkills, appName) {
+  const byLocalSlug = /* @__PURE__ */ new Map();
+  for (const remote of remoteSkills) {
+    const localSlug = localProjectSkillSlug(appName, remote.slug);
+    const existing = byLocalSlug.get(localSlug);
+    if (!existing || remote.slug === scopedProjectSkillSlug(appName, localSlug)) {
+      byLocalSlug.set(localSlug, remote);
+    }
+  }
+  return byLocalSlug;
+}
+function projectSkillRefCandidates(refs, appName) {
+  return [...new Set(refs.flatMap((ref) => appName && SKILL_SLUG_RE.test(ref) ? [scopedProjectSkillSlug(appName, ref), ref] : [ref]))];
+}
+async function resolveAgentSkillRefs(api, refs, projectId, appName, localSourceSkillSlugs = /* @__PURE__ */ new Set()) {
+  const refToId = /* @__PURE__ */ new Map();
+  const skillIdToSlug = /* @__PURE__ */ new Map();
+  const blockedRefs = /* @__PURE__ */ new Set();
+  const outsideProjectRefs = /* @__PURE__ */ new Set();
+  if (refs.length === 0) return { refToId, skillIdToSlug, blockedRefs, outsideProjectRefs };
+  const skills = await api.lookupAgentSkills(projectSkillRefCandidates(refs, appName));
+  const byID = new Map(skills.map((skill) => [skill.id, skill]));
+  const bySlug = new Map(skills.map((skill) => [skill.slug, skill]));
+  const projectByLocalSlug = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const inRuntimeProject = !!projectId && skill.project_id === projectId;
+    const inScope = !skill.project_id || inRuntimeProject;
+    if (inScope && isAvailableToCustomAgents(skill)) {
+      skillIdToSlug.set(skill.id, inRuntimeProject ? localProjectSkillSlug(appName, skill.slug) : skill.slug);
+    }
+    if (!inRuntimeProject) continue;
+    const localSlug = localProjectSkillSlug(appName, skill.slug);
+    const existing = projectByLocalSlug.get(localSlug);
+    if (!existing || skill.slug === scopedProjectSkillSlug(appName, localSlug)) {
+      projectByLocalSlug.set(localSlug, skill);
+    }
+  }
+  for (const ref of refs) {
+    let selected = byID.get(ref);
+    if (!selected && SKILL_SLUG_RE.test(ref)) {
+      selected = projectByLocalSlug.get(ref);
+      if (!selected && localSourceSkillSlugs.has(ref)) {
+        continue;
+      }
+    }
+    selected ||= bySlug.get(ref);
+    if (!selected) continue;
+    if (selected.project_id && selected.project_id !== projectId) {
+      outsideProjectRefs.add(ref);
+      continue;
+    }
+    if (!isAvailableToCustomAgents(selected)) {
+      blockedRefs.add(ref);
+      continue;
+    }
+    refToId.set(ref, selected.id);
+  }
+  return { refToId, skillIdToSlug, blockedRefs, outsideProjectRefs };
+}
+function validateProjectSkillStorageSlugs(localSkills, appName) {
+  for (const skill of localSkills) {
+    const storedSlug = scopedProjectSkillSlug(appName, skill.slug);
+    if (storedSlug.length > SKILL_SLUG_MAX_LENGTH) {
+      throw new Error(`Project skill slug "${storedSlug}" must be at most ${SKILL_SLUG_MAX_LENGTH} characters including the project prefix`);
+    }
+  }
+}
+async function planSkills(api, localSkills, projectId, appName) {
+  if (localSkills.length === 0) return [];
+  validateProjectSkillStorageSlugs(localSkills, appName);
+  const scopedProjectID = requireProjectSkillsProjectID(projectId);
+  const remoteSkills = await api.listAgentSkills({ project_id: scopedProjectID });
+  const remoteBySlug = remoteSkillsByLocalSlug(remoteSkills, appName);
+  const changes = [];
+  for (const skill of localSkills) {
+    const remote = remoteBySlug.get(skill.slug);
+    if (!remote) {
+      changes.push({ type: "create", resource: "skill", id: skill.slug, name: skill.name });
+      continue;
+    }
+    const changed = [];
+    if (remote.name !== skill.name) changed.push("name");
+    if ((remote.summary || "").trim() !== skill.summary.trim()) changed.push("summary");
+    if ((remote.instructions || "").trim() !== skill.instructions.trim()) changed.push("instructions");
+    if (changed.length > 0) {
+      changes.push({
+        type: "update",
+        resource: "skill",
+        id: skill.slug,
+        name: skill.name,
+        details: `changed: ${changed.join(", ")}`,
+        textDiffs: changed.includes("instructions") || changed.includes("summary") ? [{ field: "SKILL.md", oldText: skillMarkdown({ slug: skill.slug, name: remote.name, summary: remote.summary || "", instructions: remote.instructions || "" }), newText: skillMarkdown(skill) }] : void 0
+      });
+    }
+  }
+  return changes;
+}
+async function applySkills(api, localSkills, projectId, appName) {
+  if (localSkills.length === 0) return 0;
+  validateProjectSkillStorageSlugs(localSkills, appName);
+  const scopedProjectID = requireProjectSkillsProjectID(projectId);
+  let errors = 0;
+  const remoteSkills = await api.listAgentSkills({ project_id: scopedProjectID });
+  const remoteBySlug = remoteSkillsByLocalSlug(remoteSkills, appName);
+  for (const skill of localSkills) {
+    const remote = remoteBySlug.get(skill.slug);
+    try {
+      if (remote) {
+        await api.updateAgentSkill(remote.id, {
+          name: skill.name,
+          summary: skill.summary,
+          instructions: skill.instructions
+        });
+        console.log(pc2.green("  \u2713"), `${skill.name} (updated)`);
+      } else {
+        await api.createAgentSkill({
+          ...skill,
+          slug: scopedProjectSkillSlug(appName, skill.slug),
+          project_id: scopedProjectID
+        });
+        console.log(pc2.green("  \u2713"), `${skill.name} (created)`);
+      }
+    } catch (error3) {
+      console.log(pc2.red("  \u2717"), `${skill.name}: ${error3}`);
+      errors++;
+    }
+  }
+  return errors;
+}
+async function pullSkills(api, platformDir, filterName, projectId, appName) {
+  if (!projectId) {
+    console.log(pc2.dim("  Skipped \u2014 project not registered (run `lumera register`)"));
+    return;
+  }
+  const scopedProjectID = requireProjectSkillsProjectID(projectId);
+  const skillsDir = join2(platformDir, "skills");
+  const remoteSkills = remoteSkillsByLocalSlug(
+    await api.listAgentSkills({ project_id: scopedProjectID }),
+    appName
+  );
+  for (const [localSlug, skill] of remoteSkills) {
+    if (!SKILL_SLUG_RE.test(localSlug)) {
+      console.log(pc2.yellow(`  \u26A0 Skipping ${skill.name}: skill slug ${skill.slug} cannot be represented in platform/skills`));
+      continue;
+    }
+    if (filterName && localSlug !== filterName && skill.slug !== filterName && skill.name !== filterName) continue;
+    if (!(skill.summary || "").trim() || !(skill.instructions || "").trim()) {
+      console.log(pc2.yellow(`  \u26A0 Skipping ${skill.name}: source-managed skills require both summary and instructions`));
+      continue;
+    }
+    const skillDir = join2(skillsDir, localSlug);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join2(skillDir, "SKILL.md"), skillMarkdown({
+      slug: localSlug,
+      name: skill.name,
+      summary: skill.summary || "",
+      instructions: skill.instructions || ""
+    }));
+    console.log(pc2.green("  \u2713"), `${skill.name} \u2192 skills/${localSlug}/`);
+  }
+}
 function loadLocalAgents(platformDir, filterName, appName) {
   const agentsDir = join2(platformDir, "agents");
   if (!existsSync2(agentsDir)) return [];
@@ -2545,45 +2795,47 @@ function loadLocalAgents(platformDir, filterName, appName) {
   }
   return agents;
 }
-async function planAgents(api, localAgents, projectId) {
+async function planAgents(api, localAgents, projectId, localSourceSkillSlugs = /* @__PURE__ */ new Set(), pendingLocalSkillSlugs = /* @__PURE__ */ new Set(), appName) {
   const changes = [];
+  let validationErrors = 0;
   const remoteAgents = await api.listAgents(projectId ? { project_id: projectId } : void 0);
   const remoteByExternalId = new Map(
     remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a])
   );
-  const refToId = /* @__PURE__ */ new Map();
-  const skillIdToSlug = /* @__PURE__ */ new Map();
-  const blockedRefs = /* @__PURE__ */ new Set();
   const planRefs = [
     .../* @__PURE__ */ new Set([
       ...localAgents.flatMap((a) => a.agent.skills ?? []),
       ...remoteAgents.flatMap((a) => a.skill_ids ?? [])
     ])
   ];
-  if (planRefs.length > 0) {
-    try {
-      const skills = await api.lookupAgentSkills(planRefs);
-      for (const s of skills) {
-        skillIdToSlug.set(s.id, s.slug);
-        if (isAvailableToCustomAgents(s)) {
-          refToId.set(s.slug, s.id);
-          refToId.set(s.id, s.id);
-        } else {
-          blockedRefs.add(s.slug);
-          blockedRefs.add(s.id);
-        }
-      }
-    } catch (e) {
-      console.log(pc2.yellow(`    \u26A0 Could not resolve skills for plan: ${e}`));
-    }
+  let resolution = {
+    refToId: /* @__PURE__ */ new Map(),
+    skillIdToSlug: /* @__PURE__ */ new Map(),
+    blockedRefs: /* @__PURE__ */ new Set(),
+    outsideProjectRefs: /* @__PURE__ */ new Set()
+  };
+  try {
+    resolution = await resolveAgentSkillRefs(api, planRefs, projectId, appName, localSourceSkillSlugs);
+  } catch (e) {
+    console.log(pc2.yellow(`    \u26A0 Could not resolve skills for plan: ${e}`));
   }
+  const { refToId, skillIdToSlug, blockedRefs, outsideProjectRefs } = resolution;
   for (const { agent, systemPrompt, policyScript } of localAgents) {
     const remote = remoteByExternalId.get(agent.external_id);
     for (const ref of agent.skills ?? []) {
-      if (blockedRefs.has(ref)) {
+      if (outsideProjectRefs.has(ref)) {
+        console.log(pc2.red(`    \u2717 Skill "${ref}" belongs to another project \u2014 apply will fail for this agent`));
+        validationErrors++;
+      } else if (blockedRefs.has(ref)) {
         console.log(pc2.red(`    \u2717 Skill "${ref}" is a Lumera platform skill, only available to Lumera-built agents \u2014 apply will fail for this agent`));
-      } else if (!refToId.has(ref)) {
-        console.log(pc2.red(`    \u2717 Skill "${ref}" not found \u2014 apply will fail for this agent`));
+        validationErrors++;
+      } else if (!refToId.has(ref) && !pendingLocalSkillSlugs.has(ref)) {
+        if (localSourceSkillSlugs.has(ref)) {
+          console.log(pc2.red(`    \u2717 Skill "${ref}" exists in project source but is not deployed \u2014 run 'lumera apply skills' first or use 'lumera apply'`));
+        } else {
+          console.log(pc2.red(`    \u2717 Skill "${ref}" not found \u2014 apply will fail for this agent`));
+        }
+        validationErrors++;
       }
     }
     if (!remote) {
@@ -2600,12 +2852,14 @@ async function planAgents(api, localAgents, projectId) {
       if ((remote.policy_enabled || false) !== (agent.policy_enabled || false)) diffs.push("policy_enabled");
       if ((remote.policy_description || "") !== (agent.policy_description || "")) diffs.push("policy_description");
       const localSkillIds = (agent.skills || []).map((s) => refToId.get(s)).filter((id) => !!id).sort();
+      const pendingSkillSlugs = (agent.skills || []).filter((ref) => pendingLocalSkillSlugs.has(ref) && !refToId.has(ref));
       const remoteSkillIds = [...remote.skill_ids || []].sort();
-      if (localSkillIds.join(",") !== remoteSkillIds.join(",")) {
+      if (localSkillIds.join(",") !== remoteSkillIds.join(",") || pendingSkillSlugs.length > 0) {
         const addedSlugs = localSkillIds.filter((id) => !remoteSkillIds.includes(id)).map((id) => skillIdToSlug.get(id) || id);
         const removedSlugs = remoteSkillIds.filter((id) => !localSkillIds.includes(id)).map((id) => skillIdToSlug.get(id) || id);
         const parts = [];
         if (addedSlugs.length) parts.push(`+${addedSlugs.join(", +")}`);
+        if (pendingSkillSlugs.length) parts.push(`+${pendingSkillSlugs.join(", +")}`);
         if (removedSlugs.length) parts.push(`-${removedSlugs.join(", -")}`);
         diffs.push(`skills (${parts.join(", ")})`);
       }
@@ -2621,64 +2875,71 @@ async function planAgents(api, localAgents, projectId) {
       }
     }
   }
-  return changes;
+  return { changes, validationErrors };
 }
 var TAG_AVAILABLE_TO_CUSTOM_AGENTS = "available_to_custom_agents";
 function isAvailableToCustomAgents(skill) {
   if (!skill.managed) return true;
   return (skill.tags ?? []).includes(TAG_AVAILABLE_TO_CUSTOM_AGENTS);
 }
-async function applyAgents(api, localAgents, projectId) {
+async function applyAgents(api, localAgents, projectId, localSourceSkillSlugs = /* @__PURE__ */ new Set(), appName) {
   let errors = 0;
   const remoteAgents = await api.listAgents(projectId ? { project_id: projectId } : void 0);
   const remoteByExternalId = new Map(
     remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a])
   );
-  const refToId = /* @__PURE__ */ new Map();
-  const blockedRefs = /* @__PURE__ */ new Set();
   const refs = [...new Set(localAgents.flatMap((a) => a.agent.skills ?? []))];
-  if (refs.length > 0) {
-    try {
-      const skills = await api.lookupAgentSkills(refs);
-      for (const s of skills) {
-        if (isAvailableToCustomAgents(s)) {
-          refToId.set(s.slug, s.id);
-          refToId.set(s.id, s.id);
-        } else {
-          blockedRefs.add(s.slug);
-          blockedRefs.add(s.id);
-        }
-      }
-    } catch (e) {
-      console.log(pc2.yellow(`    \u26A0 Could not resolve skills: ${e}`));
-    }
+  let resolution = {
+    refToId: /* @__PURE__ */ new Map(),
+    skillIdToSlug: /* @__PURE__ */ new Map(),
+    blockedRefs: /* @__PURE__ */ new Set(),
+    outsideProjectRefs: /* @__PURE__ */ new Set()
+  };
+  try {
+    resolution = await resolveAgentSkillRefs(api, refs, projectId, appName, localSourceSkillSlugs);
+  } catch (e) {
+    console.log(pc2.yellow(`    \u26A0 Could not resolve skills: ${e}`));
   }
+  const { refToId, blockedRefs, outsideProjectRefs } = resolution;
   for (const { agent, systemPrompt, policyScript } of localAgents) {
     const remote = remoteByExternalId.get(agent.external_id);
     const skillIds = [];
+    const outsideProjectForAgent = [];
     const blockedForAgent = [];
+    const undeployedLocalForAgent = [];
     const notFoundForAgent = [];
     if (agent.skills) {
       for (const ref of agent.skills) {
         const id = refToId.get(ref);
         if (id) {
           skillIds.push(id);
+        } else if (outsideProjectRefs.has(ref)) {
+          outsideProjectForAgent.push(ref);
         } else if (blockedRefs.has(ref)) {
           blockedForAgent.push(ref);
+        } else if (localSourceSkillSlugs.has(ref)) {
+          undeployedLocalForAgent.push(ref);
         } else {
           notFoundForAgent.push(ref);
         }
       }
     }
-    if (blockedForAgent.length > 0 || notFoundForAgent.length > 0) {
+    if (outsideProjectForAgent.length > 0 || blockedForAgent.length > 0 || undeployedLocalForAgent.length > 0 || notFoundForAgent.length > 0) {
       console.log(pc2.red("  \u2717"), `${agent.name}:`);
+      if (outsideProjectForAgent.length > 0) {
+        console.log(pc2.red(`      skills outside the agent project: ${outsideProjectForAgent.join(", ")}`));
+      }
       if (blockedForAgent.length > 0) {
         console.log(pc2.red(`      skills not available for custom agents: ${blockedForAgent.join(", ")}`));
       }
+      if (undeployedLocalForAgent.length > 0) {
+        console.log(pc2.red(`      locally authored skills not deployed: ${undeployedLocalForAgent.join(", ")}`));
+        console.log(pc2.dim(`      run 'lumera apply skills' first, or use 'lumera apply' to deploy skills and agents together`));
+      }
       if (notFoundForAgent.length > 0) {
         console.log(pc2.red(`      skills not found: ${notFoundForAgent.join(", ")}`));
+        console.log(pc2.dim(`      pick skills from GET /api/skills (tags includes "available_to_custom_agents")`));
       }
-      console.log(pc2.dim(`      pick skills from GET /api/skills (tags includes "available_to_custom_agents")`));
       errors++;
       continue;
     }
@@ -2711,7 +2972,7 @@ async function applyAgents(api, localAgents, projectId) {
   }
   return errors;
 }
-async function pullAgents(api, platformDir, filterName, projectId) {
+async function pullAgents(api, platformDir, filterName, projectId, appName) {
   const agentsDir = join2(platformDir, "agents");
   mkdirSync(agentsDir, { recursive: true });
   const agents = await api.listAgents(projectId ? { project_id: projectId } : void 0);
@@ -2720,7 +2981,9 @@ async function pullAgents(api, platformDir, filterName, projectId) {
   if (pullRefs.length > 0) {
     try {
       const skills = await api.lookupAgentSkills(pullRefs);
-      for (const s of skills) skillIdToSlug.set(s.id, s.slug);
+      for (const s of skills) {
+        skillIdToSlug.set(s.id, s.project_id === projectId ? localProjectSkillSlug(appName, s.slug) : s.slug);
+      }
     } catch (e) {
       console.log(pc2.yellow(`    \u26A0 Could not resolve skills for pull: ${e}`));
       console.log(pc2.yellow(`      Pulled configs may omit skills \u2014 review before re-applying.`));
@@ -2875,6 +3138,28 @@ async function listResources(api, platformDir, filterType, appName, projectId) {
       }
     }
   }
+  if (!filterType || filterType === "skills") {
+    const localSkills = loadLocalSkills(platformDir);
+    if (localSkills.length > 0) requireProjectSkillsProjectID(projectId);
+    const remoteSkills = projectId ? await api.listAgentSkills({ project_id: projectId }) : [];
+    const remoteBySlug = remoteSkillsByLocalSlug(remoteSkills, appName);
+    const localSlugs = new Set(localSkills.map((skill) => skill.slug));
+    for (const skill of localSkills) {
+      const remote = remoteBySlug.get(skill.slug);
+      if (!remote) {
+        results.push({ name: skill.name, type: "skills", status: "local-only" });
+      } else if (remote.name !== skill.name || (remote.summary || "").trim() !== skill.summary.trim() || (remote.instructions || "").trim() !== skill.instructions.trim()) {
+        results.push({ name: skill.name, type: "skills", status: "changed", details: "SKILL.md" });
+      } else {
+        results.push({ name: skill.name, type: "skills", status: "synced" });
+      }
+    }
+    for (const remote of remoteSkills) {
+      if (!localSlugs.has(localProjectSkillSlug(appName, remote.slug))) {
+        results.push({ name: remote.name, type: "skills", status: "remote-only" });
+      }
+    }
+  }
   if (!filterType || filterType === "mailboxes") {
     const localMailboxes = loadLocalMailboxes(platformDir);
     const remoteMailboxes = await api.listMailboxes();
@@ -3022,6 +3307,20 @@ async function destroyResources(api, platformDir, resourceType, resourceName, sk
     } catch {
     }
   }
+  if (!resourceType || resourceType === "skills") {
+    const localSkills = loadLocalSkills(platformDir, resourceName || void 0);
+    if (localSkills.length > 0) {
+      const scopedProjectID = requireProjectSkillsProjectID(projectId);
+      const remoteSkills = await api.listAgentSkills({ project_id: scopedProjectID });
+      const remoteBySlug = remoteSkillsByLocalSlug(remoteSkills, appName);
+      for (const skill of localSkills) {
+        const remote = remoteBySlug.get(skill.slug);
+        if (remote) {
+          toDelete.push({ type: "skill", id: skill.slug, name: skill.name, remoteId: remote.id });
+        }
+      }
+    }
+  }
   if (toDelete.length === 0) {
     console.log(pc2.green("  \u2713 No resources found to delete"));
     return;
@@ -3045,6 +3344,7 @@ async function destroyResources(api, platformDir, resourceType, resourceName, sk
     }
   }
   const agents = toDelete.filter((r) => r.type === "agent");
+  const skills = toDelete.filter((r) => r.type === "skill");
   const hooks = toDelete.filter((r) => r.type === "hook");
   const automations = toDelete.filter((r) => r.type === "automation");
   const collections = toDelete.filter((r) => r.type === "collection");
@@ -3058,6 +3358,15 @@ async function destroyResources(api, platformDir, resourceType, resourceName, sk
       errors++;
     }
   }
+  for (const resource of skills) {
+    try {
+      await api.deleteAgentSkill(resource.remoteId);
+      console.log(pc2.green("  \u2713"), `Deleted skill: ${resource.name}`);
+    } catch (e) {
+      console.log(pc2.red("  \u2717"), `Failed to delete skill ${resource.name}: ${e}`);
+      errors++;
+    }
+  }
   for (const resource of hooks) {
     try {
       await api.deleteHook(resource.remoteId);
@@ -3314,6 +3623,31 @@ async function showResource(api, platformDir, resourceType, resourceName, appNam
       console.log(`  Skills: ${skills.join(", ")}`);
     }
     console.log();
+  } else if (resourceType === "skills") {
+    const localSkills = loadLocalSkills(platformDir, resourceName);
+    if (localSkills.length > 0) requireProjectSkillsProjectID(projectId);
+    const remoteSkills = projectId ? await api.listAgentSkills({ project_id: projectId }) : [];
+    const local = localSkills[0];
+    const remote = remoteSkillsByLocalSlug(remoteSkills, appName).get(resourceName) || remoteSkills.find((skill) => skill.name === resourceName);
+    if (!local && !remote) {
+      console.log(pc2.red(`  Skill "${resourceName}" not found`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc2.bold(`  Skill: ${local?.name || remote?.name}`));
+    console.log();
+    if (local && remote) {
+      const changed = local.name !== remote.name || local.summary.trim() !== (remote.summary || "").trim() || local.instructions.trim() !== (remote.instructions || "").trim();
+      console.log(`  Status: ${changed ? pc2.yellow("changed") : pc2.green("synced")}`);
+    } else if (local) {
+      console.log(`  Status: ${pc2.yellow("local only")}`);
+    } else {
+      console.log(`  Status: ${pc2.cyan("remote only")}`);
+    }
+    console.log(`  Slug: ${local?.slug || (remote ? localProjectSkillSlug(appName, remote.slug) : "")}`);
+    const summary = local?.summary || remote?.summary;
+    if (summary) console.log(`  Summary: ${summary}`);
+    console.log();
   } else if (resourceType === "mailboxes") {
     const localMailboxes = loadLocalMailboxes(platformDir, resourceName);
     const remoteMailboxes = await api.listMailboxes();
@@ -3401,6 +3735,7 @@ async function plan(args) {
   }
   await syncDeps(projectRoot, { ignorePermissionDenied: true });
   const allChanges = [];
+  let planValidationErrors = 0;
   let collections;
   try {
     const remoteCollections = await api.listCollections();
@@ -3430,11 +3765,19 @@ async function plan(args) {
       allChanges.push(...changes);
     }
   }
+  const localSkills = !type || type === "skills" ? loadLocalSkills(platformDir, name || void 0) : [];
+  const sourceSkillsForAgentResolution = type === "agents" ? loadLocalSkills(platformDir) : localSkills;
+  const localSourceSkillSlugs = new Set(sourceSkillsForAgentResolution.map((skill) => skill.slug));
+  const pendingLocalSkillSlugs = new Set(localSkills.map((skill) => skill.slug));
+  if (localSkills.length > 0) {
+    allChanges.push(...await planSkills(api, localSkills, projectId, appName));
+  }
   if (!type || type === "agents") {
     const localAgents = loadLocalAgents(platformDir, name || void 0, appName);
     if (localAgents.length > 0) {
-      const changes = await planAgents(api, localAgents, projectId);
-      allChanges.push(...changes);
+      const result = await planAgents(api, localAgents, projectId, localSourceSkillSlugs, pendingLocalSkillSlugs, appName);
+      allChanges.push(...result.changes);
+      planValidationErrors += result.validationErrors;
     }
   }
   if (!type || type === "mailboxes") {
@@ -3447,7 +3790,14 @@ async function plan(args) {
   const lintWarnings = await safeLint(projectRoot, localAutomations);
   if (allChanges.length === 0) {
     if (jsonOutput) {
-      console.log(JSON.stringify({ changes: [], warnings: [], lintWarnings: serializeLintWarnings(lintWarnings, projectRoot) }));
+      console.log(JSON.stringify({ changes: [], warnings: [], validationErrors: planValidationErrors, lintWarnings: serializeLintWarnings(lintWarnings, projectRoot) }));
+      if (planValidationErrors > 0) process.exitCode = 1;
+      return;
+    }
+    if (planValidationErrors > 0) {
+      console.log(pc2.red(`  \u2717 Plan has ${planValidationErrors} agent skill validation error${planValidationErrors === 1 ? "" : "s"}.`));
+      console.log();
+      process.exitCode = 1;
       return;
     }
     console.log(pc2.green("  \u2713 No changes detected"));
@@ -3465,7 +3815,8 @@ async function plan(args) {
         }
       }
     }
-    console.log(JSON.stringify({ changes: allChanges, warnings, lintWarnings: serializeLintWarnings(lintWarnings, projectRoot) }));
+    console.log(JSON.stringify({ changes: allChanges, warnings, validationErrors: planValidationErrors, lintWarnings: serializeLintWarnings(lintWarnings, projectRoot) }));
+    if (planValidationErrors > 0) process.exitCode = 1;
     return;
   }
   console.log(pc2.bold("  Changes:"));
@@ -3506,7 +3857,12 @@ async function plan(args) {
   }
   console.log();
   safePrintLint(lintWarnings, projectRoot);
-  console.log(pc2.dim(`  Run 'lumera apply' to apply these changes.`));
+  if (planValidationErrors > 0) {
+    console.log(pc2.red(`  \u2717 Fix ${planValidationErrors} agent skill validation error${planValidationErrors === 1 ? "" : "s"} before applying.`));
+    process.exitCode = 1;
+  } else {
+    console.log(pc2.dim(`  Run 'lumera apply' to apply these changes.`));
+  }
   console.log();
 }
 async function apply(args) {
@@ -3553,24 +3909,40 @@ async function apply(args) {
     collections = /* @__PURE__ */ new Map();
   }
   const allChanges = [];
+  let planValidationErrors = 0;
   const localCollections = !type || type === "collections" ? loadLocalCollections(platformDir, name || void 0) : [];
   const localAutomations = !type || type === "automations" ? loadLocalAutomations(platformDir, name || void 0, appName) : [];
   const localHooks = !type || type === "hooks" ? loadLocalHooks(platformDir, name || void 0, appName) : [];
+  const localSkills = !type || type === "skills" ? loadLocalSkills(platformDir, name || void 0) : [];
+  const sourceSkillsForAgentResolution = type === "agents" ? loadLocalSkills(platformDir) : localSkills;
+  const localSourceSkillSlugs = new Set(sourceSkillsForAgentResolution.map((skill) => skill.slug));
+  const pendingLocalSkillSlugs = new Set(localSkills.map((skill) => skill.slug));
   const localAgents = !type || type === "agents" ? loadLocalAgents(platformDir, name || void 0, appName) : [];
   const localMailboxes = !type || type === "mailboxes" ? loadLocalMailboxes(platformDir, name || void 0) : [];
   if (localCollections.length > 0) allChanges.push(...await planCollections(api, localCollections, appName, projectId));
   if (localAutomations.length > 0) allChanges.push(...await planAutomations(api, localAutomations, projectId));
   if (localHooks.length > 0) allChanges.push(...await planHooks(api, localHooks, collections, projectId));
-  if (localAgents.length > 0) allChanges.push(...await planAgents(api, localAgents, projectId));
+  if (localSkills.length > 0) allChanges.push(...await planSkills(api, localSkills, projectId, appName));
+  if (localAgents.length > 0) {
+    const result = await planAgents(api, localAgents, projectId, localSourceSkillSlugs, pendingLocalSkillSlugs, appName);
+    allChanges.push(...result.changes);
+    planValidationErrors += result.validationErrors;
+  }
   if (localMailboxes.length > 0) allChanges.push(...await planMailboxes(api, localMailboxes));
   if (name) {
-    const hasLocal = localCollections.length > 0 || localAutomations.length > 0 || localHooks.length > 0 || localAgents.length > 0 || localMailboxes.length > 0;
+    const hasLocal = localCollections.length > 0 || localAutomations.length > 0 || localHooks.length > 0 || localSkills.length > 0 || localAgents.length > 0 || localMailboxes.length > 0;
     if (!hasLocal) {
       console.log();
       console.log(pc2.red(`  Resource "${name}" not found locally`));
       process.exit(1);
     }
   }
+  if (planValidationErrors > 0) {
+    console.log();
+    console.log(pc2.red(`  \u2717 Apply aborted: fix ${planValidationErrors} agent skill validation error${planValidationErrors === 1 ? "" : "s"} first.`));
+    console.log();
+    process.exit(1);
+  }
   let willDeployApp = false;
   if (!type && !skipApp) {
     try {
@@ -3651,9 +4023,14 @@ async function apply(args) {
     totalErrors += await applyHooks(api, localHooks, collections, projectId);
     console.log();
   }
+  if (localSkills.length > 0) {
+    console.log(pc2.bold("  Skills:"));
+    totalErrors += await applySkills(api, localSkills, projectId, appName);
+    console.log();
+  }
   if (localAgents.length > 0) {
     console.log(pc2.bold("  Agents:"));
-    totalErrors += await applyAgents(api, localAgents, projectId);
+    totalErrors += await applyAgents(api, localAgents, projectId, localSourceSkillSlugs, appName);
     console.log();
   }
   if (localMailboxes.length > 0) {
@@ -3706,10 +4083,27 @@ async function pull(args) {
     } catch {
       collections = /* @__PURE__ */ new Map();
     }
+    if (projectId && (!type || type === "skills")) {
+      const localSkills = loadLocalSkills(platformDir, name || void 0);
+      if (localSkills.length > 0) {
+        const changes = await planSkills(api, localSkills, projectId, appName);
+        for (const change of changes) {
+          if (change.type === "update") conflicts.push(`skills/${change.id}`);
+        }
+      }
+    }
     if (!type || type === "agents") {
       const localAgents = loadLocalAgents(platformDir, name || void 0, appName);
       if (localAgents.length > 0) {
-        const changes = await planAgents(api, localAgents, projectId);
+        const localSkillSlugs = new Set(loadLocalSkills(platformDir).map((skill) => skill.slug));
+        const { changes } = await planAgents(
+          api,
+          localAgents,
+          projectId,
+          localSkillSlugs,
+          localSkillSlugs,
+          appName
+        );
         for (const c of changes) {
           if (c.type === "update") conflicts.push(`agents/${c.name}`);
         }
@@ -3770,9 +4164,14 @@ async function pull(args) {
     await pullHooks(api, platformDir, name || void 0, appName, projectId);
     console.log();
   }
+  if (!type || type === "skills") {
+    console.log(pc2.bold("  Skills:"));
+    await pullSkills(api, platformDir, name || void 0, projectId, appName);
+    console.log();
+  }
   if (!type || type === "agents") {
     console.log(pc2.bold("  Agents:"));
-    await pullAgents(api, platformDir, name || void 0, projectId);
+    await pullAgents(api, platformDir, name || void 0, projectId, appName);
     console.log();
   }
   if (!type || type === "mailboxes") {
@@ -3924,6 +4323,7 @@ ${pc2.dim("Usage:")}
 
 ${pc2.dim("Resources:")}
   agents/<name>       Diff agent (system_prompt, policy_script)
+  skills/<slug>       Diff project skill instructions
   automations/<name>  Diff automation code
   hooks/<name>        Diff hook script
 
@@ -4072,23 +4472,71 @@ async function diff(args) {
     } else if (scriptChanged) {
       renderFullDiff(local.fileName, remote.script || "", local.script);
     }
+  } else if (type === "skills") {
+    const localSkills = loadLocalSkills(platformDir, name);
+    if (localSkills.length > 0) requireProjectSkillsProjectID(projectId);
+    const remoteSkills = projectId ? await api.listAgentSkills({ project_id: projectId }) : [];
+    const local = localSkills[0];
+    const remote = remoteSkillsByLocalSlug(remoteSkills, appName).get(name) || remoteSkills.find((skill) => skill.name === name);
+    if (!local && !remote) {
+      console.log(pc2.red(`  Skill "${name}" not found locally or remotely`));
+      process.exit(1);
+    }
+    if (!local) {
+      console.log(pc2.cyan(`  Skill "${name}" exists only remotely`));
+      process.exit(0);
+    }
+    if (!remote) {
+      console.log(pc2.yellow(`  Skill "${name}" exists only locally (not yet deployed)`));
+      process.exit(0);
+    }
+    console.log(pc2.bold(`  Skill: ${local.name}`));
+    console.log();
+    if (remote.name !== local.name) {
+      console.log(`  name: ${pc2.red(remote.name)} \u2192 ${pc2.green(local.name)}`);
+    }
+    if ((remote.summary || "").trim() !== local.summary.trim()) {
+      console.log(`  summary: ${pc2.red(remote.summary || "(empty)")} \u2192 ${pc2.green(local.summary)}`);
+    }
+    const remoteMarkdown = skillMarkdown({
+      slug: localProjectSkillSlug(appName, remote.slug),
+      name: remote.name,
+      summary: remote.summary || "",
+      instructions: remote.instructions || ""
+    });
+    const localMarkdown = skillMarkdown(local);
+    if (remoteMarkdown === localMarkdown) {
+      console.log(pc2.green("  \u2713 No changes"));
+    } else {
+      renderFullDiff("SKILL.md", remoteMarkdown, localMarkdown);
+    }
   } else {
-    console.log(pc2.red(`  Diff not supported for "${type}" \u2014 use agents, automations, or hooks`));
+    console.log(pc2.red(`  Diff not supported for "${type}" \u2014 use agents, skills, automations, or hooks`));
     process.exit(1);
   }
   console.log();
 }
 export {
   apply,
+  applyAgents,
   applyCollections,
+  applySkills,
   convertCollectionToApiFormat,
   destroy,
   diff,
   list,
   loadLocalCollections,
+  loadLocalSkills,
+  localProjectSkillSlug,
   plan,
+  planAgents,
   planCollections,
+  planSkills,
+  projectSkillRefCandidates,
   pull,
   pullCollections,
+  pullSkills,
+  resolveAgentSkillRefs,
+  scopedProjectSkillSlug,
   show
 };

package/dist/{run-WHVUVIYB.js → run-SLLDX3RF.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2CR762KB.js";
 import {
   createApiClient
-} from "./chunk-FHHWIV4C.js";
+} from "./chunk-U3ZLIXGD.js";
 import {
   findProjectRoot,
   getApiUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {

package/templates/default/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "{{projectTitle}} - Lumera custom app"
 requires-python = ">=3.11"
 dependencies = [
-    "lumera[functions]>=0.32.0,<0.33.0",
+    "lumera[functions]>=0.33.0,<0.34.0",
 ]
 
 [project.optional-dependencies]