lua-cli 3.20.0 → 3.21.0

package/dist/index.js

@@ -8,8 +8,13 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -1449,7 +1454,8 @@ Feel free to add, remove, or rename sections. Your persona can be a single parag
       "mcp",
       "rag",
       "device",
-      "device-trigger"
+      "device-trigger",
+      "model-resolver"
     ];
     VoiceNameSchema = z.string().regex(/^[a-zA-Z0-9_-]+$/, "Voice name must contain only alphanumeric characters, underscores, or hyphens").min(1).max(64);
     PluginProviderSchema = z.enum([
@@ -21021,6 +21027,106 @@ function runBundleInContext(context, source, options) {
 }
 __name(runBundleInContext, "runBundleInContext");
 __name4(runBundleInContext, "runBundleInContext");
+var USER_CODE_ERROR_CODE = "USER_CODE_ERROR";
+var PLATFORM_VM_ERROR_CODE = "PLATFORM_VM_ERROR";
+var UserCodeError = class extends Error {
+  static {
+    __name(this, "UserCodeError");
+  }
+  static {
+    __name4(this, "UserCodeError");
+  }
+  code = USER_CODE_ERROR_CODE;
+  source;
+  constructor(source, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), {
+      cause
+    });
+    this.name = "UserCodeError";
+    this.source = source;
+    if (cause instanceof Error && cause.stack) {
+      this.stack = cause.stack;
+    }
+  }
+};
+function isUserCodeError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.code === USER_CODE_ERROR_CODE;
+}
+__name(isUserCodeError, "isUserCodeError");
+__name4(isUserCodeError, "isUserCodeError");
+function isPlatformVmError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.code === PLATFORM_VM_ERROR_CODE;
+}
+__name(isPlatformVmError, "isPlatformVmError");
+__name4(isPlatformVmError, "isPlatformVmError");
+var DEFAULT_MAX_CAUSE_DEPTH = 10;
+function findUserCodeErrorInCauseChain(value, maxDepth = DEFAULT_MAX_CAUSE_DEPTH) {
+  let current = value;
+  for (let depth = 0; depth < maxDepth; depth++) {
+    if (isUserCodeError(current)) return current;
+    if (!current || typeof current !== "object") return null;
+    const next = current.cause;
+    if (next === current || next === value) return null;
+    current = next;
+  }
+  return null;
+}
+__name(findUserCodeErrorInCauseChain, "findUserCodeErrorInCauseChain");
+__name4(findUserCodeErrorInCauseChain, "findUserCodeErrorInCauseChain");
+var MissingPrimitiveCodeError = class extends Error {
+  static {
+    __name(this, "MissingPrimitiveCodeError");
+  }
+  static {
+    __name4(this, "MissingPrimitiveCodeError");
+  }
+  code = PLATFORM_VM_ERROR_CODE;
+  source;
+  // The message reaches the customer's vmExecutionLogs dashboard (via Mastra's
+  // re-wrap → LuaMastraLogger.logToMongo), so it must be customer-safe: no
+  // internal ticket refs, no jargon, and it must NOT imply the customer's code
+  // is at fault (it isn't — the artifact exists; delivery failed). Internal
+  // triage keys off the error NAME + PLATFORM_VM_ERROR code + ERROR level, not
+  // this prose.
+  constructor(source) {
+    super(`This ${source}'s code could not be loaded due to a temporary platform issue and was not executed. Please try again shortly.`);
+    this.name = "MissingPrimitiveCodeError";
+    this.source = source;
+  }
+};
+function assertPrimitiveCodePresent(code, source) {
+  if (typeof code !== "string" || code.length === 0) {
+    throw new MissingPrimitiveCodeError(source);
+  }
+}
+__name(assertPrimitiveCodePresent, "assertPrimitiveCodePresent");
+__name4(assertPrimitiveCodePresent, "assertPrimitiveCodePresent");
+async function withUserCodeBoundary(source, fn) {
+  try {
+    return await fn();
+  } catch (cause) {
+    if (isUserCodeError(cause)) throw cause;
+    if (isPlatformVmError(cause)) throw cause;
+    throw new UserCodeError(source, cause);
+  }
+}
+__name(withUserCodeBoundary, "withUserCodeBoundary");
+__name4(withUserCodeBoundary, "withUserCodeBoundary");
+function logUserCodeOrError(logger, message, error, context = {}) {
+  if (isUserCodeError(error)) {
+    logger.warn(`${message} (user code)`, {
+      ...context,
+      source: error.source,
+      error: error.message
+    });
+  } else {
+    logger.error(message, error, context);
+  }
+}
+__name(logUserCodeOrError, "logUserCodeOrError");
+__name4(logUserCodeOrError, "logUserCodeOrError");
 
 // src/utils/env-loader.utils.ts
 import path15 from "path";
@@ -22142,66 +22248,89 @@ var ALIAS_MAP = {
       del: "delete"
     })
   },
