lua-cli 3.16.0 → 3.17.0

package/dist/index.js

@@ -132,13 +132,14 @@ var init_semver = __esm({
 // src/config/constants.ts
 import { join } from "path";
 import { homedir } from "os";
-var CLI_CONFIG_DIR, VERSION_CHECK_FILE, TELEMETRY_FILE, BASE_URLS, CREDENTIALS_FILE, PREFERRED_AGENT_TYPES, SANDBOX_STORAGE_FILE, POSTHOG_API_KEY, POSTHOG_HOST;
+var CLI_CONFIG_DIR, VERSION_CHECK_FILE, TELEMETRY_FILE, CLI_CACHE_FILE, BASE_URLS, CREDENTIALS_FILE, PREFERRED_AGENT_TYPES, SANDBOX_STORAGE_FILE, POSTHOG_API_KEY, POSTHOG_HOST;
 var init_constants = __esm({
   "src/config/constants.ts"() {
     "use strict";
     CLI_CONFIG_DIR = join(homedir(), ".lua-cli");
     VERSION_CHECK_FILE = join(CLI_CONFIG_DIR, "version-check.json");
     TELEMETRY_FILE = join(CLI_CONFIG_DIR, "telemetry.json");
+    CLI_CACHE_FILE = join(CLI_CONFIG_DIR, "cache.json");
     BASE_URLS = {
       API: process.env.LUA_API_URL || "https://api.heylua.ai",
       AUTH: process.env.LUA_AUTH_URL || "https://auth.heylua.ai",
@@ -1526,7 +1527,7 @@ var init_artifact_loader = __esm({
 });
 
 // src/api/backup.api.service.ts
-var BackupApi;
+var BackupApi, backup_api_service_default;
 var init_backup_api_service = __esm({
   "src/api/backup.api.service.ts"() {
     "use strict";
@@ -1645,7 +1646,20 @@ var init_backup_api_service = __esm({
           Authorization: `Bearer ${this.apiKey}`
         });
       }
+      /**
+      * Get the list of backup versions for this agent.
+      *
+      * @param all - If true, lifts the server-side 50-version cap
+      * @returns Promise resolving to the list of version summaries (newest first)
+      */
+      async getBackupVersions(all = false) {
+        const qs = all ? "?all=true" : "";
+        return this.httpGet(`/developer/agents/${this.agentId}/backup/versions${qs}`, {
+          Authorization: `Bearer ${this.apiKey}`
+        });
+      }
     };
+    backup_api_service_default = BackupApi;
   }
 });
 
@@ -1662,7 +1676,7 @@ async function ensureBundlesUploaded(apiKey, agentId, bundles) {
       uploaded: 0
     };
   }
-  const api = new BackupApi(BASE_URLS.API, apiKey, agentId);
+  const api = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
   const hashes = Array.from(bundles.keys());
   const urlResponse = await api.getBlobUploadUrls(hashes);
   if (!urlResponse.success) {
@@ -4122,8 +4136,12 @@ var init_tool_plugin = __esm({
       displayName = "Tool";
       defineFunction = "defineTool";
       legacyClassNames = [
-        "LuaTool"
+        "LuaTool",
+        "LuaVoiceTool"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Extract metadata from a `defineTool({...})` / `new LuaTool({...})`
@@ -4298,6 +4316,9 @@ var init_job_plugin = __esm({
       legacyClassNames = [
         "LuaJob"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads `name`/`description`/`schedule`/
@@ -4479,6 +4500,9 @@ var init_webhook_plugin = __esm({
       legacyClassNames = [
         "LuaWebhook"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition shape: read fields off the inheritance chain
@@ -4705,6 +4729,9 @@ var init_preprocessor_plugin = __esm({
         "PreProcessor",
         "LuaPreprocessor"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       /**
       * Class-definition extraction. Reads `name`/`description`/`async`/
       * `priority`/`execute` off the inheritance chain (most-derived wins).
@@ -4788,6 +4815,9 @@ var init_postprocessor_plugin = __esm({
         "PostProcessor",
         "LuaPostprocessor"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       /**
       * Class-definition extraction. Reads `name`/`description`/`priority`/
       * `execute` off the inheritance chain.
@@ -4863,6 +4893,9 @@ var init_mcp_server_plugin = __esm({
       legacyClassNames = [
         "LuaMCPServer"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads `name`/`description`/`transport`/
@@ -5034,11 +5067,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 readFileSync6, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
 import { join as join4, sep } from "path";
 import { gunzipSync, gzipSync } from "zlib";
-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 { 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 { 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";
@@ -5098,7 +5131,7 @@ function walkWorkspace(rootDir, opts = {}) {
       if (stats.size > maxBytes) continue;
       let content;
       try {
-        content = readFileSync6(abs);
+        content = readFileSync7(abs);
       } catch {
         continue;
       }
@@ -5215,10 +5248,10 @@ function restoreFromBlobs(manifest, blobs, targetDir, opts = {}) {
         continue;
       }
     }
-    mkdirSync5(dirname3(targetPath), {
+    mkdirSync6(dirname4(targetPath), {
       recursive: true
     });
-    writeFileSync5(targetPath, content);
+    writeFileSync6(targetPath, content);
     filesWritten++;
   }
   return {
@@ -5413,12 +5446,12 @@ var init_dist2 = __esm({
         this.options = options;
         this.fetchFn = options.fetch ?? fetch;
       }
-      url(path18) {
+      url(path19) {
         const base = this.options.baseUrl.replace(/\/$/, "");
-        return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path18}`;
+        return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path19}`;
       }
-      async json(method, path18, body) {
-        const endpoint = this.url(path18);
+      async json(method, path19, body) {
+        const endpoint = this.url(path19);
         const res = await this.fetchFn(endpoint, {
           method,
           headers: {
@@ -5437,7 +5470,7 @@ var init_dist2 = __esm({
           } catch {
             text2 = void 0;
           }
-          throw new BackupHttpError(`Backup request failed: ${method} ${path18} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
+          throw new BackupHttpError(`Backup request failed: ${method} ${path19} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
         }
         const text = await res.text();
         if (!text) return void 0;
@@ -5504,16 +5537,16 @@ var init_dist2 = __esm({
 });
 
 // src/compiler/utils/common.ts
-import path3 from "path";
+import path4 from "path";
 function hashContent(content) {
   return hashContentTruncated(content);
 }
 function isInside(child, parent) {
-  const resolvedChild = path3.resolve(child);
-  const resolvedParent = path3.resolve(parent);
+  const resolvedChild = path4.resolve(child);
+  const resolvedParent = path4.resolve(parent);
   if (resolvedChild === resolvedParent) return true;
-  const rel = path3.relative(resolvedParent, resolvedChild);
-  return !!rel && !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(resolvedParent, resolvedChild);
+  return !!rel && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function classifyProjectFile(name) {
   if (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js")) {
@@ -5542,20 +5575,20 @@ var init_common = __esm({
 });
 
 // src/compiler/utils/path-resolver.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 function getTsConfigPathMappings(rootDir) {
-  const resolvedRoot = path4.resolve(rootDir);
+  const resolvedRoot = path5.resolve(rootDir);
   if (mappingsCache.has(resolvedRoot)) {
     return mappingsCache.get(resolvedRoot) ?? null;
   }
-  const tsconfigPath = path4.join(resolvedRoot, "tsconfig.json");
-  if (!fs3.existsSync(tsconfigPath)) {
+  const tsconfigPath = path5.join(resolvedRoot, "tsconfig.json");
+  if (!fs4.existsSync(tsconfigPath)) {
     mappingsCache.set(resolvedRoot, null);
     return null;
   }
   try {
-    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs4.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     const compilerOptions = tsconfig.compilerOptions || {};
     if (compilerOptions.paths) {
@@ -5582,7 +5615,7 @@ function resolvePathAlias(specifier, rootDir) {
     if (match) {
       const captured = match[1] || "";
       const targetPath = targets[0].replace("*", captured);
-      return path4.join(mappings.rootDir, mappings.baseUrl, targetPath);
+      return path5.join(mappings.rootDir, mappings.baseUrl, targetPath);
     }
   }
   return null;
@@ -5594,20 +5627,20 @@ function resolveModuleSpecifier(specifier, fromFile, rootDir) {
     return tryExtensions(aliasResolved);
   }
   if (normalized.startsWith("./") || normalized.startsWith("../")) {
-    const basePath = path4.resolve(path4.dirname(fromFile), normalized);
+    const basePath = path5.resolve(path5.dirname(fromFile), normalized);
     return tryExtensions(basePath);
   }
   return void 0;
 }
 function tryExtensions(basePath) {
   for (const ext of MODULE_EXTENSIONS) {
-    const full = ext.startsWith("/") ? path4.join(basePath, ext) : basePath + ext;
-    if (fs3.existsSync(full)) return full;
+    const full = ext.startsWith("/") ? path5.join(basePath, ext) : basePath + ext;
+    if (fs4.existsSync(full)) return full;
   }
   return void 0;
 }
 function registerProjectRootDir(project, rootDir) {
-  projectRootDirs.set(project, path4.resolve(rootDir));
+  projectRootDirs.set(project, path5.resolve(rootDir));
 }
 function getProjectRootDir(project) {
   return projectRootDirs.get(project);
@@ -6207,7 +6240,7 @@ var init_reference_resolver = __esm({
 });
 
 // src/compiler/plugins/skill.plugin.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import { Node as Node11 } from "ts-morph";
 function findEnclosingVariableDeclaration(config) {
   let current = config.getParent();
@@ -6256,6 +6289,22 @@ var init_skill_plugin = __esm({
       legacyClassNames = [
         "LuaSkill"
       ];
+      // Whitelist drops `tools` for the same reasons agent drops skills/webhooks/jobs:
+      //   1. Bundle size — preserving class references drags tool source files into
+      //      the parent bundle.
+      //   2. Residual super-edge cases — `stripSuperCallsInConstructors` covers
+      //      top-level `super(...)` only; `super.method()` mid-constructor and
+      //      `field = super.x` survive a strip and explode at runtime.
+      // MAINTENANCE: this whitelist also assumes skills are JSON-only artifacts (via
+      // `buildArtifact`). If skills ever migrate to bundled JS, this drop will silently
+      // lose `tools` from skill bundles — re-evaluate.
+      crossFileRewrite = {
+        fields: [
+          "name",
+          "description",
+          "context"
+        ]
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads `name`/`description`/`context`/
@@ -6524,7 +6573,7 @@ var init_skill_plugin = __esm({
           description: metadata.description,
           metadata: this.sanitizeForPersistence(metadata.metadata)
         }, null, 2);
-        const originalSource = await fs4.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs5.readFile(metadata.sourcePath, "utf-8");
         return {
           code,
           sourceMap: "",
@@ -6647,6 +6696,22 @@ var init_agent_plugin = __esm({
       legacyClassNames = [
         "LuaAgent"
       ];
+      // Whitelist (not copyAllFields). Two reasons, both real:
+      //   1. Bundle size — `skills`/`webhooks`/`jobs`/etc. hold CLASS references;
+      //      preserving them drags every subclass source file into the agent bundle.
+      //   2. Residual super-edge cases — `stripSuperCallsInConstructors` handles
+      //      top-level `super(...)`, but NOT `super.method()` mid-constructor or
+      //      `field = super.x` initializers, both of which still orphan after
+      //      `stripSdkExtendsClauses` runs on dragged-in files.
+      // Agent runtime only needs name/persona/model; references are resolved by `resolveArrayRefs`.
+      crossFileRewrite = {
+        fields: [
+          "name",
+          "description",
+          "persona",
+          "model"
+        ]
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads the agent's own metadata
@@ -6993,6 +7058,9 @@ var init_device_plugin = __esm({
       legacyClassNames = [
         "LuaDevice"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads `name`/`description`/`group`
@@ -7115,6 +7183,9 @@ var init_device_trigger_plugin = __esm({
       legacyClassNames = [
         "LuaDeviceTrigger"
       ];
+      crossFileRewrite = {
+        copyAllFields: true
+      };
       supportsClassDefinition = true;
       /**
       * Class-definition extraction. Reads `name`/`description`/has-flags
@@ -7255,13 +7326,355 @@ var init_device_trigger_plugin = __esm({
   }
 });
 
+// src/compiler/utils/primitive-rewrite.ts
+import { readFileSync as readFileSync9 } 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 localProject = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      allowJs: true,
+      target: 99,
+      module: 99
+    }
+  });
+  const sf = localProject.createSourceFile(`__rewrite_${metadata.kind}_${metadata.name}.ts`, sourceCode);
+  const isPrimitiveCall = /* @__PURE__ */ __name((n) => {
+    if (Node14.isNewExpression(n)) {
+      const callee = n.getExpression();
+      return Node14.isIdentifier(callee) && opts.constructorNames.includes(callee.getText());
+    }
+    if (Node14.isCallExpression(n)) {
+      const callee = n.getExpression();
+      return Node14.isIdentifier(callee) && opts.defineFunctionName !== void 0 && callee.getText() === opts.defineFunctionName;
+    }
+    return false;
+  }, "isPrimitiveCall");
+  const callNode = findCallByExportName(sf, metadata, isPrimitiveCall);
+  if (!callNode) {
+    throw new Error(`Primitive call for export "${metadata.exportName}" (kind=${metadata.kind}) not found in ${metadata.sourcePath}`);
+  }
+  const arg = callNode.getArguments()[0];
+  if (!arg || !Node14.isObjectLiteralExpression(arg)) {
+    throw new Error(`Primitive config arg is not an object literal in ${metadata.sourcePath}`);
+  }
+  const synthesized = opts.buildLiteral(arg, {
+    metadata,
+    compilerVersion: COMPILER_VERSION
+  });
+  callNode.replaceWithText(synthesized);
+  sf.forEachDescendant((n) => {
+    if (n === callNode) return;
+    if (isPrimitiveCall(n)) n.replaceWithText("undefined");
+  });
+  rewriteCrossFileCallsInSourceFile(sf, opts.crossFileSpecs, opts.sdkBaseClassNames);
+  stripLuaCliImports(sf);
+  ensureDefaultExport(sf, metadata);
+  return sf.getText();
+}
+function rewriteCrossFileCallsInSourceFile(sf, specs, sdkBaseClassNames) {
+  warnUnsupportedNamespaceImports(sf);
+  const sdkIdentifiers = new Set(sdkBaseClassNames);
+  for (const spec of specs) {
+    if (spec.defineFunction) sdkIdentifiers.add(spec.defineFunction);
+  }
+  const aliasMap = buildSdkAliasMap(sf, sdkIdentifiers);
+  let progressed = true;
+  while (progressed) {
+    progressed = false;
+    const callNode = findFirstCrossFileSdkCall(sf, specs, aliasMap);
+    if (!callNode) break;
+    const spec = callNode.spec;
+    const node = callNode.node;
+    const arg = node.getArguments()[0];
+    const objArg = arg && Node14.isObjectLiteralExpression(arg) ? arg : void 0;
+    node.replaceWithText(buildBareObjectLiteral(spec, objArg));
+    progressed = true;
+  }
+  stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap);
+}
+function warnUnsupportedNamespaceImports(sf) {
+  for (const imp of sf.getImportDeclarations()) {
+    const spec = imp.getModuleSpecifierValue();
+    if (spec !== "lua-cli" && spec !== "lua-cli/skill" && spec !== "lua-cli/voice") continue;
+    const ns = imp.getNamespaceImport();
+    if (!ns) continue;
+    const localName = ns.getText();
+    const pos = sf.getLineAndColumnAtPos(imp.getStart());
+    console.warn(formatSarifWarning({
+      ruleId: "lua/unsupported-namespace-import",
+      filePath: sf.getFilePath(),
+      line: pos.line,
+      column: pos.column,
+      message: `namespace import \`import * as ${localName} from '${spec}'\` is not supported by the cross-file rewrite. \`new ${localName}.X({...})\` calls will leak \`${localName}\` into the bundle as an undefined identifier.`,
+      hint: `Use named imports instead: \`import { LuaTool, LuaWebhook, ... } from '${spec}'\`.`
+    }));
+  }
+}
+function stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap) {
+  const matchesSdkClass = /* @__PURE__ */ __name((text) => {
+    const canonical = aliasMap.get(text) ?? text;
+    return sdkBaseClassNames.has(canonical);
+  }, "matchesSdkClass");
+  for (const classDecl of sf.getClasses()) {
+    const ext = classDecl.getExtends();
+    if (!ext) continue;
+    const expr = ext.getExpression();
+    if (!Node14.isIdentifier(expr)) continue;
+    if (matchesSdkClass(expr.getText())) {
+      classDecl.removeExtends();
+      stripSuperCallsInConstructors(classDecl);
+    }
+  }
+  sf.forEachDescendant((n) => {
+    if (!Node14.isClassExpression(n)) return;
+    const ext = n.getExtends();
+    if (!ext) return;
+    const expr = ext.getExpression();
+    if (!Node14.isIdentifier(expr)) return;
+    if (matchesSdkClass(expr.getText())) {
+      n.removeExtends();
+      stripSuperCallsInConstructors(n);
+    }
+  });
+}
+function stripSuperCallsInConstructors(classNode) {
+  for (const ctor of classNode.getConstructors()) {
+    const body = ctor.getBody();
+    if (!body || !Node14.isBlock(body)) continue;
+    const toRemove = [];
+    for (const stmt of body.getStatements()) {
+      if (!Node14.isExpressionStatement(stmt)) continue;
+      const expr = stmt.getExpression();
+      if (!Node14.isCallExpression(expr)) continue;
+      if (expr.getExpression().getKind() !== ts3.SyntaxKind.SuperKeyword) continue;
+      toRemove.push(stmt);
+    }
+    for (const stmt of toRemove) stmt.remove();
+  }
+  warnRemainingSuperReferences(classNode);
+}
+function warnRemainingSuperReferences(classNode) {
+  const sf = classNode.getSourceFile();
+  classNode.forEachDescendant((n) => {
+    if (n.getKind() !== ts3.SyntaxKind.SuperKeyword) return;
+    const parent = n.getParent();
+    if (parent && Node14.isCallExpression(parent) && parent.getExpression() === n && Node14.isExpressionStatement(parent.getParent())) {
+      return;
+    }
+    const pos = sf.getLineAndColumnAtPos(n.getStart());
+    console.warn(formatSarifWarning({
+      ruleId: "lua/orphan-super-reference",
+      filePath: sf.getFilePath(),
+      line: pos.line,
+      column: pos.column,
+      message: `\`super\` reference will become orphan after the SDK base class is stripped from the bundle. The compiled artifact will throw \`SyntaxError: 'super' keyword is only allowed in a derived class\` at sandbox eval.`,
+      hint: `Move the override into a class field initializer (the canonical subclass-with-field-override pattern), or stop subclassing the SDK base and use the \`defineX({...})\` / \`new LuaX({...})\` form.`
+    }));
+  });
+}
+function buildSdkAliasMap(sf, sdkIdentifiers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const imp of sf.getImportDeclarations()) {
+    const spec = imp.getModuleSpecifierValue();
+    if (spec !== "lua-cli" && spec !== "lua-cli/skill" && spec !== "lua-cli/voice") continue;
+    for (const named of imp.getNamedImports()) {
+      const exported = named.getName();
+      const alias = named.getAliasNode()?.getText();
+      if (!sdkIdentifiers.has(exported)) continue;
+      const local = alias ?? exported;
+      map.set(local, exported);
+    }
+  }
+  let progressed = true;
+  while (progressed) {
+    progressed = false;
+    for (const vd of sf.getVariableDeclarations()) {
+      const init = vd.getInitializer();
+      if (!init || !Node14.isIdentifier(init)) continue;
+      const name = vd.getName();
+      if (map.has(name)) continue;
+      const initText = init.getText();
+      const canonical = map.get(initText) ?? (sdkIdentifiers.has(initText) ? initText : void 0);
+      if (canonical) {
+        map.set(name, canonical);
+        progressed = true;
+      }
+    }
+  }
+  return map;
+}
+function findFirstCrossFileSdkCall(sf, specs, aliasMap) {
+  let found;
+  sf.forEachDescendant((n) => {
+    if (found) return;
+    if (Node14.isNewExpression(n)) {
+      const callee = n.getExpression();
+      if (!Node14.isIdentifier(callee)) return;
+      const canonical = aliasMap.get(callee.getText()) ?? callee.getText();
+      const spec = specs.find((s) => s.classNames.includes(canonical));
+      if (spec) found = {
+        node: n,
+        spec
+      };
+    } else if (Node14.isCallExpression(n)) {
+      const callee = n.getExpression();
+      if (!Node14.isIdentifier(callee)) return;
+      const canonical = aliasMap.get(callee.getText()) ?? callee.getText();
+      const spec = specs.find((s) => s.defineFunction !== void 0 && s.defineFunction === canonical);
+      if (spec) found = {
+        node: n,
+        spec
+      };
+    }
+  });
+  return found;
+}
+function buildBareObjectLiteral(spec, arg) {
+  if (!arg) return "{}";
+  if (spec.mode === "copyAllFields") {
+    return arg.getText();
+  }
+  const parts = [];
+  for (const f of spec.fields) {
+    const prop = arg.getProperty(f);
+    if (prop && Node14.isPropertyAssignment(prop)) {
+      const init = prop.getInitializer();
+      if (init) parts.push(`${f}: ${init.getText()}`);
+    } else if (prop && Node14.isShorthandPropertyAssignment(prop)) {
+      parts.push(`${f}: ${prop.getName()}`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function findCallByExportName(sf, metadata, isPrimitiveCall) {
+  if (metadata.isDefaultExport) {
+    for (const stmt of sf.getStatements()) {
+      if (!Node14.isExportAssignment(stmt)) continue;
+      const expr = stmt.getExpression();
+      if (isPrimitiveCall(expr)) return expr;
+      if (Node14.isIdentifier(expr)) {
+        const varDecl2 = sf.getVariableDeclaration(expr.getText());
+        const init2 = varDecl2?.getInitializer();
+        if (init2 && isPrimitiveCall(init2)) return init2;
+      }
+    }
+    return void 0;
+  }
+  const varDecl = sf.getVariableDeclaration(metadata.exportName);
+  const init = varDecl?.getInitializer();
+  if (init && isPrimitiveCall(init)) return init;
+  return void 0;
+}
+function stripLuaCliImports(sf) {
+  for (const imp of sf.getImportDeclarations()) {
+    const spec = imp.getModuleSpecifierValue();
+    if (spec === "lua-cli" || spec === "lua-cli/skill" || spec === "lua-cli/voice") {
+      imp.remove();
+    }
+  }
+}
+function ensureDefaultExport(sf, metadata) {
+  if (metadata.isDefaultExport) return;
+  const existingDefault = sf.getStatements().find(Node14.isExportAssignment);
+  if (!existingDefault) {
+    sf.addStatements(`
+export default ${metadata.exportName};`);
+    return;
+  }
+  const expr = existingDefault.getExpression();
+  const alreadyCorrect = Node14.isIdentifier(expr) && expr.getText() === metadata.exportName;
+  if (!alreadyCorrect) {
+    existingDefault.remove();
+    sf.addStatements(`
+export default ${metadata.exportName};`);
+  }
+}
+function getPropertyText(arg, name) {
+  const prop = arg.getProperty(name);
+  if (prop && Node14.isPropertyAssignment(prop)) {
+    return prop.getInitializer()?.getText();
+  }
+  if (prop && Node14.isShorthandPropertyAssignment(prop)) {
+    return prop.getName();
+  }
+  return void 0;
+}
+function buildLuaPrimitiveMarker(metadata, kind) {
+  return `__lua_primitive__: { version: ${JSON.stringify(COMPILER_VERSION)}, kind: '${kind}', name: ${JSON.stringify(metadata.name)}, description: ${JSON.stringify(metadata.description)}, exportName: ${JSON.stringify(metadata.exportName)} }`;
+}
+var init_primitive_rewrite = __esm({
+  "src/compiler/utils/primitive-rewrite.ts"() {
+    "use strict";
+    init_types();
+    init_reference_resolver();
+    __name(rewritePrimitiveSource, "rewritePrimitiveSource");
+    __name(rewriteCrossFileCallsInSourceFile, "rewriteCrossFileCallsInSourceFile");
+    __name(warnUnsupportedNamespaceImports, "warnUnsupportedNamespaceImports");
+    __name(stripSdkExtendsClauses, "stripSdkExtendsClauses");
+    __name(stripSuperCallsInConstructors, "stripSuperCallsInConstructors");
+    __name(warnRemainingSuperReferences, "warnRemainingSuperReferences");
+    __name(buildSdkAliasMap, "buildSdkAliasMap");
+    __name(findFirstCrossFileSdkCall, "findFirstCrossFileSdkCall");
+    __name(buildBareObjectLiteral, "buildBareObjectLiteral");
+    __name(findCallByExportName, "findCallByExportName");
+    __name(stripLuaCliImports, "stripLuaCliImports");
+    __name(ensureDefaultExport, "ensureDefaultExport");
+    __name(getPropertyText, "getPropertyText");
+    __name(buildLuaPrimitiveMarker, "buildLuaPrimitiveMarker");
+  }
+});
+
+// src/compiler/utils/cross-file-specs.ts
+function buildCrossFileSpecs(plugins = pluginRegistry.getAll()) {
+  const specs = [];
+  for (const plugin of plugins) {
+    if (!plugin.crossFileRewrite) continue;
+    const classNames = [
+      ...plugin.legacyClassNames
+    ];
+    const defineFunction = plugin.defineFunction || void 0;
+    if ("copyAllFields" in plugin.crossFileRewrite && plugin.crossFileRewrite.copyAllFields) {
+      specs.push({
+        classNames,
+        defineFunction,
+        mode: "copyAllFields"
+      });
+    } else if ("fields" in plugin.crossFileRewrite) {
+      specs.push({
+        classNames,
+        defineFunction,
+        mode: "whitelist",
+        fields: plugin.crossFileRewrite.fields
+      });
+    }
+  }
+  return specs;
+}
+function buildSdkBaseClassNames(plugins = pluginRegistry.getAll()) {
+  const names = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    for (const cls of plugin.legacyClassNames) names.add(cls);
+  }
+  return names;
+}
+var init_cross_file_specs = __esm({
+  "src/compiler/utils/cross-file-specs.ts"() {
+    "use strict";
+    init_registry();
+    __name(buildCrossFileSpecs, "buildCrossFileSpecs");
+    __name(buildSdkBaseClassNames, "buildSdkBaseClassNames");
+  }
+});
+
 // src/compiler/plugins/voice.plugin.ts
-import fs5 from "fs/promises";
-import { Node as Node14 } from "ts-morph";
+import fs6 from "fs/promises";
+import { Node as Node15 } from "ts-morph";
 function astObjectToPlain(obj) {
   const result = {};
   for (const prop of obj.getProperties()) {
-    if (Node14.isSpreadAssignment(prop)) {
+    if (Node15.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const evaluated = astValueToPlain(expr);
       if (evaluated && typeof evaluated === "object" && !Array.isArray(evaluated)) {
@@ -7269,14 +7682,14 @@ function astObjectToPlain(obj) {
       }
       continue;
     }
-    if (Node14.isShorthandPropertyAssignment(prop)) {
+    if (Node15.isShorthandPropertyAssignment(prop)) {
       const key2 = prop.getName();
       if (!key2) continue;
       const v2 = astValueToPlain(prop.getNameNode());
       if (v2 !== void 0) result[key2] = v2;
       continue;
     }
-    if (!Node14.isPropertyAssignment(prop)) continue;
+    if (!Node15.isPropertyAssignment(prop)) continue;
     const key = prop.getName();
     if (!key) continue;
     const value = prop.getInitializer();
@@ -7287,16 +7700,16 @@ function astObjectToPlain(obj) {
   return result;
 }
 function astValueToPlain(value) {
-  if (Node14.isStringLiteral(value) || Node14.isNoSubstitutionTemplateLiteral(value)) {
+  if (Node15.isStringLiteral(value) || Node15.isNoSubstitutionTemplateLiteral(value)) {
     return value.getLiteralText();
   }
-  if (Node14.isNumericLiteral(value)) {
+  if (Node15.isNumericLiteral(value)) {
     return Number(value.getLiteralText());
   }
-  if (Node14.isTrueLiteral(value)) return true;
-  if (Node14.isFalseLiteral(value)) return false;
-  if (Node14.isObjectLiteralExpression(value)) return astObjectToPlain(value);
-  if (Node14.isArrayLiteralExpression(value)) {
+  if (Node15.isTrueLiteral(value)) return true;
+  if (Node15.isFalseLiteral(value)) return false;
+  if (Node15.isObjectLiteralExpression(value)) return astObjectToPlain(value);
+  if (Node15.isArrayLiteralExpression(value)) {
     return value.getElements().map((el) => astValueToPlain(el)).filter((x) => x !== void 0);
   }
   return void 0;
@@ -7355,15 +7768,36 @@ function stripKeys(obj, keys) {
 }
 function leftmostIdentifierName(node) {
   let current = node;
-  while (Node14.isPropertyAccessExpression(current)) {
+  while (Node15.isPropertyAccessExpression(current)) {
     current = current.getExpression();
   }
-  return Node14.isIdentifier(current) ? current.getText() : void 0;
+  return Node15.isIdentifier(current) ? current.getText() : void 0;
+}
+function resolveProviderAlias(node, localName) {
+  const sourceFile = node.getSourceFile();
+  for (const imp of sourceFile.getImportDeclarations()) {
+    const moduleSpec = imp.getModuleSpecifierValue();
+    const livekitPlugin = moduleSpec.startsWith("@livekit/agents-plugin-");
+    const isLuaCliVoice = moduleSpec === "lua-cli/voice";
+    const isLivekitAgents = moduleSpec === "@livekit/agents";
+    if (!isLuaCliVoice && !livekitPlugin && !isLivekitAgents) continue;
+    for (const named of imp.getNamedImports()) {
+      const alias = named.getAliasNode()?.getText();
+      const exported = named.getName();
+      const bound = alias ?? exported;
+      if (bound === localName) return exported;
+    }
+    const ns = imp.getNamespaceImport();
+    if (ns && ns.getText() === localName && livekitPlugin) {
+      return moduleSpec.replace("@livekit/agents-plugin-", "");
+    }
+  }
+  return localName;
 }
 function extractRealtimeFromNewExpression(newExpr, classExpr, field) {
   if (classExpr.getName() !== "RealtimeModel") return void 0;
   const realtimeNode = classExpr.getExpression();
-  if (!Node14.isPropertyAccessExpression(realtimeNode) || realtimeNode.getName() !== "realtime") {
+  if (!Node15.isPropertyAccessExpression(realtimeNode) || realtimeNode.getName() !== "realtime") {
     return void 0;
   }
   if (field !== "llm") {
@@ -7374,7 +7808,8 @@ function extractRealtimeFromNewExpression(newExpr, classExpr, field) {
       }
     };
   }
-  const provider = leftmostIdentifierName(realtimeNode.getExpression());
+  const providerLocal = leftmostIdentifierName(realtimeNode.getExpression());
+  const provider = providerLocal ? resolveProviderAlias(realtimeNode, providerLocal) : void 0;
   if (!provider) {
     return {
       error: {
@@ -7393,7 +7828,7 @@ function extractRealtimeFromNewExpression(newExpr, classExpr, field) {
   }
   const optsArg = newExpr.getArguments()[0];
   let options = {};
-  if (optsArg && Node14.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && Node15.isObjectLiteralExpression(optsArg)) {
     options = astObjectToPlain(optsArg);
   }
   return {
@@ -7406,7 +7841,7 @@ function extractRealtimeFromNewExpression(newExpr, classExpr, field) {
 }
 function extractFromNewExpression(newExpr, field) {
   const expr = newExpr.getExpression();
-  if (!Node14.isPropertyAccessExpression(expr)) {
+  if (!Node15.isPropertyAccessExpression(expr)) {
     return {
       error: {
         field,
@@ -7416,7 +7851,7 @@ function extractFromNewExpression(newExpr, field) {
   }
   const realtimeResult = extractRealtimeFromNewExpression(newExpr, expr, field);
   if (realtimeResult) return realtimeResult;
-  const moduleName = expr.getExpression().getText();
+  const moduleName = resolveProviderAlias(expr, expr.getExpression().getText());
   const className = expr.getName();
   if (!PLUGIN_CLASSES.includes(className)) {
     return {
@@ -7436,7 +7871,7 @@ function extractFromNewExpression(newExpr, field) {
   }
   const optsArg = newExpr.getArguments()[0];
   let options = {};
-  if (optsArg && Node14.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && Node15.isObjectLiteralExpression(optsArg)) {
     options = astObjectToPlain(optsArg);
   }
   if (moduleName === "inference") {
@@ -7484,7 +7919,7 @@ function extractFromNewExpression(newExpr, field) {
 }
 function unwrapType(node) {
   let current = node;
-  while (Node14.isAsExpression(current) || Node14.isSatisfiesExpression(current) || Node14.isParenthesizedExpression(current)) {
+  while (Node15.isAsExpression(current) || Node15.isSatisfiesExpression(current) || Node15.isParenthesizedExpression(current)) {
     const inner = current.getExpression?.();
     if (!inner) break;
     current = inner;
@@ -7493,11 +7928,11 @@ function unwrapType(node) {
 }
 function extractModelField(config, field) {
   const prop = config.getProperty(field);
-  if (!prop || !Node14.isPropertyAssignment(prop)) return {};
+  if (!prop || !Node15.isPropertyAssignment(prop)) return {};
   const initializer = prop.getInitializer();
   if (!initializer) return {};
   const value = unwrapType(initializer);
-  if (Node14.isStringLiteral(value) || Node14.isNoSubstitutionTemplateLiteral(value)) {
+  if (Node15.isStringLiteral(value) || Node15.isNoSubstitutionTemplateLiteral(value)) {
     const text = value.getLiteralText();
     if (!text) {
       return {
@@ -7509,7 +7944,7 @@ function extractModelField(config, field) {
     }
     return parseDescriptor(text, field);
   }
-  if (Node14.isObjectLiteralExpression(value)) {
+  if (Node15.isObjectLiteralExpression(value)) {
     if (field !== "tts") {
       return {
         error: {
@@ -7536,7 +7971,7 @@ function extractModelField(config, field) {
       model: out
     };
   }
-  if (Node14.isNewExpression(value)) {
+  if (Node15.isNewExpression(value)) {
     return extractFromNewExpression(value, field);
   }
   return {
@@ -7549,20 +7984,23 @@ function extractModelField(config, field) {
 function hasFunctionProperty(config, propertyName) {
   const prop = config.getProperty(propertyName);
   if (!prop) return false;
-  if (Node14.isMethodDeclaration(prop)) return true;
-  if (!Node14.isPropertyAssignment(prop)) return false;
+  if (Node15.isMethodDeclaration(prop)) return true;
+  if (!Node15.isPropertyAssignment(prop)) return false;
   const value = prop.getInitializer();
   if (!value) return false;
-  if (Node14.isArrowFunction(value) || Node14.isFunctionExpression(value)) return true;
-  if (Node14.isIdentifier(value)) return true;
+  if (Node15.isArrowFunction(value) || Node15.isFunctionExpression(value)) return true;
+  if (Node15.isIdentifier(value)) return true;
   return false;
 }
 function hasArrayProperty(config, propertyName) {
   const prop = config.getProperty(propertyName);
-  if (!prop || !Node14.isPropertyAssignment(prop)) return false;
+  if (!prop || !Node15.isPropertyAssignment(prop)) return false;
   const value = prop.getInitializer();
   if (!value) return false;
-  return Node14.isArrayLiteralExpression(value);
+  if (Node15.isArrayLiteralExpression(value)) return value.getElements().length > 0;
+  if (Node15.isNullLiteral(value)) return false;
+  if (Node15.isIdentifier(value) && value.getText() === "undefined") return false;
+  return true;
 }
 function normalizePronunciations(raw) {
   if (!raw) return {
@@ -7588,6 +8026,8 @@ var init_voice_plugin = __esm({
   "src/compiler/plugins/voice.plugin.ts"() {
     "use strict";
     init_dist();
+    init_primitive_rewrite();
+    init_cross_file_specs();
     init_types();
     init_ast_helpers();
     init_common();
@@ -7618,6 +8058,7 @@ var init_voice_plugin = __esm({
     __name(parseDescriptor, "parseDescriptor");
     __name(stripKeys, "stripKeys");
     __name(leftmostIdentifierName, "leftmostIdentifierName");
+    __name(resolveProviderAlias, "resolveProviderAlias");
     __name(extractRealtimeFromNewExpression, "extractRealtimeFromNewExpression");
     __name(extractFromNewExpression, "extractFromNewExpression");
     __name(unwrapType, "unwrapType");
@@ -7635,6 +8076,14 @@ var init_voice_plugin = __esm({
       legacyClassNames = [
         "LuaVoice"
       ];
+      // Voice's cross-file rewrite uses a narrow whitelist because configs can
+      // have nested provider SDK calls (new deepgram.STT, new elevenlabs.TTS)
+      // that the top-level rewrite (in generateEntryPoint) handles separately.
+      crossFileRewrite = {
+        fields: [
+          "name"
+        ]
+      };
       extractFromConfig(config, exportName, sourcePath, position, pattern) {
         const common = this.extractCommonFields(config, exportName, sourcePath, position);
         if (!common) return null;
@@ -7761,8 +8210,8 @@ var init_voice_plugin = __esm({
             }, "isMissingTopLevelRequired");
             for (const issue of parsed.error.issues) {
               if (isMissingTopLevelRequired(issue)) continue;
-              const path18 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-              errors.push(validationError(`Voice config invalid at \`${path18}\`: ${issue.message}`, {
+              const path19 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+              errors.push(validationError(`Voice config invalid at \`${path19}\`: ${issue.message}`, {
                 line
               }));
             }
@@ -7775,43 +8224,45 @@ var init_voice_plugin = __esm({
         };
       }
       /**
-      * Entry-point emitter for the bundled JS path. Imports the dev's
-      * LuaVoice instance and re-exports its hooks + voice-only tools in
-      * the flat shape the worker sandbox expects (sandbox.ts:extractExports).
+      * Entry-point emitter for hook-bearing voices.
+      *
+      * Architecturally, the bundle must NOT re-evaluate `new LuaVoice({...})` in
+      * the worker sandbox — that call's only purpose is compile-time metadata
+      * extraction (provider/class/options for stt/tts/llm), and re-running it
+      * with stripped SDK imports requires runtime stub injection (a Proxy that
+      * covers only a fraction of the dev's possible introspection patterns).
+      *
+      * Instead, this method does a source-level AST rewrite:
+      *   1. Parse the dev's source file
+      *   2. Find the LuaVoice / defineVoice call site
+      *   3. Splice the hook function-expression texts + tool entries directly
+      *      into a synthesized `{ __lua_primitive__, onEnter, ..., tools }`
+      *      object literal at the same module-scope position
+      *   4. Strip the stripped lua-cli / lua-cli/voice imports
       *
-      * Tools land as a name-keyed map; sandbox.normalizeTools also accepts
-      * arrays, but pre-normalizing here avoids one walk per session start
-      * and keeps the bundle's wire shape obvious to anyone inspecting it.
+      * Closure references (module-level helpers, consts, types) survive
+      * because the splice happens at the same lexical position as the
+      * original call site.
       *
       * Only invoked by the compiler when `buildArtifact` returns undefined
-      * (i.e. when the voice declares hooks or voice-only tools) — see
-      * the conditional in `buildArtifact` below.
+      * (i.e. when the voice declares hooks or voice-only tools).
       */
       generateEntryPoint(metadata) {
-        const importStatement = metadata.isDefaultExport ? `import __voice__ from ${JSON.stringify(metadata.sourcePath)};` : `import { __lua_target__ as __voice__ } from ${JSON.stringify(metadata.sourcePath)};`;
-        return `// AUTO-GENERATED ENTRY POINT \u2014 Voice: ${metadata.name}
-${importStatement}
-
-const __luaTools = {};
-if (__voice__ && Array.isArray(__voice__.tools)) {
-  for (const t of __voice__.tools) {
-    if (t && typeof t === 'object' && typeof t.name === 'string') {
-      __luaTools[t.name] = {
-        name: t.name,
-        description: t.description,
-        execute: t.execute,
-        condition: t.condition,
-        voice: t.voice,
-      };
-    }
-  }
-}
-
-export const onEnter = __voice__ && __voice__.onEnter;
-export const onUserTurnCompleted = __voice__ && __voice__.onUserTurnCompleted;
-export const onExit = __voice__ && __voice__.onExit;
-export const tools = __luaTools;
-`;
+        return rewritePrimitiveSource(metadata, {
+          constructorNames: [
+            "LuaVoice"
+          ],
+          defineFunctionName: this.defineFunction,
+          buildLiteral: /* @__PURE__ */ __name((arg, ctx) => `{
+  ${buildLuaPrimitiveMarker(ctx.metadata, "voice")},
+  onEnter: ${getPropertyText(arg, "onEnter") ?? "undefined"},
+  onUserTurnCompleted: ${getPropertyText(arg, "onUserTurnCompleted") ?? "undefined"},
+  onExit: ${getPropertyText(arg, "onExit") ?? "undefined"},
+  tools: ${getPropertyText(arg, "tools") ?? "[]"}
+}`, "buildLiteral"),
+          crossFileSpecs: buildCrossFileSpecs(),
+          sdkBaseClassNames: buildSdkBaseClassNames()
+        });
       }
       /**
       * Emit a JSON metadata sidecar OR fall through to esbuild bundling.
@@ -7841,7 +8292,7 @@ export const tools = __luaTools;
           description: metadata.description,
           metadata: sanitized
         }, null, 2);
-        const originalSource = await fs5.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs6.readFile(metadata.sourcePath, "utf-8");
         return {
           code,
           sourceMap: "",
@@ -7994,8 +8445,8 @@ var init_registry = __esm({
 });
 
 // src/compiler/bundler.ts
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path6 from "path";
 import crypto4 from "crypto";
 import { build } from "esbuild";
 var Bundler;
@@ -8003,6 +8454,8 @@ var init_bundler = __esm({
   "src/compiler/bundler.ts"() {
     "use strict";
     init_types();
+    init_primitive_rewrite();
+    init_cross_file_specs();
     Bundler = class {
       static {
         __name(this, "Bundler");
@@ -8010,24 +8463,43 @@ var init_bundler = __esm({
       options;
       project;
       verbose;
+      // Snapshotted at construction. Plugins registered after this Bundler
+      // is instantiated (test fixtures, "lua-cli as a library" usage) won't appear.
+      // Today the registry is module-load-time only, so this is fine.
+      crossFileSpecs = buildCrossFileSpecs();
+      sdkBaseClassNames = buildSdkBaseClassNames();
       constructor(options, project, verbose) {
         this.options = options;
         this.project = project;
         this.verbose = verbose;
       }
       /**
-      * Strip lua-cli and api-exports import statements from source code using TypeScript AST.
-      * This is more robust than regex and handles all edge cases (multiline, comments, etc.).
+      * Strip lua-cli / lua-cli/skill / lua-cli/voice / api-exports imports from
+      * a source file, then rewrite every SDK class constructor / define-function
+      * call in the file to a bare object literal (`{ name, execute, ... }`).
+      *
+      * After this transform:
+      *   - SDK class identifiers (LuaTool, LuaJob, defineWebhook, ...) no longer
+      *     appear in the source. The call sites that used them are replaced with
+      *     inline object literals carrying the runtime fields. By construction,
+      *     the bundle has zero references to stripped SDK identifiers, so the
+      *     sandbox doesn't need any runtime stub for them.
+      *   - Platform-API identifiers (Data, User, AI, Agents, Jobs, Lua, env, ...)
+      *     remain as free identifiers in the dev's execute / hook bodies. esbuild
+      *     leaves them alone (they're not imported, not local), and at runtime
+      *     they resolve to the sandbox's injected globals.
+      *
+      * Replaces the prior `buildLuaCliStubBlock` runtime-stub approach (BAC-234).
       */
       stripLuaCliImportsAST(code, filename = "temp.ts") {
         try {
           const tempFile = this.project.createSourceFile(`__strip_${filename}`, code, {
             overwrite: true
           });
-          const imports = tempFile.getImportDeclarations();
-          imports.forEach((imp) => {
-            const moduleSpecifier = imp.getModuleSpecifierValue();
-            if (moduleSpecifier === "lua-cli" || moduleSpecifier === "lua-cli/skill" || moduleSpecifier.includes("api-exports")) {
+          rewriteCrossFileCallsInSourceFile(tempFile, this.crossFileSpecs, this.sdkBaseClassNames);
+          tempFile.getImportDeclarations().forEach((imp) => {
+            const spec = imp.getModuleSpecifierValue();
+            if (spec === "lua-cli" || spec === "lua-cli/skill" || spec === "lua-cli/voice" || spec.includes("api-exports")) {
               imp.remove();
             }
           });
@@ -8035,16 +8507,17 @@ var init_bundler = __esm({
           this.project.removeSourceFile(tempFile);
           return result;
         } catch (error) {
-          return code;
+          const msg = error instanceof Error ? error.message : String(error);
+          throw new Error(`[lua-cli] AST rewrite failed for ${filename}: ${msg}. Source: bare SDK identifiers would survive into the bundle and fail at runtime; aborting compile.`);
         }
       }
       /**
       * Bundle a primitive's entry point using esbuild.
       */
       async bundle(metadata, entryPointCode) {
-        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);
+        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);
         if (this.options.debug) {
           this.verbose(`      Source: ${metadata.sourcePath}`);
           this.verbose(`      Output: ${outfile}`);
@@ -8074,15 +8547,15 @@ var init_bundler = __esm({
           ],
           logLevel: this.options.debug ? "debug" : "silent"
         });
-        const code = await fs6.readFile(outfile, "utf-8");
+        const code = await fs7.readFile(outfile, "utf-8");
         let sourceMap = "";
         try {
-          sourceMap = await fs6.readFile(outfile + ".map", "utf-8");
+          sourceMap = await fs7.readFile(outfile + ".map", "utf-8");
         } catch {
         }
-        const originalSource = await fs6.readFile(metadata.sourcePath, "utf-8");
+        const originalSource = await fs7.readFile(metadata.sourcePath, "utf-8");
         const hash = crypto4.createHash("sha256").update(code).digest("hex").slice(0, 16);
-        const stats = await fs6.stat(outfile);
+        const stats = await fs7.stat(outfile);
         return {
           code,
           sourceMap,
@@ -8099,14 +8572,14 @@ var init_bundler = __esm({
         const bundler = this;
         const sourcePath = metadata.sourcePath;
         const exportName = metadata.exportName;
-        const sourceDir = path5.dirname(sourcePath);
+        const sourceDir = path6.dirname(sourcePath);
         return {
           name: "lua-virtual-source",
           setup(build2) {
             build2.onResolve({
               filter: /.*/
             }, (args2) => {
-              const resolved = args2.path.startsWith(".") ? path5.resolve(args2.resolveDir, args2.path) : args2.path;
+              const resolved = args2.path.startsWith(".") ? path6.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) {
@@ -8122,8 +8595,8 @@ var init_bundler = __esm({
               namespace: "lua-virtual-source"
             }, async () => {
               const sourceFile = bundler.project.getSourceFile(sourcePath);
-              let content = sourceFile?.getText() ?? await fs6.readFile(sourcePath, "utf-8");
-              content = bundler.stripLuaCliImportsAST(content, path5.basename(sourcePath));
+              let content = sourceFile?.getText() ?? await fs7.readFile(sourcePath, "utf-8");
+              content = bundler.stripLuaCliImportsAST(content, path6.basename(sourcePath));
               const virtualContent = metadata.isDefaultExport ? content : `${content}
 export { ${exportName} as __lua_target__ };
 `;
@@ -8143,8 +8616,6 @@ export { ${exportName} as __lua_target__ };
       */
       createLuaCliShimPlugin() {
         const stripImports = this.stripLuaCliImportsAST.bind(this);
-        const debug = this.options.debug;
-        const verbose = this.verbose.bind(this);
         return {
           name: "lua-cli-import-stripper",
           setup(build2) {
@@ -8153,29 +8624,27 @@ export { ${exportName} as __lua_target__ };
               namespace: "file"
             }, async (args2) => {
               if (args2.path.includes("node_modules")) return null;
-              const contents = await fs6.readFile(args2.path, "utf-8");
+              const contents = await fs7.readFile(args2.path, "utf-8");
               if (!contents.includes("lua-cli") && !contents.includes("api-exports")) {
                 return null;
               }
               try {
-                const modifiedContents = stripImports(contents, path5.basename(args2.path));
+                const modifiedContents = stripImports(contents, path6.basename(args2.path));
                 if (modifiedContents !== contents) {
                   return {
                     contents: modifiedContents,
                     loader: args2.path.endsWith(".ts") || args2.path.endsWith(".tsx") ? "ts" : "js",
-                    resolveDir: path5.dirname(args2.path)
+                    resolveDir: path6.dirname(args2.path)
                   };
                 }
                 return null;
               } catch (error) {
-                if (debug) {
-                  verbose(`      Warning: Failed to parse ${args2.path} with ts-morph, using fallback`);
-                }
-                return null;
+                const msg = error instanceof Error ? error.message : String(error);
+                throw new Error(`[lua-cli] AST rewrite failed for ${args2.path}: ${msg}. Aborting compile (silent fallback would corrupt the bundle).`);
               }
             });
             build2.onResolve({
-              filter: /^lua-cli(\/skill)?$/
+              filter: /^lua-cli(\/(skill|voice))?$/
             }, () => ({
               path: "lua-cli-empty",
               namespace: "lua-cli-empty"
@@ -8201,9 +8670,9 @@ export { ${exportName} as __lua_target__ };
 });
 
 // src/compiler/agent-traverser.ts
-import { Project, Node as Node15 } from "ts-morph";
-import path6 from "path";
-import fs7 from "fs";
+import { Project as Project2, Node as Node16 } from "ts-morph";
+import path7 from "path";
+import fs8 from "fs";
 var PRIMITIVE_TYPES, AgentTraverser;
 var init_agent_traverser = __esm({
   "src/compiler/agent-traverser.ts"() {
@@ -8275,8 +8744,8 @@ var init_agent_traverser = __esm({
       constructor(rootDir, debug = false) {
         this.rootDir = rootDir;
         this.debug = debug;
-        this.project = new Project({
-          tsConfigFilePath: path6.join(rootDir, "tsconfig.json"),
+        this.project = new Project2({
+          tsConfigFilePath: path7.join(rootDir, "tsconfig.json"),
           skipAddingFilesFromTsConfig: true
         });
         registerProjectRootDir(this.project, this.rootDir);
@@ -8360,15 +8829,15 @@ var init_agent_traverser = __esm({
       */
       detectAgent() {
         const priorityFiles = [
-          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")
+          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")
         ];
         for (const filePath of priorityFiles) {
-          if (fs7.existsSync(filePath)) {
+          if (fs8.existsSync(filePath)) {
             try {
               const sourceFile = this.project.addSourceFileAtPath(filePath);
               const agent = this.detectAgentInFile(sourceFile);
@@ -8424,7 +8893,7 @@ var init_agent_traverser = __esm({
       */
       extractArrayRefs(config, propName) {
         const prop = config.getProperty(propName);
-        if (!prop || !Node15.isPropertyAssignment(prop)) return [];
+        if (!prop || !Node16.isPropertyAssignment(prop)) return [];
         const value = prop.getInitializer();
         if (!value) return [];
         const ctx = {
@@ -8509,7 +8978,7 @@ var init_agent_traverser = __esm({
             for (const assign of file.getExportAssignments()) {
               if (assign.isExportEquals()) continue;
               const expr = assign.getExpression();
-              if (!Node15.isIdentifier(expr)) continue;
+              if (!Node16.isIdentifier(expr)) continue;
               const targetName = expr.getText();
               defaultMatch = detected.find((d) => d.exportName === targetName);
               if (defaultMatch) break;
@@ -8520,7 +8989,7 @@ var init_agent_traverser = __esm({
             console.warn(formatSarifWarning({
               ruleId: "lua/missing-primitive-declaration",
               filePath: sourcePath,
-              message: `agent references ${kind} "${refName}" but ${path6.basename(sourcePath)} does not define a matching primitive`,
+              message: `agent references ${kind} "${refName}" but ${path7.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;
@@ -8540,20 +9009,20 @@ var init_agent_traverser = __esm({
 });
 
 // src/compiler/utils/workspace.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function findWorkspaceRoot(rootDir) {
-  const resolvedInput = path7.resolve(rootDir);
+  const resolvedInput = path8.resolve(rootDir);
   const cached = workspaceRootCache.get(resolvedInput);
   if (cached !== void 0) return cached;
   let current = resolvedInput;
-  const { root } = path7.parse(current);
+  const { root } = path8.parse(current);
   while (true) {
     if (isWorkspaceRoot(current)) {
       workspaceRootCache.set(resolvedInput, current);
       return current;
     }
-    const parent = path7.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current || current === root) break;
     current = parent;
   }
@@ -8561,22 +9030,22 @@ function findWorkspaceRoot(rootDir) {
   return resolvedInput;
 }
 function isWorkspaceRoot(dir) {
-  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;
+  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;
   return false;
 }
 function fileExists(p) {
   try {
-    return fs8.statSync(p).isFile();
+    return fs9.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function dirExists(p) {
   try {
-    return fs8.statSync(p).isDirectory();
+    return fs9.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -8584,7 +9053,7 @@ function dirExists(p) {
 function packageJsonHasWorkspaces(pkgPath) {
   if (!fileExists(pkgPath)) return false;
   try {
-    const raw = fs8.readFileSync(pkgPath, "utf-8");
+    const raw = fs9.readFileSync(pkgPath, "utf-8");
     const json = JSON.parse(raw);
     if (!json.workspaces) return false;
     return Array.isArray(json.workspaces) || typeof json.workspaces === "object";
@@ -8606,9 +9075,9 @@ var init_workspace = __esm({
 });
 
 // src/compiler/compiler.ts
-import fs9 from "fs/promises";
-import path8 from "path";
-import { Project as Project2 } from "ts-morph";
+import fs10 from "fs/promises";
+import path9 from "path";
+import { Project as Project3 } from "ts-morph";
 async function compile(options) {
   const compiler = new Compiler(options);
   return compiler.compile();
@@ -8659,8 +9128,8 @@ var init_compiler = __esm({
           runtimeValidation: true,
           ...options
         };
-        this.project = new Project2({
-          tsConfigFilePath: path8.join(options.rootDir, "tsconfig.json")
+        this.project = new Project3({
+          tsConfigFilePath: path9.join(options.rootDir, "tsconfig.json")
         });
         registerProjectRootDir(this.project, this.options.rootDir);
         this.bundler = new Bundler({
@@ -8737,10 +9206,10 @@ var init_compiler = __esm({
             return await this.createResult(false, [], errors, warnings, startTime);
           }
           this.verbose("\u{1F4E6} Bundling primitives...");
-          await fs9.mkdir(this.options.outDir, {
+          await fs10.mkdir(this.options.outDir, {
             recursive: true
           });
-          await fs9.mkdir(path8.join(this.options.outDir, ".temp"), {
+          await fs10.mkdir(path9.join(this.options.outDir, ".temp"), {
             recursive: true
           });
           const CONCURRENCY = 4;
@@ -8760,7 +9229,7 @@ var init_compiler = __esm({
           this.verbose("\u{1F4BE} Writing artifacts...");
           await this.writeArtifacts(compiledPrimitives);
           if (!this.options.debug) {
-            await fs9.rm(path8.join(this.options.outDir, ".temp"), {
+            await fs10.rm(path9.join(this.options.outDir, ".temp"), {
               recursive: true,
               force: true
             });
@@ -8803,7 +9272,7 @@ var init_compiler = __esm({
       */
       getWorkspaceRoot() {
         if (this._workspaceRoot === void 0) {
-          this._workspaceRoot = findWorkspaceRoot(path8.resolve(this.options.rootDir));
+          this._workspaceRoot = findWorkspaceRoot(path9.resolve(this.options.rootDir));
         }
         return this._workspaceRoot;
       }
@@ -8817,18 +9286,18 @@ var init_compiler = __esm({
       *  - Files outside the detected workspace root (not our code)
       */
       collectExternalWorkspaceFiles(traverser) {
-        const rootDir = path8.resolve(this.options.rootDir);
+        const rootDir = path9.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 = path8.resolve(raw);
+          const abs = path9.resolve(raw);
           if (seen.has(abs)) continue;
           seen.add(abs);
           if (isInside(abs, rootDir)) continue;
-          if (abs.includes(`${path8.sep}node_modules${path8.sep}`)) continue;
+          if (abs.includes(`${path9.sep}node_modules${path9.sep}`)) continue;
           if (!isInside(abs, workspaceRoot)) continue;
           result.push(abs);
         }
@@ -8961,9 +9430,9 @@ var init_compiler = __esm({
       * @param primitives - All compiled primitives to write
       */
       async writeArtifacts(primitives) {
-        const artifactsDir = path8.join(this.options.outDir, "artifacts");
-        const sourcesDir = path8.join(this.options.outDir, "sources");
-        await fs9.mkdir(sourcesDir, {
+        const artifactsDir = path9.join(this.options.outDir, "artifacts");
+        const sourcesDir = path9.join(this.options.outDir, "sources");
+        await fs10.mkdir(sourcesDir, {
           recursive: true
         });
         const writtenSources = /* @__PURE__ */ new Map();
@@ -8971,7 +9440,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 fs9.writeFile(path8.join(this.options.outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+        await fs10.writeFile(path9.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) {
@@ -8983,25 +9452,25 @@ var init_compiler = __esm({
       */
       async writePrimitiveArtifacts(primitives, artifactsDir, sourcesDir, writtenSources) {
         for (const primitive of primitives) {
-          const primitiveDir = path8.join(artifactsDir, primitive.kind);
-          await fs9.mkdir(primitiveDir, {
+          const primitiveDir = path9.join(artifactsDir, primitive.kind);
+          await fs10.mkdir(primitiveDir, {
             recursive: true
           });
           const baseName = primitive.name;
-          await fs9.writeFile(path8.join(primitiveDir, `${baseName}.js`), primitive.artifact.code);
+          await fs10.writeFile(path9.join(primitiveDir, `${baseName}.js`), primitive.artifact.code);
           if (primitive.artifact.sourceMap) {
-            await fs9.writeFile(path8.join(primitiveDir, `${baseName}.js.map`), primitive.artifact.sourceMap);
+            await fs10.writeFile(path9.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 fs9.writeFile(path8.join(sourcesDir, `${sourceHash}${ext}`), primitive.artifact.originalSource);
-            const relativePath = path8.relative(this.options.rootDir, primitive.sourcePath);
+            await fs10.writeFile(path9.join(sourcesDir, `${sourceHash}${ext}`), primitive.artifact.originalSource);
+            const relativePath = path9.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 fs9.writeFile(path8.join(primitiveDir, `${baseName}.json`), JSON.stringify({
+          await fs10.writeFile(path9.join(primitiveDir, `${baseName}.json`), JSON.stringify({
             kind: primitive.kind,
             name: primitive.name,
             description: primitive.description,
@@ -9023,12 +9492,12 @@ var init_compiler = __esm({
         const allFiles = await this.collectProjectFiles();
         const workspaceRoot = this.getWorkspaceRoot();
         for (const file of allFiles) {
-          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 absPath = file.external ? path9.join(workspaceRoot, file.relativePath) : path9.join(this.options.rootDir, file.relativePath);
+          const content = await fs10.readFile(absPath, "utf-8");
           const hash = hashContent(content);
           if (!writtenSources.has(hash)) {
-            const ext = path8.extname(file.relativePath) || ".txt";
-            await fs9.writeFile(path8.join(sourcesDir, `${hash}${ext}`), content);
+            const ext = path9.extname(file.relativePath) || ".txt";
+            await fs10.writeFile(path9.join(sourcesDir, `${hash}${ext}`), content);
             writtenSources.set(hash, file.relativePath);
           }
           projectFiles.push({
@@ -9104,12 +9573,12 @@ var init_compiler = __esm({
       async collectProjectFiles() {
         const files = [];
         const scanDir = /* @__PURE__ */ __name(async (dir, relativeBase = "") => {
-          const entries = await fs9.readdir(dir, {
+          const entries = await fs10.readdir(dir, {
             withFileTypes: true
           });
           for (const entry of entries) {
             const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
-            const fullPath = path8.join(dir, entry.name);
+            const fullPath = path9.join(dir, entry.name);
             if (entry.isDirectory()) {
               if (shouldSkipDirectory(entry.name)) continue;
               await scanDir(fullPath, relativePath);
@@ -9126,10 +9595,10 @@ var init_compiler = __esm({
         const workspaceRoot = this.getWorkspaceRoot();
         const externalSeen = /* @__PURE__ */ new Set();
         for (const abs of this.externalWorkspaceFiles) {
-          const rel = path8.relative(workspaceRoot, abs).split(path8.sep).join("/");
+          const rel = path9.relative(workspaceRoot, abs).split(path9.sep).join("/");
           if (!rel || rel.startsWith("..")) continue;
           if (externalSeen.has(rel)) continue;
-          const name = path8.basename(abs);
+          const name = path9.basename(abs);
           if (shouldSkipFile(rel) || shouldSkipFile(name)) continue;
           externalSeen.add(rel);
           files.push({
@@ -9230,13 +9699,13 @@ var init_compiler = __esm({
 });
 
 // src/compiler/utils/file-discovery.ts
-import path9 from "path";
-import fs10 from "fs";
+import path10 from "path";
+import fs11 from "fs";
 function findEntryPoint(projectDir) {
   const baseDir = projectDir || process.cwd();
   for (const relativePath of ENTRY_POINT_PRIORITY) {
-    const fullPath = path9.join(baseDir, relativePath);
-    if (fs10.existsSync(fullPath)) {
+    const fullPath = path10.join(baseDir, relativePath);
+    if (fs11.existsSync(fullPath)) {
       return fullPath;
     }
   }
@@ -9272,9 +9741,9 @@ var init_file_discovery = __esm({
 });
 
 // src/compiler/source-writer.ts
-import { Project as Project3, Node as Node16 } from "ts-morph";
-import fs11 from "fs";
-import path10 from "path";
+import { Project as Project4, Node as Node17 } from "ts-morph";
+import fs12 from "fs";
+import path11 from "path";
 function resolveEntryPath(options) {
   let indexPath;
   try {
@@ -9286,14 +9755,14 @@ function resolveEntryPath(options) {
         indexPath = entryPoint;
       } else {
         const baseDir = options?.projectDir || process.cwd();
-        indexPath = path10.join(baseDir, "src", "index.ts");
+        indexPath = path11.join(baseDir, "src", "index.ts");
       }
     }
   } catch {
     const baseDir = options?.projectDir || process.cwd();
-    indexPath = path10.join(baseDir, "src", "index.ts");
+    indexPath = path11.join(baseDir, "src", "index.ts");
   }
-  if (!fs11.existsSync(indexPath)) {
+  if (!fs12.existsSync(indexPath)) {
     console.warn(`Warning: Entry file not found at ${indexPath}`);
     return null;
   }
@@ -9315,20 +9784,20 @@ function updateAgentConfig(updates, options) {
   const indexPath = resolveEntryPath(options);
   if (!indexPath) return false;
   try {
-    const project = new Project3({
+    const project = new Project4({
       skipAddingFilesFromTsConfig: true
     });
     const sourceFile = project.addSourceFileAtPath(indexPath);
     let updated = false;
     sourceFile.forEachDescendant((node) => {
-      if (Node16.isNewExpression(node) && node.getExpression().getText() === "LuaAgent") {
+      if (Node17.isNewExpression(node) && node.getExpression().getText() === "LuaAgent") {
         const args2 = node.getArguments();
-        if (args2.length > 0 && Node16.isObjectLiteralExpression(args2[0])) {
+        if (args2.length > 0 && Node17.isObjectLiteralExpression(args2[0])) {
           const configObj = args2[0];
           const replacedKeys = /* @__PURE__ */ new Set();
           let lastReplacedIndex = -1;
           configObj.getProperties().forEach((prop, index) => {
-            if (Node16.isPropertyAssignment(prop)) {
+            if (Node17.isPropertyAssignment(prop)) {
               const propName = prop.getName();
               if (Object.prototype.hasOwnProperty.call(filteredUpdates, propName)) {
                 const newValue = filteredUpdates[propName];
@@ -9384,21 +9853,21 @@ function removeAgentConfigProperty(propertyName, options) {
   const indexPath = resolveEntryPath(options);
   if (!indexPath) return false;
   try {
-    const project = new Project3({
+    const project = new Project4({
       skipAddingFilesFromTsConfig: true
     });
     const sourceFile = project.addSourceFileAtPath(indexPath);
     let foundConstructor = false;
     let removed = false;
     sourceFile.forEachDescendant((node) => {
-      if (Node16.isNewExpression(node) && node.getExpression().getText() === "LuaAgent") {
+      if (Node17.isNewExpression(node) && node.getExpression().getText() === "LuaAgent") {
         const args2 = node.getArguments();
-        if (args2.length > 0 && Node16.isObjectLiteralExpression(args2[0])) {
+        if (args2.length > 0 && Node17.isObjectLiteralExpression(args2[0])) {
           foundConstructor = true;
           const configObj = args2[0];
           const props = configObj.getProperties();
           for (const prop of props) {
-            if (Node16.isPropertyAssignment(prop) && prop.getName() === propertyName) {
+            if (Node17.isPropertyAssignment(prop) && prop.getName() === propertyName) {
               prop.remove();
               removed = true;
               break;
@@ -13283,6 +13752,164 @@ __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;
@@ -13292,11 +13919,13 @@ 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);
       }
@@ -13305,8 +13934,10 @@ async function configureCommand(options = {}) {
       clearPromptLines(2);
       if (authMethod === "api-key") {
         await handleApiKeyAuth();
+        invalidateVersioningModeCache();
       } else if (authMethod === "email") {
         await handleEmailAuth();
+        invalidateVersioningModeCache();
       }
     }
     trackEvent("cli_auth_completed", {
@@ -13978,8 +14609,8 @@ init_compile_constants();
 init_artifact_loader();
 init_backup_api_service();
 init_constants();
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 var BACKUP_CACHE_FILENAME = "backup-manifest.json";
 function calculateProjectHash(projectFiles) {
   return combineFileHashes(projectFiles);
@@ -13992,11 +14623,11 @@ function getCurrentProjectHash(projectPath = process.cwd()) {
 }
 __name(getCurrentProjectHash, "getCurrentProjectHash");
 function loadSourceByHash(hash, relativePath, projectPath = process.cwd()) {
-  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");
+  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");
   }
   return null;
 }
@@ -14015,30 +14646,30 @@ function prepareFileRefs(projectPath = process.cwd()) {
 }
 __name(prepareFileRefs, "prepareFileRefs");
 function reconcileManifestWithDisk(projectPath = process.cwd()) {
-  const manifestPath = path11.join(projectPath, COMPILE_DIRS.DIST_V2, "manifest.json");
-  if (!fs12.existsSync(manifestPath)) return;
+  const manifestPath = path12.join(projectPath, COMPILE_DIRS.DIST_V2, "manifest.json");
+  if (!fs13.existsSync(manifestPath)) return;
   const manifest = loadManifest(projectPath);
-  const sourcesDir = path11.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
-  fs12.mkdirSync(sourcesDir, {
+  const sourcesDir = path12.join(projectPath, COMPILE_DIRS.DIST_V2, "sources");
+  fs13.mkdirSync(sourcesDir, {
     recursive: true
   });
   let changed = false;
   for (const file of manifest.projectFiles) {
     if (file.external) continue;
-    const absPath = path11.join(projectPath, file.relativePath);
-    if (!fs12.existsSync(absPath)) continue;
+    const absPath = path12.join(projectPath, file.relativePath);
+    if (!fs13.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs12.readFileSync(absPath, "utf-8");
+      content = fs13.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
     const freshHash = hashContent(content);
     if (freshHash === file.hash) continue;
-    const ext = path11.extname(file.relativePath) || ".txt";
-    const sourceTargetPath = path11.join(sourcesDir, `${freshHash}${ext}`);
+    const ext = path12.extname(file.relativePath) || ".txt";
+    const sourceTargetPath = path12.join(sourcesDir, `${freshHash}${ext}`);
     try {
-      fs12.writeFileSync(sourceTargetPath, content, "utf-8");
+      fs13.writeFileSync(sourceTargetPath, content, "utf-8");
     } catch {
       continue;
     }
@@ -14047,7 +14678,7 @@ function reconcileManifestWithDisk(projectPath = process.cwd()) {
     changed = true;
   }
   if (changed) {
-    fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    fs13.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 }
 __name(reconcileManifestWithDisk, "reconcileManifestWithDisk");
@@ -14120,7 +14751,7 @@ function checkRestoreConflicts(manifest, targetDir) {
   const existingFiles = [];
   for (const file of manifest.files) {
     const filePath = resolveBackupFileTarget2(file, targetDir);
-    if (fs12.existsSync(filePath)) {
+    if (fs13.existsSync(filePath)) {
       existingFiles.push(file.relativePath);
     } else {
       newFiles.push(file.relativePath);
@@ -14146,16 +14777,16 @@ function createBackupTracking(projectHash) {
 }
 __name(createBackupTracking, "createBackupTracking");
 function getBackupCachePath(projectPath = process.cwd()) {
-  return path11.join(projectPath, ".lua", BACKUP_CACHE_FILENAME);
+  return path12.join(projectPath, ".lua", BACKUP_CACHE_FILENAME);
 }
 __name(getBackupCachePath, "getBackupCachePath");
 function writeBackupManifestCache(cache, projectPath = process.cwd()) {
   const cachePath = getBackupCachePath(projectPath);
   try {
-    fs12.mkdirSync(path11.dirname(cachePath), {
+    fs13.mkdirSync(path12.dirname(cachePath), {
       recursive: true
     });
-    fs12.writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+    fs13.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}`);
@@ -14164,9 +14795,9 @@ function writeBackupManifestCache(cache, projectPath = process.cwd()) {
 __name(writeBackupManifestCache, "writeBackupManifestCache");
 function readBackupManifestCache(projectPath = process.cwd()) {
   const cachePath = getBackupCachePath(projectPath);
-  if (!fs12.existsSync(cachePath)) return null;
+  if (!fs13.existsSync(cachePath)) return null;
   try {
-    const raw = fs12.readFileSync(cachePath, "utf-8");
+    const raw = fs13.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;
@@ -14193,18 +14824,18 @@ function detectLocalConflictsForPull(incomingFiles, projectPath = process.cwd())
     f.hash
   ]));
   const conflicts = /* @__PURE__ */ new Set();
-  const projectRoot = path11.resolve(projectPath);
+  const projectRoot = path12.resolve(projectPath);
   for (const incoming of incomingFiles) {
     if (COMPILE_MANAGED_FILES.has(incoming.relativePath)) continue;
     if (incoming.external) continue;
-    const absPath = path11.resolve(projectRoot, incoming.relativePath);
-    if (absPath !== projectRoot && !absPath.startsWith(projectRoot + path11.sep)) {
+    const absPath = path12.resolve(projectRoot, incoming.relativePath);
+    if (absPath !== projectRoot && !absPath.startsWith(projectRoot + path12.sep)) {
       continue;
     }
-    if (!fs12.existsSync(absPath)) continue;
+    if (!fs13.existsSync(absPath)) continue;
     let diskHash;
     try {
-      const bytes = fs12.readFileSync(absPath, "utf-8");
+      const bytes = fs13.readFileSync(absPath, "utf-8");
       diskHash = hashContent(bytes);
     } catch {
       conflicts.add(incoming.relativePath);
@@ -14231,7 +14862,7 @@ function detectLocalConflictsForPull(incomingFiles, projectPath = process.cwd())
 __name(detectLocalConflictsForPull, "detectLocalConflictsForPull");
 async function fetchBackupManifestForPull(apiKey, agentId) {
   try {
-    const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const backupApi = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
     const response = await backupApi.getBackupManifest();
     return {
       fetched: response.data ?? null
@@ -14262,7 +14893,7 @@ __name(decideBackupFreshness, "decideBackupFreshness");
 async function checkServerBackupNewerThanLocal(apiKey, agentId, projectPath = process.cwd()) {
   const local = readBackupManifestCache(projectPath);
   try {
-    const api = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const api = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
     const resp = await api.getBackupMetadata();
     const metadata = resp.success && resp.data ? {
       projectHash: resp.data.projectHash
@@ -14275,7 +14906,7 @@ async function checkServerBackupNewerThanLocal(apiKey, agentId, projectPath = pr
 __name(checkServerBackupNewerThanLocal, "checkServerBackupNewerThanLocal");
 async function checkBackupAvailability(apiKey, agentId) {
   try {
-    const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const backupApi = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
     const metadata = await backupApi.getBackupMetadata();
     if (metadata.data && metadata.data.fileCount > 0) {
       return {
@@ -14297,7 +14928,7 @@ __name(checkBackupAvailability, "checkBackupAvailability");
 async function restoreFromBackupForSync(apiKey, agentId, expectedPrimitives = [], projectPath, preFetchedManifest) {
   const targetDir = projectPath || process.cwd();
   try {
-    const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const backupApi = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
     const manifest = preFetchedManifest ?? (await backupApi.getBackupManifest()).data ?? null;
     if (!manifest || !manifest.files?.length) {
       return {
@@ -14383,17 +15014,17 @@ function writeBackupFilesWithByteCompare(manifest, blobs, targetDir) {
     }
     restoredContents.set(makeRestoredContentsKey(file), content);
     const filePath = resolveBackupFileTarget2(file, targetDir);
-    if (fs12.existsSync(filePath)) {
-      const existing = fs12.readFileSync(filePath);
+    if (fs13.existsSync(filePath)) {
+      const existing = fs13.readFileSync(filePath);
       if (existing.equals(content)) {
         filesUnchanged++;
         continue;
       }
     }
-    fs12.mkdirSync(path11.dirname(filePath), {
+    fs13.mkdirSync(path12.dirname(filePath), {
       recursive: true
     });
-    fs12.writeFileSync(filePath, content);
+    fs13.writeFileSync(filePath, content);
     filesWritten++;
   }
   return {
@@ -16119,7 +16750,7 @@ async function checkAndRestoreBackup(apiKey, agentId, options) {
     if (!confirm) return false;
   }
   try {
-    const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const backupApi = new backup_api_service_default(BASE_URLS.API, apiKey, agentId);
     const urlsResponse = await backupApi.getBlobUrls(manifest.files.map((f) => f.hash));
     if (!urlsResponse.success || !urlsResponse.data) {
       writeError(`Failed to fetch download URLs: ${urlsResponse.error?.message ?? "unknown error"}`);
@@ -16173,6 +16804,7 @@ 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.");
@@ -16198,6 +16830,7 @@ 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.");
@@ -16268,13 +16901,13 @@ __name(apiKeyCommand, "apiKeyCommand");
 init_cli();
 init_files();
 init_auth();
-import path13 from "path";
+import path14 from "path";
 
 // src/commands/sync.ts
 init_dist();
 init_cli();
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 
 // src/utils/prompt-handler.ts
 init_cli();
@@ -16485,8 +17118,8 @@ init_mcp_server_handler();
 async function syncCommand(options) {
   return withErrorHandling(async () => {
     const preCompileYaml = readYamlConfig();
-    const yamlPath = path12.resolve(process.cwd(), "lua.skill.yaml");
-    const preCompileYamlBytes = fs13.existsSync(yamlPath) ? fs13.readFileSync(yamlPath, "utf-8") : null;
+    const yamlPath = path13.resolve(process.cwd(), "lua.skill.yaml");
+    const preCompileYamlBytes = fs14.existsSync(yamlPath) ? fs14.readFileSync(yamlPath, "utf-8") : null;
     let syncCompletedSuccessfully = false;
     try {
       writeProgress("\u{1F504} Compiling to get latest local state...");
@@ -16547,7 +17180,7 @@ async function syncCommand(options) {
     } finally {
       if (!syncCompletedSuccessfully && preCompileYamlBytes !== null) {
         try {
-          fs13.writeFileSync(yamlPath, preCompileYamlBytes, "utf-8");
+          fs14.writeFileSync(yamlPath, preCompileYamlBytes, "utf-8");
         } catch {
         }
       }
@@ -18104,7 +18737,7 @@ async function compileCommand(options) {
     }
     writeProgress("\u{1F528} Compiling...");
     const rootDir = process.cwd();
-    const outDir = path13.join(rootDir, "dist-v2");
+    const outDir = path14.join(rootDir, "dist-v2");
     const result = await compile({
       rootDir,
       outDir,
@@ -18267,17 +18900,18 @@ init_cli();
 init_command_utils();
 
 // src/utils/sandbox.ts
-import vm2 from "vm";
-import path16 from "path";
+import vm3 from "vm";
+import path17 from "path";
 
 // ../shared-sandbox/dist/index.mjs
 import vm from "vm";
 import { createRequire } from "module";
-import path14 from "path";
+import path15 from "path";
 import dns from "dns";
 import net from "net";
 import { promisify } from "util";
 import { Agent as UndiciAgent } from "undici";
+import vm2 from "vm";
 var __defProp4 = Object.defineProperty;
 var __name4 = /* @__PURE__ */ __name((target, value) => __defProp4(target, "name", { value, configurable: true }), "__name");
 function buildSandboxProcess(opts) {
@@ -18442,7 +19076,7 @@ var REQUIRE_BLOCKLIST = /* @__PURE__ */ new Set([
 var SANDBOX_FAKE_DIRNAME = "/";
 var SANDBOX_FAKE_FILENAME = "/index.ts";
 function buildSandboxRequire(opts) {
-  const realRequire = createRequire(path14.join(opts.cwd, "package.json"));
+  const realRequire = createRequire(path15.join(opts.cwd, "package.json"));
   const wrapped = /* @__PURE__ */ __name4((id) => {
     if (REQUIRE_BLOCKLIST.has(id)) {
       const evt = {
@@ -19088,16 +19722,38 @@ function applyGlobalSelfReference(context) {
 }
 __name(applyGlobalSelfReference, "applyGlobalSelfReference");
 __name4(applyGlobalSelfReference, "applyGlobalSelfReference");
+function resolveExtraAllowedCidrs() {
+  const csv = process.env.LUA_ALLOWED_EGRESS_CIDRS;
+  if (!csv) return [];
+  return csv.split(",").map((s) => s.trim()).filter(Boolean);
+}
+__name(resolveExtraAllowedCidrs, "resolveExtraAllowedCidrs");
+__name4(resolveExtraAllowedCidrs, "resolveExtraAllowedCidrs");
+function wrapBundleAsCjsModule(source) {
+  return "(function(module, exports, require) {\n" + source + "\n})(module, module.exports, require);";
+}
+__name(wrapBundleAsCjsModule, "wrapBundleAsCjsModule");
+__name4(wrapBundleAsCjsModule, "wrapBundleAsCjsModule");
+function runBundleInContext(context, source, options) {
+  const wrapped = wrapBundleAsCjsModule(source);
+  vm2.runInContext(wrapped, context, {
+    filename: options.filename,
+    timeout: options.timeoutMs ?? 1e3,
+    lineOffset: -1
+  });
+}
+__name(runBundleInContext, "runBundleInContext");
+__name4(runBundleInContext, "runBundleInContext");
 
 // src/utils/env-loader.utils.ts
-import path15 from "path";
-import fs14 from "fs";
+import path16 from "path";
+import fs15 from "fs";
 function parseEnvFile(filePath) {
-  if (!fs14.existsSync(filePath)) {
+  if (!fs15.existsSync(filePath)) {
     return {};
   }
   try {
-    const content = fs14.readFileSync(filePath, "utf8");
+    const content = fs15.readFileSync(filePath, "utf8");
     if (!content.trim()) return {};
     const envVars = {};
     content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).forEach((line) => {
@@ -19123,7 +19779,7 @@ async function loadEnvironmentVariables(context) {
 }
 __name(loadEnvironmentVariables, "loadEnvironmentVariables");
 function loadSandboxEnvVariables() {
-  const envFilePath = path15.join(process.cwd(), ".env");
+  const envFilePath = path16.join(process.cwd(), ".env");
   const envMap = parseEnvFile(envFilePath);
   return Object.entries(envMap).map(([key, value]) => ({
     key,
@@ -19200,12 +19856,12 @@ function resolveEgressMode() {
   return "off";
 }
 __name(resolveEgressMode, "resolveEgressMode");
-function resolveExtraAllowedCidrs() {
+function resolveExtraAllowedCidrs2() {
   const csv = process.env.LUA_ALLOWED_EGRESS_CIDRS;
   if (!csv) return [];
   return csv.split(",").map((s) => s.trim()).filter(Boolean);
 }
-__name(resolveExtraAllowedCidrs, "resolveExtraAllowedCidrs");
+__name(resolveExtraAllowedCidrs2, "resolveExtraAllowedCidrs");
 function defaultSecurityEventLogger(evt) {
   console.warn("[sandbox]", JSON.stringify(evt));
 }
@@ -19218,7 +19874,7 @@ function loadEnvironmentVariables2() {
       envVars[key] = value;
     }
   }
-  const envFilePath = path16.join(process.cwd(), ".env");
+  const envFilePath = path17.join(process.cwd(), ".env");
   const fileEnvVars = parseEnvFile(envFilePath);
   Object.assign(envVars, fileEnvVars);
   return envVars;
@@ -19353,7 +20009,7 @@ function createSandbox(options) {
     extraGlobals,
     requireMode: resolveRequireMode(),
     egressMode: resolveEgressMode(),
-    egressExtraAllowedCidrs: resolveExtraAllowedCidrs(),
+    egressExtraAllowedCidrs: resolveExtraAllowedCidrs2(),
     onSecurityEvent: defaultSecurityEventLogger
   });
 }
@@ -19361,11 +20017,14 @@ __name(createSandbox, "createSandbox");
 async function executeTool(options) {
   const { toolCode, inputs } = options;
   const sandbox = createSandbox(options);
-  const context = vm2.createContext(sandbox);
+  const context = vm3.createContext(sandbox);
   applyGlobalSelfReference(context);
   const isBundledArtifact = toolCode.includes("__lua_primitive__");
   if (isBundledArtifact) {
-    vm2.runInContext(toolCode, context);
+    runBundleInContext(context, toolCode, {
+      filename: "tool.bundle.js",
+      timeoutMs: 18e4
+    });
     const moduleExports = context.module.exports;
     const primitive = moduleExports.default?.primitive || moduleExports.primitive;
     if (!primitive || !primitive.execute) {
@@ -19393,7 +20052,7 @@ module.exports = async (input) => {
   }
 };
 `;
-    vm2.runInContext(commonJsWrapper, context);
+    vm3.runInContext(commonJsWrapper, context);
     const executeFunction = context.module.exports;
     return await executeFunction(inputs);
   }
@@ -19402,7 +20061,7 @@ __name(executeTool, "executeTool");
 async function executeWebhook(options) {
   const { webhookCode, query, headers, body } = options;
   const sandbox = createSandbox(options);
-  const context = vm2.createContext(sandbox);
+  const context = vm3.createContext(sandbox);
   applyGlobalSelfReference(context);
   const event = {
     query: query ?? {},
@@ -19412,7 +20071,10 @@ async function executeWebhook(options) {
   };
   const isBundledArtifact = webhookCode.includes("__lua_primitive__");
   if (isBundledArtifact) {
-    vm2.runInContext(webhookCode, context);
+    runBundleInContext(context, webhookCode, {
+      filename: "webhook.bundle.js",
+      timeoutMs: 18e4
+    });
     const moduleExports = context.module.exports;
     const primitive = moduleExports.default?.primitive || moduleExports.primitive;
     if (!primitive || !primitive.execute) {
@@ -19440,7 +20102,7 @@ module.exports = async (event) => {
   }
 };
 `;
-    vm2.runInContext(commonJsWrapper, context);
+    vm3.runInContext(commonJsWrapper, context);
     const executeFunction = context.module.exports;
     return await executeFunction(event);
   }
@@ -19449,7 +20111,7 @@ __name(executeWebhook, "executeWebhook");
 async function executeJob(options) {
   const { jobCode, jobData, apiKey, agentId } = options;
   const sandbox = createSandbox(options);
-  const context = vm2.createContext(sandbox);
+  const context = vm3.createContext(sandbox);
   applyGlobalSelfReference(context);
   let jobInstance = void 0;
   if (jobData) {
@@ -19475,7 +20137,10 @@ async function executeJob(options) {
   }
   const isBundledArtifact = jobCode.includes("__lua_primitive__");
   if (isBundledArtifact) {
-    vm2.runInContext(jobCode, context);
+    runBundleInContext(context, jobCode, {
+      filename: "job.bundle.js",
+      timeoutMs: 18e4
+    });
     const moduleExports = context.module.exports;
     const primitive = moduleExports.default?.primitive || moduleExports.primitive;
     if (!primitive || !primitive.execute) {
@@ -19503,7 +20168,7 @@ module.exports = async (job) => {
   }
 };
 `;
-    vm2.runInContext(commonJsWrapper, context);
+    vm3.runInContext(commonJsWrapper, context);
     const executeFunction = context.module.exports;
     return await executeFunction(jobInstance);
   }
@@ -19515,11 +20180,14 @@ async function executePreProcessor(options) {
   const UserDataApi2 = (await Promise.resolve().then(() => (init_user_data_api_service(), user_data_api_service_exports))).default;
   const userService = new UserDataApi2(BASE_URLS.API, apiKey, agentId);
   const userInstance = await userService.get();
-  const context = vm2.createContext(sandbox);
+  const context = vm3.createContext(sandbox);
   applyGlobalSelfReference(context);
   const isBundledArtifact = processorCode.includes("__lua_primitive__");
   if (isBundledArtifact) {
-    vm2.runInContext(processorCode, context);
+    runBundleInContext(context, processorCode, {
+      filename: "preprocessor.bundle.js",
+      timeoutMs: 18e4
+    });
     const moduleExports = context.module.exports;
     const primitive = moduleExports.default?.primitive || moduleExports.primitive;
     if (!primitive || !primitive.execute) {
@@ -19547,7 +20215,7 @@ module.exports = async (input) => {
   }
 };
 `;
-    vm2.runInContext(commonJsWrapper, context);
+    vm3.runInContext(commonJsWrapper, context);
     const executeFunction = context.module.exports;
     return await executeFunction({
       user: userInstance,
@@ -19563,11 +20231,14 @@ async function executePostProcessor(options) {
   const UserDataApi2 = (await Promise.resolve().then(() => (init_user_data_api_service(), user_data_api_service_exports))).default;
   const userService = new UserDataApi2(BASE_URLS.API, apiKey, agentId);
   const userInstance = await userService.get();
-  const context = vm2.createContext(sandbox);
+  const context = vm3.createContext(sandbox);
   applyGlobalSelfReference(context);
   const isBundledArtifact = processorCode.includes("__lua_primitive__");
   if (isBundledArtifact) {
-    vm2.runInContext(processorCode, context);
+    runBundleInContext(context, processorCode, {
+      filename: "postprocessor.bundle.js",
+      timeoutMs: 18e4
+    });
     const moduleExports = context.module.exports;
     const primitive = moduleExports.default?.primitive || moduleExports.primitive;
     if (!primitive || !primitive.execute) {
@@ -19592,7 +20263,7 @@ module.exports = async (input) => {
   }
 };
 `;
-    vm2.runInContext(commonJsWrapper, context);
+    vm3.runInContext(commonJsWrapper, context);
     const executeFunction = context.module.exports;
     return await executeFunction({
       user: userInstance,
@@ -21089,6 +21760,7 @@ init_dist();
 init_files();
 init_cli();
 init_command_utils();
+init_auth();
 init_semver();
 init_auth_error();
 init_constants();
@@ -21155,7 +21827,7 @@ async function runBackupPush(opts) {
       projectHash: manifestProjectHash
     };
   }
-  const backupApi = new BackupApi(BASE_URLS.API, opts.apiKey, opts.agentId);
+  const backupApi = new backup_api_service_default(BASE_URLS.API, opts.apiKey, opts.agentId);
   const allHashes = opts.fresh ? [
     ...new Set(fileRefs.map((f) => f.hash))
   ] : getAllFileHashes(projectPath);
@@ -21216,8 +21888,8 @@ async function runBackupPush(opts) {
 }
 __name(runBackupPush, "runBackupPush");
 async function uploadBlobsFromDisk(uploadUrls, files, projectPath, concurrency = 10) {
-  const fs16 = await import("fs");
-  const path18 = await import("path");
+  const fs17 = await import("fs");
+  const path19 = await import("path");
   const zlib2 = await import("zlib");
   const hashToPath = /* @__PURE__ */ new Map();
   for (const f of files) {
@@ -21231,8 +21903,8 @@ async function uploadBlobsFromDisk(uploadUrls, files, projectPath, concurrency =
       if (!rel) {
         throw new Error(`No file found for hash: ${hash}`);
       }
-      const abs = path18.join(projectPath, rel);
-      const content = fs16.readFileSync(abs);
+      const abs = path19.join(projectPath, rel);
+      const content = fs17.readFileSync(abs);
       const compressed = zlib2.gzipSync(content);
       const response = await fetch(uploadUrls[hash], {
         method: "PUT",
@@ -21323,6 +21995,262 @@ init_analytics();
 init_dist2();
 init_skills_api_service();
 
+// src/utils/try-git-commit.ts
+init_cli();
+init_files();
+
+// src/utils/git.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function runGit(args2, opts = {}) {
+  return new Promise((resolve6, reject) => {
+    const child = spawn("git", args2, {
+      cwd: opts.cwd,
+      shell: false,
+      stdio: [
+        "ignore",
+        "pipe",
+        "pipe"
+      ]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      child.kill("SIGKILL");
+      reject(new Error(`git ${args2.join(" ")} timed out after ${opts.timeout ?? DEFAULT_TIMEOUT_MS}ms`));
+    }, opts.timeout ?? DEFAULT_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stdout?.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.stderr?.on("error", () => {
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve6({
+        stdout,
+        stderr,
+        code: code ?? 0
+      });
+    });
+  });
+}
+__name(runGit, "runGit");
+function classifyGitError(err, stderr = "") {
+  if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+    return "no-git";
+  }
+  const s = stderr.toLowerCase();
+  if (s.includes("not a git repository")) return "no-repo";
+  if (s.includes("head detached") || s.includes("does not point to a branch") || s.includes("src refspec head does not match")) return "detached-head";
+  if (s.includes("pre-commit hook") || s.includes("hook failed")) return "hook-failed";
+  if (s.includes("already exists")) return "tag-exists";
+  if (s.includes("nothing to commit")) return "nothing-to-commit";
+  if (s.includes("authentication failed") || s.includes("could not read username")) return "auth";
+  return "unknown";
+}
+__name(classifyGitError, "classifyGitError");
+async function isGitAvailable() {
+  try {
+    const { code } = await runGit([
+      "--version"
+    ]);
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+__name(isGitAvailable, "isGitAvailable");
+async function isInsideGitRepo(cwd) {
+  try {
+    const { code } = await runGit([
+      "rev-parse",
+      "--is-inside-work-tree"
+    ], {
+      cwd
+    });
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+__name(isInsideGitRepo, "isInsideGitRepo");
+async function gitUserConfigured(cwd) {
+  const readOne = /* @__PURE__ */ __name(async (key) => {
+    try {
+      const { stdout, code } = await runGit([
+        "config",
+        "--get",
+        key
+      ], {
+        cwd
+      });
+      if (code !== 0) return void 0;
+      const trimmed = stdout.trim();
+      return trimmed.length > 0 ? trimmed : void 0;
+    } catch {
+      return void 0;
+    }
+  }, "readOne");
+  const [name, email] = await Promise.all([
+    readOne("user.name"),
+    readOne("user.email")
+  ]);
+  return {
+    name,
+    email
+  };
+}
+__name(gitUserConfigured, "gitUserConfigured");
+async function getCommitSha(cwd) {
+  try {
+    const { stdout, code } = await runGit([
+      "rev-parse",
+      "HEAD"
+    ], {
+      cwd
+    });
+    if (code !== 0) return null;
+    const sha = stdout.trim();
+    return sha.length > 0 ? sha : null;
+  } catch {
+    return null;
+  }
+}
+__name(getCommitSha, "getCommitSha");
+
+// src/utils/try-git-commit.ts
+init_analytics();
+async function tryGitCommit(opts) {
+  const config = readYamlConfig();
+  if (!config?.git?.enabled) {
+    return {
+      committed: false
+    };
+  }
+  const runOpts = {
+    cwd: opts.cwd
+  };
+  if (!opts.allowEmpty) {
+    try {
+      const addResult = await runGit([
+        "add",
+        "-A"
+      ], runOpts);
+      if (addResult.code !== 0) {
+        const reason = classifyGitError(null, addResult.stderr);
+        reportFailure("add", reason);
+        return {
+          committed: false
+        };
+      }
+    } catch (err) {
+      const reason = classifyGitError(err);
+      reportFailure("add", reason);
+      return {
+        committed: false
+      };
+    }
+  }
+  const commitArgs = [
+    "commit"
+  ];
+  if (opts.allowEmpty) commitArgs.push("--allow-empty");
+  commitArgs.push("-m", opts.message);
+  try {
+    const commitResult = await runGit(commitArgs, runOpts);
+    if (commitResult.code !== 0) {
+      const reason = classifyGitError(null, commitResult.stderr);
+      if (reason !== "nothing-to-commit") {
+        reportFailure("commit", reason);
+      }
+      return {
+        committed: false
+      };
+    }
+  } catch (err) {
+    const reason = classifyGitError(err);
+    if (reason !== "nothing-to-commit") {
+      reportFailure("commit", reason);
+    }
+    return {
+      committed: false
+    };
+  }
+  const sha = await getCommitSha(opts.cwd) ?? void 0;
+  let tagged;
+  if (opts.tag) {
+    try {
+      const tagResult = await runGit([
+        "tag",
+        opts.tag
+      ], runOpts);
+      if (tagResult.code !== 0) {
+        const reason = classifyGitError(null, tagResult.stderr);
+        reportFailure("tag", reason);
+        tagged = false;
+      } else {
+        tagged = true;
+      }
+    } catch (err) {
+      const reason = classifyGitError(err);
+      reportFailure("tag", reason);
+      tagged = false;
+    }
+  }
+  trackEvent("cli_git_sideeffect_succeeded", {
+    action: opts.action,
+    has_sha: Boolean(sha),
+    has_tag: tagged === true
+  });
+  return {
+    committed: true,
+    sha,
+    tagged
+  };
+}
+__name(tryGitCommit, "tryGitCommit");
+function reportFailure(action, reason) {
+  writeInfo(`\u26A0\uFE0F  Git ${action} skipped: ${reason}`);
+  trackEvent("cli_git_sideeffect_failed", {
+    action,
+    reason
+  });
+}
+__name(reportFailure, "reportFailure");
+
+// src/utils/git-messages.ts
+var GIT_MESSAGES = {
+  pushStaged: "lua: push staged code",
+  createVersion: /* @__PURE__ */ __name((version, message) => {
+    const trimmed = message?.trim();
+    return trimmed ? `lua: create version v${version}: ${trimmed}` : `lua: create version v${version}`;
+  }, "createVersion"),
+  promote: /* @__PURE__ */ __name((version) => `lua: promote v${version} to production`, "promote"),
+  delete: /* @__PURE__ */ __name((version) => `lua: delete version v${version}`, "delete"),
+  pullLatest: "lua: pull latest backup",
+  pullVersion: /* @__PURE__ */ __name((version) => `lua: pull version v${version}`, "pullVersion")
+};
+var tagName = /* @__PURE__ */ __name((version) => `lua/v${version}`, "tagName");
+
 // src/commands/push-helpers.ts
 function pickPushAllNextStepVariant(opts) {
   if (opts.pushedSomething && opts.failedCount === 0) return "success";
@@ -21637,6 +22565,34 @@ 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);
+    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;
+    }
+    if (options.entityName && !type) {
+      console.log("\nUsage:");
+      console.log("  lua push skill --name mySkill --set-version 1.0.5        Push specific skill");
+      console.log("  lua push webhook --name myWebhook --set-version 2.0.0    Push specific webhook");
+      throw new Error("Type must be specified when using the --name option.");
+    }
+    if (isStageAll) {
+      return await pushAllCommand({
+        ...options,
+        autoDeployNoopWarned: isAutoDeployNoOp
+      });
+    }
+    if (isGranular) {
+      writeInfo("\u26A0\uFE0F  Granular push is deprecated when agent versioning is on. Use `lua push` (no args) to stage all changes, then `lua version create`.");
+    }
     if (type === "all") {
       if (!options.force) {
         console.log("\nUsage:");
@@ -21644,13 +22600,10 @@ async function pushCommand(type, cmdObj) {
         console.log("  lua push all --force --auto-deploy  Push and deploy all to production");
         throw new Error('The "all" type requires the --force flag');
       }
-      return await pushAllCommand(options);
-    }
-    if (options.entityName && !type) {
-      console.log("\nUsage:");
-      console.log("  lua push skill --name mySkill --set-version 1.0.5        Push specific skill");
-      console.log("  lua push webhook --name myWebhook --set-version 2.0.0    Push specific webhook");
-      throw new Error("Type must be specified when using the --name option.");
+      return await pushAllCommand({
+        ...options,
+        autoDeployNoopWarned: isAutoDeployNoOp
+      });
     }
     if (type) {
       selectedType = type;
@@ -21791,13 +22744,17 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
       bundles_total: versionedPushDeployResult?.bundleStats?.total ?? 0,
       bundles_uploaded: versionedPushDeployResult?.bundleStats?.uploaded ?? 0,
       bundles_existed: versionedPushDeployResult?.bundleStats?.alreadyExisted ?? 0,
-      // Phase 2 `--include-source` telemetry. Tracks adoption of the flag
-      // and whether the per-skill source attach actually lands cleanly —
-      // useful for the eventual "flip default to ON" decision in Slice 5.
+      // `--include-source` telemetry. Tracks adoption of the flag and whether
+      // the per-skill source attach actually lands cleanly — useful for the
+      // eventual "flip default to ON" decision.
       include_source_requested: options.includeSource || false,
       include_source_attempted: trackedIncludeSource?.attempted ?? 0,
       include_source_attached: trackedIncludeSource?.attached ?? 0,
-      include_source_failed: trackedIncludeSource?.failed ?? 0
+      include_source_failed: trackedIncludeSource?.failed ?? 0,
+      // Agent-versioning telemetry. Driven by isStageAll / isGranular.
+      versioning_mode: versioning.enabled ? isGranular ? "granular" : "all" : "flag-off",
+      granular_deprecation_warned: isGranular,
+      auto_deploy_noop_warned: isAutoDeployNoOp
     });
     const productionDeployedActually = versionedPushDeployResult?.productionDeploySucceeded === true || !!agentOutcome && !agentOutcome.cancelled && agentOutcome.productionDeployedWithAutoDeploy;
     const personaAutoDeployRanAndFailed = selectedType === "agent" && options.autoDeploy && !!agentOutcome && !agentOutcome.cancelled && "personaAutoDeployFailed" in agentOutcome && agentOutcome.personaAutoDeployFailed;
@@ -22090,6 +23047,7 @@ 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();
@@ -22386,15 +23344,26 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
     bundles_total: bundleStatsAggregate.total,
     bundles_uploaded: bundleStatsAggregate.uploaded,
     bundles_existed: bundleStatsAggregate.existed,
-    // Phase 2 `--include-source` telemetry, parallel to the single-push
+    // `--include-source` telemetry, parallel to the single-push
     // `cli_push_completed` shape. Without these the `lua push all` path —
-    // arguably the highest-volume one for multi-skill agents — would be
-    // invisible to adoption monitoring.
+    // the highest-volume one for multi-skill agents — would be invisible
+    // to adoption monitoring.
     include_source_requested: options.includeSource || false,
     include_source_attempted: includeSourceStats?.attempted ?? 0,
     include_source_attached: includeSourceStats?.attached ?? 0,
-    include_source_failed: includeSourceStats?.failed ?? 0
+    include_source_failed: includeSourceStats?.failed ?? 0,
+    // Agent-versioning telemetry.
+    versioning_mode: pushAllVersioning.enabled ? "stage-all" : "flag-off",
+    granular_deprecation_warned: false,
+    auto_deploy_noop_warned: options.autoDeployNoopWarned || false
   });
+  try {
+    await tryGitCommit({
+      message: GIT_MESSAGES.pushStaged,
+      action: "push-staged"
+    });
+  } catch {
+  }
   const pushedSomething = allResults.length > 0 || mcpPushedCount > 0 || !!personaPushResult || backupSuccess;
   const variant = pickPushAllNextStepVariant({
     pushedSomething,
@@ -22402,7 +23371,11 @@ Until the backup catches up, \`lua init\` for this agent will restore an older s
   });
   if (variant === "success") {
     console.log("");
-    if (options.autoDeploy) {
+    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: [
@@ -22670,6 +23643,10 @@ 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.");
+    }
     let personaDeployed = false;
     let versionedOutcome = null;
     if (selectedType === "persona") {
@@ -22682,7 +23659,8 @@ async function deployCommand(type, cmdObj) {
       primitive_type: selectedType,
       force_mode: options.force || false,
       entity_selected_by_name: !!options.name,
-      version_selected_by_flag: !!options.version
+      version_selected_by_flag: !!options.version,
+      granular_deprecation_warned: versioning.enabled
     });
     const deployed = selectedType === "persona" ? personaDeployed : versionedOutcome?.deployed ?? false;
     const hintPrintedAlready = selectedType !== "persona" && !!versionedOutcome?.hintPrinted;
@@ -23176,11 +24154,11 @@ init_cli();
 
 // src/utils/sandbox-storage.ts
 init_constants();
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname5 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname6 } from "path";
 function readStore() {
   try {
-    const raw = readFileSync8(SANDBOX_STORAGE_FILE, "utf8");
+    const raw = readFileSync10(SANDBOX_STORAGE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       skills: parsed.skills ?? {},
@@ -23200,10 +24178,10 @@ function readStore() {
 __name(readStore, "readStore");
 function writeStore(store) {
   try {
-    mkdirSync6(dirname5(SANDBOX_STORAGE_FILE), {
+    mkdirSync7(dirname6(SANDBOX_STORAGE_FILE), {
       recursive: true
     });
-    writeFileSync6(SANDBOX_STORAGE_FILE, JSON.stringify(store, null, 2), "utf8");
+    writeFileSync7(SANDBOX_STORAGE_FILE, JSON.stringify(store, null, 2), "utf8");
   } catch {
   }
 }
@@ -23707,7 +24685,15 @@ var MIME_TYPES = {
   ".json": "application/json",
   // Email
   ".eml": "message/rfc822",
-  ".msg": "application/vnd.ms-outlook"
+  ".msg": "application/vnd.ms-outlook",
+  // Audio. lua-core picks the path per provider: types in the provider's
+  // native allowlist go straight to the model, the rest are transcribed by
+  // Deepgram via FileConversionService.
+  ".m4a": "audio/mp4",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/opus"
 };
 var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
@@ -24517,8 +25503,8 @@ init_cli();
 init_constants();
 init_command_utils();
 init_developer_api_service();
-import fs15 from "fs";
-import path17 from "path";
+import fs16 from "fs";
+import path18 from "path";
 import inquirer10 from "inquirer";
 init_analytics();
 function resolveEnvironment(env, hasNonInteractiveFlags) {
@@ -24877,10 +25863,10 @@ function variablesToEnvContent(variables) {
 }
 __name(variablesToEnvContent, "variablesToEnvContent");
 function saveSandboxEnvVariables(variables) {
-  const envFilePath = path17.join(process.cwd(), ".env");
+  const envFilePath = path18.join(process.cwd(), ".env");
   try {
     const content = variablesToEnvContent(variables);
-    fs15.writeFileSync(envFilePath, content, "utf8");
+    fs16.writeFileSync(envFilePath, content, "utf8");
     return true;
   } catch (error) {
     console.error("\u274C Error saving .env file:", error);
@@ -29372,7 +30358,7 @@ init_auth();
 init_auth_api_service();
 init_files();
 init_artifact_loader();
-import { existsSync as existsSync7, readFileSync as readFileSync9 } 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";
@@ -29723,7 +30709,7 @@ function gatherTelemetry() {
   } else {
     try {
       if (existsSync7(TELEMETRY_FILE)) {
-        const raw = readFileSync9(TELEMETRY_FILE, "utf8");
+        const raw = readFileSync11(TELEMETRY_FILE, "utf8");
         const cfg = JSON.parse(raw);
         if (typeof cfg.enabled === "boolean") enabled = cfg.enabled;
       }
@@ -38904,7 +39890,7 @@ __name(telemetryCommand, "telemetryCommand");
 init_cli();
 init_command_utils();
 init_analytics();
-import { writeFileSync as writeFileSync7, 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();
@@ -39065,7 +40051,7 @@ async function governanceCommand(action) {
       }
     }
     const content = generateFile(setup);
-    writeFileSync7(filePath, content, "utf-8");
+    writeFileSync8(filePath, content, "utf-8");
     const relativePath = filePath.replace(process.cwd() + "/", "");
     writeSuccess(`Created ${relativePath}`);
     console.log("");
@@ -39329,14 +40315,14 @@ init_analytics();
 init_command_utils();
 init_artifact_loader();
 init_types();
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join8, relative, resolve as resolve5 } from "path";
 init_voice_api_service();
 init_constants();
 
 // src/commands/voice-terminal.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn as spawn2, spawnSync } from "child_process";
 import { platform as platform3 } from "os";
 import { AudioFrame, AudioSource, AudioStream, LocalAudioTrack, Room, RoomEvent, TrackKind, TrackPublishOptions, TrackSource } from "@livekit/rtc-node";
 
@@ -39599,7 +40585,7 @@ function spawnCapture() {
     String(FRAME_SAMPLES * 2),
     "-"
   ];
-  const proc = spawn("sox", args2, {
+  const proc = spawn2("sox", args2, {
     stdio: [
       "ignore",
       "pipe",
@@ -39630,7 +40616,7 @@ function spawnPlayback() {
     "-",
     "-d"
   ];
-  const proc = spawn("sox", args2, {
+  const proc = spawn2("sox", args2, {
     stdio: [
       "pipe",
       "ignore",
@@ -39960,7 +40946,7 @@ function buildRunnerArgs(runner, opts) {
 __name(buildRunnerArgs, "buildRunnerArgs");
 async function spawnRunner(runner, args2, cwd) {
   return new Promise((resolveExit) => {
-    const proc = spawn2("npx", [
+    const proc = spawn3("npx", [
       runner,
       ...args2
     ], {
@@ -40353,6 +41339,12 @@ async function sourceRollbackCommand(opts) {
   const config = readYamlConfig();
   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.");
+    }
+  }
   const fetchM = opts.fetchManifest ?? defaultFetchManifest;
   const fetchU = opts.fetchUrls ?? defaultFetchUrls;
   const dlBlobs = opts.downloadBlobs ?? downloadBlobsParallel;
@@ -40423,6 +41415,560 @@ function defaultRestore(manifest, blobs, targetDir) {
 }
 __name(defaultRestore, "defaultRestore");
 
+// src/commands/version.ts
+init_cli();
+init_command_utils();
+init_analytics();
+init_files();
+init_constants();
+
+// src/utils/parse-version.ts
+function parseVersion2(arg) {
+  if (!arg) throw new Error(`Invalid version "${arg}": must be a positive integer like "3" or "v3".`);
+  const stripped = arg.replace(/^v/i, "");
+  const n = Number.parseInt(stripped, 10);
+  if (!Number.isFinite(n) || n <= 0 || String(n) !== stripped) {
+    throw new Error(`Invalid version "${arg}": must be a positive integer like "3" or "v3".`);
+  }
+  return n;
+}
+__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) {
+      await pushAllCommand({
+        force: true,
+        includeSource: true,
+        suppressVersionCreateHint: true
+      });
+      config = readYamlConfig();
+      backupVersion = config?.backup?.activeVersion;
+      if (backupVersion == null) {
+        throw new Error("Backup tracking lost after push. Aborting.");
+      }
+    }
+    if (backupVersion == null) {
+      throw new Error("No backup exists for this agent. Run `lua push` first, or pass `--auto-push` to push and snapshot in one step.");
+    }
+    let message = options.message;
+    const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const isCi = isCiModeEnabled();
+    if (!message && isTTY && !isCi) {
+      const answers = await safePrompt([
+        {
+          type: "input",
+          name: "input",
+          message: "Optional description (blank to skip):"
+        }
+      ]);
+      message = answers?.input?.trim() || void 0;
+    }
+    const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.createVersion({
+      message,
+      sourceManifestVersion: backupVersion,
+      commitHash: options.commitHash
+    });
+    if (!result.success || !result.data) {
+      throw new Error(result.error?.message ?? "Failed to create version");
+    }
+    writeInfo(`\u2713 Created v${result.data.version} (staged). Run \`lua version promote v${result.data.version}\` to deploy.`);
+    try {
+      const gitResult = await tryGitCommit({
+        message: GIT_MESSAGES.createVersion(result.data.version, message),
+        action: "version-create",
+        tag: tagName(result.data.version),
+        allowEmpty: true
+      });
+      if (gitResult.committed && gitResult.sha) {
+        await api.patchCommitHash(result.data.version, gitResult.sha);
+      }
+    } catch {
+    }
+    trackEvent("cli_version_create_completed", {
+      auto_push: Boolean(options.autoPush),
+      has_message: Boolean(message),
+      non_interactive: !isTTY || isCi
+    });
+  }, "version create");
+}
+__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;
+    if (options.status) query.status = options.status;
+    const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
+    const response = await api.listVersions(query);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message ?? "Failed to list versions");
+    }
+    const versions = response.data;
+    if (options.json) {
+      console.log(JSON.stringify(versions, null, 2));
+    } else if (versions.length === 0) {
+      writeInfo("(no versions yet \u2014 run `lua version create` to make one)");
+    } else {
+      console.log("VERSION    STATUS       CREATED              BY         MESSAGE");
+      for (const v of versions) {
+        const star = v.status === "active" ? "*" : " ";
+        const date = new Date(v.createdAt).toISOString().slice(0, 16).replace("T", " ");
+        const status = v.status.padEnd(11);
+        const by = (v.createdBy || "").slice(0, 10).padEnd(10);
+        const msg = (v.message || "").slice(0, 60);
+        console.log(`v${v.version}${star}    ${status} ${date}  ${by}${msg}`);
+      }
+    }
+    trackEvent("cli_version_list_completed", {
+      count: versions.length,
+      status_filter: options.status ?? "all"
+    });
+  }, "version list");
+}
+__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);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message ?? `Version v${version} not found`);
+    }
+    const v = response.data;
+    if (options.json) {
+      console.log(JSON.stringify(v, null, 2));
+    } else {
+      console.log(`Version v${v.version} (${v.status})`);
+      console.log(`  Created: ${v.createdAt} by ${v.createdBy}`);
+      if (v.message) console.log(`  Message: ${v.message}`);
+      if (v.commitHash) console.log(`  Commit:  ${v.commitHash}`);
+      console.log(`  Model:   ${v.snapshot.model}`);
+      console.log(`  Snapshot:`);
+      console.log(`    Skills:         ${v.snapshot.skills.length}`);
+      console.log(`    Webhooks:       ${v.snapshot.webhooks.length}`);
+      console.log(`    Jobs:           ${v.snapshot.jobs.length}`);
+      console.log(`    Preprocessors:  ${v.snapshot.preprocessors.length}`);
+      console.log(`    Postprocessors: ${v.snapshot.postprocessors.length}`);
+      console.log(`    MCP servers:    ${v.snapshot.mcpServers.length}`);
+      console.log(`    Persona:        ${v.snapshot.persona.versionId || "(none)"}`);
+    }
+    trackEvent("cli_version_show_completed", {
+      version,
+      json: Boolean(options.json)
+    });
+  }, "version show");
+}
+__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);
+    const response = await api.diffVersions(from, to);
+    if (!response.success || !response.data) {
+      throw new Error(response.error?.message ?? "Failed to diff versions");
+    }
+    const diff = response.data;
+    if (options.json) {
+      console.log(JSON.stringify(diff, null, 2));
+    } else {
+      console.log(`Diff v${from} \u2192 v${to}`);
+      const sections = [
+        {
+          name: "Skills",
+          entry: diff.skills,
+          key: "skillId"
+        },
+        {
+          name: "Webhooks",
+          entry: diff.webhooks,
+          key: "webhookId"
+        },
+        {
+          name: "Jobs",
+          entry: diff.jobs,
+          key: "jobId"
+        },
+        {
+          name: "Preprocessors",
+          entry: diff.preprocessors,
+          key: "id"
+        },
+        {
+          name: "Postprocessors",
+          entry: diff.postprocessors,
+          key: "id"
+        }
+      ];
+      for (const { name, entry, key } of sections) {
+        const total = entry.added.length + entry.removed.length + entry.changed.length;
+        if (total === 0) {
+          console.log(`${name}: (no changes)`);
+          continue;
+        }
+        console.log(`${name}:`);
+        for (const a of entry.added) {
+          console.log(`  + ${a[key]}@${a.version} (added)`);
+        }
+        for (const r of entry.removed) {
+          console.log(`  - ${r[key]}@${r.version} (removed)`);
+        }
+        for (const c of entry.changed) {
+          console.log(`  ~ ${c[key]} ${c.from.version} \u2192 ${c.to.version}`);
+        }
+      }
+      const mcp = diff.mcpServers;
+      if (mcp.added.length || mcp.removed.length || mcp.changed.length) {
+        console.log("MCP servers:");
+        mcp.added.forEach((m) => console.log(`  + ${m.id} (added)`));
+        mcp.removed.forEach((m) => console.log(`  - ${m.id} (removed)`));
+        mcp.changed.forEach((m) => console.log(`  ~ ${m.id} (config changed)`));
+      } else {
+        console.log("MCP servers: (no changes)");
+      }
+      console.log(`Persona: ${diff.persona ? `${diff.persona.from} \u2192 ${diff.persona.to}` : "(unchanged)"}`);
+      console.log(`Model: ${diff.model ? `${diff.model.from} \u2192 ${diff.model.to}` : "(unchanged)"}`);
+    }
+    trackEvent("cli_version_diff_completed", {
+      from_to_distance: Math.abs(to - from)
+    });
+  }, "version diff");
+}
+__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);
+    if (!response.success) {
+      const errCode = response.error?.code;
+      if (errCode === "VERSION_ALREADY_ACTIVE") {
+        writeInfo(`v${version} is already active. No change.`);
+        return;
+      }
+      throw new Error(response.error?.message ?? `Failed to promote v${version}`);
+    }
+    if (!response.data) {
+      throw new Error(`Promote returned no data`);
+    }
+    const { promoted, previousActive } = response.data;
+    const rollback = previousActive != null && previousActive > promoted;
+    if (previousActive == null) {
+      writeInfo(`\u2713 Promoted v${promoted}. (No previous active version.)`);
+    } else {
+      writeInfo(`\u2713 Promoted v${promoted}. Previous active: v${previousActive}.`);
+    }
+    try {
+      await tryGitCommit({
+        message: GIT_MESSAGES.promote(promoted),
+        action: "version-promote",
+        allowEmpty: true
+      });
+    } catch {
+    }
+    trackEvent("cli_version_promote_completed", {
+      from_version: previousActive,
+      to_version: promoted,
+      rollback
+    });
+  }, "version promote");
+}
+__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.`);
+    }
+    const version = parseVersion2(versionArg);
+    const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const isCi = isCiModeEnabled();
+    if (!options.force && isTTY && !isCi) {
+      const answer = await safePrompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Delete v${version}?`,
+          default: false
+        }
+      ]);
+      if (!answer?.confirm) {
+        writeInfo("Aborted.");
+        return;
+      }
+    }
+    const api = new AgentVersionApi(BASE_URLS.API, apiKey, agentId);
+    const response = await api.deleteVersion(version);
+    if (!response.success) {
+      const errCode = response.error?.code;
+      if (errCode === "CANNOT_DELETE_ACTIVE_VERSION") {
+        throw new Error(`Cannot delete v${version}: it is the active version. Promote a different version first.`);
+      }
+      if (errCode === "CANNOT_DELETE_LAST_VERSION") {
+        throw new Error(`Cannot delete v${version}: it is the only remaining version.`);
+      }
+      throw new Error(response.error?.message ?? `Failed to delete v${version}`);
+    }
+    writeInfo(`\u2713 Deleted v${version}.`);
+    try {
+      await tryGitCommit({
+        message: GIT_MESSAGES.delete(version),
+        action: "version-delete",
+        allowEmpty: true
+      });
+    } catch {
+    }
+    trackEvent("cli_version_delete_completed", {
+      version,
+      force: Boolean(options.force)
+    });
+  }, "version delete");
+}
+__name(versionDeleteCommand, "versionDeleteCommand");
+
+// src/commands/git.ts
+init_cli();
+init_files();
+init_analytics();
+var NO_YAML_MESSAGE = "No lua.skill.yaml found. Please run this command from a skill directory.";
+function failConnect(status, banner, errorMessage) {
+  if (banner) writeError(banner);
+  trackEvent("cli_git_connect_completed", {
+    ...status,
+    succeeded: false
+  });
+  throw new Error(errorMessage);
+}
+__name(failConnect, "failConnect");
+async function gitConnectCommand() {
+  return withErrorHandling(async () => {
+    const config = readYamlConfig();
+    if (!config) {
+      failConnect({
+        git_available: false,
+        in_repo: false,
+        user_configured: false
+      }, null, NO_YAML_MESSAGE);
+    }
+    if (!await isGitAvailable()) {
+      failConnect({
+        git_available: false,
+        in_repo: false,
+        user_configured: false
+      }, "\u2717 Git binary not found on PATH.\n   Fix: install git from https://git-scm.com/downloads, then re-run `lua git connect`.", "git is not installed");
+    }
+    if (!await isInsideGitRepo()) {
+      failConnect({
+        git_available: true,
+        in_repo: false,
+        user_configured: false
+      }, "\u2717 This directory is not inside a git repository.\n   Fix: run `git init` in your project root, then re-run `lua git connect`.", "not inside a git repository");
+    }
+    const identity = await gitUserConfigured();
+    if (!identity.email) {
+      failConnect({
+        git_available: true,
+        in_repo: true,
+        user_configured: false
+      }, '\u2717 Git user.email is not configured.\n   Fix: git config --global user.email "you@example.com"', "git user.email is not configured");
+    }
+    if (!identity.name) {
+      failConnect({
+        git_available: true,
+        in_repo: true,
+        user_configured: false
+      }, '\u2717 Git user.name is not configured.\n   Fix: git config --global user.name "Your Name"', "git user.name is not configured");
+    }
+    config.git = {
+      enabled: true
+    };
+    writeYamlConfig(config);
+    writeSuccess("\u2713 Git integration enabled. Future `lua push`, `lua version *`, and `lua pull` runs will auto-commit.");
+    trackEvent("cli_git_connect_completed", {
+      git_available: true,
+      in_repo: true,
+      user_configured: true,
+      succeeded: true
+    });
+  }, "git connect");
+}
+__name(gitConnectCommand, "gitConnectCommand");
+async function gitDisconnectCommand() {
+  return withErrorHandling(async () => {
+    const config = readYamlConfig();
+    if (!config) {
+      throw new Error(NO_YAML_MESSAGE);
+    }
+    config.git = {
+      enabled: false
+    };
+    writeYamlConfig(config);
+    writeSuccess("\u2713 Git integration disabled. Existing commits and tags are untouched.");
+    trackEvent("cli_git_disconnect_completed", {});
+  }, "git disconnect");
+}
+__name(gitDisconnectCommand, "gitDisconnectCommand");
+async function gitStatusCommand() {
+  return withErrorHandling(async () => {
+    const config = readYamlConfig();
+    const enabled = Boolean(config?.git?.enabled);
+    if (!enabled) {
+      writeInfo("Git integration: disabled (run `lua git connect` to enable)");
+      trackEvent("cli_git_status_completed", {
+        enabled: false
+      });
+      return;
+    }
+    const settled = await Promise.allSettled([
+      runGit([
+        "--version"
+      ]),
+      gitUserConfigured(),
+      runGit([
+        "log",
+        "--grep",
+        "^lua: ",
+        "-n",
+        "1",
+        "--format=%h  %s"
+      ]),
+      // tryGitCommit creates lightweight tags (`git tag <name>`), which have
+      // no taggerdate field. creatordate works for both flavors and returns
+      // the committerdate of the referenced commit — chronological order
+      // matches our pattern of tagging immediately after the commit.
+      runGit([
+        "for-each-ref",
+        "--sort=-creatordate",
+        "refs/tags/lua/",
+        "--count=1",
+        "--format=%(refname:short)"
+      ])
+    ]);
+    const versionResult = settled[0].status === "fulfilled" ? settled[0].value : {
+      stdout: "",
+      stderr: "",
+      code: 1
+    };
+    const identity = settled[1].status === "fulfilled" ? settled[1].value : {
+      name: void 0,
+      email: void 0
+    };
+    const lastCommitResult = settled[2].status === "fulfilled" ? settled[2].value : {
+      stdout: "",
+      stderr: "",
+      code: 1
+    };
+    const lastTagResult = settled[3].status === "fulfilled" ? settled[3].value : {
+      stdout: "",
+      stderr: "",
+      code: 1
+    };
+    const versionLine = versionResult.code === 0 ? `${versionResult.stdout.trim()} (\u2713)` : "(not detected)";
+    const identityLine = identity.name && identity.email ? `${identity.name} <${identity.email}> (\u2713)` : "(not configured)";
+    const lastCommit = lastCommitResult.code === 0 && lastCommitResult.stdout.trim() ? lastCommitResult.stdout.trim() : "(none yet)";
+    const lastTag = lastTagResult.code === 0 && lastTagResult.stdout.trim() ? lastTagResult.stdout.trim() : "(none yet)";
+    writeInfo(`Git integration:    enabled`);
+    writeInfo(`Project repo:       ${process.cwd()}`);
+    writeInfo(`Git binary:         ${versionLine}`);
+    writeInfo(`User identity:      ${identityLine}`);
+    writeInfo(`Last lua commit:    ${lastCommit}`);
+    writeInfo(`Last lua tag:       ${lastTag}`);
+    trackEvent("cli_git_status_completed", {
+      enabled: true
+    });
+  }, "git status");
+}
+__name(gitStatusCommand, "gitStatusCommand");
+
+// src/commands/pull.ts
+init_cli();
+init_command_utils();
+init_analytics();
+init_backup_api_service();
+init_constants();
+async function pullCommand(options = {}) {
+  return withErrorHandling(async () => {
+    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);
+      if (!response.success || !response.data) {
+        throw new Error(response.error?.message ?? `Version v${version} not found`);
+      }
+      const sourceManifestVersion = response.data.sourceManifestVersion;
+      if (sourceManifestVersion == null) {
+        throw new Error(`Version v${version} has no source backup linked. Cannot pull source for this version.`);
+      }
+      writeInfo(`Pulling source for agent version v${version} (backup v${sourceManifestVersion})\u2026`);
+      await sourceRollbackCommand({
+        version: sourceManifestVersion,
+        force,
+        silent: true
+      });
+      try {
+        await tryGitCommit({
+          message: GIT_MESSAGES.pullVersion(version),
+          action: "pull-version"
+        });
+      } catch {
+      }
+      trackEvent("cli_pull_completed", {
+        has_version_arg: true
+      });
+      return;
+    }
+    const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
+    const backupResp = await backupApi.getBackupVersions();
+    if (!backupResp.success || !backupResp.data?.versions?.length) {
+      throw new Error("No backup versions available to pull.");
+    }
+    const latest = backupResp.data.versions[0].version;
+    writeInfo(`Pulling latest source backup (v${latest})\u2026`);
+    await sourceRollbackCommand({
+      version: latest,
+      force,
+      silent: true
+    });
+    try {
+      await tryGitCommit({
+        message: GIT_MESSAGES.pullLatest,
+        action: "pull-latest"
+      });
+    } catch {
+    }
+    trackEvent("cli_pull_completed", {
+      has_version_arg: false
+    });
+  }, "pull");
+}
+__name(pullCommand, "pullCommand");
+
 // src/cli/command-definitions.ts
 init_cli();
 function setupAuthCommands(program2) {
@@ -41051,6 +42597,50 @@ 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 (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
+  $ lua version create -m "Add FAQ skill"      Include a description
+  $ lua version create --auto-push             Push then snapshot in one step
+`).action((opts) => versionCreateCommand(opts));
+  versionGroup.command("list").description("List versions of the current agent").option("--all", "Show all versions (no server-side cap)").option("--limit <n>", "Cap output to this many entries", (v) => parseInt(v, 10)).option("--status <status>", "Filter by status: active | staged | all", "all").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ lua version list                     List all versions (default)
+  $ lua version list --status active     Show only active versions
+  $ lua version list --limit 10          Show the 10 most recent
+  $ lua version list --json              Machine-readable output
+`).action((opts) => versionListCommand(opts));
+  versionGroup.command("show <version>").description("Show full snapshot of a specific version").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ lua version show 3          Show version 3 details
+  $ lua version show v3 --json  JSON output
+`).action((version, opts) => versionShowCommand(version, opts));
+  versionGroup.command("diff <from> <to>").description("Compare two versions side-by-side").option("--json", "Output diff as JSON").addHelpText("after", `
+Examples:
+  $ lua version diff 2 3          Compare v2 \u2192 v3
+  $ lua version diff v2 v3 --json Machine-readable diff
+`).action((from, to, opts) => versionDiffCommand(from, to, opts));
+  versionGroup.command("promote <version>").description("Promote a version to active (atomic, instant)").addHelpText("after", `
+Examples:
+  $ lua version promote 3     Promote v3 to the active version
+  $ lua version promote v3    Same (v-prefix accepted)
+`).action((version) => versionPromoteCommand(version));
+  versionGroup.command("delete <version>").description("Soft-delete a version").option("--force", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ lua version delete 3          Delete v3 (confirms first)
+  $ lua version delete v3 --force Skip confirmation
+`).action((version, opts) => versionDeleteCommand(version, opts));
+  const gitGroup = program2.command("git").description("Manage opt-in git auto-commits for this project");
+  gitGroup.command("connect").description("Enable git auto-commits (runs sanity checks, writes git.enabled: true)").action(() => gitConnectCommand());
+  gitGroup.command("disconnect").description("Disable git auto-commits (existing commits/tags untouched)").action(() => gitDisconnectCommand());
+  gitGroup.command("status").description("Show git integration config + last lua-issued commit/tag").action(() => gitStatusCommand());
+  program2.command("pull").description("\u{1F4E5}  Pull the agent's source code locally").option("--version <version>", "Pull source linked to a specific agent version (requires versioning)").option("--force", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ lua pull                  Restore the latest source backup
+  $ lua pull --version 3      Restore the source snapshot from agent version 3
+  $ lua pull --version v3 --force  Skip the confirmation prompt
+`).action((opts) => pullCommand(opts));
   const sourceCmd = program2.command("source").description("\u{1F5C2}\uFE0F  Manage workspace source versions");
   sourceCmd.command("list").description("List source versions for the current agent").option("--all", "Show all versions instead of the most recent 50", false).option("--limit <n>", "Number of versions to show", "50").addHelpText("after", `
 Examples: