@lumerahq/cli 0.28.0 → 0.30.0-dev.0

package/dist/{chunk-NIVQLH6V.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.31.0,<0.32.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;
@@ -50,14 +50,18 @@ ${pc.dim("Usage:")}
   lumera functions list
   lumera functions inspect <function-id>
   lumera functions invoke <function-id> --input <path|-> --local
+  lumera functions invoke <function-id> --input <path|-> --remote --project <project>
   lumera functions test [-- <pytest-options>]
 
 ${pc.dim("Description:")}
-  Discover, inspect, invoke, and test configured Functions in a fresh local
-  Python process. Phase 1 does not deploy or invoke Functions remotely.
+  Discover, inspect, invoke, and test configured Functions. Invocation can run
+  in a fresh local process or create a durable remote execution.
 
 ${pc.dim("Options:")}
-  --local                Required for invoke; remote invocation is unavailable
+  --local                Run from the local project source
+  --remote               Create a durable execution from the active release
+  --project <project>    Project ID or external ID for remote invocation
+  --idempotency-key <k>  Deduplicate matching remote invocation requests
   --input <path|->       Read a JSON object from a project file or stdin (-)
   --help, -h             Show this help
 
@@ -65,6 +69,7 @@ ${pc.dim("Examples:")}
   lumera functions list
   lumera functions inspect invoices:approve
   lumera functions invoke invoices:approve --input input.json --local
+  lumera functions invoke invoices:approve --input input.json --remote --project finance
   cat input.json | lumera functions invoke invoices:approve --input - --local
   lumera functions test
   lumera functions test -- -k approve
@@ -74,10 +79,17 @@ function buildFunctionRunnerArgs(subcommand, args, projectRoot) {
   if (!SUPPORTED_SUBCOMMANDS.has(subcommand)) {
     throw new Error(`Unknown functions subcommand: ${subcommand}`);
   }
-  if (subcommand === "invoke" && !args.includes("--local")) {
-    throw new Error(
-      "Function invocation is local-only in Phase 1; pass --local explicitly."
-    );
+  if (subcommand === "invoke") {
+    const local = args.includes("--local");
+    const remote = args.includes("--remote");
+    if (local === remote) {
+      throw new Error(
+        "Pass exactly one of --local or --remote for Function invocation."
+      );
+    }
+    if (remote && !args.includes("--project")) {
+      throw new Error("--project is required for remote Function invocation.");
+    }
   }
   const runnerPrefix = ["run"];
   if (existsSync(join(projectRoot, "uv.lock"))) {

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-JUOVWQQH.js → functions-55J6E2RF.js}

@@ -4,7 +4,7 @@ import {
   findFunctionsProjectRoot,
   functions,
   runFunctionRunner
-} from "./chunk-NIVQLH6V.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-R53XKJL2.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-R53XKJL2.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-R53XKJL2.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-R53XKJL2.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-R53XKJL2.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-R53XKJL2.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-YEOQ7YN6.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-R53XKJL2.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-YEOQ7YN6.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-JUOVWQQH.js").then(
+        await import("./functions-55J6E2RF.js").then(
           (m) => m.functions(subcommand, args.slice(2))
         );
         break;
       case "project":
-        await import("./project-2PYA24JV.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-2PYA24JV.js → project-6POVRBZL.js}

@@ -1,14 +1,21 @@
 import {
   findFunctionsProjectRoot
-} from "./chunk-NIVQLH6V.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.31.0,<0.32.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", "inspect", "contract-test", "deploy"]);
+var RELEASE_COMMANDS = /* @__PURE__ */ new Set([
+  "build",
+  "inspect",
+  "contract-test",
+  "deploy",
+  "stage",
+  "activate"
+]);
 function showHelp() {
   console.log(`
 ${pc.dim("Usage:")}
@@ -16,10 +23,13 @@ ${pc.dim("Usage:")}
   lumera project release inspect <archive> [--expected-digest <sha256>]
   lumera project release contract-test <archive> [--mode api|worker|all]
   lumera project release deploy <archive> --project <project-id>
+  lumera project release stage <release-id> --project <project-id> --expected-generation <n>
+  lumera project release activate <deployment-id> --project <project-id> --expected-generation <n>
 
 ${pc.dim("Description:")}
   Build, verify, and contract-test immutable Python 3.13/Linux/ARM64 project
-  releases, or upload a verified release as an inactive project resource.
+  releases, upload an inactive resource, stage a healthy runtime, and activate
+  it atomically with an expected generation.
 `);
 }
 function buildReleaseRunnerArgs(command, args, projectRoot) {

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-R53XKJL2.js → resources-YEOQ7YN6.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,
@@ -93,10 +93,132 @@ var automationConfigRule = {
   }
 };
 
-// src/lib/lint/rules/collection-schema.ts
+// src/lib/lint/rules/automation-main-guard.ts
+import { spawnSync } from "child_process";
+var PYTHON_AST_SCRIPT = String.raw`
+import ast
+import json
+import sys
+
+source = sys.stdin.read()
+try:
+    module = ast.parse(source)
+except SyntaxError:
+    print("null")
+    raise SystemExit(0)
+
+
+def is_name(node):
+    return isinstance(node, ast.Name) and node.id == "__name__"
+
+
+def is_main_string(node):
+    if isinstance(node, ast.Str):
+        return node.s == "__main__"
+    return isinstance(node, ast.Constant) and node.value == "__main__"
+
+
+def is_main_guard(node):
+    test = node.test
+    if not isinstance(test, ast.Compare):
+        return False
+    if len(test.ops) != 1 or not isinstance(test.ops[0], ast.Eq):
+        return False
+    if len(test.comparators) != 1:
+        return False
+    right = test.comparators[0]
+    return (is_name(test.left) and is_main_string(right)) or (
+        is_main_string(test.left) and is_name(right)
+    )
+
+
+for statement in module.body:
+    if not isinstance(statement, ast.If) or not is_main_guard(statement):
+        continue
+    get_segment = getattr(ast, "get_source_segment", None)
+    condition = get_segment(source, statement.test) if get_segment else None
+    if not condition:
+        condition = '__name__ == "__main__"'
+    snippet = "if " + " ".join(condition.split()) + ":"
+    print(json.dumps({"line": statement.lineno, "snippet": snippet}))
+    break
+else:
+    print("null")
+`;
+var cachedPython3;
+function findPython3() {
+  if (cachedPython3 !== void 0) return cachedPython3;
+  for (const executable of ["python3", "python"]) {
+    const probe = spawnSync(executable, ["-I", "-S", "--version"], {
+      encoding: "utf8",
+      timeout: 2e3,
+      windowsHide: true
+    });
+    const version = `${probe.stdout ?? ""}${probe.stderr ?? ""}`.trim();
+    if (probe.status === 0 && /^Python 3(?:\.|\s|$)/.test(version)) {
+      cachedPython3 = executable;
+      return executable;
+    }
+  }
+  cachedPython3 = null;
+  return null;
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function functionEntrypoint(config) {
+  if (!isRecord2(config) || !isRecord2(config.function)) {
+    return null;
+  }
+  const name = config.function.name;
+  return typeof name === "string" && name.trim() !== "" ? name.trim() : null;
+}
+function findTopLevelMainGuard(source) {
+  const python = findPython3();
+  if (python === null) return null;
+  const parsed = spawnSync(python, ["-I", "-S", "-c", PYTHON_AST_SCRIPT], {
+    input: source,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+    timeout: 5e3,
+    windowsHide: true
+  });
+  if (parsed.status !== 0) return null;
+  try {
+    const value = JSON.parse(parsed.stdout.trim());
+    if (!isRecord2(value) || typeof value.line !== "number" || typeof value.snippet !== "string") {
+      return null;
+    }
+    return { line: value.line, snippet: value.snippet };
+  } catch {
+    return null;
+  }
+}
+var automationMainGuardRule = {
+  id: "automation-main-guard",
+  description: "Warns when a function automation contains a top-level __main__ guard.",
+  appliesTo: ["automation"],
+  check(target) {
+    const entrypoint = functionEntrypoint(target.config);
+    if (entrypoint === null) return [];
+    const guard = findTopLevelMainGuard(target.source);
+    if (guard === null) return [];
+    const warning2 = {
+      ruleId: "automation-main-guard",
+      target,
+      severity: "warning",
+      line: guard.line,
+      snippet: guard.snippet,
+      message: `Function automations must not contain a top-level __main__ guard. Lumera invokes "${entrypoint}" automatically; remove the guard.`
+    };
+    return [warning2];
+  }
+};
+
+// src/lib/lint/rules/collection-schema.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function error(target, message, snippet) {
   return {
     ruleId: "collection-schema",
@@ -118,7 +240,7 @@ var collectionSchemaRule = {
       const message = err instanceof Error ? err.message : String(err);
       return [error(target, `Invalid JSON: ${message}`)];
     }
-    if (!isRecord2(parsed)) {
+    if (!isRecord3(parsed)) {
       return [error(target, "Collection file must contain a JSON object.")];
     }
     const issues = [];
@@ -131,7 +253,7 @@ var collectionSchemaRule = {
     const localFieldTypes = /* @__PURE__ */ new Map();
     if (Array.isArray(fields)) {
       for (const field of fields) {
-        if (isRecord2(field) && typeof field.name === "string") {
+        if (isRecord3(field) && typeof field.name === "string") {
           localFieldTypes.set(field.name, field.type);
         }
       }
@@ -155,7 +277,7 @@ var collectionSchemaRule = {
     } else {
       for (let i = 0; i < fields.length; i++) {
         const field = fields[i];
-        if (!isRecord2(field)) {
+        if (!isRecord3(field)) {
           issues.push(error(target, `Field at index ${i} must be an object.`));
           continue;
         }
@@ -176,7 +298,7 @@ var collectionSchemaRule = {
       } else {
         for (let i = 0; i < indexes.length; i++) {
           const index = indexes[i];
-          if (!isRecord2(index)) {
+          if (!isRecord3(index)) {
             const hint = typeof index === "string" ? ' Indexes are objects like { "fields": ["title"], "unique": true }, not CREATE INDEX SQL strings.' : "";
             issues.push(error(target, `Index at index ${i} must be an object.${hint}`));
             continue;
@@ -193,7 +315,7 @@ var collectionSchemaRule = {
       }
     }
     if (search !== void 0) {
-      if (!isRecord2(search)) {
+      if (!isRecord3(search)) {
         issues.push(error(target, 'Optional field "search" must be an object when present.'));
       } else {
         const unknownSearchKeys = Object.keys(search).filter((key) => key !== "fulltext" && key !== "semantic");
@@ -205,14 +327,14 @@ var collectionSchemaRule = {
         if (fulltext === void 0 && semantic === void 0) {
           issues.push(error(target, '"search" must include "fulltext" or "semantic".'));
         }
-        if (fulltext !== void 0 && !isRecord2(fulltext)) {
+        if (fulltext !== void 0 && !isRecord3(fulltext)) {
           issues.push(error(target, '"search.fulltext" must be an object when present.'));
-        } else if (isRecord2(fulltext)) {
+        } else if (isRecord3(fulltext)) {
           const allowed = /* @__PURE__ */ new Set(["fields", "language", "fuzzy_fields"]);
           for (const key of Object.keys(fulltext).filter((key2) => !allowed.has(key2))) {
             issues.push(error(target, `Unknown search.fulltext option "${key}".`));
           }
-          if (!isRecord2(fulltext.fields) || Object.keys(fulltext.fields).length === 0) {
+          if (!isRecord3(fulltext.fields) || Object.keys(fulltext.fields).length === 0) {
             issues.push(error(target, '"search.fulltext.fields" must be a non-empty field-to-weight object.'));
           } else {
             if (Object.keys(fulltext.fields).length > 8) {
@@ -244,9 +366,9 @@ var collectionSchemaRule = {
             }
           }
         }
-        if (semantic !== void 0 && !isRecord2(semantic)) {
+        if (semantic !== void 0 && !isRecord3(semantic)) {
           issues.push(error(target, '"search.semantic" must be an object when present.'));
-        } else if (isRecord2(semantic)) {
+        } else if (isRecord3(semantic)) {
           const allowed = /* @__PURE__ */ new Set(["fields", "model"]);
           for (const key of Object.keys(semantic).filter((key2) => !allowed.has(key2))) {
             issues.push(error(target, `Unknown search.semantic option "${key}".`));
@@ -653,7 +775,13 @@ var llmImportRule = {
 };
 
 // src/lib/lint/registry.ts
-var ALL_RULES = [automationConfigRule, collectionSchemaRule, hookVerifyRule, llmImportRule];
+var ALL_RULES = [
+  automationConfigRule,
+  automationMainGuardRule,
+  collectionSchemaRule,
+  hookVerifyRule,
+  llmImportRule
+];
 
 // src/lib/lint/format.ts
 import { relative } from "path";
@@ -1159,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
@@ -1187,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
@@ -1231,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
 
@@ -1258,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:")}
@@ -1284,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:")}
@@ -1308,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
 
@@ -1324,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);
@@ -2347,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, pendingLocalSkillSlugs = /* @__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 && pendingLocalSkillSlugs.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 [];
@@ -2417,44 +2795,38 @@ function loadLocalAgents(platformDir, filterName, appName) {
   }
   return agents;
 }
-async function planAgents(api, localAgents, projectId) {
+async function planAgents(api, localAgents, projectId, localSkillSlugs = /* @__PURE__ */ new Set(), appName) {
   const changes = [];
   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, localSkillSlugs);
+  } 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`));
+      } 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)) {
+      } else if (!refToId.has(ref) && !localSkillSlugs.has(ref)) {
         console.log(pc2.red(`    \u2717 Skill "${ref}" not found \u2014 apply will fail for this agent`));
       }
     }
@@ -2472,12 +2844,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 pendingLocalSkillSlugs = (agent.skills || []).filter((ref) => localSkillSlugs.has(ref) && !refToId.has(ref));
       const remoteSkillIds = [...remote.skill_ids || []].sort();
-      if (localSkillIds.join(",") !== remoteSkillIds.join(",")) {
+      if (localSkillIds.join(",") !== remoteSkillIds.join(",") || pendingLocalSkillSlugs.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 (pendingLocalSkillSlugs.length) parts.push(`+${pendingLocalSkillSlugs.join(", +")}`);
         if (removedSlugs.length) parts.push(`-${removedSlugs.join(", -")}`);
         diffs.push(`skills (${parts.join(", ")})`);
       }
@@ -2500,34 +2874,29 @@ 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, localSkillSlugs = /* @__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, localSkillSlugs);
+  } 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 notFoundForAgent = [];
     if (agent.skills) {
@@ -2535,6 +2904,8 @@ async function applyAgents(api, localAgents, projectId) {
         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 {
@@ -2542,8 +2913,11 @@ async function applyAgents(api, localAgents, projectId) {
         }
       }
     }
-    if (blockedForAgent.length > 0 || notFoundForAgent.length > 0) {
+    if (outsideProjectForAgent.length > 0 || blockedForAgent.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(", ")}`));
       }
@@ -2583,7 +2957,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);
@@ -2592,7 +2966,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.`));
@@ -2747,6 +3123,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();
@@ -2894,6 +3292,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;
@@ -2917,6 +3329,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");
@@ -2930,6 +3343,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);
@@ -3186,6 +3608,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();
@@ -3302,10 +3749,15 @@ async function plan(args) {
       allChanges.push(...changes);
     }
   }
+  const localSkills = !type || type === "skills" ? loadLocalSkills(platformDir, name || void 0) : [];
+  const localSkillSlugs = new Set(!type || type === "skills" || type === "agents" ? (localSkills.length > 0 || type !== "agents" ? localSkills : loadLocalSkills(platformDir)).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);
+      const changes = await planAgents(api, localAgents, projectId, localSkillSlugs, appName);
       allChanges.push(...changes);
     }
   }
@@ -3428,15 +3880,18 @@ async function apply(args) {
   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 localSkillSlugs = new Set(!type || type === "skills" || type === "agents" ? (localSkills.length > 0 || type !== "agents" ? localSkills : loadLocalSkills(platformDir)).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) allChanges.push(...await planAgents(api, localAgents, projectId, localSkillSlugs, appName));
   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`));
@@ -3523,9 +3978,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, localSkillSlugs, appName);
     console.log();
   }
   if (localMailboxes.length > 0) {
@@ -3578,10 +4038,25 @@ 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 changes = await planAgents(
+          api,
+          localAgents,
+          projectId,
+          new Set(loadLocalSkills(platformDir).map((skill) => skill.slug)),
+          appName
+        );
         for (const c of changes) {
           if (c.type === "update") conflicts.push(`agents/${c.name}`);
         }
@@ -3642,9 +4117,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") {
@@ -3796,6 +4276,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
 
@@ -3944,23 +4425,70 @@ 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,
   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.28.0",
+  "version": "0.30.0-dev.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.31.0,<0.32.0",
+    "lumera[functions]>=0.33.0,<0.34.0",
 ]
 
 [project.optional-dependencies]