-  "marketplace.role": {
+  "marketplace.noun": {
     canonical: [
-      "create",
-      "install"
+      "skill",
+      "template"
     ],
     aliases: lowerKeys({
-      creator: "create",
-      new: "create",
-      publish: "create",
-      installer: "install",
-      consumer: "install",
-      use: "install"
+      skills: "skill",
+      templates: "template",
+      "agent-template": "template",
+      "agent-templates": "template"
     })
   },
-  "marketplace.action.create": {
+  // Flat skill-marketplace action namespace. `list`/`publish`/`edit`/`unlist`/
+  // `unpublish`/`mine` are the old creator actions; `search`/`view`/`install`/
+  // `update`/`uninstall`/`installed` are the old installer actions.
+  "marketplace.skill.action": {
     canonical: [
       "list",
       "publish",
-      "update",
+      "edit",
       "unlist",
       "unpublish",
-      "view"
+      "mine",
+      "search",
+      "view",
+      "install",
+      "update",
+      "uninstall",
+      "installed"
     ],
     aliases: lowerKeys({
       ls: "list",
       l: "list",
       new: "publish",
       submit: "publish",
-      edit: "update",
-      modify: "update",
+      modify: "edit",
       hide: "unlist",
-      delete: "unpublish",
-      remove: "unpublish",
-      rm: "unpublish",
+      delist: "unlist",
+      retract: "unpublish",
+      deprecate: "unpublish",
+      my: "mine",
+      "my-listings": "mine",
+      listed: "mine",
+      find: "search",
       show: "view",
-      info: "view"
+      info: "view",
+      details: "view",
+      add: "install",
+      upgrade: "update",
+      remove: "uninstall",
+      rm: "uninstall",
+      delete: "uninstall"
     })
   },
-  "marketplace.action.install": {
+  "template.action": {
     canonical: [
-      "search",
+      "create",
+      "publish",
       "view",
+      "versions",
       "install",
-      "update",
-      "uninstall",
-      "installed"
+      "apply",
+      "status",
+      "installed",
+      "uninstall"
     ],
     aliases: lowerKeys({
-      find: "search",
+      new: "create",
+      publish_version: "publish",
+      submit: "publish",
       show: "view",
       info: "view",
+      details: "view",
+      history: "versions",
       add: "install",
-      edit: "update",
-      upgrade: "update",
+      deploy: "apply",
+      "fleet-apply": "apply",
+      rollout: "apply",
+      ls: "installed",
+      list: "installed",
       remove: "uninstall",
       rm: "uninstall",
-      delete: "uninstall",
-      list: "installed",
-      ls: "installed",
-      l: "installed"
+      delete: "uninstall"
     })
   },
   "models.action": {
@@ -25806,16 +25935,14 @@ var ChatApi = class extends HttpClient {
     }
   }
   /**
-  * Clears conversation history for an agent
+  * Clears the authenticated user's conversation history for an agent
   * @param agentId - The unique identifier of the agent
-  * @param targetIdentifier - Optional user identifier to clear history for specific user
   * @param threadId - Optional thread ID to clear a specific conversation thread
   * @returns Promise resolving to an ApiResponse with confirmation
   * @throws Error if the agent is not found or the clear operation fails
   */
-  async clearHistory(agentId, targetIdentifier, threadId) {
+  async clearHistory(agentId, threadId) {
     const params = new URLSearchParams();
-    if (targetIdentifier) params.set("targetIdentifier", targetIdentifier);
     if (threadId) params.set("threadId", threadId);
     const query = params.toString() ? `?${params.toString()}` : "";
     const url = `/chat/history/${agentId}${query}`;
@@ -26984,7 +27111,7 @@ __name(startChatLoop, "startChatLoop");
 async function clearOnExit(chatEnv) {
   try {
     const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
-    const response = await chatApi.clearHistory(chatEnv.agentId, void 0, chatEnv.threadId);
+    const response = await chatApi.clearHistory(chatEnv.agentId, chatEnv.threadId);
     if (response.success) {
       const scope = chatEnv.threadId ? ` for thread "${chatEnv.threadId}"` : "";
       console.log(`
@@ -27248,22 +27375,22 @@ init_analytics();
 async function chatClearCommand(options, command) {
   return withErrorHandling(async () => {
     const resolvedOptions = options ?? {};
+    if (resolvedOptions.user) {
+      throw new Error("The --user option was removed: cross-user history clear is no longer supported. This command only clears your own chat history \u2014 re-run it without --user.");
+    }
     const { agentId, apiKey } = await initializeCommand();
-    const targetIdentifier = resolvedOptions.user;
     const threadId = resolvedOptions.thread ?? command?.parent?.opts()?.thread;
     const force = !!resolvedOptions.force;
-    const userContext = targetIdentifier ? `for user ${targetIdentifier}` : "for your current user";
     const threadContext = threadId ? ` in thread "${threadId}"` : "";
-    const context = `${userContext}${threadContext}`;
     if (!force) {
       console.log(`
-\u26A0\uFE0F  WARNING: This will clear conversation history ${context}!`);
+\u26A0\uFE0F  WARNING: This will clear your conversation history${threadContext}!`);
       console.log("\u26A0\uFE0F  This action cannot be undone.\n");
       const confirmAnswer = await safePrompt([
         {
           type: "confirm",
           name: "confirm",
-          message: `Are you sure you want to clear the conversation history ${context}?`,
+          message: `Are you sure you want to clear your conversation history${threadContext}?`,
           default: false
         }
       ]);
@@ -27273,16 +27400,15 @@ async function chatClearCommand(options, command) {
     }
     writeProgress("\u{1F504} Clearing conversation history...");
     const chatApi = new ChatApi(BASE_URLS.CHAT, apiKey);
-    const response = await chatApi.clearHistory(agentId, targetIdentifier, threadId);
+    const response = await chatApi.clearHistory(agentId, threadId);
     if (!response.success) {
       throw new Error(response.error?.message || "Failed to clear conversation history");
     }
-    writeSuccess(`\u2705 Conversation history cleared successfully ${context}`);
-    console.log(`\u{1F4A1} The chat history has been completely removed ${context}.
+    writeSuccess(`\u2705 Your conversation history has been cleared${threadContext}`);
+    console.log(`\u{1F4A1} Your chat history has been completely removed${threadContext}.
 `);
     trackEvent("cli_chat_cleared", {
       force_mode: force,
-      has_user_target: !!targetIdentifier,
       has_thread_target: !!threadId
     });
   }, "chat clear");
@@ -37233,48 +37359,828 @@ init_developer_api_service();
 init_semver();
 init_analytics();
 import inquirer14 from "inquirer";
-async function marketplaceCommand(role, action, options) {
-  return withErrorHandling(async () => {
-    const { config, apiKey } = await initializeCommand();
-    const marketplaceApi = new MarketplaceApiService(apiKey);
-    let selectedRole = null;
-    if (role) {
-      const normalizedRole = validateOrSuggest("marketplace.role", role);
-      selectedRole = normalizedRole === "create" ? "creator" : "installer";
-    }
-    if (selectedRole && action) {
-      if (selectedRole === "creator") {
-        const normalizedAction = validateOrSuggest("marketplace.action.create", action);
-        await executeCreatorActionNonInteractive(marketplaceApi, config, apiKey, normalizedAction, options || {});
-      } else {
-        const normalizedAction = validateOrSuggest("marketplace.action.install", action);
-        await executeInstallerActionNonInteractive(marketplaceApi, config, apiKey, normalizedAction, options || {});
+
+// src/commands/template.ts
+init_cli();
+import { readFileSync as readFileSync13 } from "fs";
+
+// src/api/template.api.service.ts
+init_constants();
+var TemplateApiService = class {
+  static {
+    __name(this, "TemplateApiService");
+  }
+  apiKey;
+  baseUrl = BASE_URLS.API;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async _fetch(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API Error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    if (response.status === 204) {
+      return null;
+    }
+    return response.json();
+  }
+  async createTemplate(data) {
+    return this._fetch("/marketplace/templates", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async createVersion(templateId, data) {
+    return this._fetch(`/marketplace/templates/${templateId}/versions`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async listTemplates() {
+    return this._fetch("/marketplace/templates");
+  }
+  async getTemplate(templateId) {
+    return this._fetch(`/marketplace/templates/${templateId}`);
+  }
+  async getVersions(templateId) {
+    return this._fetch(`/marketplace/templates/${templateId}/versions`);
+  }
+  async getVersion(templateId, version) {
+    return this._fetch(`/marketplace/templates/${templateId}/versions/${version}`);
+  }
+  async install(templateId, agentId, data) {
+    return this._fetch(`/marketplace/templates/${templateId}/install/${agentId}`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async apply(templateId, data) {
+    return this._fetch(`/marketplace/templates/${templateId}/apply`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getApplyRun(templateId, runId) {
+    return this._fetch(`/marketplace/templates/${templateId}/apply-runs/${runId}`);
+  }
+  async getInstalls(templateId, page, limit) {
+    const params = new URLSearchParams();
+    if (page !== void 0) params.set("page", String(page));
+    if (limit !== void 0) params.set("limit", String(limit));
+    const query = params.toString();
+    return this._fetch(`/marketplace/templates/${templateId}/installs${query ? `?${query}` : ""}`);
+  }
+  async getAllInstalls(templateId) {
+    const pageSize = 1e3;
+    const all = [];
+    for (let page = 1; ; page++) {
+      const batch = await this.getInstalls(templateId, page, pageSize);
+      all.push(...batch);
+      if (batch.length < pageSize) return all;
+    }
+  }
+  async getAgentTemplates(agentId) {
+    return this._fetch(`/marketplace/templates/agent/${agentId}`);
+  }
+  async uninstall(templateId, agentId) {
+    return this._fetch(`/marketplace/templates/${templateId}/installs/${agentId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/commands/template.ts
+init_command_utils();
+init_analytics();
+function showTemplateUsage() {
+  console.log("\nUsage:");
+  console.log("  lua marketplace template                       Interactive mode");
+  console.log("  lua marketplace template <action> [options]    Non-interactive mode");
+  console.log("\nActions:");
+  console.log("  create     --name <n> --display-name <n> [--description <text>] [--visibility public|private]");
+  console.log("  publish    --template-id <id> [--source-version <n>] [--changelog <text>] [--env-contract KEY=desc,...]");
+  console.log("  view       --template-id <id> [--version <n>] [--json]");
+  console.log("  versions   --template-id <id> [--json]");
+  console.log("  install    --template-id <id> [--version <n>] [--env-vars k=v,...] --force");
+  console.log("  apply      --template-id <id> [--version <n>] (--agents a,b | --file <path> | --all-installed) --force [--no-wait]");
+  console.log("  status     --template-id <id> [--json]");
+  console.log("  installed  [--json]");
+  console.log("  uninstall  --template-id <id> --force");
+}
+__name(showTemplateUsage, "showTemplateUsage");
+async function templateCommand(action, options = {}) {
+  const { config, apiKey } = await initializeCommand();
+  const templateApi = new TemplateApiService(apiKey);
+  let selectedAction;
+  if (action) {
+    selectedAction = validateOrSuggest("template.action", action);
+  } else {
+    const answer = await safePrompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          {
+            name: "Create a template from this agent",
+            value: "create"
+          },
+          {
+            name: "Publish a new template version",
+            value: "publish"
+          },
+          {
+            name: "View a template",
+            value: "view"
+          },
+          {
+            name: "List a template\u2019s versions",
+            value: "versions"
+          },
+          {
+            name: "Install a template onto this agent",
+            value: "install"
+          },
+          {
+            name: "Apply a template to a fleet of agents",
+            value: "apply"
+          },
+          {
+            name: "View a template\u2019s fleet install status",
+            value: "status"
+          },
+          {
+            name: "List templates installed on this agent",
+            value: "installed"
+          },
+          {
+            name: "Uninstall a template from this agent",
+            value: "uninstall"
+          },
+          {
+            name: "Exit",
+            value: "exit"
+          }
+        ]
       }
+    ]);
+    if (!answer || answer.action === "exit") {
+      console.log("\n\u{1F44B} Goodbye!\n");
       return;
     }
-    if (selectedRole) {
-      if (selectedRole === "creator") {
-        await handleCreatorActions(marketplaceApi, config, apiKey);
-      } else {
-        await handleInstallerActions(marketplaceApi, config, apiKey);
+    selectedAction = answer.action;
+  }
+  switch (selectedAction) {
+    case "create":
+      await templateCreateAction(templateApi, config, options);
+      break;
+    case "publish":
+      await templatePublishAction(templateApi, options);
+      break;
+    case "view":
+      await templateViewAction(templateApi, options);
+      break;
+    case "versions":
+      await templateVersionsAction(templateApi, options);
+      break;
+    case "install":
+      await templateInstallAction(templateApi, config, options);
+      break;
+    case "apply":
+      await templateApplyAction(templateApi, options);
+      break;
+    case "status":
+      await templateStatusAction(templateApi, options);
+      break;
+    case "installed":
+      await templateInstalledAction(templateApi, config, options);
+      break;
+    case "uninstall":
+      await templateUninstallAction(templateApi, config, options);
+      break;
+    default:
+      showTemplateUsage();
+  }
+  trackEvent("cli_template_action", {
+    action: selectedAction,
+    non_interactive: !!action
+  });
+}
+__name(templateCommand, "templateCommand");
+function sleep2(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+__name(sleep2, "sleep");
+async function resolveTemplateId(templateApi, options, message) {
+  if (options.templateId) return options.templateId;
+  writeProgress("\u{1F504} Loading your templates...");
+  const { templates } = await templateApi.listTemplates();
+  if (!templates.length) {
+    throw new Error("You haven't created any templates yet. Run `lua marketplace template create` first.");
+  }
+  const answer = await safePrompt([
+    {
+      type: "list",
+      name: "template",
+      message,
+      choices: templates.map((t) => ({
+        name: `${t.displayName} (${t.name})`,
+        value: t
+      }))
+    }
+  ]);
+  if (!answer) throw new Error("Cancelled.");
+  return answer.template.id;
+}
+__name(resolveTemplateId, "resolveTemplateId");
+function parseKeyValuePairs(raw) {
+  const result = {};
+  for (const pair of raw.split(",")) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      result[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return result;
+}
+__name(parseKeyValuePairs, "parseKeyValuePairs");
+function parseEnvContract(raw) {
+  if (!raw || raw.length === 0) return void 0;
+  const result = {};
+  for (const entry of raw) {
+    for (const pair of entry.split(",")) {
+      const trimmed = pair.trim();
+      if (!trimmed) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      let key = trimmed.slice(0, eqIdx).trim();
+      const description = trimmed.slice(eqIdx + 1).trim();
+      let required = true;
+      if (key.endsWith("?")) {
+        required = false;
+        key = key.slice(0, -1).trim();
+      }
+      if (!key) continue;
+      result[key] = {
+        description,
+        required
+      };
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+__name(parseEnvContract, "parseEnvContract");
+function printManifestSummary(content) {
+  console.log(`  Skills:         ${content.skills.length}`);
+  console.log(`  Webhooks:       ${content.webhooks.length}`);
+  console.log(`  Jobs:           ${content.jobs.length}`);
+  console.log(`  Preprocessors:  ${content.preprocessors.length}`);
+  console.log(`  Postprocessors: ${content.postprocessors.length}`);
+  console.log(`  Triggers:       ${content.triggers.length}`);
+  console.log(`  Model:          ${content.model ?? "(unchanged)"}`);
+}
+__name(printManifestSummary, "printManifestSummary");
+function printManifestDetail(content, envContract) {
+  const sections = [
+    {
+      name: "Skills",
+      items: content.skills
+    },
+    {
+      name: "Webhooks",
+      items: content.webhooks
+    },
+    {
+      name: "Jobs",
+      items: content.jobs
+    },
+    {
+      name: "Preprocessors",
+      items: content.preprocessors
+    },
+    {
+      name: "Postprocessors",
+      items: content.postprocessors
+    },
+    {
+      name: "Triggers",
+      items: content.triggers
+    }
+  ];
+  for (const { name, items } of sections) {
+    console.log(`
+${name}:`);
+    if (items.length === 0) {
+      console.log("  (none)");
+      continue;
+    }
+    for (const item of items) {
+      console.log(`  ${item.name ?? item.key} \u2014 v${item.version} (${item.key})`);
+    }
+  }
+  console.log(`
+Model: ${content.model ?? "(none)"}`);
+  console.log(`
+Env contract:`);
+  const entries = envContract ? Object.entries(envContract) : [];
+  if (entries.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const [key, meta] of entries) {
+      const optionalTag = meta.required ? "" : " (optional)";
+      const example = meta.example ? ` \u2014 e.g. ${meta.example}` : "";
+      console.log(`  ${key}${optionalTag}: ${meta.description}${example}`);
+    }
+  }
+}
+__name(printManifestDetail, "printManifestDetail");
+async function templateCreateAction(templateApi, config, options) {
+  const agentId = config.agent?.agentId;
+  if (!agentId) throw new Error("Agent ID not found in configuration.");
+  let { name, displayName, description, visibility } = options;
+  if (visibility && visibility !== "public" && visibility !== "private") {
+    throw new Error('Invalid --visibility: must be "public" or "private"');
+  }
+  const questions = [];
+  if (!name) {
+    questions.push({
+      type: "input",
+      name: "name",
+      message: "Template name (internal identifier):",
+      validate: /* @__PURE__ */ __name((input) => input && input.trim().length > 0 ? true : "Name cannot be empty.", "validate")
+    });
+  }
+  if (!displayName) {
+    questions.push({
+      type: "input",
+      name: "displayName",
+      message: "Display name:",
+      validate: /* @__PURE__ */ __name((input) => input && input.trim().length > 0 ? true : "Display name cannot be empty.", "validate")
+    });
+  }
+  if (description === void 0) {
+    questions.push({
+      type: "input",
+      name: "description",
+      message: "Description (optional):"
+    });
+  }
+  if (!visibility) {
+    questions.push({
+      type: "list",
+      name: "visibility",
+      message: "Who can see and install this template?",
+      choices: [
+        {
+          name: "Private \u2014 only your org can find and install it",
+          value: "private"
+        },
+        {
+          name: "Public \u2014 anyone can find and install it",
+          value: "public"
+        }
+      ],
+      default: "private"
+    });
+  }
+  if (questions.length > 0) {
+    const answers = await safePrompt(questions);
+    if (!answers) throw new Error("Cancelled.");
+    name = name ?? answers.name;
+    displayName = displayName ?? answers.displayName;
+    description = description ?? answers.description;
+    visibility = visibility ?? answers.visibility;
+  }
+  if (!name || !displayName) {
+    throw new Error("Missing required options: --name and --display-name");
+  }
+  writeProgress("\u{1F504} Creating template...");
+  const template = await templateApi.createTemplate({
+    sourceAgentId: agentId,
+    name,
+    displayName,
+    description: description || void 0,
+    visibility
+  });
+  if (options.json) {
+    console.log(JSON.stringify(template, null, 2));
+    return;
+  }
+  writeSuccess(`\u2705 Template "${template.displayName}" created!`);
+  writeInfo(`Template ID: ${template.id}`);
+  writeInfo(`Visibility: ${template.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
+  writeHintBlock({
+    headline: "Publish a version to make it installable:",
+    lines: [
+      {
+        label: "Publish:",
+        command: `lua marketplace template publish --template-id ${template.id}`
       }
+    ],
+    when: "success"
+  });
+}
+__name(templateCreateAction, "templateCreateAction");
+async function templatePublishAction(templateApi, options) {
+  const templateId = await resolveTemplateId(templateApi, options, "Which template would you like to publish a version for?");
+  const sourceAgentVersion = options.sourceVersion ? Number.parseInt(options.sourceVersion, 10) : void 0;
+  if (options.sourceVersion && (!Number.isFinite(sourceAgentVersion) || sourceAgentVersion <= 0)) {
+    throw new Error(`Invalid --source-version "${options.sourceVersion}": must be a positive integer.`);
+  }
+  const envContract = parseEnvContract(options.envContract);
+  writeProgress("\u{1F504} Publishing template version...");
+  const version = await templateApi.createVersion(templateId, {
+    sourceAgentVersion,
+    changelog: options.changelog || void 0,
+    envContract
+  });
+  if (options.json) {
+    console.log(JSON.stringify(version, null, 2));
+    return;
+  }
+  writeSuccess(`\u2705 Published v${version.version}`);
+  writeInfo(`Frozen from agent version v${version.sourceAgentVersion}`);
+  console.log("\nManifest:");
+  printManifestSummary(version.content);
+  const envCount = version.envContract ? Object.keys(version.envContract).length : 0;
+  console.log(`  Env contract:   ${envCount} var(s)`);
+}
+__name(templatePublishAction, "templatePublishAction");
+async function templateViewAction(templateApi, options) {
+  const templateId = await resolveTemplateId(templateApi, options, "Which template would you like to view?");
+  if (options.version) {
+    const versionNum = Number.parseInt(options.version, 10);
+    if (!Number.isFinite(versionNum) || versionNum <= 0) {
+      throw new Error(`Invalid --version "${options.version}": must be a positive integer.`);
+    }
+    const version = await templateApi.getVersion(templateId, versionNum).catch(() => null);
+    if (!version) throw new Error(`Version v${versionNum} not found for this template.`);
+    if (options.json) {
+      console.log(JSON.stringify(version, null, 2));
       return;
     }
-    let exit = false;
-    while (!exit) {
-      const roleAnswer = await safePrompt([
+    console.log(`
+${"=".repeat(60)}`);
+    console.log(`Template v${version.version} \u2014 ${templateId}`);
+    console.log(`${"=".repeat(60)}`);
+    if (version.changelog) console.log(`
+Changelog: ${version.changelog}`);
+    printManifestDetail(version.content, version.envContract);
+    return;
+  }
+  const template = await templateApi.getTemplate(templateId);
+  if (options.json) {
+    console.log(JSON.stringify(template, null, 2));
+    return;
+  }
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`\u{1F4E6} ${template.displayName}`);
+  console.log(`${"=".repeat(60)}
+`);
+  console.log(`ID: ${template.id}`);
+  console.log(`Name: ${template.name}`);
+  if (template.description) console.log(`Description: ${template.description}`);
+  console.log(`Visibility: ${template.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
+  console.log(`Listed: ${template.listed ? "Yes" : "No"}`);
+  console.log(`Installs: ${template.installCount}`);
+  if (template.latestVersion != null) console.log(`Latest version: v${template.latestVersion}`);
+  console.log(`Created: ${new Date(template.createdAt).toLocaleDateString()}`);
+  console.log(`
+${"=".repeat(60)}
+`);
+}
+__name(templateViewAction, "templateViewAction");
+async function templateVersionsAction(templateApi, options) {
+  const templateId = await resolveTemplateId(templateApi, options, "Which template\u2019s versions would you like to see?");
+  const versions = await templateApi.getVersions(templateId);
+  if (options.json) {
+    console.log(JSON.stringify(versions, null, 2));
+    return;
+  }
+  if (versions.length === 0) {
+    writeInfo("(no versions yet \u2014 run `lua marketplace template publish` to make one)");
+    return;
+  }
+  const sorted = [
+    ...versions
+  ].sort((a, b) => b.version - a.version);
+  for (const v of sorted) {
+    console.log(`v${v.version} \u2014 from agent v${v.sourceAgentVersion} \u2014 ${new Date(v.createdAt).toLocaleString()}`);
+    if (v.changelog) console.log(`  ${v.changelog}`);
+  }
+}
+__name(templateVersionsAction, "templateVersionsAction");
+async function templateInstallAction(templateApi, config, options) {
+  const agentId = config.agent?.agentId;
+  if (!agentId) throw new Error("Agent ID not found in configuration.");
+  const templateId = await resolveTemplateId(templateApi, options, "Which template would you like to install?");
+  const version = options.version ? Number.parseInt(options.version, 10) : void 0;
+  const envValues = options.envVars ? parseKeyValuePairs(options.envVars) : void 0;
+  if (!options.force) {
+    writeInfo("\n\u{1F4CB} Install Summary:");
+    writeInfo(`  Template: ${templateId}`);
+    writeInfo(`  Version: ${version ?? "(latest)"}`);
+    writeInfo(`  Agent: ${agentId}`);
+    if (envValues && Object.keys(envValues).length > 0) {
+      writeInfo(`  Env values: ${Object.keys(envValues).length} configured`);
+    }
+    console.error("\n\u274C Use --force to confirm installation");
+    throw new Error("This action requires --force to confirm");
+  }
+  writeProgress("\u{1F504} Installing template...");
+  const install = await templateApi.install(templateId, agentId, {
+    version,
+    envValues,
+    allowCreatorUpdates: options.allowCreatorUpdates,
+    skipEnvCheck: options.skipEnvCheck
+  });
+  if (options.json) {
+    console.log(JSON.stringify(install, null, 2));
+    return;
+  }
+  writeSuccess(`\u2705 Template installed! (v${install.installedVersion})`);
+  if (install.appliedAgentVersion != null) {
+    writeInfo(`Applied as agent version v${install.appliedAgentVersion}.`);
+  }
+  writeHintBlock({
+    headline: "Roll back this agent to a prior state anytime:",
+    lines: [
+      {
+        label: "Rollback:",
+        command: "lua version promote <n>"
+      }
+    ],
+    when: "success"
+  });
+}
+__name(templateInstallAction, "templateInstallAction");
+function formatApplyResultTable(targets) {
+  const header = {
+    agentId: "AGENT ID",
+    status: "STATUS",
+    localAgentVersion: "LOCAL VERSION",
+    error: "ERROR"
+  };
+  const rows = targets.map((t) => ({
+    agentId: t.agentId,
+    status: t.status,
+    localAgentVersion: t.localAgentVersion != null ? `v${t.localAgentVersion}` : "\u2014",
+    error: t.error ?? ""
+  }));
+  const cols = [
+    "agentId",
+    "status",
+    "localAgentVersion",
+    "error"
+  ];
+  const widths = {};
+  for (const c of cols) {
+    widths[c] = Math.max(header[c].length, ...rows.map((r) => r[c].length));
+  }
+  const fmt = /* @__PURE__ */ __name((r) => cols.map((c) => r[c].padEnd(widths[c])).join("  ").trimEnd(), "fmt");
+  return [
+    fmt(header),
+    ...rows.map(fmt)
+  ];
+}
+__name(formatApplyResultTable, "formatApplyResultTable");
+function resolveApplyTargets(options) {
+  if (options.agents) {
+    return options.agents.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (options.file) {
+    const contents = readFileSync13(options.file, "utf-8");
+    return contents.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  return null;
+}
+__name(resolveApplyTargets, "resolveApplyTargets");
+async function templateApplyAction(templateApi, options) {
+  const templateId = await resolveTemplateId(templateApi, options, "Which template would you like to apply?");
+  let targets = resolveApplyTargets(options);
+  if (!targets && options.allInstalled) {
+    writeProgress("\u{1F504} Loading install ledger...");
+    const installs = await templateApi.getAllInstalls(templateId);
+    targets = installs.map((i) => i.agentId);
+  }
+  if (!targets) {
+    throw new Error("Provide targets via --agents <a,b,c>, --file <path>, or --all-installed");
+  }
+  if (targets.length === 0) {
+    writeInfo("No target agents resolved \u2014 nothing to apply.");
+    return;
+  }
+  writeInfo(`Resolved ${targets.length} target agent(s): ${targets.join(", ")}`);
+  const template = await templateApi.getTemplate(templateId);
+  if (!template.latestVersion) {
+    throw new Error("This template has no published versions. Run `lua marketplace template publish` first.");
+  }
+  const versionNum = options.version ? Number.parseInt(options.version, 10) : template.latestVersion;
+  const versionObj = await templateApi.getVersion(templateId, versionNum).catch(() => null);
+  if (!versionObj) throw new Error(`Version v${versionNum} not found for this template.`);
+  if (!options.force) {
+    console.log(`
+Apply plan:`);
+    console.log(`  Template: ${template.displayName} (${templateId})`);
+    console.log(`  Version:  v${versionObj.version}`);
+    console.log(`  Targets:  ${targets.length}`);
+    console.log("\nManifest:");
+    printManifestSummary(versionObj.content);
+    const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const isCi = isCiModeEnabled();
+    if (isTTY && !isCi) {
+      const confirmed = await confirmAction(`
+Apply v${versionObj.version} to ${targets.length} agent(s)?`);
+      if (!confirmed) {
+        writeInfo("Aborted.");
+        return;
+      }
+    } else {
+      throw new Error("This action requires --force to confirm (non-interactive mode)");
+    }
+  }
+  writeProgress("\u{1F504} Starting apply run...");
+  const { runId } = await templateApi.apply(templateId, {
+    version: versionObj.version,
+    targets,
+    skipEnvCheck: options.skipEnvCheck
+  });
+  if (options.wait === false) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        runId
+      }, null, 2));
+    } else {
+      writeSuccess(`\u2705 Apply run started: ${runId}`);
+    }
+    return;
+  }
+  writeProgress("\u{1F504} Waiting for apply run to complete...");
+  const waitDeadline = Date.now() + 30 * 60 * 1e3;
+  let run = await templateApi.getApplyRun(templateId, runId);
+  while (run.status === "running") {
+    if (Date.now() > waitDeadline) {
+      throw new Error(`Apply run ${runId} still running after 30 minutes \u2014 a crashed worker can leave a run stuck. Check later with: lua marketplace template status --template-id ${templateId}`);
+    }
+    await sleep2(3e3);
+    run = await templateApi.getApplyRun(templateId, runId);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(run, null, 2));
+  } else {
+    console.log(`
+Apply run ${run.status} (${run.id})`);
+    for (const line of formatApplyResultTable(run.targets)) {
+      console.log(line);
+    }
+  }
+  const failedCount = run.targets.filter((t) => t.status === "failed").length;
+  if (failedCount > 0) {
+    throw new Error(`Apply run finished with ${failedCount} failed target(s).`);
+  }
+}
+__name(templateApplyAction, "templateApplyAction");
+async function templateStatusAction(templateApi, options) {
+  const templateId = await resolveTemplateId(templateApi, options, "Which template\u2019s fleet status would you like to see?");
+  const installs = await templateApi.getAllInstalls(templateId);
+  if (options.json) {
+    console.log(JSON.stringify(installs, null, 2));
+    return;
+  }
+  if (installs.length === 0) {
+    writeInfo("No agents have installed this template yet.");
+    return;
+  }
+  const header = {
+    agentId: "AGENT ID",
+    installedVersion: "TEMPLATE VERSION",
+    appliedAgentVersion: "AGENT VERSION",
+    status: "STATUS",
+    appliedAt: "APPLIED AT"
+  };
+  const rows = installs.map((i) => ({
+    agentId: i.agentId,
+    installedVersion: `v${i.installedVersion}`,
+    appliedAgentVersion: i.appliedAgentVersion != null ? `v${i.appliedAgentVersion}` : "\u2014",
+    status: i.status,
+    appliedAt: new Date(i.appliedAt).toISOString().slice(0, 16).replace("T", " ")
+  }));
+  const cols = [
+    "agentId",
+    "installedVersion",
+    "appliedAgentVersion",
+    "status",
+    "appliedAt"
+  ];
+  const widths = {};
+  for (const c of cols) {
+    widths[c] = Math.max(header[c].length, ...rows.map((r) => r[c].length));
+  }
+  const fmt = /* @__PURE__ */ __name((r) => cols.map((c) => r[c].padEnd(widths[c])).join("  ").trimEnd(), "fmt");
+  console.log(fmt(header));
+  for (const r of rows) console.log(fmt(r));
+  writeInfo("\n\u{1F4A1} Per-agent rollback: run `lua version promote <n>` directly on that agent.");
+}
+__name(templateStatusAction, "templateStatusAction");
+async function templateInstalledAction(templateApi, config, options) {
+  const agentId = config.agent?.agentId;
+  if (!agentId) throw new Error("Agent ID not found in configuration.");
+  const summaries = await templateApi.getAgentTemplates(agentId);
+  if (options.json) {
+    console.log(JSON.stringify(summaries, null, 2));
+    return;
+  }
+  if (summaries.length === 0) {
+    writeInfo("\u{1F4E6} No templates installed on this agent.");
+    return;
+  }
+  console.log(`
+\u{1F4CA} ${summaries.length} template(s) installed on this agent:
+`);
+  for (const s of summaries) {
+    console.log(`\u{1F4E6} ${s.displayName} (${s.templateId})`);
+    console.log(`   Installed version: v${s.installedVersion}`);
+    console.log(`   Status: ${s.status}`);
+    console.log(`   Applied: ${new Date(s.appliedAt).toLocaleString()}`);
+    console.log("");
+  }
+}
+__name(templateInstalledAction, "templateInstalledAction");
+async function templateUninstallAction(templateApi, config, options) {
+  const agentId = config.agent?.agentId;
+  if (!agentId) throw new Error("Agent ID not found in configuration.");
+  const templateId = await resolveTemplateId(templateApi, options, "Which template would you like to uninstall?");
+  if (!options.force) {
+    console.error(`
+\u274C Use --force to confirm uninstalling template ${templateId} from this agent`);
+    throw new Error("This action requires --force to confirm");
+  }
+  writeProgress("\u{1F504} Uninstalling template...");
+  await templateApi.uninstall(templateId, agentId);
+  writeSuccess("\u2705 Template uninstalled from this agent.");
+}
+__name(templateUninstallAction, "templateUninstallAction");
+
+// src/commands/marketplace.ts
+var SKILL_ACTIONS = [
+  "list",
+  "publish",
+  "edit",
+  "unlist",
+  "unpublish",
+  "mine",
+  "search",
+  "view",
+  "install",
+  "update",
+  "uninstall",
+  "installed"
+];
+var INTERACTIVE_SKILL_ACTIONS = SKILL_ACTIONS.filter((a) => a !== "view");
+var SKILL_ACTION_LABELS = {
+  search: "Browse & search for skills",
+  install: "Install a skill",
+  update: "Update an installed skill",
+  uninstall: "Uninstall a skill",
+  installed: "List installed skills",
+  list: "List a new skill on the Marketplace",
+  publish: "Publish a new version of a skill",
+  edit: "Edit metadata for a listed skill",
+  unlist: "Unlist a skill from the Marketplace",
+  unpublish: "Unpublish a skill version",
+  mine: "View my listed skills"
+};
+async function marketplaceCommand(noun, action, options = {}) {
+  return withErrorHandling(async () => {
+    let domain;
+    if (noun) {
+      domain = validateOrSuggest("marketplace.noun", noun);
+    } else {
+      const domainAnswer = await safePrompt([
         {
           type: "list",
-          name: "role",
-          message: "What would you like to do?",
+          name: "domain",
+          message: "What would you like to browse?",
           choices: [
             {
-              name: "As a Creator (Publish & Manage your skills)",
-              value: "creator"
+              name: "Skills",
+              value: "skill"
             },
             {
-              name: "As an Installer (Find & Install skills)",
-              value: "installer"
+              name: "Agent templates",
+              value: "template"
             },
             {
               name: "Exit",
@@ -37283,26 +38189,67 @@ async function marketplaceCommand(role, action, options) {
           ]
         }
       ]);
-      if (!roleAnswer || roleAnswer.role === "exit") {
-        exit = true;
+      if (!domainAnswer || domainAnswer.domain === "exit") {
         console.log("\n\u{1F44B} Goodbye!\n");
-        continue;
+        return;
       }
-      if (roleAnswer.role === "creator") {
-        await handleCreatorActions(marketplaceApi, config, apiKey);
-      } else if (roleAnswer.role === "installer") {
-        await handleInstallerActions(marketplaceApi, config, apiKey);
+      domain = domainAnswer.domain;
+    }
+    if (domain === "template") {
+      return templateCommand(action, options);
+    }
+    return skillMarketplaceCommand(action, options);
+  }, "marketplace");
+}
+__name(marketplaceCommand, "marketplaceCommand");
+async function skillMarketplaceCommand(action, options = {}) {
+  const { config, apiKey } = await initializeCommand();
+  const marketplaceApi = new MarketplaceApiService(apiKey);
+  if (action) {
+    const selectedAction = validateOrSuggest("marketplace.skill.action", action);
+    await executeSkillActionNonInteractive(marketplaceApi, config, apiKey, selectedAction, options);
+    trackEvent("cli_marketplace_action", {
+      domain: "skill",
+      action: selectedAction,
+      non_interactive: true
+    });
+    return;
+  }
+  let exit = false;
+  while (!exit) {
+    const answer = await safePrompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          ...INTERACTIVE_SKILL_ACTIONS.map((a) => ({
+            name: SKILL_ACTION_LABELS[a],
+            value: a
+          })),
+          {
+            name: "Exit",
+            value: "exit"
+          }
+        ]
       }
+    ]);
+    if (!answer || answer.action === "exit") {
+      exit = true;
+      console.log("\n\u{1F44B} Goodbye!\n");
+      continue;
     }
+    const selectedAction = answer.action;
+    await executeSkillActionInteractive(marketplaceApi, config, apiKey, selectedAction);
     trackEvent("cli_marketplace_action", {
-      role: role || "interactive",
-      action: action || null,
-      non_interactive: !!(selectedRole && action)
+      domain: "skill",
+      action: selectedAction,
+      non_interactive: false
     });
-  }, "marketplace");
+  }
 }
-__name(marketplaceCommand, "marketplaceCommand");
-async function executeCreatorActionNonInteractive(marketplaceApi, config, apiKey, action, options) {
+__name(skillMarketplaceCommand, "skillMarketplaceCommand");
+async function executeSkillActionNonInteractive(marketplaceApi, config, apiKey, action, options) {
   switch (action) {
     case "list":
       await listSkillNonInteractive(marketplaceApi, config, apiKey, options);
@@ -37310,7 +38257,7 @@ async function executeCreatorActionNonInteractive(marketplaceApi, config, apiKey
     case "publish":
       await publishVersionNonInteractive(marketplaceApi, config, apiKey, options);
       break;
-    case "update":
+    case "edit":
       await updateMetadataNonInteractive(marketplaceApi, options);
       break;
     case "unlist":
@@ -37319,14 +38266,9 @@ async function executeCreatorActionNonInteractive(marketplaceApi, config, apiKey
     case "unpublish":
       await unpublishVersionNonInteractive(marketplaceApi, options);
       break;
-    case "view":
+    case "mine":
       await viewMyListedSkillsNonInteractive(marketplaceApi, options);
       break;
-  }
-}
-__name(executeCreatorActionNonInteractive, "executeCreatorActionNonInteractive");
-async function executeInstallerActionNonInteractive(marketplaceApi, config, apiKey, action, options) {
-  switch (action) {
     case "search":
       await searchSkillsNonInteractive(marketplaceApi, options);
       break;
@@ -37347,14 +38289,58 @@ async function executeInstallerActionNonInteractive(marketplaceApi, config, apiK
       break;
   }
 }
-__name(executeInstallerActionNonInteractive, "executeInstallerActionNonInteractive");
+__name(executeSkillActionNonInteractive, "executeSkillActionNonInteractive");
+async function executeSkillActionInteractive(marketplaceApi, config, apiKey, action) {
+  switch (action) {
+    case "list":
+      await listSkillOnMarketplace(marketplaceApi, config, apiKey);
+      break;
+    case "publish":
+      await publishSkillVersion(marketplaceApi, config, apiKey);
+      break;
+    case "edit":
+      await updateSkillMetadata(marketplaceApi, config);
+      break;
+    case "unlist":
+      await unlistSkillFromMarketplace(marketplaceApi);
+      break;
+    case "unpublish":
+      await unpublishSkillVersion(marketplaceApi);
+      break;
+    case "mine":
+      await viewMyListedSkills(marketplaceApi);
+      break;
+    case "search":
+      await searchMarketplaceSkills(marketplaceApi);
+      break;
+    case "install":
+      await installMarketplaceSkill(marketplaceApi, config, apiKey);
+      break;
+    case "update":
+      await updateInstalledSkill(marketplaceApi, config, apiKey);
+      break;
+    case "uninstall":
+      await uninstallMarketplaceSkill(marketplaceApi, config);
+      break;
+    case "installed":
+      await listInstalledSkills(marketplaceApi, config);
+      break;
+    case "view":
+      break;
+  }
+}
+__name(executeSkillActionInteractive, "executeSkillActionInteractive");
 async function listSkillNonInteractive(marketplaceApi, config, apiKey, options) {
-  const { skillName, displayName } = options;
+  const { skillName, displayName, visibility } = options;
   if (!skillName || !displayName) {
     console.error("\u274C Missing required options");
-    console.log("\nUsage: lua marketplace create list --skill-name <name> --display-name <name>");
+    console.log("\nUsage: lua marketplace skill list --skill-name <name> --display-name <name>");
     throw new Error("Missing required options");
   }
+  if (visibility && visibility !== "public" && visibility !== "private") {
+    console.error('\u274C Invalid --visibility: must be "public" or "private"');
+    throw new Error('Invalid --visibility: must be "public" or "private"');
+  }
   const agentId = config.agent?.agentId;
   if (!agentId) {
     console.error("\u274C Agent ID not found in configuration.");
@@ -37385,10 +38371,12 @@ async function listSkillNonInteractive(marketplaceApi, config, apiKey, options)
   writeProgress("\u{1F504} Listing skill on marketplace...");
   const marketplaceSkill = await marketplaceApi.listSkill({
     skillId: skill.id,
-    displayName
+    displayName,
+    visibility
   });
   writeSuccess(`\u2705 Skill "${marketplaceSkill.displayName}" listed successfully!`);
   writeInfo(`Marketplace Skill ID: ${marketplaceSkill.id}`);
+  writeInfo(`Visibility: ${marketplaceSkill.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
   writeInfo("\u{1F4A1} You can now publish a version to make it installable.");
 }
 __name(listSkillNonInteractive, "listSkillNonInteractive");
@@ -37396,7 +38384,7 @@ async function publishVersionNonInteractive(marketplaceApi, config, apiKey, opti
   const { marketplaceId, versionId, changelog, envVarsJson } = options;
   if (!marketplaceId || !versionId) {
     console.error("\u274C Missing required options");
-    console.log("\nUsage: lua marketplace create publish --marketplace-id <id> --version-id <id> [--changelog <text>]");
+    console.log("\nUsage: lua marketplace skill publish --marketplace-id <id> --version-id <id> [--changelog <text>]");
     throw new Error("Missing required options");
   }
   let envVars;
@@ -37423,7 +38411,7 @@ async function updateMetadataNonInteractive(marketplaceApi, options) {
   const { marketplaceId, displayName } = options;
   if (!marketplaceId) {
     console.error("\u274C Missing required option: --marketplace-id");
-    console.log("\nUsage: lua marketplace create update --marketplace-id <id> --display-name <name>");
+    console.log("\nUsage: lua marketplace skill edit --marketplace-id <id> --display-name <name>");
     throw new Error("Missing required option: --marketplace-id");
   }
   if (!displayName) {
@@ -37441,12 +38429,12 @@ async function unlistSkillNonInteractive(marketplaceApi, options) {
   const { marketplaceId, force } = options;
   if (!marketplaceId) {
     console.error("\u274C Missing required option: --marketplace-id");
-    console.log("\nUsage: lua marketplace create unlist --marketplace-id <id> [--force]");
+    console.log("\nUsage: lua marketplace skill unlist --marketplace-id <id> [--force]");
     throw new Error("Missing required option: --marketplace-id");
   }
   if (!force) {
     console.error("\u274C This action requires --force to confirm");
-    console.log("\nUsage: lua marketplace create unlist --marketplace-id <id> --force");
+    console.log("\nUsage: lua marketplace skill unlist --marketplace-id <id> --force");
     throw new Error("This action requires --force to confirm");
   }
   writeProgress("\u{1F504} Unlisting skill...");
@@ -37459,7 +38447,7 @@ async function unpublishVersionNonInteractive(marketplaceApi, options) {
   const { marketplaceId, versionId, force } = options;
   if (!marketplaceId || !versionId) {
     console.error("\u274C Missing required options");
-    console.log("\nUsage: lua marketplace create unpublish --marketplace-id <id> --version-id <id> [--force]");
+    console.log("\nUsage: lua marketplace skill unpublish --marketplace-id <id> --version-id <id> [--force]");
     throw new Error("Missing required options");
   }
   if (!force) {
@@ -37492,6 +38480,7 @@ async function viewMyListedSkillsNonInteractive(marketplaceApi, options) {
     console.log(`${statusIcon} ${skill.displayName} (${skill.name})`);
     console.log(`   ID: ${skill.id}`);
     console.log(`   Status: ${statusText}`);
+    console.log(`   Visibility: ${skill.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
     if (skill.versions && skill.versions.length > 0) {
       const publishedVersions = skill.versions.filter((v) => v.published);
       console.log(`   Versions: ${publishedVersions.length} published / ${skill.versions.length} total`);
@@ -37540,7 +38529,7 @@ async function viewSkillNonInteractive(marketplaceApi, options) {
   const { marketplaceId } = options;
   if (!marketplaceId) {
     console.error("\u274C Missing required option: --marketplace-id");
-    console.log("\nUsage: lua marketplace install view --marketplace-id <id>");
+    console.log("\nUsage: lua marketplace skill view --marketplace-id <id>");
     throw new Error("Missing required option: --marketplace-id");
   }
   writeProgress("\u{1F504} Loading skill details...");
@@ -37584,7 +38573,7 @@ async function installSkillNonInteractive(marketplaceApi, config, options) {
   const { marketplaceId, versionId, envVars, force } = options;
   if (!marketplaceId || !versionId) {
     console.error("\u274C Missing required options");
-    console.log("\nUsage: lua marketplace install install --marketplace-id <id> --version-id <id> [--env-vars <k=v,...>]");
+    console.log("\nUsage: lua marketplace skill install --marketplace-id <id> --version-id <id> [--env-vars <k=v,...>]");
     throw new Error("Missing required options");
   }
   const agentId = config.agent?.agentId;
@@ -37641,7 +38630,7 @@ async function updateInstalledSkillNonInteractive(marketplaceApi, config, apiKey
   const { skillName, versionId, envVars } = options;
   if (!skillName) {
     console.error("\u274C Missing required option: --skill-name");
-    console.log("\nUsage: lua marketplace install update --skill-name <name> [--version-id <id>] [--env-vars <k=v,...>]");
+    console.log("\nUsage: lua marketplace skill update --skill-name <name> [--version-id <id>] [--env-vars <k=v,...>]");
     throw new Error("Missing required option: --skill-name");
   }
   const agentId = config.agent?.agentId;
@@ -37693,7 +38682,7 @@ async function uninstallSkillNonInteractive(marketplaceApi, config, options) {
   const { skillName, force } = options;
   if (!skillName) {
     console.error("\u274C Missing required option: --skill-name");
-    console.log("\nUsage: lua marketplace install uninstall --skill-name <name> [--force]");
+    console.log("\nUsage: lua marketplace skill uninstall --skill-name <name> [--force]");
     throw new Error("Missing required option: --skill-name");
   }
   const agentId = config.agent?.agentId;
@@ -37756,86 +38745,6 @@ async function listInstalledSkillsNonInteractive(marketplaceApi, config, options
   }
 }
 __name(listInstalledSkillsNonInteractive, "listInstalledSkillsNonInteractive");
-async function handleCreatorActions(marketplaceApi, config, apiKey) {
-  let back = false;
-  while (!back) {
-    const creatorAnswer = await safePrompt([
-      {
-        type: "list",
-        name: "action",
-        message: "Creator Menu:",
-        choices: [
-          {
-            name: "List a new skill on the Marketplace",
-            value: "list"
-          },
-          {
-            name: "Publish a new version of a skill",
-            value: "publish"
-          },
-          {
-            name: "Update metadata for a listed skill",
-            value: "update"
-          },
-          {
-            name: "Unlist a skill from the Marketplace",
-            value: "unlist"
-          },
-          {
-            name: "Unpublish a skill version",
-            value: "unpublish"
-          },
-          {
-            name: "View my listed skills",
-            value: "view"
-          },
-          {
-            name: "Back",
-            value: "back"
-          }
-        ]
-      }
-    ]);
-    if (!creatorAnswer || creatorAnswer.action === "back") {
-      back = true;
-      continue;
-    }
-    switch (creatorAnswer.action) {
-      case "list":
-        await listSkillOnMarketplace(marketplaceApi, config, apiKey);
-        continue;
-      case "publish":
-        await publishSkillVersion(marketplaceApi, config, apiKey);
-        continue;
-      case "update":
-        await updateSkillMetadata(marketplaceApi, config);
-        continue;
-      case "unlist":
-        await unlistSkillFromMarketplace(marketplaceApi);
-        continue;
-      case "unpublish":
-        await unpublishSkillVersion(marketplaceApi);
-        continue;
-      case "view":
-        await viewMyListedSkills(marketplaceApi);
-        continue;
-      // Other cases will be added here
-      default:
-        console.log(`
-Action '${creatorAnswer.action}' is not implemented yet.
-`);
-        await safePrompt([
-          {
-            type: "input",
-            name: "continue",
-            message: "Press Enter to continue..."
-          }
-        ]);
-        continue;
-    }
-  }
-}
-__name(handleCreatorActions, "handleCreatorActions");
 async function listSkillOnMarketplace(marketplaceApi, config, apiKey) {
   const agentId = config.agent?.agentId;
   if (!agentId) {
@@ -37898,9 +38807,29 @@ async function listSkillOnMarketplace(marketplaceApi, config, apiKey) {
     }
   ]);
   if (!metadata) return;
+  const visibilityAnswer = await safePrompt([
+    {
+      type: "list",
+      name: "visibility",
+      message: "Who can see and install this skill?",
+      choices: [
+        {
+          name: "Public \u2014 anyone can find and install it",
+          value: "public"
+        },
+        {
+          name: "Private \u2014 only you (and your org) can find and install it",
+          value: "private"
+        }
+      ],
+      default: "public"
+    }
+  ]);
+  if (!visibilityAnswer) return;
   const payload = {
     skillId: skillToList.id,
-    displayName: metadata.displayName
+    displayName: metadata.displayName,
+    visibility: visibilityAnswer.visibility
   };
   try {
     writeProgress("\nListing skill on the marketplace...");
@@ -37908,6 +38837,7 @@ async function listSkillOnMarketplace(marketplaceApi, config, apiKey) {
     writeSuccess(`
 \u2705 Skill "${marketplaceSkill.displayName}" listed successfully!`);
     writeInfo(`Marketplace Skill ID: ${marketplaceSkill.id}`);
+    writeInfo(`Visibility: ${marketplaceSkill.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
     writeInfo("\u{1F4A1} You can now publish a version to make it installable.\n");
   } catch (error) {
     console.error(`
@@ -38278,6 +39208,7 @@ async function viewMyListedSkills(marketplaceApi) {
       const statusText = skill.listed ? "Listed" : "Unlisted";
       console.log(`${statusIcon} ${skill.displayName} (${skill.name})`);
       console.log(`   Status: ${statusText}`);
+      console.log(`   Visibility: ${skill.visibility === "private" ? "\u{1F512} Private" : "\u{1F310} Public"}`);
       if (skill.description) {
         console.log(`   Description: ${skill.description}`);
       }
@@ -38509,79 +39440,6 @@ async function configureEnvVar(varName, envVars) {
 `);
 }
 __name(configureEnvVar, "configureEnvVar");
-async function handleInstallerActions(marketplaceApi, config, apiKey) {
-  let back = false;
-  while (!back) {
-    const installerAnswer = await safePrompt([
-      {
-        type: "list",
-        name: "action",
-        message: "Installer Menu:",
-        choices: [
-          {
-            name: "Browse & Search for skills",
-            value: "search"
-          },
-          {
-            name: "Install a skill from the Marketplace",
-            value: "install"
-          },
-          {
-            name: "Update an installed skill",
-            value: "update"
-          },
-          {
-            name: "Uninstall a skill",
-            value: "uninstall"
-          },
-          {
-            name: "List my currently installed skills",
-            value: "installed"
-          },
-          {
-            name: "Back",
-            value: "back"
-          }
-        ]
-      }
-    ]);
-    if (!installerAnswer || installerAnswer.action === "back") {
-      back = true;
-      continue;
-    }
-    switch (installerAnswer.action) {
-      case "search":
-        await searchMarketplaceSkills(marketplaceApi);
-        continue;
-      case "install":
-        await installMarketplaceSkill(marketplaceApi, config, apiKey);
-        continue;
-      case "update":
-        await updateInstalledSkill(marketplaceApi, config, apiKey);
-        continue;
-      case "uninstall":
-        await uninstallMarketplaceSkill(marketplaceApi, config);
-        continue;
-      case "installed":
-        await listInstalledSkills(marketplaceApi, config);
-        continue;
-      // Other cases will be added here
-      default:
-        console.log(`
-Action '${installerAnswer.action}' is not implemented yet.
-`);
-        await safePrompt([
-          {
-            type: "input",
-            name: "continue",
-            message: "Press Enter to continue..."
-          }
-        ]);
-        continue;
-    }
-  }
-}
-__name(handleInstallerActions, "handleInstallerActions");
 var MARKETPLACE_PAGE_SIZE = 10;
 async function browseAndSelectSkill(marketplaceApi, purpose, publishedVersionsOnly) {
   try {
@@ -44946,20 +45804,21 @@ Examples:
 }
 __name(setupAuthCommands, "setupAuthCommands");
 function setupMarketplaceCommands(program2) {
-  program2.command("marketplace [role] [action]").description("\u{1F6CD}\uFE0F  Browse, install, and manage marketplace skills").option("--skill-name <name>", "Skill name (for creator list, installer update/uninstall)").option("--display-name <name>", "Display name (for creator list/update)").option("--marketplace-id <id>", "Marketplace skill ID").option("--version-id <id>", "Version ID (for publish/install)").option("--changelog <text>", "Changelog for version (for publish)").option("--env-vars-json <json>", "JSON string with env var metadata (for creator publish)").option("--env-vars <pairs>", "Comma-separated key=value pairs (for installer)").option("--query <text>", "Search query (for search)").option("--page <n>", "Page number (for search)").option("--limit <n>", "Results per page (for search)").option("--json", "Output as JSON").option("--force", "Skip confirmation prompts").addHelpText("after", `
+  program2.command("marketplace [noun] [action]").description("\u{1F6CD}\uFE0F  Browse, install, and manage marketplace skills and agent templates").option("--skill-name <name>", "Skill name (for skill list/update/uninstall)").option("--marketplace-id <id>", "Marketplace skill ID").option("--version-id <id>", "Version ID (for skill publish/install)").option("--env-vars-json <json>", "JSON string with env var metadata (for skill publish)").option("--query <text>", "Search query (for skill search)").option("--page <n>", "Page number (for skill search)").option("--limit <n>", "Results per page (for skill search)").option("--name <name>", "Template name, an internal identifier (for template create)").option("--description <text>", "Description (for template create)").option("--template-id <id>", "Template ID").option("--source-version <n>", "Agent version to freeze into this template version (default: active) (for template publish)").option("--env-contract <pair>", "KEY=description env contract entry, repeatable; use KEY?=description for optional (for template publish)", (val, previous) => [
+    ...previous,
+    val
+  ], []).option("--version <n>", "Template version (for template view/install/apply)").option("--allow-creator-updates", "Allow the template creator to push future updates onto this install").option("--skip-env-check", "Skip env-contract validation (for template install/apply)").option("--agents <ids>", "Comma-separated target agent IDs (for template apply)").option("--file <path>", "Path to a file with one target agent ID per line (for template apply)").option("--all-installed", "Target every agent that already has this template installed (for template apply)").option("--no-wait", "Print the apply runId immediately instead of polling for completion (for template apply)").option("--display-name <name>", "Display name (for skill list/edit, template create)").option("--visibility <visibility>", "Who can see and install it: public or private (for skill list, template create)").option("--changelog <text>", "Changelog for this version (for skill/template publish)").option("--env-vars <pairs>", "Comma-separated key=value pairs (for skill/template install/update)").option("--json", "Output as JSON").option("--force", "Skip confirmation prompts").addHelpText("after", `
 Arguments:
-  role                   Optional: 'create' or 'install' (prompts if not provided)
+  noun                   Optional: 'skill' or 'template' (prompts if not provided)
   action                 Optional: specific action for non-interactive mode
 
-Creator Actions:
-  list      --skill-name <name> --display-name <name>
+Skill Actions:
+  list      --skill-name <name> --display-name <name> [--visibility public|private]
   publish   --marketplace-id <id> --version-id <id> [--changelog <text>] [--env-vars-json <json>]
-  update    --marketplace-id <id> --display-name <name>
+  edit      --marketplace-id <id> --display-name <name>
   unlist    --marketplace-id <id> --force
   unpublish --marketplace-id <id> --version-id <id> --force
-  view      [--json]
-
-Installer Actions:
+  mine      [--json]
   search    [--query <text>] [--page <n>] [--limit <n>] [--json]
   view      --marketplace-id <id> [--json]
   install   --marketplace-id <id> --version-id <id> [--env-vars <k=v,...>] --force
@@ -44967,18 +45826,32 @@ Installer Actions:
   uninstall --skill-name <name> --force
   installed [--json]
 
+Template Actions:
+  create     --name <n> --display-name <n> [--description <text>] [--visibility public|private]
+  publish    --template-id <id> [--source-version <n>] [--changelog <text>] [--env-contract KEY=desc,...]
+  view       --template-id <id> [--version <n>] [--json]
+  versions   --template-id <id> [--json]
+  install    --template-id <id> [--version <n>] [--env-vars <k=v,...>] --force
+  apply      --template-id <id> [--version <n>] (--agents <a,b,c> | --file <path> | --all-installed) --force [--no-wait]
+  status     --template-id <id> [--json]
+  installed  [--json]
+  uninstall  --template-id <id> --force
+
 Examples:
-  $ lua marketplace                                              Interactive selection
-  $ lua marketplace create                                       Creator menu
-  $ lua marketplace install                                      Installer menu
-  $ lua marketplace create view                                  View my listed skills
-  $ lua marketplace create list --skill-name mySkill --display-name "My Skill"
-  $ lua marketplace create publish --marketplace-id xyz --version-id v1
-  $ lua marketplace create unlist --marketplace-id xyz --force
-  $ lua marketplace install search --query "CRM"
-  $ lua marketplace install view --marketplace-id xyz --json
-  $ lua marketplace install install --marketplace-id xyz --version-id v1 --force
-  $ lua marketplace install installed --json
+  $ lua marketplace                                                     Interactive domain selection
+  $ lua marketplace skill                                               Skill action menu
+  $ lua marketplace skill mine                                          View my listed skills
+  $ lua marketplace skill list --skill-name mySkill --display-name "My Skill"
+  $ lua marketplace skill publish --marketplace-id xyz --version-id v1
+  $ lua marketplace skill unlist --marketplace-id xyz --force
+  $ lua marketplace skill search --query "CRM"
+  $ lua marketplace skill view --marketplace-id xyz --json
+  $ lua marketplace skill install --marketplace-id xyz --version-id v1 --force
+  $ lua marketplace skill installed --json
+  $ lua marketplace template                                            Template action menu
+  $ lua marketplace template create --name support-bot --display-name "Support Bot"
+  $ lua marketplace template publish --template-id xyz --changelog "Add refund skill"
+  $ lua marketplace template apply --template-id xyz --all-installed --force
 `).action(marketplaceCommand);
 }
 __name(setupMarketplaceCommands, "setupMarketplaceCommands");
@@ -45121,20 +45994,16 @@ Examples:
   $ lua chat -b "Hello" "What is the weather?" "Tell me a joke" -d 2000 -e sandbox  Batch test
   $ lua chat --agent-version 3 -m "test"         Preview agent version 3 in an isolated thread
 `).action(chatCommand);
-  chatCmd.command("clear").description("Clear conversation history").option("--user <identifier>", "User ID, email, or mobile number of the user whose history to clear").option("-t, --thread <id>", "Clear a specific thread's history instead of all history").option("--force", "Skip confirmation prompt").addHelpText("after", `
+  chatCmd.command("clear").description("Clear your conversation history").option("--user <identifier>", "[removed] cross-user history clear is no longer supported").option("-t, --thread <id>", "Clear a specific thread's history instead of all history").option("--force", "Skip confirmation prompt").addHelpText("after", `
 Examples:
-  $ lua chat clear                                   Clear history
-  $ lua chat clear --force                           Clear history without confirmation
-  $ lua chat clear --user <userId>                   Clear user's history by user ID
-  $ lua chat clear --user <email>                    Clear user's history by email
-  $ lua chat clear --user <mobile>                   Clear user's history by mobile number
-  $ lua chat clear --user <userId> --force           Clear user's history without confirmation
+  $ lua chat clear                                   Clear your history
+  $ lua chat clear --force                           Clear your history without confirmation
   $ lua chat clear --thread <threadId>               Clear a specific thread's history
   $ lua chat clear --thread <threadId> --force       Clear a specific thread's history without confirmation
 
 Notes:
-  - User identifier can be UUID, email address, or mobile number
-  - Mobile numbers should be in international format without + (e.g., 919876543210)
+  - This command only clears YOUR OWN conversation history
+  - The --user option was removed: cross-user history clear is no longer supported
 `).action(chatClearCommand);
   program2.command("env [environment]").description("\u2699\uFE0F  Manage environment variables").option("-k, --key <name>", "Environment variable key").option("-v, --value <value>", "Environment variable value").option("-d, --delete", "Delete the specified key").option("--list", "List all environment variables").addHelpText("after", `
 Arguments:
@@ -45689,7 +46558,7 @@ if (isBareInvocation || isHelpInvocation) {
   });
 }
 var program = new Command();
-program.showSuggestionAfterError().name("lua").description("Lua AI - Build and deploy AI agents with superpowers").version(CLI_VERSION).option("--ci", "CI/CD mode: fail loudly on missing required flags instead of prompting").addHelpText("after", `
+program.showSuggestionAfterError().name("lua").description("Lua AI - Build and deploy AI agents with superpowers").version(CLI_VERSION, "-V, --cli-version").option("--ci", "CI/CD mode: fail loudly on missing required flags instead of prompting").addHelpText("after", `
 Categories:
   \u{1F510} Authentication    Manage API keys and authentication
   \u{1F680} Project Setup     Initialize and configure projects
@@ -45731,7 +46600,8 @@ Examples:
   $ lua evals              \u{1F4CA} Open evaluations dashboard
   $ lua docs               \u{1F4D6} Open documentation
   $ lua completion         \u{1F3AF} Enable shell autocomplete
-  $ lua marketplace        \u{1F6CD}\uFE0F Interact with the Lua Marketplace
+  $ lua marketplace        \u{1F6CD}\uFE0F Interact with the Lua Marketplace (skills & agent templates)
+  $ lua marketplace template \u{1F9E9} Create, publish, and apply marketplace agent templates
  
  \u{1F319} Documentation: https://docs.heylua.ai
  \u{1F319} Support: https://heylua.ai/support
@@ -45745,5 +46615,10 @@ program.hook("preAction", (thisCommand) => {
 setupAuthCommands(program);
 setupSkillCommands(program);
 setupMarketplaceCommands(program);
+var rawArgs = process.argv.slice(2);
+if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+  console.log(CLI_VERSION);
+  process.exit(0);
+}
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map