lua-cli 3.17.3 → 3.17.4

package/dist/index.js

@@ -5075,11 +5075,11 @@ var init_mcp_server_plugin = __esm({
 // ../shared-source-sync/dist/index.mjs
 import { createHash } from "crypto";
 import { extname } from "path";
-import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
 import { join as join4, sep } from "path";
 import { gunzipSync, gzipSync } from "zlib";
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync22, statSync as statSync22, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname4, join as join22, resolve, sep as sep2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync22, statSync as statSync22, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join22, resolve, sep as sep2 } from "path";
 import { mkdirSync as mkdirSync22, readdirSync as readdirSync22, readFileSync as readFileSync32, statSync as statSync3, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname22, join as join32, sep as sep3 } from "path";
 import { gunzipSync as gunzipSync2, gzipSync as gzipSync2 } from "zlib";
@@ -5139,7 +5139,7 @@ function walkWorkspace(rootDir, opts = {}) {
       if (stats.size > maxBytes) continue;
       let content;
       try {
-        content = readFileSync7(abs);
+        content = readFileSync6(abs);
       } catch {
         continue;
       }
@@ -5256,10 +5256,10 @@ function restoreFromBlobs(manifest, blobs, targetDir, opts = {}) {
         continue;
       }
     }
-    mkdirSync6(dirname4(targetPath), {
+    mkdirSync5(dirname3(targetPath), {
       recursive: true
     });
-    writeFileSync6(targetPath, content);
+    writeFileSync5(targetPath, content);
     filesWritten++;
   }
   return {
@@ -5454,12 +5454,12 @@ var init_dist2 = __esm({
         this.options = options;
         this.fetchFn = options.fetch ?? fetch;
       }
-      url(path19) {
+      url(path18) {
         const base = this.options.baseUrl.replace(/\/$/, "");
-        return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path19}`;
+        return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path18}`;
       }
-      async json(method, path19, body) {
-        const endpoint = this.url(path19);
+      async json(method, path18, body) {
+        const endpoint = this.url(path18);
         const res = await this.fetchFn(endpoint, {
           method,
           headers: {
@@ -5478,7 +5478,7 @@ var init_dist2 = __esm({
           } catch {
             text2 = void 0;
           }
-          throw new BackupHttpError(`Backup request failed: ${method} ${path19} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
+          throw new BackupHttpError(`Backup request failed: ${method} ${path18} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
         }
         const text = await res.text();
         if (!text) return void 0;
@@ -5545,16 +5545,16 @@ var init_dist2 = __esm({
 });
 
 // src/compiler/utils/common.ts
-import path4 from "path";
+import path3 from "path";
 function hashContent(content) {
   return hashContentTruncated(content);
 }
 function isInside(child, parent) {
-  const resolvedChild = path4.resolve(child);
-  const resolvedParent = path4.resolve(parent);
+  const resolvedChild = path3.resolve(child);
+  const resolvedParent = path3.resolve(parent);
   if (resolvedChild === resolvedParent) return true;
-  const rel = path4.relative(resolvedParent, resolvedChild);
-  return !!rel && !rel.startsWith("..") && !path4.isAbsolute(rel);
+  const rel = path3.relative(resolvedParent, resolvedChild);
+  return !!rel && !rel.startsWith("..") && !path3.isAbsolute(rel);
 }
 function classifyProjectFile(name) {
   if (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js")) {
@@ -5583,20 +5583,20 @@ var init_common = __esm({
 });
 
 // src/compiler/utils/path-resolver.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 function getTsConfigPathMappings(rootDir) {
-  const resolvedRoot = path5.resolve(rootDir);
+  const resolvedRoot = path4.resolve(rootDir);
   if (mappingsCache.has(resolvedRoot)) {
     return mappingsCache.get(resolvedRoot) ?? null;
   }
-  const tsconfigPath = path5.join(resolvedRoot, "tsconfig.json");
-  if (!fs4.existsSync(tsconfigPath)) {
+  const tsconfigPath = path4.join(resolvedRoot, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) {
     mappingsCache.set(resolvedRoot, null);
     return null;
   }
   try {
-    const tsconfigContent = fs4.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     const compilerOptions = tsconfig.compilerOptions || {};
     if (compilerOptions.paths) {
@@ -5623,7 +5623,7 @@ function resolvePathAlias(specifier, rootDir) {
     if (match) {
       const captured = match[1] || "";
       const targetPath = targets[0].replace("*", captured);
-      return path5.join(mappings.rootDir, mappings.baseUrl, targetPath);
+      return path4.join(mappings.rootDir, mappings.baseUrl, targetPath);
     }
   }
   return null;
@@ -5635,20 +5635,20 @@ function resolveModuleSpecifier(specifier, fromFile, rootDir) {
     return tryExtensions(aliasResolved);
   }
   if (normalized.startsWith("./") || normalized.startsWith("../")) {
-    const basePath = path5.resolve(path5.dirname(fromFile), normalized);
+    const basePath = path4.resolve(path4.dirname(fromFile), normalized);
     return tryExtensions(basePath);
   }
   return void 0;
 }
 function tryExtensions(basePath) {
   for (const ext of MODULE_EXTENSIONS) {
-    const full = ext.startsWith("/") ? path5.join(basePath, ext) : basePath + ext;
-    if (fs4.existsSync(full)) return full;
+    const full = ext.startsWith("/") ? path4.join(basePath, ext) : basePath + ext;
+    if (fs3.existsSync(full)) return full;
   }
   return void 0;
 }
 function registerProjectRootDir(project, rootDir) {
-  projectRootDirs.set(project, path5.resolve(rootDir));
+  projectRootDirs.set(project, path4.resolve(rootDir));
 }
 function getProjectRootDir(project) {
   return projectRootDirs.get(project);
@@ -6248,7 +6248,7 @@ var init_reference_resolver = __esm({
 });
 
 // src/compiler/plugins/skill.plugin.ts
-import fs5 from "fs/promises";
+import fs4 from "fs/promises";
 import { Node as Node11 } from "ts-morph";
 function findEnclosingVariableDeclaration(config) {
   let current = config.getParent();
@@ -6581,7 +6581,7 @@ var init_skill_plugin = __esm({
           description: metadata.description,
           metadata: this.sanitizeForPersistence(metadata.metadata)
         }, null, 2);
-        const originalSource = await fs5.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs4.readFile(metadata.sourcePath, "utf-8");
         return {
           code,
           sourceMap: "",
@@ -7380,10 +7380,10 @@ var init_device_trigger_plugin = __esm({
 });
 
 // src/compiler/utils/primitive-rewrite.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { Node as Node14, Project, ts as ts3 } from "ts-morph";
 function rewritePrimitiveSource(metadata, opts) {
-  const sourceCode = readFileSync9(metadata.sourcePath, "utf-8");
+  const sourceCode = readFileSync8(metadata.sourcePath, "utf-8");
   const localProject = new Project({
     useInMemoryFileSystem: true,
     compilerOptions: {
@@ -7722,7 +7722,7 @@ var init_cross_file_specs = __esm({
 });
 
 // src/compiler/plugins/voice.plugin.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import { Node as Node15 } from "ts-morph";
 function astObjectToPlain(obj) {
   const result = {};
@@ -8266,8 +8266,8 @@ var init_voice_plugin = __esm({
             }, "isMissingTopLevelRequired");
             for (const issue of parsed.error.issues) {
               if (isMissingTopLevelRequired(issue)) continue;
-              const path19 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-              errors.push(validationError(`Voice config invalid at \`${path19}\`: ${issue.message}`, {
+              const path18 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+              errors.push(validationError(`Voice config invalid at \`${path18}\`: ${issue.message}`, {
                 line
               }));
             }
@@ -8348,7 +8348,7 @@ var init_voice_plugin = __esm({
           description: metadata.description,
           metadata: sanitized
         }, null, 2);
-        const originalSource = await fs6.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs5.readFile(metadata.sourcePath, "utf-8");
         return {
           code,
           sourceMap: "",
@@ -8502,8 +8502,8 @@ var init_registry = __esm({
 });
 
 // src/compiler/bundler.ts
-import fs7 from "fs/promises";
-import path6 from "path";
+import fs6 from "fs/promises";
+import path5 from "path";
 import crypto4 from "crypto";
 import { build } from "esbuild";
 var Bundler;
@@ -8572,9 +8572,9 @@ var init_bundler = __esm({
       * Bundle a primitive's entry point using esbuild.
       */
       async bundle(metadata, entryPointCode) {
-        const tempDir = path6.join(this.options.outDir, ".temp");
-        const outfile = path6.join(tempDir, `${metadata.kind}-${metadata.name}.bundle.js`);
-        const sourceDir = path6.dirname(metadata.sourcePath);
+        const tempDir = path5.join(this.options.outDir, ".temp");
+        const outfile = path5.join(tempDir, `${metadata.kind}-${metadata.name}.bundle.js`);
+        const sourceDir = path5.dirname(metadata.sourcePath);
         if (this.options.debug) {
           this.verbose(`      Source: ${metadata.sourcePath}`);
           this.verbose(`      Output: ${outfile}`);
@@ -8604,15 +8604,15 @@ var init_bundler = __esm({
           ],
           logLevel: this.options.debug ? "debug" : "silent"
         });
-        const code = await fs7.readFile(outfile, "utf-8");
+        const code = await fs6.readFile(outfile, "utf-8");
         let sourceMap = "";
         try {
-          sourceMap = await fs7.readFile(outfile + ".map", "utf-8");
+          sourceMap = await fs6.readFile(outfile + ".map", "utf-8");
         } catch {
         }
-        const originalSource = await fs7.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs6.readFile(metadata.sourcePath, "utf-8");
         const hash = crypto4.createHash("sha256").update(code).digest("hex").slice(0, 16);
-        const stats = await fs7.stat(outfile);
+        const stats = await fs6.stat(outfile);
         return {
           code,
           sourceMap,
@@ -8629,14 +8629,14 @@ var init_bundler = __esm({
         const bundler = this;
         const sourcePath = metadata.sourcePath;
         const exportName = metadata.exportName;
-        const sourceDir = path6.dirname(sourcePath);
+        const sourceDir = path5.dirname(sourcePath);
         return {
           name: "lua-virtual-source",
           setup(build2) {
             build2.onResolve({
               filter: /.*/
             }, (args2) => {
-              const resolved = args2.path.startsWith(".") ? path6.resolve(args2.resolveDir, args2.path) : args2.path;
+              const resolved = args2.path.startsWith(".") ? path5.resolve(args2.resolveDir, args2.path) : args2.path;
               const normalizedResolved = resolved.replace(/\.(ts|tsx|js|jsx)$/, "");
               const normalizedSource = sourcePath.replace(/\.(ts|tsx|js|jsx)$/, "");
               if (normalizedResolved === normalizedSource) {
@@ -8652,8 +8652,8 @@ var init_bundler = __esm({
               namespace: "lua-virtual-source"
             }, async () => {
               const sourceFile = bundler.project.getSourceFile(sourcePath);
-              let content = sourceFile?.getText() ?? await fs7.readFile(sourcePath, "utf-8");
-              content = bundler.stripLuaCliImportsAST(content, path6.basename(sourcePath));
+              let content = sourceFile?.getText() ?? await fs6.readFile(sourcePath, "utf-8");
+              content = bundler.stripLuaCliImportsAST(content, path5.basename(sourcePath));
               const virtualContent = metadata.isDefaultExport ? content : `${content}
 export { ${exportName} as __lua_target__ };
 `;
@@ -8681,17 +8681,17 @@ export { ${exportName} as __lua_target__ };
               namespace: "file"
             }, async (args2) => {
               if (args2.path.includes("node_modules")) return null;
-              const contents = await fs7.readFile(args2.path, "utf-8");
+              const contents = await fs6.readFile(args2.path, "utf-8");
               if (!contents.includes("lua-cli") && !contents.includes("api-exports")) {
                 return null;
               }
               try {
-                const modifiedContents = stripImports(contents, path6.basename(args2.path));
+                const modifiedContents = stripImports(contents, path5.basename(args2.path));
                 if (modifiedContents !== contents) {
                   return {
                     contents: modifiedContents,
                     loader: args2.path.endsWith(".ts") || args2.path.endsWith(".tsx") ? "ts" : "js",
-                    resolveDir: path6.dirname(args2.path)
+                    resolveDir: path5.dirname(args2.path)
                   };
                 }
                 return null;
@@ -8728,8 +8728,8 @@ export { ${exportName} as __lua_target__ };
 
 // src/compiler/agent-traverser.ts
 import { Project as Project2, Node as Node16 } from "ts-morph";
-import path7 from "path";
-import fs8 from "fs";
+import path6 from "path";
+import fs7 from "fs";
 var PRIMITIVE_TYPES, AgentTraverser;
 var init_agent_traverser = __esm({
   "src/compiler/agent-traverser.ts"() {
@@ -8802,7 +8802,7 @@ var init_agent_traverser = __esm({
         this.rootDir = rootDir;
         this.debug = debug;
         this.project = new Project2({
-          tsConfigFilePath: path7.join(rootDir, "tsconfig.json"),
+          tsConfigFilePath: path6.join(rootDir, "tsconfig.json"),
           skipAddingFilesFromTsConfig: true
         });
         registerProjectRootDir(this.project, this.rootDir);
@@ -8886,15 +8886,15 @@ var init_agent_traverser = __esm({
       */
       detectAgent() {
         const priorityFiles = [
-          path7.join(this.rootDir, "index.ts"),
-          path7.join(this.rootDir, "src", "index.ts"),
-          path7.join(this.rootDir, "agent.ts"),
-          path7.join(this.rootDir, "src", "agent.ts"),
-          path7.join(this.rootDir, "main.ts"),
-          path7.join(this.rootDir, "src", "main.ts")
+          path6.join(this.rootDir, "index.ts"),
+          path6.join(this.rootDir, "src", "index.ts"),
+          path6.join(this.rootDir, "agent.ts"),
+          path6.join(this.rootDir, "src", "agent.ts"),
+          path6.join(this.rootDir, "main.ts"),
+          path6.join(this.rootDir, "src", "main.ts")
         ];
         for (const filePath of priorityFiles) {
-          if (fs8.existsSync(filePath)) {
+          if (fs7.existsSync(filePath)) {
             try {
               const sourceFile = this.project.addSourceFileAtPath(filePath);
               const agent = this.detectAgentInFile(sourceFile);
@@ -9046,7 +9046,7 @@ var init_agent_traverser = __esm({
             console.warn(formatSarifWarning({
               ruleId: "lua/missing-primitive-declaration",
               filePath: sourcePath,
-              message: `agent references ${kind} "${refName}" but ${path7.basename(sourcePath)} does not define a matching primitive`,
+              message: `agent references ${kind} "${refName}" but ${path6.basename(sourcePath)} does not define a matching primitive`,
               hint: `export a named ${plugin.displayName.toLowerCase()} declaration as "${refName}", or adjust the import so it points to the file that does`
             }));
             return null;
@@ -9066,20 +9066,20 @@ var init_agent_traverser = __esm({
 });
 
 // src/compiler/utils/workspace.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path7 from "path";
 function findWorkspaceRoot(rootDir) {
-  const resolvedInput = path8.resolve(rootDir);
+  const resolvedInput = path7.resolve(rootDir);
   const cached = workspaceRootCache.get(resolvedInput);
   if (cached !== void 0) return cached;
   let current = resolvedInput;
-  const { root } = path8.parse(current);
+  const { root } = path7.parse(current);
   while (true) {
     if (isWorkspaceRoot(current)) {
       workspaceRootCache.set(resolvedInput, current);
       return current;
     }
-    const parent = path8.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current || current === root) break;
     current = parent;
   }
@@ -9087,22 +9087,22 @@ function findWorkspaceRoot(rootDir) {
   return resolvedInput;
 }
 function isWorkspaceRoot(dir) {
-  if (fileExists(path8.join(dir, "pnpm-workspace.yaml"))) return true;
-  if (fileExists(path8.join(dir, "lerna.json"))) return true;
-  if (packageJsonHasWorkspaces(path8.join(dir, "package.json"))) return true;
-  if (dirExists(path8.join(dir, ".git"))) return true;
+  if (fileExists(path7.join(dir, "pnpm-workspace.yaml"))) return true;
+  if (fileExists(path7.join(dir, "lerna.json"))) return true;
+  if (packageJsonHasWorkspaces(path7.join(dir, "package.json"))) return true;
+  if (dirExists(path7.join(dir, ".git"))) return true;
   return false;
 }
 function fileExists(p) {
   try {
-    return fs9.statSync(p).isFile();
+    return fs8.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function dirExists(p) {
   try {
-    return fs9.statSync(p).isDirectory();
+    return fs8.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -9110,7 +9110,7 @@ function dirExists(p) {
 function packageJsonHasWorkspaces(pkgPath) {
   if (!fileExists(pkgPath)) return false;
   try {
-    const raw = fs9.readFileSync(pkgPath, "utf-8");
+    const raw = fs8.readFileSync(pkgPath, "utf-8");
     const json = JSON.parse(raw);
     if (!json.workspaces) return false;
     return Array.isArray(json.workspaces) || typeof json.workspaces === "object";
@@ -9132,8 +9132,8 @@ var init_workspace = __esm({
 });
 
 // src/compiler/compiler.ts
-import fs10 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path8 from "path";
 import { Project as Project3 } from "ts-morph";
 async function compile(options) {
   const compiler = new Compiler(options);
@@ -9186,7 +9186,7 @@ var init_compiler = __esm({
           ...options
         };
         this.project = new Project3({
-          tsConfigFilePath: path9.join(options.rootDir, "tsconfig.json")
+          tsConfigFilePath: path8.join(options.rootDir, "tsconfig.json")
         });
         registerProjectRootDir(this.project, this.options.rootDir);
         this.bundler = new Bundler({
@@ -9263,10 +9263,10 @@ var init_compiler = __esm({
             return await this.createResult(false, [], errors, warnings, startTime);
           }
           this.verbose("\u{1F4E6} Bundling primitives...");
-          await fs10.mkdir(this.options.outDir, {
+          await fs9.mkdir(this.options.outDir, {
             recursive: true
           });
-          await fs10.mkdir(path9.join(this.options.outDir, ".temp"), {
+          await fs9.mkdir(path8.join(this.options.outDir, ".temp"), {
             recursive: true
           });
           const CONCURRENCY = 4;
@@ -9286,7 +9286,7 @@ var init_compiler = __esm({
           this.verbose("\u{1F4BE} Writing artifacts...");
           await this.writeArtifacts(compiledPrimitives);
           if (!this.options.debug) {
-            await fs10.rm(path9.join(this.options.outDir, ".temp"), {
+            await fs9.rm(path8.join(this.options.outDir, ".temp"), {
               recursive: true,
               force: true
             });
@@ -9329,7 +9329,7 @@ var init_compiler = __esm({
       */
       getWorkspaceRoot() {
         if (this._workspaceRoot === void 0) {
-          this._workspaceRoot = findWorkspaceRoot(path9.resolve(this.options.rootDir));
+          this._workspaceRoot = findWorkspaceRoot(path8.resolve(this.options.rootDir));
         }
         return this._workspaceRoot;
       }
@@ -9343,18 +9343,18 @@ var init_compiler = __esm({
       *  - Files outside the detected workspace root (not our code)
       */
       collectExternalWorkspaceFiles(traverser) {
-        const rootDir = path9.resolve(this.options.rootDir);
+        const rootDir = path8.resolve(this.options.rootDir);
         const workspaceRoot = this.getWorkspaceRoot();
         if (workspaceRoot === rootDir) return [];
         const loaded = traverser.getAllLoadedSourceFilePaths();
         const result = [];
         const seen = /* @__PURE__ */ new Set();
         for (const raw of loaded) {
-          const abs = path9.resolve(raw);
+          const abs = path8.resolve(raw);
           if (seen.has(abs)) continue;
           seen.add(abs);
           if (isInside(abs, rootDir)) continue;
-          if (abs.includes(`${path9.sep}node_modules${path9.sep}`)) continue;
+          if (abs.includes(`${path8.sep}node_modules${path8.sep}`)) continue;
           if (!isInside(abs, workspaceRoot)) continue;
           result.push(abs);
         }
@@ -9487,9 +9487,9 @@ var init_compiler = __esm({
       * @param primitives - All compiled primitives to write
       */
       async writeArtifacts(primitives) {
-        const artifactsDir = path9.join(this.options.outDir, "artifacts");
-        const sourcesDir = path9.join(this.options.outDir, "sources");
-        await fs10.mkdir(sourcesDir, {
+        const artifactsDir = path8.join(this.options.outDir, "artifacts");
+        const sourcesDir = path8.join(this.options.outDir, "sources");
+        await fs9.mkdir(sourcesDir, {
           recursive: true
         });
         const writtenSources = /* @__PURE__ */ new Map();
@@ -9497,7 +9497,7 @@ var init_compiler = __esm({
         this.verbose("   \u{1F4C2} Collecting project files...");
         const projectFiles = await this.storeProjectFiles(sourcesDir, writtenSources);
         const manifest = await this.createManifest(primitives, projectFiles);
-        await fs10.writeFile(path9.join(this.options.outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+        await fs9.writeFile(path8.join(this.options.outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
         this.verbose(`   \u{1F4E6} Total files stored: ${writtenSources.size} (deduplicated)`);
         this.verbose(`   \u{1F4C1} Project files: ${projectFiles.length}`);
         if (this.options.verbose || this.options.debug) {
@@ -9509,25 +9509,25 @@ var init_compiler = __esm({
       */
       async writePrimitiveArtifacts(primitives, artifactsDir, sourcesDir, writtenSources) {
         for (const primitive of primitives) {
-          const primitiveDir = path9.join(artifactsDir, primitive.kind);
-          await fs10.mkdir(primitiveDir, {
+          const primitiveDir = path8.join(artifactsDir, primitive.kind);
+          await fs9.mkdir(primitiveDir, {
             recursive: true
           });
           const baseName = primitive.name;
-          await fs10.writeFile(path9.join(primitiveDir, `${baseName}.js`), primitive.artifact.code);
+          await fs9.writeFile(path8.join(primitiveDir, `${baseName}.js`), primitive.artifact.code);
           if (primitive.artifact.sourceMap) {
-            await fs10.writeFile(path9.join(primitiveDir, `${baseName}.js.map`), primitive.artifact.sourceMap);
+            await fs9.writeFile(path8.join(primitiveDir, `${baseName}.js.map`), primitive.artifact.sourceMap);
           }
           const sourceHash = hashContent(primitive.artifact.originalSource);
           if (!writtenSources.has(sourceHash)) {
             const ext = primitive.sourcePath.endsWith(".tsx") ? ".tsx" : ".ts";
-            await fs10.writeFile(path9.join(sourcesDir, `${sourceHash}${ext}`), primitive.artifact.originalSource);
-            const relativePath = path9.relative(this.options.rootDir, primitive.sourcePath);
+            await fs9.writeFile(path8.join(sourcesDir, `${sourceHash}${ext}`), primitive.artifact.originalSource);
+            const relativePath = path8.relative(this.options.rootDir, primitive.sourcePath);
             writtenSources.set(sourceHash, relativePath);
           }
           const sidecarPlugin = pluginRegistry.get(primitive.kind);
           const sidecarMetadata = sidecarPlugin?.sanitizeForPersistence ? sidecarPlugin.sanitizeForPersistence(primitive.metadata) : primitive.metadata;
-          await fs10.writeFile(path9.join(primitiveDir, `${baseName}.json`), JSON.stringify({
+          await fs9.writeFile(path8.join(primitiveDir, `${baseName}.json`), JSON.stringify({
             kind: primitive.kind,
             name: primitive.name,
             description: primitive.description,
@@ -9549,12 +9549,12 @@ var init_compiler = __esm({
         const allFiles = await this.collectProjectFiles();
         const workspaceRoot = this.getWorkspaceRoot();
         for (const file of allFiles) {
-          const absPath = file.external ? path9.join(workspaceRoot, file.relativePath) : path9.join(this.options.rootDir, file.relativePath);
-          const content = await fs10.readFile(absPath, "utf-8");
+          const absPath = file.external ? path8.join(workspaceRoot, file.relativePath) : path8.join(this.options.rootDir, file.relativePath);
+          const content = await fs9.readFile(absPath, "utf-8");
           const hash = hashContent(content);
           if (!writtenSources.has(hash)) {
-            const ext = path9.extname(file.relativePath) || ".txt";
-            await fs10.writeFile(path9.join(sourcesDir, `${hash}${ext}`), content);
+            const ext = path8.extname(file.relativePath) || ".txt";
+            await fs9.writeFile(path8.join(sourcesDir, `${hash}${ext}`), content);
             writtenSources.set(hash, file.relativePath);
           }
           projectFiles.push({
@@ -9630,12 +9630,12 @@ var init_compiler = __esm({
       async collectProjectFiles() {
         const files = [];
         const scanDir = /* @__PURE__ */ __name(async (dir, relativeBase = "") => {
-          const entries = await fs10.readdir(dir, {
+          const entries = await fs9.readdir(dir, {
             withFileTypes: true
           });
           for (const entry of entries) {
             const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
-            const fullPath = path9.join(dir, entry.name);
+            const fullPath = path8.join(dir, entry.name);
             if (entry.isDirectory()) {
               if (shouldSkipDirectory(entry.name)) continue;
               await scanDir(fullPath, relativePath);
@@ -9652,10 +9652,10 @@ var init_compiler = __esm({
         const workspaceRoot = this.getWorkspaceRoot();
         const externalSeen = /* @__PURE__ */ new Set();
         for (const abs of this.externalWorkspaceFiles) {
-          const rel = path9.relative(workspaceRoot, abs).split(path9.sep).join("/");
+          const rel = path8.relative(workspaceRoot, abs).split(path8.sep).join("/");
           if (!rel || rel.startsWith("..")) continue;
           if (externalSeen.has(rel)) continue;
-          const name = path9.basename(abs);
+          const name = path8.basename(abs);
           if (shouldSkipFile(rel) || shouldSkipFile(name)) continue;
           externalSeen.add(rel);
           files.push({
@@ -9756,13 +9756,13 @@ var init_compiler = __esm({
 });
 
 // src/compiler/utils/file-discovery.ts
-import path10 from "path";
-import fs11 from "fs";
+import path9 from "path";
+import fs10 from "fs";
 function findEntryPoint(projectDir) {
   const baseDir = projectDir || process.cwd();
   for (const relativePath of ENTRY_POINT_PRIORITY) {
-    const fullPath = path10.join(baseDir, relativePath);
-    if (fs11.existsSync(fullPath)) {
+    const fullPath = path9.join(baseDir, relativePath);
+    if (fs10.existsSync(fullPath)) {
       return fullPath;
     }
   }
@@ -9799,8 +9799,8 @@ var init_file_discovery = __esm({
 
 // src/compiler/source-writer.ts
 import { Project as Project4, Node as Node17 } from "ts-morph";
-import fs12 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path10 from "path";
 function resolveEntryPath(options) {
   let indexPath;
   try {
@@ -9812,14 +9812,14 @@ function resolveEntryPath(options) {
         indexPath = entryPoint;
       } else {
         const baseDir = options?.projectDir || process.cwd();
-        indexPath = path11.join(baseDir, "src", "index.ts");
+        indexPath = path10.join(baseDir, "src", "index.ts");
       }
     }
   } catch {
     const baseDir = options?.projectDir || process.cwd();
-    indexPath = path11.join(baseDir, "src", "index.ts");
+    indexPath = path10.join(baseDir, "src", "index.ts");
   }
-  if (!fs12.existsSync(indexPath)) {
+  if (!fs11.existsSync(indexPath)) {
     console.warn(`Warning: Entry file not found at ${indexPath}`);
     return null;
   }
@@ -13809,164 +13809,6 @@ __name(promptAuthMethod, "promptAuthMethod");
 
 // src/commands/configure.ts
 init_analytics();
-
-// src/utils/versioning-mode-cache.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-
-// src/api/agent-version.api.service.ts
-init_http_client();
-var AgentVersionApi = class extends HttpClient {
-  static {
-    __name(this, "AgentVersionApi");
-  }
-  apiKey;
-  agentId;
-  constructor(baseUrl, apiKey, agentId) {
-    super(baseUrl);
-    this.apiKey = apiKey;
-    this.agentId = agentId;
-  }
-  get basePath() {
-    return `/developer/agents/${encodeURIComponent(this.agentId)}`;
-  }
-  get authHeader() {
-    return {
-      Authorization: `Bearer ${this.apiKey}`
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Versioning mode
-  // ---------------------------------------------------------------------------
-  async getVersioningMode() {
-    return this.httpGet(`${this.basePath}/versioning/mode`, this.authHeader);
-  }
-  // ---------------------------------------------------------------------------
-  // Version CRUD
-  // ---------------------------------------------------------------------------
-  async createVersion(body) {
-    return this.httpPost(`${this.basePath}/versions`, body, this.authHeader);
-  }
-  async listVersions(query) {
-    const params = new URLSearchParams();
-    if (query?.all !== void 0) params.append("all", String(query.all));
-    if (query?.limit !== void 0) params.append("limit", String(query.limit));
-    if (query?.status !== void 0) params.append("status", query.status);
-    const qs = params.toString();
-    const url = qs ? `${this.basePath}/versions?${qs}` : `${this.basePath}/versions`;
-    return this.httpGet(url, this.authHeader);
-  }
-  async getVersion(version) {
-    return this.httpGet(`${this.basePath}/versions/${version}`, this.authHeader);
-  }
-  async deleteVersion(version) {
-    return this.httpDelete(`${this.basePath}/versions/${version}`, this.authHeader);
-  }
-  // ---------------------------------------------------------------------------
-  // Diff
-  // ---------------------------------------------------------------------------
-  async diffVersions(from, to) {
-    const url = `${this.basePath}/versions/diff?from=${from}&to=${to}`;
-    return this.httpGet(url, this.authHeader);
-  }
-  // ---------------------------------------------------------------------------
-  // Promote
-  // ---------------------------------------------------------------------------
-  async promoteVersion(version) {
-    return this.httpPost(`${this.basePath}/versions/${version}/promote`, {}, this.authHeader);
-  }
-  // ---------------------------------------------------------------------------
-  // Patch commit hash — called by `lua version create` after a successful git
-  // commit + tag to propagate the SHA to the backend AgentVersion record.
-  // Failure is non-fatal; the version snapshot is valid whether or not this
-  // PATCH lands.
-  // ---------------------------------------------------------------------------
-  async patchCommitHash(version, commitHash) {
-    return this.httpPatch(`${this.basePath}/versions/${version}/commit-hash`, {
-      commitHash
-    }, this.authHeader);
-  }
-};
-
-// src/utils/versioning-mode-cache.ts
-init_constants();
-init_auth_error();
-init_constants();
-var CACHE_TTL_MS = 60 * 60 * 1e3;
-function readCacheFile() {
-  try {
-    const raw = fs3.readFileSync(CLI_CACHE_FILE, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-__name(readCacheFile, "readCacheFile");
-function writeCacheFile(data) {
-  try {
-    fs3.mkdirSync(path3.dirname(CLI_CACHE_FILE), {
-      recursive: true
-    });
-    fs3.writeFileSync(CLI_CACHE_FILE, JSON.stringify(data, null, 2));
-  } catch {
-  }
-}
-__name(writeCacheFile, "writeCacheFile");
-function isFresh(entry) {
-  const age = Date.now() - new Date(entry.cachedAt).getTime();
-  return age >= 0 && age < CACHE_TTL_MS;
-}
-__name(isFresh, "isFresh");
-async function getVersioningModeCached(apiKey, agentId) {
-  const file = readCacheFile();
-  const existing = file.versioningMode?.[agentId];
-  if (existing && isFresh(existing)) {
-    return {
-      enabled: existing.enabled
-    };
-  }
-  try {
-    const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
-    const response = await api.getVersioningMode();
-    if (!response.success || !response.data) {
-      if (existing) return {
-        enabled: existing.enabled
-      };
-      return {
-        enabled: false
-      };
-    }
-    const enabled = response.data.enabled === true;
-    file.versioningMode = file.versioningMode ?? {};
-    file.versioningMode[agentId] = {
-      enabled,
-      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeCacheFile(file);
-    return {
-      enabled
-    };
-  } catch (err) {
-    if (err instanceof AuthenticationError) throw err;
-    if (err instanceof Error && /access denied|forbidden|403|401/i.test(err.message)) throw err;
-    if (existing) return {
-      enabled: existing.enabled
-    };
-    return {
-      enabled: false
-    };
-  }
-}
-__name(getVersioningModeCached, "getVersioningModeCached");
-function invalidateVersioningModeCache() {
-  const file = readCacheFile();
-  if (!file.versioningMode) return;
-  delete file.versioningMode;
-  writeCacheFile(file);
-}
-__name(invalidateVersioningModeCache, "invalidateVersioningModeCache");
-
-// src/commands/configure.ts
 async function configureCommand(options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, email, otp } = options;
@@ -13976,13 +13818,11 @@ async function configureCommand(options = {}) {
       authMethod = "api-key";
       nonInteractive = true;
       await handleApiKeyAuthNonInteractive(apiKey);
-      invalidateVersioningModeCache();
     } else if (email) {
       authMethod = "email";
       nonInteractive = true;
       if (otp) {
         await handleEmailOtpVerify(email, otp);
-        invalidateVersioningModeCache();
       } else {
         await handleEmailOtpRequest(email);
       }
@@ -13991,10 +13831,8 @@ async function configureCommand(options = {}) {
       clearPromptLines(2);
       if (authMethod === "api-key") {
         await handleApiKeyAuth();
-        invalidateVersioningModeCache();
       } else if (authMethod === "email") {
         await handleEmailAuth();
-        invalidateVersioningModeCache();
       }
     }
     trackEvent("cli_auth_completed", {
@@ -14666,8 +14504,8 @@ init_compile_constants();
 init_artifact_loader();
 init_backup_api_service();
 init_constants();
-import fs13 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path11 from "path";
 var BACKUP_CACHE_FILENAME = "backup-manifest.json";
 function calculateProjectHash(projectFiles) {
   return combineFileHashes(projectFiles);
@@ -14680,11 +14518,11 @@ function getCurrentProjectHash(projectPath = process.cwd()) {
 }
 __name(getCurrentProjectHash, "getCurrentProjectHash");
 function loadSourceByHash(hash, relativePath, projectPath = process.cwd()) {
-  const sourcesDir = path12.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
-  const ext = path12.extname(relativePath) || ".txt";
-  const sourcePath = path12.join(sourcesDir, `${hash}${ext}`);
-  if (fs13.existsSync(sourcePath)) {
-    return fs13.readFileSync(sourcePath, "utf-8");
+  const sourcesDir = path11.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
+  const ext = path11.extname(relativePath) || ".txt";
+  const sourcePath = path11.join(sourcesDir, `${hash}${ext}`);
+  if (fs12.existsSync(sourcePath)) {
+    return fs12.readFileSync(sourcePath, "utf-8");
   }
   return null;
 }
@@ -14703,30 +14541,30 @@ function prepareFileRefs(projectPath = process.cwd()) {
 }
 __name(prepareFileRefs, "prepareFileRefs");
 function reconcileManifestWithDisk(projectPath = process.cwd()) {
-  const manifestPath = path12.join(projectPath, COMPILE_DIRS.DIST_V2, "manifest.json");
-  if (!fs13.existsSync(manifestPath)) return;
+  const manifestPath = path11.join(projectPath, COMPILE_DIRS.DIST_V2, "manifest.json");
+  if (!fs12.existsSync(manifestPath)) return;
   const manifest = loadManifest(projectPath);
-  const sourcesDir = path12.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
-  fs13.mkdirSync(sourcesDir, {
+  const sourcesDir = path11.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
+  fs12.mkdirSync(sourcesDir, {
     recursive: true
   });
   let changed = false;
   for (const file of manifest.projectFiles) {
     if (file.external) continue;
-    const absPath = path12.join(projectPath, file.relativePath);
-    if (!fs13.existsSync(absPath)) continue;
+    const absPath = path11.join(projectPath, file.relativePath);
+    if (!fs12.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs13.readFileSync(absPath, "utf-8");
+      content = fs12.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
     const freshHash = hashContent(content);
     if (freshHash === file.hash) continue;
-    const ext = path12.extname(file.relativePath) || ".txt";
-    const sourceTargetPath = path12.join(sourcesDir, `${freshHash}${ext}`);
+    const ext = path11.extname(file.relativePath) || ".txt";
+    const sourceTargetPath = path11.join(sourcesDir, `${freshHash}${ext}`);
     try {
-      fs13.writeFileSync(sourceTargetPath, content, "utf-8");
+      fs12.writeFileSync(sourceTargetPath, content, "utf-8");
     } catch {
       continue;
     }
@@ -14735,7 +14573,7 @@ function reconcileManifestWithDisk(projectPath = process.cwd()) {
     changed = true;
   }
   if (changed) {
-    fs13.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 }
 __name(reconcileManifestWithDisk, "reconcileManifestWithDisk");
@@ -14808,7 +14646,7 @@ function checkRestoreConflicts(manifest, targetDir) {
   const existingFiles = [];
   for (const file of manifest.files) {
     const filePath = resolveBackupFileTarget2(file, targetDir);
-    if (fs13.existsSync(filePath)) {
+    if (fs12.existsSync(filePath)) {
       existingFiles.push(file.relativePath);
     } else {
       newFiles.push(file.relativePath);
@@ -14834,16 +14672,16 @@ function createBackupTracking(projectHash) {
 }
 __name(createBackupTracking, "createBackupTracking");
 function getBackupCachePath(projectPath = process.cwd()) {
-  return path12.join(projectPath, ".lua", BACKUP_CACHE_FILENAME);
+  return path11.join(projectPath, ".lua", BACKUP_CACHE_FILENAME);
 }
 __name(getBackupCachePath, "getBackupCachePath");
 function writeBackupManifestCache(cache, projectPath = process.cwd()) {
   const cachePath = getBackupCachePath(projectPath);
   try {
-    fs13.mkdirSync(path12.dirname(cachePath), {
+    fs12.mkdirSync(path11.dirname(cachePath), {
       recursive: true
     });
-    fs13.writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+    fs12.writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.warn(`Could not write backup manifest cache: ${message}`);
@@ -14852,9 +14690,9 @@ function writeBackupManifestCache(cache, projectPath = process.cwd()) {
 __name(writeBackupManifestCache, "writeBackupManifestCache");
 function readBackupManifestCache(projectPath = process.cwd()) {
   const cachePath = getBackupCachePath(projectPath);
-  if (!fs13.existsSync(cachePath)) return null;
+  if (!fs12.existsSync(cachePath)) return null;
   try {
-    const raw = fs13.readFileSync(cachePath, "utf-8");
+    const raw = fs12.readFileSync(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.lastHash !== "string" || typeof parsed.lastPushedAt !== "string" || !Array.isArray(parsed.files) || !parsed.files.every((f) => f && typeof f.relativePath === "string" && typeof f.hash === "string")) {
       return null;
@@ -14881,18 +14719,18 @@ function detectLocalConflictsForPull(incomingFiles, projectPath = process.cwd())
     f.hash
   ]));
   const conflicts = /* @__PURE__ */ new Set();
-  const projectRoot = path12.resolve(projectPath);
+  const projectRoot = path11.resolve(projectPath);
   for (const incoming of incomingFiles) {
     if (COMPILE_MANAGED_FILES.has(incoming.relativePath)) continue;
     if (incoming.external) continue;
-    const absPath = path12.resolve(projectRoot, incoming.relativePath);
-    if (absPath !== projectRoot && !absPath.startsWith(projectRoot + path12.sep)) {
+    const absPath = path11.resolve(projectRoot, incoming.relativePath);
+    if (absPath !== projectRoot && !absPath.startsWith(projectRoot + path11.sep)) {
       continue;
     }
-    if (!fs13.existsSync(absPath)) continue;
+    if (!fs12.existsSync(absPath)) continue;
     let diskHash;
     try {
-      const bytes = fs13.readFileSync(absPath, "utf-8");
+      const bytes = fs12.readFileSync(absPath, "utf-8");
       diskHash = hashContent(bytes);
     } catch {
       conflicts.add(incoming.relativePath);
@@ -15071,17 +14909,17 @@ function writeBackupFilesWithByteCompare(manifest, blobs, targetDir) {
     }
     restoredContents.set(makeRestoredContentsKey(file), content);
     const filePath = resolveBackupFileTarget2(file, targetDir);
-    if (fs13.existsSync(filePath)) {
-      const existing = fs13.readFileSync(filePath);
+    if (fs12.existsSync(filePath)) {
+      const existing = fs12.readFileSync(filePath);
       if (existing.equals(content)) {
         filesUnchanged++;
         continue;
       }
     }
-    fs13.mkdirSync(path12.dirname(filePath), {
+    fs12.mkdirSync(path11.dirname(filePath), {
       recursive: true
     });
-    fs13.writeFileSync(filePath, content);
+    fs12.writeFileSync(filePath, content);
     filesWritten++;
   }
   return {
@@ -16895,7 +16733,6 @@ async function destroyCommand(options) {
     if (options?.force) {
       const deleted2 = deleteApiKey();
       if (deleted2) {
-        invalidateVersioningModeCache();
         writeSuccess("\u2705 API key deleted successfully.");
       } else {
         writeProgress("\u274C Failed to delete API key.");
@@ -16921,7 +16758,6 @@ async function destroyCommand(options) {
     if (confirm) {
       deleted = deleteApiKey();
       if (deleted) {
-        invalidateVersioningModeCache();
         writeSuccess("\u2705 API key deleted successfully.");
       } else {
         writeProgress("\u274C Failed to delete API key.");
@@ -16992,13 +16828,13 @@ __name(apiKeyCommand, "apiKeyCommand");
 init_cli();
 init_files();
 init_auth();
-import path14 from "path";
+import path13 from "path";
 
 // src/commands/sync.ts
 init_dist();
 init_cli();
-import fs14 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path12 from "path";
 
 // src/utils/prompt-handler.ts
 init_cli();
@@ -17221,8 +17057,8 @@ init_mcp_server_handler();
 async function syncCommand(options) {
   return withErrorHandling(async () => {
     const preCompileYaml = readYamlConfig();
-    const yamlPath = path13.resolve(process.cwd(), "lua.skill.yaml");
-    const preCompileYamlBytes = fs14.existsSync(yamlPath) ? fs14.readFileSync(yamlPath, "utf-8") : null;
+    const yamlPath = path12.resolve(process.cwd(), "lua.skill.yaml");
+    const preCompileYamlBytes = fs13.existsSync(yamlPath) ? fs13.readFileSync(yamlPath, "utf-8") : null;
     let syncCompletedSuccessfully = false;
     try {
       writeProgress("\u{1F504} Compiling to get latest local state...");
@@ -17283,7 +17119,7 @@ async function syncCommand(options) {
     } finally {
       if (!syncCompletedSuccessfully && preCompileYamlBytes !== null) {
         try {
-          fs14.writeFileSync(yamlPath, preCompileYamlBytes, "utf-8");
+          fs13.writeFileSync(yamlPath, preCompileYamlBytes, "utf-8");
         } catch {
         }
       }
@@ -18841,7 +18677,7 @@ async function compileCommand(options) {
     }
     writeProgress("\u{1F528} Compiling...");
     const rootDir = process.cwd();
-    const outDir = path14.join(rootDir, "dist-v2");
+    const outDir = path13.join(rootDir, "dist-v2");
     const result = await compile({
       rootDir,
       outDir,
@@ -19005,12 +18841,12 @@ init_command_utils();
 
 // src/utils/sandbox.ts
 import vm3 from "vm";
-import path17 from "path";
+import path16 from "path";
 
 // ../shared-sandbox/dist/index.mjs
 import vm from "vm";
 import { createRequire } from "module";
-import path15 from "path";
+import path14 from "path";
 import dns from "dns";
 import net from "net";
 import { promisify } from "util";
@@ -19180,7 +19016,7 @@ var REQUIRE_BLOCKLIST = /* @__PURE__ */ new Set([
 var SANDBOX_FAKE_DIRNAME = "/";
 var SANDBOX_FAKE_FILENAME = "/index.ts";
 function buildSandboxRequire(opts) {
-  const realRequire = createRequire(path15.join(opts.cwd, "package.json"));
+  const realRequire = createRequire(path14.join(opts.cwd, "package.json"));
   const wrapped = /* @__PURE__ */ __name4((id) => {
     if (REQUIRE_BLOCKLIST.has(id)) {
       const evt = {
@@ -19850,14 +19686,14 @@ __name(runBundleInContext, "runBundleInContext");
 __name4(runBundleInContext, "runBundleInContext");
 
 // src/utils/env-loader.utils.ts
-import path16 from "path";
-import fs15 from "fs";
+import path15 from "path";
+import fs14 from "fs";
 function parseEnvFile(filePath) {
-  if (!fs15.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     return {};
   }
   try {
-    const content = fs15.readFileSync(filePath, "utf8");
+    const content = fs14.readFileSync(filePath, "utf8");
     if (!content.trim()) return {};
     const envVars = {};
     content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).forEach((line) => {
@@ -19883,7 +19719,7 @@ async function loadEnvironmentVariables(context) {
 }
 __name(loadEnvironmentVariables, "loadEnvironmentVariables");
 function loadSandboxEnvVariables() {
-  const envFilePath = path16.join(process.cwd(), ".env");
+  const envFilePath = path15.join(process.cwd(), ".env");
   const envMap = parseEnvFile(envFilePath);
   return Object.entries(envMap).map(([key, value]) => ({
     key,
@@ -19978,7 +19814,7 @@ function loadEnvironmentVariables2() {
       envVars[key] = value;
     }
   }
-  const envFilePath = path17.join(process.cwd(), ".env");
+  const envFilePath = path16.join(process.cwd(), ".env");
   const fileEnvVars = parseEnvFile(envFilePath);
   Object.assign(envVars, fileEnvVars);
   return envVars;
@@ -21864,7 +21700,6 @@ init_dist();
 init_files();
 init_cli();
 init_command_utils();
-init_auth();
 init_semver();
 init_auth_error();
 init_constants();
@@ -21992,8 +21827,8 @@ async function runBackupPush(opts) {
 }
 __name(runBackupPush, "runBackupPush");
 async function uploadBlobsFromDisk(uploadUrls, files, projectPath, concurrency = 10) {
-  const fs17 = await import("fs");
-  const path19 = await import("path");
+  const fs16 = await import("fs");
+  const path18 = await import("path");
   const zlib2 = await import("zlib");
   const hashToPath = /* @__PURE__ */ new Map();
   for (const f of files) {
@@ -22007,8 +21842,8 @@ async function uploadBlobsFromDisk(uploadUrls, files, projectPath, concurrency =
       if (!rel) {
         throw new Error(`No file found for hash: ${hash}`);
       }
-      const abs = path19.join(projectPath, rel);
-      const content = fs17.readFileSync(abs);
+      const abs = path18.join(projectPath, rel);
+      const content = fs16.readFileSync(abs);
       const compressed = zlib2.gzipSync(content);
       const response = await fetch(uploadUrls[hash], {
         method: "PUT",
@@ -22266,11 +22101,11 @@ init_cli();
 
 // src/utils/git-auth-store.ts
 init_constants();
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname6 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5 } from "path";
 function readStore() {
   try {
-    const raw = readFileSync10(AUTH_STORAGE_FILE, "utf8");
+    const raw = readFileSync9(AUTH_STORAGE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       providers: parsed.providers ?? {}
@@ -22283,10 +22118,10 @@ function readStore() {
 }
 __name(readStore, "readStore");
 function writeStore(store) {
-  mkdirSync7(dirname6(AUTH_STORAGE_FILE), {
+  mkdirSync6(dirname5(AUTH_STORAGE_FILE), {
     recursive: true
   });
-  writeFileSync7(AUTH_STORAGE_FILE, JSON.stringify(store, null, 2), {
+  writeFileSync6(AUTH_STORAGE_FILE, JSON.stringify(store, null, 2), {
     mode: 384
   });
 }
@@ -23050,15 +22885,9 @@ async function pushCommand(type, cmdObj) {
         allowAll: true
       });
     }
-    const earlyApiKey = loadApiKey();
-    const earlyConfig = readYamlConfig();
-    const earlyAgentId = earlyConfig?.agent?.agentId;
-    const versioning = earlyApiKey && earlyAgentId ? await getVersioningModeCached(earlyApiKey, earlyAgentId) : {
-      enabled: false
-    };
-    const isStageAll = !type && versioning.enabled;
-    const isGranular = Boolean(type && type !== "all" && versioning.enabled);
-    const isAutoDeployNoOp = versioning.enabled && (type === "all" || !type) && Boolean(options.autoDeploy);
+    const isStageAll = !type;
+    const isGranular = Boolean(type && type !== "all");
+    const isAutoDeployNoOp = (type === "all" || !type) && Boolean(options.autoDeploy);
     if (isAutoDeployNoOp) {
       writeInfo("\u26A0\uFE0F  --auto-deploy is ignored when agent versioning is on. Use `lua version promote <version>` after `lua version create`.");
       options.autoDeploy = false;
@@ -23090,64 +22919,7 @@ async function pushCommand(type, cmdObj) {
         autoDeployNoopWarned: isAutoDeployNoOp
       });
     }
-    if (type) {
-      selectedType = type;
-    } else {
-      const typeAnswer = await safePrompt([
-        {
-          type: "list",
-          name: "type",
-          message: "What would you like to push?",
-          choices: [
-            {
-              name: "\u{1F6E0}\uFE0F  Skill",
-              value: "skill"
-            },
-            {
-              name: "\u{1FA9D} Webhook",
-              value: "webhook"
-            },
-            {
-              name: "\u23F0 Job",
-              value: "job"
-            },
-            {
-              name: "\u{1F4E5} PreProcessor",
-              value: "preprocessor"
-            },
-            {
-              name: "\u{1F4E4} PostProcessor",
-              value: "postprocessor"
-            },
-            {
-              name: "\u{1F50C} MCP Server",
-              value: "mcp"
-            },
-            {
-              name: "\u{1F4E1} Device",
-              value: "device"
-            },
-            {
-              name: "\u{1F4E1} Device Trigger",
-              value: "device-trigger"
-            },
-            {
-              name: "\u{1F916} Agent (persona, model)",
-              value: "agent"
-            },
-            {
-              name: "\u{1F4BE} Backup (source files)",
-              value: "backup"
-            }
-          ]
-        }
-      ]);
-      if (!typeAnswer) {
-        console.log("Push cancelled.");
-        return;
-      }
-      selectedType = typeAnswer.type;
-    }
+    selectedType = type;
     if (selectedType === "skill") {
       versionedPushDeployResult = await pushVersionedPrimitive(skillHandler, options);
     } else if (selectedType === "webhook") {
@@ -23237,7 +23009,7 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
       include_source_attached: trackedIncludeSource?.attached ?? 0,
       include_source_failed: trackedIncludeSource?.failed ?? 0,
       // Agent-versioning telemetry. Driven by isStageAll / isGranular.
-      versioning_mode: versioning.enabled ? isGranular ? "granular" : "all" : "flag-off",
+      versioning_mode: isGranular ? "granular" : "all",
       granular_deprecation_warned: isGranular,
       auto_deploy_noop_warned: isAutoDeployNoOp
     });
@@ -23532,7 +23304,6 @@ async function pushAllCommand(options) {
   }
   const apiKey = await requireAuthOrExit(false);
   const agentId = config.agent.agentId;
-  const pushAllVersioning = await getVersioningModeCached(apiKey, agentId);
   let manifest;
   try {
     manifest = loadManifest();
@@ -23838,7 +23609,7 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
     include_source_attached: includeSourceStats?.attached ?? 0,
     include_source_failed: includeSourceStats?.failed ?? 0,
     // Agent-versioning telemetry.
-    versioning_mode: pushAllVersioning.enabled ? "stage-all" : "flag-off",
+    versioning_mode: "stage-all",
     granular_deprecation_warned: false,
     auto_deploy_noop_warned: options.autoDeployNoopWarned || false
   });
@@ -23856,42 +23627,8 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
   });
   if (variant === "success") {
     console.log("");
-    if (pushAllVersioning.enabled) {
-      if (!options.suppressVersionCreateHint) {
-        writeInfo(`Run \`lua version create [-m "<message>"]\` to snapshot the staged state into a named version, then \`lua version promote <version>\` to deploy.`);
-      }
-    } else if (options.autoDeploy) {
-      writeHintBlock({
-        headline: "All deployed. Generate test traffic first, then inspect:",
-        lines: [
-          {
-            label: "Test:",
-            command: 'lua chat -e production -m "your test message"'
-          },
-          {
-            label: "Inspect:",
-            command: buildLogsCommand({
-              limit: 10
-            })
-          }
-        ],
-        when: "success"
-      });
-    } else {
-      writeHintBlock({
-        headline: "Code staged but NOT live. Make it active:",
-        lines: [
-          {
-            label: "Deploy all:",
-            command: "lua deploy all --force"
-          },
-          {
-            label: "Or re-push:",
-            command: "lua push all --force --auto-deploy"
-          }
-        ],
-        when: "success"
-      });
+    if (!options.suppressVersionCreateHint) {
+      writeInfo(`Run \`lua version create [-m "<message>"]\` to snapshot the staged state into a named version, then \`lua version promote <version>\` to deploy.`);
     }
   } else if (variant === "partial") {
     console.log("");
@@ -24128,10 +23865,7 @@ async function deployCommand(type, cmdObj) {
       selectedType = answer.type;
     }
     const apiKey = await requireAuthOrExit();
-    const versioning = await getVersioningModeCached(apiKey, agentId);
-    if (versioning.enabled) {
-      writeInfo("\u26A0\uFE0F  `lua deploy` is deprecated when agent versioning is on. Use `lua version promote <version>` for instant, atomic promotion.");
-    }
+    writeInfo("\u26A0\uFE0F  `lua deploy` is deprecated when agent versioning is on. Use `lua version promote <version>` for instant, atomic promotion.");
     let personaDeployed = false;
     let versionedOutcome = null;
     if (selectedType === "persona") {
@@ -24145,7 +23879,7 @@ async function deployCommand(type, cmdObj) {
       force_mode: options.force || false,
       entity_selected_by_name: !!options.name,
       version_selected_by_flag: !!options.version,
-      granular_deprecation_warned: versioning.enabled
+      granular_deprecation_warned: true
     });
     const deployed = selectedType === "persona" ? personaDeployed : versionedOutcome?.deployed ?? false;
     const hintPrintedAlready = selectedType !== "persona" && !!versionedOutcome?.hintPrinted;
@@ -24639,11 +24373,11 @@ init_cli();
 
 // src/utils/sandbox-storage.ts
 init_constants();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname7 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname6 } from "path";
 function readStore2() {
   try {
-    const raw = readFileSync11(SANDBOX_STORAGE_FILE, "utf8");
+    const raw = readFileSync10(SANDBOX_STORAGE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       skills: parsed.skills ?? {},
@@ -24663,10 +24397,10 @@ function readStore2() {
 __name(readStore2, "readStore");
 function writeStore2(store) {
   try {
-    mkdirSync8(dirname7(SANDBOX_STORAGE_FILE), {
+    mkdirSync7(dirname6(SANDBOX_STORAGE_FILE), {
       recursive: true
     });
-    writeFileSync8(SANDBOX_STORAGE_FILE, JSON.stringify(store, null, 2), "utf8");
+    writeFileSync7(SANDBOX_STORAGE_FILE, JSON.stringify(store, null, 2), "utf8");
   } catch {
   }
 }
@@ -25988,8 +25722,8 @@ init_cli();
 init_constants();
 init_command_utils();
 init_developer_api_service();
-import fs16 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path17 from "path";
 import inquirer10 from "inquirer";
 init_analytics();
 function resolveEnvironment(env, hasNonInteractiveFlags) {
@@ -26348,10 +26082,10 @@ function variablesToEnvContent(variables) {
 }
 __name(variablesToEnvContent, "variablesToEnvContent");
 function saveSandboxEnvVariables(variables) {
-  const envFilePath = path18.join(process.cwd(), ".env");
+  const envFilePath = path17.join(process.cwd(), ".env");
   try {
     const content = variablesToEnvContent(variables);
-    fs16.writeFileSync(envFilePath, content, "utf8");
+    fs15.writeFileSync(envFilePath, content, "utf8");
     return true;
   } catch (error) {
     console.error("\u274C Error saving .env file:", error);
@@ -30166,13 +29900,8 @@ init_command_utils();
 
 // src/utils/primitive-version-display.ts
 var PRIMITIVE_VERSION_HISTORY_NOTE = "\u2139\uFE0F  Primitive versions are managed by agent versioning. Run `lua version list` to view agent versions.";
-async function shouldHidePrimitiveVersions(apiKey, agentId) {
-  try {
-    const { enabled } = await getVersioningModeCached(apiKey, agentId);
-    return enabled;
-  } catch {
-    return false;
-  }
+async function shouldHidePrimitiveVersions(_apiKey, _agentId) {
+  return true;
 }
 __name(shouldHidePrimitiveVersions, "shouldHidePrimitiveVersions");
 var DIVIDER = "=".repeat(60);
@@ -30889,7 +30618,7 @@ init_auth();
 init_auth_api_service();
 init_files();
 init_artifact_loader();
-import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync11 } from "fs";
 import { join as join6 } from "path";
 import { performance } from "perf_hooks";
 import * as os from "os";
@@ -31240,7 +30969,7 @@ function gatherTelemetry() {
   } else {
     try {
       if (existsSync7(TELEMETRY_FILE)) {
-        const raw = readFileSync12(TELEMETRY_FILE, "utf8");
+        const raw = readFileSync11(TELEMETRY_FILE, "utf8");
         const cfg = JSON.parse(raw);
         if (typeof cfg.enabled === "boolean") enabled = cfg.enabled;
       }
@@ -40451,7 +40180,7 @@ __name(telemetryCommand, "telemetryCommand");
 init_cli();
 init_command_utils();
 init_analytics();
-import { writeFileSync as writeFileSync9, existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
+import { writeFileSync as writeFileSync8, existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
 import { resolve as resolve4, join as join7 } from "path";
 init_artifact_loader();
 init_types();
@@ -40612,7 +40341,7 @@ async function governanceCommand(action) {
       }
     }
     const content = generateFile(setup);
-    writeFileSync9(filePath, content, "utf-8");
+    writeFileSync8(filePath, content, "utf-8");
     const relativePath = filePath.replace(process.cwd() + "/", "");
     writeSuccess(`Created ${relativePath}`);
     console.log("");
@@ -41901,10 +41630,7 @@ async function sourceRollbackCommand(opts) {
   const agentId = config?.agent?.agentId;
   if (!agentId) throw new Error("No agentId in lua.skill.yaml. Run `lua init` first.");
   if (!opts.silent) {
-    const versioning = await getVersioningModeCached(apiKey, agentId);
-    if (versioning.enabled) {
-      writeInfo("\u26A0\uFE0F  `lua source rollback` is deprecated when agent versioning is on. Use `lua version promote <version>` \u2014 instant, no re-upload required.");
-    }
+    writeInfo("\u26A0\uFE0F  `lua source rollback` is deprecated when agent versioning is on. Use `lua version promote <version>` \u2014 instant, no re-upload required.");
   }
   const fetchM = opts.fetchManifest ?? defaultFetchManifest;
   const fetchU = opts.fetchUrls ?? defaultFetchUrls;
@@ -41980,6 +41706,76 @@ __name(defaultRestore, "defaultRestore");
 init_cli();
 init_command_utils();
 init_analytics();
+
+// src/api/agent-version.api.service.ts
+init_http_client();
+var AgentVersionApi = class extends HttpClient {
+  static {
+    __name(this, "AgentVersionApi");
+  }
+  apiKey;
+  agentId;
+  constructor(baseUrl, apiKey, agentId) {
+    super(baseUrl);
+    this.apiKey = apiKey;
+    this.agentId = agentId;
+  }
+  get basePath() {
+    return `/developer/agents/${encodeURIComponent(this.agentId)}`;
+  }
+  get authHeader() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Version CRUD
+  // ---------------------------------------------------------------------------
+  async createVersion(body) {
+    return this.httpPost(`${this.basePath}/versions`, body, this.authHeader);
+  }
+  async listVersions(query) {
+    const params = new URLSearchParams();
+    if (query?.all !== void 0) params.append("all", String(query.all));
+    if (query?.limit !== void 0) params.append("limit", String(query.limit));
+    if (query?.status !== void 0) params.append("status", query.status);
+    const qs = params.toString();
+    const url = qs ? `${this.basePath}/versions?${qs}` : `${this.basePath}/versions`;
+    return this.httpGet(url, this.authHeader);
+  }
+  async getVersion(version) {
+    return this.httpGet(`${this.basePath}/versions/${version}`, this.authHeader);
+  }
+  async deleteVersion(version) {
+    return this.httpDelete(`${this.basePath}/versions/${version}`, this.authHeader);
+  }
+  // ---------------------------------------------------------------------------
+  // Diff
+  // ---------------------------------------------------------------------------
+  async diffVersions(from, to) {
+    const url = `${this.basePath}/versions/diff?from=${from}&to=${to}`;
+    return this.httpGet(url, this.authHeader);
+  }
+  // ---------------------------------------------------------------------------
+  // Promote
+  // ---------------------------------------------------------------------------
+  async promoteVersion(version) {
+    return this.httpPost(`${this.basePath}/versions/${version}/promote`, {}, this.authHeader);
+  }
+  // ---------------------------------------------------------------------------
+  // Patch commit hash — called by `lua version create` after a successful git
+  // commit + tag to propagate the SHA to the backend AgentVersion record.
+  // Failure is non-fatal; the version snapshot is valid whether or not this
+  // PATCH lands.
+  // ---------------------------------------------------------------------------
+  async patchCommitHash(version, commitHash) {
+    return this.httpPatch(`${this.basePath}/versions/${version}/commit-hash`, {
+      commitHash
+    }, this.authHeader);
+  }
+};
+
+// src/commands/version.ts
 init_files();
 init_constants();
 
@@ -41996,17 +41792,9 @@ function parseVersion2(arg) {
 __name(parseVersion2, "parseVersion");
 
 // src/commands/version.ts
-async function assertVersioningEnabled(apiKey, agentId) {
-  const { enabled } = await getVersioningModeCached(apiKey, agentId);
-  if (!enabled) {
-    throw new Error("Agent versioning is not enabled for your organization. Contact your admin to enable it, or use `lua push <primitive>` for the legacy flow.");
-  }
-}
-__name(assertVersioningEnabled, "assertVersioningEnabled");
 async function versionCreateCommand(options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     let config = readYamlConfig();
     let backupVersion = config?.backup?.activeVersion;
     if (options.autoPush) {
@@ -42070,7 +41858,6 @@ __name(versionCreateCommand, "versionCreateCommand");
 async function versionListCommand(options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     const query = {};
     if (options.all) query.all = true;
     if (options.limit != null) query.limit = options.limit;
@@ -42106,7 +41893,6 @@ __name(versionListCommand, "versionListCommand");
 async function versionShowCommand(versionArg, options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     const version = parseVersion2(versionArg);
     const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
     const response = await api.getVersion(version);
@@ -42141,7 +41927,6 @@ __name(versionShowCommand, "versionShowCommand");
 async function versionDiffCommand(fromArg, toArg, options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     const from = parseVersion2(fromArg);
     const to = parseVersion2(toArg);
     const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
@@ -42219,7 +42004,6 @@ __name(versionDiffCommand, "versionDiffCommand");
 async function versionPromoteCommand(versionArg) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     const version = parseVersion2(versionArg);
     const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
     const response = await api.promoteVersion(version);
@@ -42260,7 +42044,6 @@ __name(versionPromoteCommand, "versionPromoteCommand");
 async function versionDeleteCommand(versionArg, options = {}) {
   return withErrorHandling(async () => {
     const { apiKey, agentId } = await initializeCommand();
-    await assertVersioningEnabled(apiKey, agentId);
     if (versionArg === "current" || versionArg === "active") {
       throw new Error(`Cannot delete the active version directly. Use \`lua version promote <other>\` to roll back first, then delete.`);
     }
@@ -42566,7 +42349,6 @@ async function pullCommand(options = {}) {
     const { apiKey, agentId } = await initializeCommand();
     const force = Boolean(options.force);
     if (options.version) {
-      await assertVersioningEnabled(apiKey, agentId);
       const version = parseVersion2(options.version);
       const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
       const response = await api.getVersion(version);
@@ -43249,12 +43031,7 @@ Examples:
   $ lua voice test --runner vitest       Force vitest
 `).action(voiceTestCommand);
   voice.command("list").description("List LuaVoice primitives in the compiled manifest").option("--json", "Output as JSON").action(voiceListCommand);
-  const versionGroup = program2.command("version").description("\u{1F3F7}\uFE0F  Manage agent versions \u2014 atomic snapshots (requires agentVersioningEnabled for your org)").addHelpText("after", `
-Note:
-  All \`lua version\` subcommands require the \`agentVersioningEnabled\`
-  feature flag for your org. If a subcommand errors with "Agent versioning
-  is not enabled," contact your admin to enable it.
-`);
+  const versionGroup = program2.command("version").description("\u{1F3F7}\uFE0F  Manage agent versions \u2014 atomic snapshots of agent state");
   versionGroup.command("create").description("Snapshot current staged state into a new version").option("-m, --message <message>", "Optional description for this version").option("--auto-push", "Push first if local changes are not yet staged").option("--commit-hash <hash>", "Optional git commit hash to associate with this version").addHelpText("after", `
 Examples:
   $ lua version create                         Snapshot current state