clawfast 1.0.1 → 1.0.3

package/dist/clawfast.cjs

@@ -85,8 +85,8 @@ var init_boot_ui = __esm({
 var require_main = __commonJS({
   "../node_modules/.pnpm/dotenv@17.4.2/node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs3 = require("fs");
-    var path5 = require("path");
+    var fs6 = require("fs");
+    var path8 = require("path");
     var os5 = require("os");
     var crypto2 = require("crypto");
     var TIPS = [
@@ -217,7 +217,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs3.existsSync(filepath)) {
+            if (fs6.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -225,15 +225,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path5.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path8.resolve(process.cwd(), ".env.vault");
       }
-      if (fs3.existsSync(possibleVaultPath)) {
+      if (fs6.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path5.join(os5.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path8.join(os5.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -250,7 +250,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path5.resolve(process.cwd(), ".env");
+      const dotenvPath = path8.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -278,13 +278,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path6 of optionPaths) {
+      for (const path9 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path6, { encoding }));
+          const parsed = DotenvModule.parse(fs6.readFileSync(path9, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`failed to load ${path6} ${e.message}`);
+            _debug(`failed to load ${path9} ${e.message}`);
           }
           lastError = e;
         }
@@ -297,7 +297,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative2 = path5.relative(process.cwd(), filePath);
+            const relative2 = path8.relative(process.cwd(), filePath);
             shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
@@ -442,7 +442,7 @@ async function ensureProviderKey() {
   if (hasAnyProviderKey()) return true;
   if (!process.stdin.isTTY) {
     process.stderr.write(
-      `Nenhuma chave de modelo configurada. Defina OPENROUTER_API_KEY (ou HUGGINGFACE_API_KEY/HF_TOKEN/OPENAI_API_KEY) em ${clawfastEnvPath()} ou como vari\xE1vel de ambiente.
+      `Nenhuma chave de modelo configurada. Defina NVIDIA_API_KEY (ou OPENAI_API_KEY) em ${clawfastEnvPath()} ou como vari\xE1vel de ambiente.
 `
     );
     return false;
@@ -450,15 +450,15 @@ async function ensureProviderKey() {
   process.stdout.write(
     `
 ${C.greenB}Bem-vindo ao clawfast!${C.reset}
-${C.dim}Para come\xE7ar, preciso de uma chave de modelo. A mais simples \xE9 o OpenRouter (tem modelos gratuitos):${C.reset}
-  ${C.cyan}1.${C.reset} crie uma chave em ${C.green}https://openrouter.ai/keys${C.reset}
+${C.dim}Para come\xE7ar, preciso de uma chave de modelo. Use a NVIDIA build (modelos gratuitos):${C.reset}
+  ${C.cyan}1.${C.reset} crie uma chave em ${C.green}https://build.nvidia.com/${C.reset}
   ${C.cyan}2.${C.reset} cole abaixo (fica salva em ${clawfastEnvPath()})
 
 `
   );
   let key = "";
   while (!key) {
-    key = await promptLine(`${C.greenB}Chave OpenRouter${C.reset} \u276F `);
+    key = await promptLine(`${C.greenB}Chave NVIDIA${C.reset} \u276F `);
     if (!key) {
       process.stdout.write(
         `${C.dim}chave vazia \u2014 cole de novo, ou Ctrl+C para sair.${C.reset}
@@ -466,8 +466,8 @@ ${C.dim}Para come\xE7ar, preciso de uma chave de modelo. A mais simples \xE9 o O
       );
     }
   }
-  setEnvVar(clawfastEnvPath(), "OPENROUTER_API_KEY", key);
-  process.env.OPENROUTER_API_KEY = key;
+  setEnvVar(clawfastEnvPath(), "NVIDIA_API_KEY", key);
+  process.env.NVIDIA_API_KEY = key;
   process.stdout.write(
     `${C.green}\u2713 chave salva em ${clawfastEnvPath()}${C.reset}
 `
@@ -485,12 +485,7 @@ var init_config = __esm({
     import_node_readline = __toESM(require("node:readline"));
     clawfastHome = () => process.env.CLAWFAST_HOME?.trim() || import_node_path.default.join(import_node_os.default.homedir(), ".clawfast");
     clawfastEnvPath = () => import_node_path.default.join(clawfastHome(), ".env");
-    PROVIDER_KEYS = [
-      "OPENROUTER_API_KEY",
-      "OPENAI_API_KEY",
-      "HUGGINGFACE_API_KEY",
-      "HF_TOKEN"
-    ];
+    PROVIDER_KEYS = ["NVIDIA_API_KEY", "OPENAI_API_KEY"];
     hasAnyProviderKey = () => PROVIDER_KEYS.some((name25) => Boolean(process.env[name25]?.trim()));
     C = {
       reset: "\x1B[0m",
@@ -502,6 +497,101 @@ var init_config = __esm({
   }
 });
 
+// src/version.ts
+var clawfastVersion, isDevVersion, isNewerVersion;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    clawfastVersion = () => true ? "1.0.3" : "0.0.0-dev";
+    isDevVersion = () => clawfastVersion().includes("-dev");
+    isNewerVersion = (a, b) => {
+      const parse3 = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+      const pa = parse3(a);
+      const pb = parse3(b);
+      const len = Math.max(pa.length, pb.length);
+      for (let i = 0; i < len; i++) {
+        const da = pa[i] ?? 0;
+        const db = pb[i] ?? 0;
+        if (da > db) return true;
+        if (da < db) return false;
+      }
+      return false;
+    };
+  }
+});
+
+// src/update.ts
+var import_node_fs2, import_node_path2, import_node_child_process, CHECK_INTERVAL_MS, REGISTRY_URL, cacheFile, readCache, writeCache, getUpdateNotice, refreshUpdateCacheInBackground, runSelfUpdate;
+var init_update = __esm({
+  "src/update.ts"() {
+    "use strict";
+    import_node_fs2 = __toESM(require("node:fs"));
+    import_node_path2 = __toESM(require("node:path"));
+    import_node_child_process = require("node:child_process");
+    init_config();
+    init_version();
+    CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+    REGISTRY_URL = "https://registry.npmjs.org/clawfast/latest";
+    cacheFile = () => import_node_path2.default.join(clawfastHome(), "update-check.json");
+    readCache = () => {
+      try {
+        const raw = import_node_fs2.default.readFileSync(cacheFile(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.latest === "string" && typeof parsed?.lastCheck === "number") {
+          return parsed;
+        }
+      } catch {
+      }
+      return null;
+    };
+    writeCache = (cache) => {
+      try {
+        import_node_fs2.default.mkdirSync(clawfastHome(), { recursive: true });
+        import_node_fs2.default.writeFileSync(cacheFile(), JSON.stringify(cache), "utf8");
+      } catch {
+      }
+    };
+    getUpdateNotice = (current) => {
+      if (isDevVersion()) return null;
+      const cache = readCache();
+      if (cache && isNewerVersion(cache.latest, current)) {
+        return `nova versao ${cache.latest} disponivel (voce tem ${current}) \u2014 rode: clawfast update`;
+      }
+      return null;
+    };
+    refreshUpdateCacheInBackground = (current) => {
+      if (isDevVersion()) return;
+      const cache = readCache();
+      if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) return;
+      void (async () => {
+        try {
+          const controller = new AbortController();
+          const timer2 = setTimeout(() => controller.abort(), 3e3);
+          const res = await fetch(REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { accept: "application/json" }
+          });
+          clearTimeout(timer2);
+          if (!res.ok) return;
+          const body = await res.json();
+          if (typeof body.version === "string") {
+            writeCache({ lastCheck: Date.now(), latest: body.version });
+          }
+        } catch {
+        }
+      })();
+    };
+    runSelfUpdate = () => new Promise((resolve2) => {
+      const child = (0, import_node_child_process.spawn)("npm install -g clawfast@latest", {
+        stdio: "inherit",
+        shell: true
+      });
+      child.on("close", (code) => resolve2(code ?? 1));
+      child.on("error", () => resolve2(1));
+    });
+  }
+});
+
 // src/paste-input.ts
 function createPasteInput(opts = {}) {
   const input = new import_node_stream.PassThrough();
@@ -634,6 +724,215 @@ var init_paste_input = __esm({
   }
 });
 
+// src/skills.ts
+function listSkills() {
+  const dir = skillsDir();
+  let entries = [];
+  try {
+    entries = import_node_fs3.default.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort()) {
+    const file2 = import_node_path3.default.join(dir, entry);
+    let raw = "";
+    try {
+      raw = import_node_fs3.default.readFileSync(file2, "utf8");
+    } catch {
+      continue;
+    }
+    const { meta: meta3, body } = parseFrontmatter(raw);
+    const name25 = meta3.name?.trim() || entry.replace(/\.md$/, "");
+    const triggers = parseTriggers(meta3.triggers);
+    skills.push({
+      name: name25,
+      description: meta3.description?.trim() || "(sem descricao)",
+      // Default matching keywords = the slug's word parts when none were given.
+      triggers: triggers.length > 0 ? triggers : name25.split("-").filter(Boolean),
+      always: isTrue(meta3.always),
+      body: body.trim(),
+      file: file2
+    });
+  }
+  return skills;
+}
+function saveSkill(input) {
+  const slug = slugify(input.name);
+  if (!slug) {
+    throw new Error("nome de skill invalido (vazio apos normalizacao)");
+  }
+  const dir = skillsDir();
+  import_node_fs3.default.mkdirSync(dir, { recursive: true });
+  const file2 = import_node_path3.default.join(dir, `${slug}.md`);
+  const overwritten = import_node_fs3.default.existsSync(file2);
+  const triggers = (input.triggers ?? []).map((t) => t.trim().toLowerCase()).filter(Boolean);
+  const frontmatter = [
+    "---",
+    `name: ${slug}`,
+    `description: ${escapeFrontmatterValue(input.description ?? "")}`,
+    `triggers: ${triggers.join(", ")}`,
+    `always: ${input.always ? "true" : "false"}`,
+    "---",
+    ""
+  ].join("\n");
+  import_node_fs3.default.writeFileSync(file2, frontmatter + input.body.trim() + "\n", {
+    encoding: "utf8"
+  });
+  return {
+    skill: {
+      name: slug,
+      description: input.description?.trim() || "(sem descricao)",
+      triggers: triggers.length > 0 ? triggers : slug.split("-").filter(Boolean),
+      always: Boolean(input.always),
+      body: input.body.trim(),
+      file: file2
+    },
+    file: file2,
+    overwritten
+  };
+}
+function deleteSkill(name25) {
+  const slug = slugify(name25);
+  const file2 = import_node_path3.default.join(skillsDir(), `${slug}.md`);
+  try {
+    import_node_fs3.default.unlinkSync(file2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildSkillsIndexSection(skills = listSkills()) {
+  if (skills.length === 0) return "";
+  const lines = skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+  return `
+
+<skills_disponiveis>
+Voce tem skills instaladas \u2014 conhecimento e procedimentos reutilizaveis criados pelo usuario. Quando o pedido do usuario casar com uma skill, o runtime do CLI carrega AUTOMATICAMENTE o conteudo completo dela neste turno (voce nao precisa pedir). Trate o conteudo carregado como instrucao de alta prioridade. Skills instaladas:
+${lines}
+</skills_disponiveis>`;
+}
+function selectSkillsForInput(userInput, skills = listSkills()) {
+  const haystack = userInput.toLowerCase();
+  const matched = [];
+  for (const skill of skills) {
+    if (skill.always) {
+      matched.push(skill);
+      continue;
+    }
+    const keywords = [skill.name, ...skill.triggers].map((k) => k.toLowerCase()).filter((k) => k.length >= 3);
+    if (keywords.some((k) => haystack.includes(k))) {
+      matched.push(skill);
+    }
+  }
+  return matched;
+}
+function renderSkillBodies(skills) {
+  if (skills.length === 0) return "";
+  const blocks = skills.map((s) => `<skill name="${s.name}">
+${s.body}
+</skill>`).join("\n\n");
+  return `
+
+<active_skills>
+As skills a seguir foram carregadas porque o pedido atual casou com elas (ou estao marcadas como sempre-ativas). Siga o conhecimento e os procedimentos delas como instrucao de alta prioridade nesta tarefa.
+
+${blocks}
+</active_skills>`;
+}
+var import_node_fs3, import_node_path3, skillsDir, slugify, FRONTMATTER_RE, parseFrontmatter, parseTriggers, isTrue, escapeFrontmatterValue;
+var init_skills = __esm({
+  "src/skills.ts"() {
+    "use strict";
+    import_node_fs3 = __toESM(require("node:fs"));
+    import_node_path3 = __toESM(require("node:path"));
+    init_config();
+    skillsDir = () => import_node_path3.default.join(clawfastHome(), "skills");
+    slugify = (name25) => name25.trim().toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+    parseFrontmatter = (raw) => {
+      const match = raw.match(FRONTMATTER_RE);
+      if (!match) return { meta: {}, body: raw };
+      const meta3 = {};
+      for (const line of match[1].split(/\r?\n/)) {
+        const idx = line.indexOf(":");
+        if (idx === -1) continue;
+        const key = line.slice(0, idx).trim().toLowerCase();
+        const value = line.slice(idx + 1).trim();
+        if (key) meta3[key] = value;
+      }
+      return { meta: meta3, body: raw.slice(match[0].length) };
+    };
+    parseTriggers = (raw) => (raw ?? "").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+    isTrue = (raw) => /^(1|true|yes|sim)$/i.test((raw ?? "").trim());
+    escapeFrontmatterValue = (value) => value.replace(/\r?\n/g, " ").trim();
+  }
+});
+
+// src/news.ts
+var import_node_fs4, import_node_path4, NEWS, latestNewsVersion, renderNews, stateFile, readState, writeState, consumePostUpdateLaunch;
+var init_news = __esm({
+  "src/news.ts"() {
+    "use strict";
+    import_node_fs4 = __toESM(require("node:fs"));
+    import_node_path4 = __toESM(require("node:path"));
+    init_config();
+    NEWS = {
+      "1.0.3": [
+        "Atualizacao: `clawfast update` atualiza o CLI e mostra as boas-vindas; aparece um aviso quando ha versao nova; /nov lista as novidades.",
+        "Skills: /skillcreator cria ou cola uma skill (de qualquer tamanho), /skills lista e /skill delete remove. As skills viram conhecimento disponivel para TODOS os modelos.",
+        "Modelos na NVIDIA build: minimax-m3, kimi-k2.6, glm-5.1 e qwen3.5-397b \u2014 todos com function calling de verdade (as ferramentas disparam).",
+        "Resiliencia a rate limit (429): cai para os outros modelos como contingencia e espera/retenta a cadeia automaticamente."
+      ]
+    };
+    latestNewsVersion = () => {
+      const keys = Object.keys(NEWS);
+      if (keys.length === 0) return null;
+      return keys.sort((a, b) => {
+        const pa = a.split(".").map(Number);
+        const pb = b.split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+          if ((pb[i] ?? 0) !== (pa[i] ?? 0)) return (pb[i] ?? 0) - (pa[i] ?? 0);
+        }
+        return 0;
+      })[0];
+    };
+    renderNews = (version3) => {
+      const key = NEWS[version3] ? version3 : latestNewsVersion();
+      if (!key || !NEWS[key]) {
+        return "Sem novidades registradas para esta versao.";
+      }
+      const lines = NEWS[key].map((item) => `  \u2022 ${item}`).join("\n");
+      return `Novidades da versao ${key}:
+${lines}`;
+    };
+    stateFile = () => import_node_path4.default.join(clawfastHome(), "state.json");
+    readState = () => {
+      try {
+        return JSON.parse(import_node_fs4.default.readFileSync(stateFile(), "utf8"));
+      } catch {
+        return {};
+      }
+    };
+    writeState = (state) => {
+      try {
+        import_node_fs4.default.mkdirSync(clawfastHome(), { recursive: true });
+        import_node_fs4.default.writeFileSync(stateFile(), JSON.stringify(state), "utf8");
+      } catch {
+      }
+    };
+    consumePostUpdateLaunch = (current) => {
+      const state = readState();
+      const previous = state.lastVersion;
+      if (previous !== current) {
+        writeState({ ...state, lastVersion: current });
+        return Boolean(previous);
+      }
+      return false;
+    };
+  }
+});
+
 // ../node_modules/.pnpm/@ai-sdk+provider@3.0.10/node_modules/@ai-sdk/provider/dist/index.mjs
 function getErrorMessage(error51) {
   if (error51 == null) {
@@ -1100,7 +1399,7 @@ __export(util_exports, {
   required: () => required,
   safeExtend: () => safeExtend,
   shallowClone: () => shallowClone,
-  slugify: () => slugify,
+  slugify: () => slugify2,
   stringifyPrimitive: () => stringifyPrimitive,
   uint8ArrayToBase64: () => uint8ArrayToBase64,
   uint8ArrayToBase64url: () => uint8ArrayToBase64url,
@@ -1206,10 +1505,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1233,7 +1532,7 @@ function randomString(length = 10) {
 function esc(str) {
   return JSON.stringify(str);
 }
-function slugify(input) {
+function slugify2(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function isObject(data) {
@@ -1537,11 +1836,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a25;
     (_a25 = iss).path ?? (_a25.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -1759,16 +2058,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path8 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1795,17 +2094,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path8 = []) => {
     var _a25, _b18;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1837,8 +2136,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -11979,7 +12278,7 @@ function _toUpperCase() {
 }
 // @__NO_SIDE_EFFECTS__
 function _slugify() {
-  return /* @__PURE__ */ _overwrite((input) => slugify(input));
+  return /* @__PURE__ */ _overwrite((input) => slugify2(input));
 }
 // @__NO_SIDE_EFFECTS__
 function _array(Class2, element, params) {
@@ -15341,13 +15640,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16536,8 +16835,8 @@ var init_parseUtil = __esm({
     init_errors3();
     init_en2();
     makeIssue = (params) => {
-      const { data, path: path5, errorMaps, issueData } = params;
-      const fullPath = [...path5, ...issueData.path || []];
+      const { data, path: path8, errorMaps, issueData } = params;
+      const fullPath = [...path8, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -16820,11 +17119,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path5, key) {
+      constructor(parent, value, path8, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path5;
+        this._path = path8;
         this._key = key;
       }
       get path() {
@@ -22863,8 +23162,8 @@ var require_auth_config = __commonJS({
       writeAuthConfig: () => writeAuthConfig
     });
     module2.exports = __toCommonJS(auth_config_exports);
-    var fs3 = __toESM2(require("fs"));
-    var path5 = __toESM2(require("path"));
+    var fs6 = __toESM2(require("fs"));
+    var path8 = __toESM2(require("path"));
     var import_token_util = require_token_util();
     function getAuthConfigPath() {
       const dataDir = (0, import_token_util.getVercelDataDir)();
@@ -22873,15 +23172,15 @@ var require_auth_config = __commonJS({
           `Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`
         );
       }
-      return path5.join(dataDir, "auth.json");
+      return path8.join(dataDir, "auth.json");
     }
     function readAuthConfig() {
       try {
         const authPath = getAuthConfigPath();
-        if (!fs3.existsSync(authPath)) {
+        if (!fs6.existsSync(authPath)) {
           return null;
         }
-        const content = fs3.readFileSync(authPath, "utf8");
+        const content = fs6.readFileSync(authPath, "utf8");
         if (!content) {
           return null;
         }
@@ -22892,11 +23191,11 @@ var require_auth_config = __commonJS({
     }
     function writeAuthConfig(config3) {
       const authPath = getAuthConfigPath();
-      const authDir = path5.dirname(authPath);
-      if (!fs3.existsSync(authDir)) {
-        fs3.mkdirSync(authDir, { mode: 504, recursive: true });
+      const authDir = path8.dirname(authPath);
+      if (!fs6.existsSync(authDir)) {
+        fs6.mkdirSync(authDir, { mode: 504, recursive: true });
       }
-      fs3.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+      fs6.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
     }
     function isValidAccessToken(authConfig, expirationBufferMs = 0) {
       if (!authConfig.token)
@@ -23087,8 +23386,8 @@ var require_token_util = __commonJS({
       saveToken: () => saveToken
     });
     module2.exports = __toCommonJS(token_util_exports);
-    var path5 = __toESM2(require("path"));
-    var fs3 = __toESM2(require("fs"));
+    var path8 = __toESM2(require("path"));
+    var fs6 = __toESM2(require("fs"));
     var import_token_error = require_token_error();
     var import_token_io = require_token_io();
     var import_auth_config = require_auth_config();
@@ -23100,7 +23399,7 @@ var require_token_util = __commonJS({
       if (!dataDir) {
         return null;
       }
-      return path5.join(dataDir, vercelFolder);
+      return path8.join(dataDir, vercelFolder);
     }
     async function getVercelToken2(options) {
       const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -23176,13 +23475,13 @@ var require_token_util = __commonJS({
           "Unable to find project root directory. Have you linked your project with `vc link?`"
         );
       }
-      const prjPath = path5.join(dir, ".vercel", "project.json");
-      if (!fs3.existsSync(prjPath)) {
+      const prjPath = path8.join(dir, ".vercel", "project.json");
+      if (!fs6.existsSync(prjPath)) {
         throw new import_token_error.VercelOidcTokenError(
           "project.json not found, have you linked your project with `vc link?`"
         );
       }
-      const prj = JSON.parse(fs3.readFileSync(prjPath, "utf8"));
+      const prj = JSON.parse(fs6.readFileSync(prjPath, "utf8"));
       if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
         throw new TypeError(
           "Expected a string-valued projectId property. Try running `vc link` to re-link your project."
@@ -23197,11 +23496,11 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path5.join(dir, "com.vercel.token", `${projectId}.json`);
+      const tokenPath = path8.join(dir, "com.vercel.token", `${projectId}.json`);
       const tokenJson = JSON.stringify(token);
-      fs3.mkdirSync(path5.dirname(tokenPath), { mode: 504, recursive: true });
-      fs3.writeFileSync(tokenPath, tokenJson);
-      fs3.chmodSync(tokenPath, 432);
+      fs6.mkdirSync(path8.dirname(tokenPath), { mode: 504, recursive: true });
+      fs6.writeFileSync(tokenPath, tokenJson);
+      fs6.chmodSync(tokenPath, 432);
       return;
     }
     function loadToken(projectId) {
@@ -23211,11 +23510,11 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path5.join(dir, "com.vercel.token", `${projectId}.json`);
-      if (!fs3.existsSync(tokenPath)) {
+      const tokenPath = path8.join(dir, "com.vercel.token", `${projectId}.json`);
+      if (!fs6.existsSync(tokenPath)) {
         return null;
       }
-      const token = JSON.parse(fs3.readFileSync(tokenPath, "utf8"));
+      const token = JSON.parse(fs6.readFileSync(tokenPath, "utf8"));
       assertVercelOidcTokenResponse(token);
       return token;
     }
@@ -25166,7 +25465,7 @@ var init_platform = __esm({
 
 // ../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js
 var VERSION3;
-var init_version = __esm({
+var init_version2 = __esm({
   "../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js"() {
     "use strict";
     VERSION3 = "1.9.0";
@@ -25241,7 +25540,7 @@ var re, isCompatible;
 var init_semver = __esm({
   "../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
     "use strict";
-    init_version();
+    init_version2();
     re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
     isCompatible = _makeCompatibilityCheck(VERSION3);
   }
@@ -25290,7 +25589,7 @@ var init_global_utils = __esm({
   "../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
     "use strict";
     init_platform();
-    init_version();
+    init_version2();
     init_semver();
     major = VERSION3.split(".")[0];
     GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
@@ -35241,7 +35540,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -35249,7 +35548,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -35257,21 +35556,21 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createVideoModel = (modelId, settings = {}) => new OpenRouterVideoModel(modelId, settings, {
     provider: "openrouter.video",
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -39807,37 +40106,37 @@ function createOpenAI(options = {}) {
   );
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path5 }) => `${baseURL}${path5}`,
+    url: ({ path: path8 }) => `${baseURL}${path8}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -39852,7 +40151,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path5 }) => `${baseURL}${path5}`,
+      url: ({ path: path8 }) => `${baseURL}${path8}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -45073,7 +45372,7 @@ function supportsMultimodalToolResults(modelName) {
   const normalized = modelName.toLowerCase();
   return normalized === "ask-model" || normalized.includes("gemini") || normalized.includes("google/") || isAnthropicModel(normalized) || normalized.includes("anthropic/") || normalized.includes("claude") || normalized.includes("openai") || normalized.includes("openai/") || normalized.includes("gpt-") || normalized.includes("o1") || normalized.includes("o3") || normalized.includes("o4") || normalized.includes("x-ai/") || normalized.includes("grok");
 }
-var isRecord, isXaiModelSlug, isGeminiModelSlug, requestCanRouteToXai, requestCanRouteToGemini, hasOwnEncryptedContent, stripEncryptedContent, sanitizeOpenRouterRequestForXai, hasJsonRefKey, wrapToolContentIfGeminiRefSensitive, sanitizeOpenRouterRequestForGeminiFunctionResponses, patchKimiReasoningToolCalls, OPENROUTER_METADATA_HEADER, withOpenRouterMetadataHeader, openrouterPatchFetch, openrouter2, openai2, nvidia, huggingface, deepseek, kimi, buildProviderMap, hasEnvValue, hasHuggingFaceKey, isDeepSeekEnabled, isKimiEnabled, CLI_MODEL_CHAIN, baseProviders, modelCutoffDates, modelDisplayNames, getModelDisplayName, getModelCutoffDate, myProvider;
+var isRecord, isXaiModelSlug, isGeminiModelSlug, requestCanRouteToXai, requestCanRouteToGemini, hasOwnEncryptedContent, stripEncryptedContent, sanitizeOpenRouterRequestForXai, hasJsonRefKey, wrapToolContentIfGeminiRefSensitive, sanitizeOpenRouterRequestForGeminiFunctionResponses, patchKimiReasoningToolCalls, OPENROUTER_METADATA_HEADER, withOpenRouterMetadataHeader, openrouterPatchFetch, openrouter2, openai2, nvidia, deepseek, kimi, buildProviderMap, hasEnvValue, isDeepSeekEnabled, isKimiEnabled, CLI_MODEL_CHAIN, baseProviders, modelCutoffDates, modelDisplayNames, getModelDisplayName, getModelCutoffDate, myProvider;
 var init_providers = __esm({
   "../lib/ai/providers.ts"() {
     "use strict";
@@ -45238,11 +45537,6 @@ var init_providers = __esm({
       baseURL: process.env.NVIDIA_BASE_URL || "https://integrate.api.nvidia.com/v1",
       apiKey: process.env.NVIDIA_API_KEY
     });
-    huggingface = createOpenAI({
-      name: "huggingface",
-      baseURL: process.env.HUGGINGFACE_BASE_URL || "https://router.huggingface.co/v1",
-      apiKey: process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN
-    });
     deepseek = createOpenAI({
       name: "deepseek",
       // Default to the deepsproxy port the clawfast proxy-manager starts it on, so
@@ -45268,19 +45562,14 @@ var init_providers = __esm({
       "model-deepseek-v4-flash": or("z-ai/glm-4.5-air:free"),
       "model-opus-4.6": nvidia("nvidia/nemotron-3-ultra-550b-a55b"),
       "model-kimi-k2.6": or("qwen/qwen3-coder:free"),
+      // NVIDIA build models — primary provider for the local CLI (chat-completions).
+      "model-nvidia-minimax-m3": nvidia.chat("minimaxai/minimax-m3"),
+      "model-nvidia-kimi-k2.6": nvidia.chat("moonshotai/kimi-k2.6"),
+      "model-nvidia-glm-5.1": nvidia.chat("z-ai/glm-5.1"),
+      "model-nvidia-qwen3.5-397b": nvidia.chat("qwen/qwen3.5-397b-a17b"),
       // Extra explicit keys for the CLI.
-      "model-glm-4.5-air": or("z-ai/glm-4.5-air:free"),
-      "model-qwen3-coder": or("qwen/qwen3-coder:free"),
       "model-openai-chat-latest": openai2("chat-latest"),
       "model-nvidia-nemotron": nvidia("nvidia/nemotron-3-ultra-550b-a55b"),
-      "model-hf-qwen3-6-35b-a3b": huggingface.chat("Qwen/Qwen3.6-35B-A3B"),
-      "model-hf-glm-5-1-fp8": huggingface.chat("zai-org/GLM-5.1-FP8"),
-      "model-hf-deepseek-v4-flash": huggingface.chat(
-        "deepseek-ai/DeepSeek-V4-Flash"
-      ),
-      "model-hf-deepseek-v4-flash-nvfp4": huggingface.chat(
-        "nvidia/DeepSeek-V4-Flash-NVFP4"
-      ),
       // DeepSeek via logged-in web session (deepsproxy) or official API.
       "model-deepseek-proxy": deepseek.chat(
         process.env.DEEPSEEK_MODEL || "deepseek-v4-flash"
@@ -45297,7 +45586,6 @@ var init_providers = __esm({
       "title-generator-model": or("z-ai/glm-4.5-air:free")
     });
     hasEnvValue = (name25) => Boolean(process.env[name25]?.trim());
-    hasHuggingFaceKey = () => hasEnvValue("HUGGINGFACE_API_KEY") || hasEnvValue("HF_TOKEN");
     isDeepSeekEnabled = () => {
       const flag = process.env.DEEPSEEK_ENABLED?.trim().toLowerCase();
       if (flag === "1" || flag === "true" || flag === "yes") return true;
@@ -45311,23 +45599,19 @@ var init_providers = __esm({
       return hasEnvValue("KIMI_BASE_URL") || hasEnvValue("KIMI_API_KEY");
     };
     CLI_MODEL_CHAIN = [
-      ...hasEnvValue("OPENROUTER_API_KEY") ? [
-        "agent-model",
-        // OpenRouter glm-4.5-air:free — real tool calling
-        "model-qwen3-coder"
-        // OpenRouter qwen/qwen3-coder:free
+      ...hasEnvValue("NVIDIA_API_KEY") ? [
+        "model-nvidia-minimax-m3",
+        // NVIDIA minimaxai/minimax-m3
+        "model-nvidia-kimi-k2.6",
+        // NVIDIA moonshotai/kimi-k2.6
+        "model-nvidia-glm-5.1",
+        // NVIDIA z-ai/glm-5.1
+        "model-nvidia-qwen3.5-397b"
+        // NVIDIA qwen/qwen3.5-397b-a17b
       ] : [],
       // Web-session proxies: chat-grade, selectable via /model, fallbacks here.
       ...isKimiEnabled() ? ["model-kimi-proxy"] : [],
       ...isDeepSeekEnabled() ? ["model-deepseek-proxy"] : [],
-      ...hasHuggingFaceKey() ? [
-        "model-hf-qwen3-6-35b-a3b",
-        // Hugging Face Qwen/Qwen3.6-35B-A3B
-        "model-hf-glm-5-1-fp8",
-        // Hugging Face zai-org/GLM-5.1-FP8
-        "model-hf-deepseek-v4-flash"
-        // Hugging Face deepseek-ai/DeepSeek-V4-Flash
-      ] : [],
       ...hasEnvValue("OPENAI_API_KEY") ? [
         // OpenAI API model closest to the ChatGPT instant experience.
         "model-openai-chat-latest"
@@ -45344,10 +45628,10 @@ var init_providers = __esm({
       "model-deepseek-v4-flash": "May 2025",
       "model-opus-4.6": "May 2025",
       "model-kimi-k2.6": "April 2024",
-      "model-hf-qwen3-6-35b-a3b": "Unknown",
-      "model-hf-glm-5-1-fp8": "Unknown",
-      "model-hf-deepseek-v4-flash": "Unknown",
-      "model-hf-deepseek-v4-flash-nvfp4": "Unknown",
+      "model-nvidia-minimax-m3": "Unknown",
+      "model-nvidia-kimi-k2.6": "April 2024",
+      "model-nvidia-glm-5.1": "Unknown",
+      "model-nvidia-qwen3.5-397b": "Unknown",
       "model-deepseek-proxy": "July 2024",
       "model-kimi-proxy": "April 2024",
       "model-openai-chat-latest": "August 2025",
@@ -45368,10 +45652,10 @@ var init_providers = __esm({
       "model-deepseek-v4-flash": "DeepSeek V4 Flash",
       "model-opus-4.6": "Anthropic Claude Opus 4.6",
       "model-kimi-k2.6": "Moonshot Kimi K2.6",
-      "model-hf-qwen3-6-35b-a3b": "Qwen Qwen3.6 35B A3B",
-      "model-hf-glm-5-1-fp8": "Z.ai GLM 5.1 FP8",
-      "model-hf-deepseek-v4-flash": "DeepSeek V4 Flash",
-      "model-hf-deepseek-v4-flash-nvfp4": "NVIDIA DeepSeek V4 Flash NVFP4",
+      "model-nvidia-minimax-m3": "NVIDIA - MiniMax M3",
+      "model-nvidia-kimi-k2.6": "NVIDIA - Moonshot Kimi K2.6",
+      "model-nvidia-glm-5.1": "NVIDIA - Z.ai GLM 5.1",
+      "model-nvidia-qwen3.5-397b": "NVIDIA - Qwen3.5 397B A17B",
       "model-deepseek-proxy": "DeepSeek (sessao web logada / deepsproxy)",
       "model-kimi-proxy": "Kimi (sessao web logada / kimiproxy)",
       "model-openai-chat-latest": "OpenAI Chat Latest",
@@ -48403,8 +48687,8 @@ var init_background_process_tracker = __esm({
       /**
        * Normalize file path for comparison
        */
-      normalizePath(path5) {
-        let normalized = path5.trim().replace(/\/+/g, "/");
+      normalizePath(path8) {
+        let normalized = path8.trim().replace(/\/+/g, "/");
         if (normalized.startsWith("./")) {
           normalized = normalized.slice(2);
         }
@@ -48642,8 +48926,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? (0, import_pat
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path5) {
-  return path5.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path8) {
+  return path8.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 var import_path;
 var init_module_node = __esm({
@@ -51532,9 +51816,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path5, ranges, output) {
+function getContextLinesFromFile(path8, ranges, output) {
   return new Promise((resolve2) => {
-    const stream = (0, import_node_fs2.createReadStream)(path5);
+    const stream = (0, import_node_fs5.createReadStream)(path8);
     const lineReaded = (0, import_node_readline2.createInterface)({
       input: stream
     });
@@ -51549,7 +51833,7 @@ function getContextLinesFromFile(path5, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path5, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path8, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -51610,8 +51894,8 @@ function clearLineContext(frame2) {
   delete frame2.context_line;
   delete frame2.post_context;
 }
-function shouldSkipContextLinesForFile(path5) {
-  return path5.startsWith("node:") || path5.endsWith(".min.js") || path5.endsWith(".min.cjs") || path5.endsWith(".min.mjs") || path5.startsWith("data:");
+function shouldSkipContextLinesForFile(path8) {
+  return path8.startsWith("node:") || path8.endsWith(".min.js") || path8.endsWith(".min.cjs") || path8.endsWith(".min.mjs") || path8.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame2) {
   if (void 0 !== frame2.lineno && frame2.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -51682,12 +51966,12 @@ function snipLine(line, colno) {
   if (end < lineLength) newLine += "...";
   return newLine;
 }
-var import_node_fs2, import_node_readline2, LRU_FILE_CONTENTS_CACHE, LRU_FILE_CONTENTS_FS_READ_FAILED, DEFAULT_LINES_OF_CONTEXT, MAX_CONTEXTLINES_COLNO, MAX_CONTEXTLINES_LINENO;
+var import_node_fs5, import_node_readline2, LRU_FILE_CONTENTS_CACHE, LRU_FILE_CONTENTS_FS_READ_FAILED, DEFAULT_LINES_OF_CONTEXT, MAX_CONTEXTLINES_COLNO, MAX_CONTEXTLINES_LINENO;
 var init_context_lines_node = __esm({
   "../node_modules/.pnpm/posthog-node@5.35.13_rxjs@7.8.2/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs"() {
     "use strict";
     init_dist8();
-    import_node_fs2 = require("node:fs");
+    import_node_fs5 = require("node:fs");
     import_node_readline2 = require("node:readline");
     LRU_FILE_CONTENTS_CACHE = new error_tracking_exports.ReduceableCache(25);
     LRU_FILE_CONTENTS_FS_READ_FAILED = new error_tracking_exports.ReduceableCache(20);
@@ -51719,7 +52003,7 @@ var init_relative_path_node = __esm({
 
 // ../node_modules/.pnpm/posthog-node@5.35.13_rxjs@7.8.2/node_modules/posthog-node/dist/version.mjs
 var version2;
-var init_version2 = __esm({
+var init_version3 = __esm({
   "../node_modules/.pnpm/posthog-node@5.35.13_rxjs@7.8.2/node_modules/posthog-node/dist/version.mjs"() {
     "use strict";
     version2 = "5.35.13";
@@ -52837,7 +53121,7 @@ var MINIMUM_POLLING_INTERVAL, THIRTY_SECONDS, MAX_CACHE_SIZE, WAITUNTIL_DEBOUNCE
 var init_client = __esm({
   "../node_modules/.pnpm/posthog-node@5.35.13_rxjs@7.8.2/node_modules/posthog-node/dist/client.mjs"() {
     "use strict";
-    init_version2();
+    init_version3();
     init_dist8();
     init_types5();
     init_feature_flag_evaluations();
@@ -67021,8 +67305,8 @@ var init_logger2 = __esm({
 });
 
 // ../lib/ai/tools/file.ts
-function isSpritPath(path5) {
-  return path5.split(/[\\/]/).some((segment) => segment.toLowerCase() === "sprit");
+function isSpritPath(path8) {
+  return path8.split(/[\\/]/).some((segment) => segment.toLowerCase() === "sprit");
 }
 function getViewSandboxType(sandbox) {
   return isCentrifugoSandbox(sandbox) ? "centrifugo" : "e2b";
@@ -67053,7 +67337,7 @@ function captureFileViewImageUsage(args) {
   const {
     context: context2,
     sandbox,
-    path: path5,
+    path: path8,
     outcome,
     durationMs,
     mediaType,
@@ -67071,7 +67355,7 @@ function captureFileViewImageUsage(args) {
     model: getActiveModelName(context2),
     configured_model: context2.modelName,
     sandbox_type: getViewSandboxType(sandbox),
-    file_extension: getFileExtension(path5),
+    file_extension: getFileExtension(path8),
     outcome,
     success: outcome === "success",
     duration_ms: durationMs,
@@ -67145,22 +67429,22 @@ async function runSandboxCommand(sandbox, command, envVars, timeoutMs = 6e4) {
 function isWindowsSandbox(sandbox) {
   return isCentrifugoSandbox(sandbox) && sandbox.isWindows();
 }
-function getWindowsNativePath(path5) {
-  if (/^[A-Za-z]:[\\/]/.test(path5)) return path5;
-  if (path5.startsWith("/tmp/")) {
-    return `C:\\temp${path5.slice(4).replace(/\//g, "\\")}`;
+function getWindowsNativePath(path8) {
+  if (/^[A-Za-z]:[\\/]/.test(path8)) return path8;
+  if (path8.startsWith("/tmp/")) {
+    return `C:\\temp${path8.slice(4).replace(/\//g, "\\")}`;
   }
-  return path5.replace(/\//g, "\\");
+  return path8.replace(/\//g, "\\");
 }
-function getPythonPathForSandbox(sandbox, path5) {
-  return isWindowsSandbox(sandbox) ? getWindowsNativePath(path5) : path5;
+function getPythonPathForSandbox(sandbox, path8) {
+  return isWindowsSandbox(sandbox) ? getWindowsNativePath(path8) : path8;
 }
-function toWindowsBashPath(path5) {
-  const drive = path5.match(/^([A-Za-z]):[\\/](.*)$/);
+function toWindowsBashPath(path8) {
+  const drive = path8.match(/^([A-Za-z]):[\\/](.*)$/);
   if (drive) {
     return `/${drive[1].toLowerCase()}/${drive[2].replace(/\\/g, "/")}`;
   }
-  return path5.replace(/\\/g, "/");
+  return path8.replace(/\\/g, "/");
 }
 async function detectSandboxShell(sandbox) {
   if (!isWindowsSandbox(sandbox)) return "bash";
@@ -67199,8 +67483,8 @@ PY`;
     }
   }
 }
-async function getSandboxFileState(sandbox, path5) {
-  const pythonPath = getPythonPathForSandbox(sandbox, path5);
+async function getSandboxFileState(sandbox, path8) {
+  const pythonPath = getPythonPathForSandbox(sandbox, path8);
   const result = await runPythonScript(
     sandbox,
     FILE_STATE_SCRIPT,
@@ -67217,23 +67501,23 @@ async function getSandboxFileState(sandbox, path5) {
   if (result.exitCode !== 0) {
     return {
       kind: "unknown",
-      path: path5,
+      path: path8,
       error: result.stderr || result.stdout || "file state command failed"
     };
   }
   try {
     const payload = JSON.parse(result.stdout.trim());
     if (payload.kind === "file" && typeof payload.sizeBytes === "number" && Number.isFinite(payload.sizeBytes)) {
-      return { ...payload, path: path5 };
+      return { ...payload, path: path8 };
     }
     if (payload.kind === "missing" || payload.kind === "not_file") {
-      return { ...payload, path: path5 };
+      return { ...payload, path: path8 };
     }
   } catch {
   }
   return {
     kind: "unknown",
-    path: path5,
+    path: path8,
     error: result.stderr || result.stdout || "invalid file state response"
   };
 }
@@ -67265,8 +67549,8 @@ ${numberedContent}${truncatedNotice}${footerNotice}`;
     })
   };
 }
-async function readSandboxTextFile(sandbox, path5, range) {
-  const pythonPath = getPythonPathForSandbox(sandbox, path5);
+async function readSandboxTextFile(sandbox, path8, range) {
+  const pythonPath = getPythonPathForSandbox(sandbox, path8);
   const envVars = {
     HACKERAI_FILE_READ_PATH: pythonPath,
     HACKERAI_FILE_READ_RANGE_START: String(range?.[0] ?? 0),
@@ -67294,40 +67578,40 @@ async function readSandboxTextFile(sandbox, path5, range) {
   }
   return payload;
 }
-async function readSandboxTextFileWithFallback(sandbox, path5, range) {
+async function readSandboxTextFileWithFallback(sandbox, path8, range) {
   try {
-    return await readSandboxTextFile(sandbox, path5, range);
+    return await readSandboxTextFile(sandbox, path8, range);
   } catch (error51) {
     const errorMessage = error51 instanceof Error ? error51.message : String(error51);
     if (errorMessage.startsWith("Invalid ") || errorMessage.includes("File not found")) {
       throw error51;
     }
-    const state = await getSandboxFileState(sandbox, path5);
+    const state = await getSandboxFileState(sandbox, path8);
     if (state.kind === "unknown") {
       throw new Error(
-        `Unable to determine file size for ${path5}; refusing to load the file into memory. ${state.error}`
+        `Unable to determine file size for ${path8}; refusing to load the file into memory. ${state.error}`
       );
     }
     if (state.kind === "missing") {
-      throw new Error(`File not found or is not a regular file: ${path5}`);
+      throw new Error(`File not found or is not a regular file: ${path8}`);
     }
     if (state.kind === "not_file") {
-      throw new Error(`File is not a regular file: ${path5}`);
+      throw new Error(`File is not a regular file: ${path8}`);
     }
     if (state.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
       if (range) {
         throw new Error(
-          `Unable to perform a bounded range read for ${path5}, and the file is too large to load safely (${formatBytes(state.sizeBytes)}). Use a targeted terminal command that writes a small result to a separate file.`
+          `Unable to perform a bounded range read for ${path8}, and the file is too large to load safely (${formatBytes(state.sizeBytes)}). Use a targeted terminal command that writes a small result to a separate file.`
         );
       }
       return {
-        path: path5,
+        path: path8,
         sizeBytes: state.sizeBytes,
         totalLines: 0,
         tooLarge: true
       };
     }
-    const fileContent = await sandbox.files.read(path5, {
+    const fileContent = await sandbox.files.read(path8, {
       user: "user"
     });
     const lines = fileContent.split("\n");
@@ -67356,7 +67640,7 @@ async function readSandboxTextFileWithFallback(sandbox, path5, range) {
       const startIndex = start - 1;
       const endIndex = end === -1 ? lines.length : end;
       return {
-        path: path5,
+        path: path8,
         sizeBytes: Buffer.byteLength(fileContent),
         totalLines: lines.length,
         content: lines.slice(startIndex, endIndex).join("\n"),
@@ -67364,7 +67648,7 @@ async function readSandboxTextFileWithFallback(sandbox, path5, range) {
       };
     }
     return {
-      path: path5,
+      path: path8,
       sizeBytes: Buffer.byteLength(fileContent),
       totalLines: lines.length,
       content: fileContent,
@@ -67372,7 +67656,7 @@ async function readSandboxTextFileWithFallback(sandbox, path5, range) {
     };
   }
 }
-async function appendSandboxTextFile(sandbox, path5, text2) {
+async function appendSandboxTextFile(sandbox, path8, text2) {
   const tempPath = `/tmp/hackerai_append_${Date.now()}_${Math.random().toString(36).slice(2)}.tmp`;
   await sandbox.files.write(tempPath, text2, {
     user: "user"
@@ -67381,7 +67665,7 @@ async function appendSandboxTextFile(sandbox, path5, text2) {
     sandbox,
     APPEND_TEXT_FILE_SCRIPT,
     {
-      HACKERAI_FILE_APPEND_TARGET_PATH: getPythonPathForSandbox(sandbox, path5),
+      HACKERAI_FILE_APPEND_TARGET_PATH: getPythonPathForSandbox(sandbox, path8),
       HACKERAI_FILE_APPEND_SOURCE_PATH: getPythonPathForSandbox(
         sandbox,
         tempPath
@@ -67393,13 +67677,13 @@ async function appendSandboxTextFile(sandbox, path5, text2) {
     throw new Error(result.stderr || result.stdout || "Failed to append file");
   }
 }
-async function readSandboxFileForView(sandbox, path5, includeData) {
+async function readSandboxFileForView(sandbox, path8, includeData) {
   if (isCentrifugoSandbox(sandbox) && sandbox.isWindows()) {
     throw new Error(
       "The view action is not available for Windows local sandboxes yet. Use a Linux/E2B sandbox or inspect the image manually."
     );
   }
-  const sandboxPath = getSandboxViewPath(sandbox, path5);
+  const sandboxPath = getSandboxViewPath(sandbox, path8);
   const viewEnvVars = {
     HACKERAI_FILE_VIEW_PATH: sandboxPath,
     HACKERAI_FILE_VIEW_INCLUDE_DATA: includeData ? "1" : "0",
@@ -67742,19 +68026,19 @@ try:
 except OSError:
     pass
 `;
-    getFilename = (path5) => path5.split("/").pop() || path5;
-    getFileExtension = (path5) => {
-      const filename = getFilename(path5);
+    getFilename = (path8) => path8.split("/").pop() || path8;
+    getFileExtension = (path8) => {
+      const filename = getFilename(path8);
       const dotIndex = filename.lastIndexOf(".");
       if (dotIndex <= 0 || dotIndex === filename.length - 1) return void 0;
       return filename.slice(dotIndex + 1).toLowerCase();
     };
-    getSandboxViewPath = (sandbox, path5) => {
+    getSandboxViewPath = (sandbox, path8) => {
       const maybeSandbox = sandbox;
-      if (isCentrifugoSandbox(maybeSandbox) && maybeSandbox.isWindows() && path5.startsWith("/tmp/")) {
-        return `C:\\temp${path5.slice(4).replace(/\//g, "\\")}`;
+      if (isCentrifugoSandbox(maybeSandbox) && maybeSandbox.isWindows() && path8.startsWith("/tmp/")) {
+        return `C:\\temp${path8.slice(4).replace(/\//g, "\\")}`;
       }
-      return path5;
+      return path8;
     };
     stripTrailingWs = (line) => line.replace(/[ \t]+$/u, "");
     editSchema = external_exports.object({
@@ -67828,7 +68112,7 @@ ${instructionsDescription}`,
             "A list of edits to be sequentially applied to the file. Required for `edit` action."
           )
         }),
-        execute: async ({ action, path: path5, text: text2, range, edits }) => {
+        execute: async ({ action, path: path8, text: text2, range, edits }) => {
           try {
             const { sandbox } = await sandboxManager.getSandbox();
             switch (action) {
@@ -67838,7 +68122,7 @@ ${instructionsDescription}`,
                   captureFileViewImageUsage({
                     context: context2,
                     sandbox,
-                    path: path5,
+                    path: path8,
                     outcome: "unsupported_model",
                     durationMs: Date.now() - viewStartedAt,
                     failureReason: "unsupported_model"
@@ -67847,26 +68131,26 @@ ${instructionsDescription}`,
                 }
                 let viewPayload;
                 try {
-                  viewPayload = await readSandboxFileForView(sandbox, path5, false);
+                  viewPayload = await readSandboxFileForView(sandbox, path8, false);
                 } catch (error51) {
                   captureFileViewImageUsage({
                     context: context2,
                     sandbox,
-                    path: path5,
+                    path: path8,
                     outcome: "inspection_failed",
                     durationMs: Date.now() - viewStartedAt,
                     failureReason: classifyFileViewError(error51)
                   });
                   throw error51;
                 }
-                const filename = getFilename(path5);
+                const filename = getFilename(path8);
                 let previewFiles = [];
                 let previewUploadError;
                 try {
                   previewFiles = await uploadViewPreviewFiles({
                     context: context2,
                     sandbox,
-                    sourcePath: path5,
+                    sourcePath: path8,
                     payload: viewPayload
                   });
                 } catch (error51) {
@@ -67880,7 +68164,7 @@ ${instructionsDescription}`,
                       user_id: context2.userID,
                       sandbox_type: getViewSandboxType(sandbox),
                       file_name: filename,
-                      source_path: path5,
+                      source_path: path8,
                       kind: viewPayload.kind,
                       media_type: viewPayload.mediaType,
                       size_bytes: viewPayload.sizeBytes,
@@ -67891,7 +68175,7 @@ ${instructionsDescription}`,
                 captureFileViewImageUsage({
                   context: context2,
                   sandbox,
-                  path: path5,
+                  path: path8,
                   outcome: "success",
                   durationMs: Date.now() - viewStartedAt,
                   mediaType: viewPayload.mediaType,
@@ -67901,7 +68185,7 @@ ${instructionsDescription}`,
                 return {
                   action: "view",
                   content: `Viewing image file: ${filename} (${viewPayload.mediaType}, ${viewPayload.sizeBytes} bytes).`,
-                  path: path5,
+                  path: path8,
                   filename,
                   mediaType: viewPayload.mediaType,
                   sizeBytes: viewPayload.sizeBytes,
@@ -67911,8 +68195,8 @@ ${instructionsDescription}`,
                 };
               }
               case "read": {
-                const filename = path5.split("/").pop() || path5;
-                const spritChunked = isSpritPath(path5);
+                const filename = path8.split("/").pop() || path8;
+                const spritChunked = isSpritPath(path8);
                 let effectiveRange = range;
                 if (spritChunked) {
                   const start = range && range[0] > 0 ? range[0] : 1;
@@ -67925,7 +68209,7 @@ ${instructionsDescription}`,
                 }
                 const readPayload = await readSandboxTextFileWithFallback(
                   sandbox,
-                  path5,
+                  path8,
                   effectiveRange
                 );
                 if (readPayload.tooLarge) {
@@ -67962,46 +68246,46 @@ File is too large to read in full (${formatBytes(readPayload.sizeBytes)}, ${tota
                 if (text2 === void 0) {
                   return { error: "text is required for write action" };
                 }
-                await sandbox.files.write(path5, text2, {
+                await sandbox.files.write(path8, text2, {
                   user: "user"
                 });
-                return `File written: ${path5}`;
+                return `File written: ${path8}`;
               }
               case "append": {
                 if (text2 === void 0) {
                   return { error: "text is required for append action" };
                 }
-                const existingState = await getSandboxFileState(sandbox, path5);
+                const existingState = await getSandboxFileState(sandbox, path8);
                 if (existingState.kind === "unknown") {
                   return {
-                    error: `Cannot append safely because the existing file size could not be determined for ${path5}. ${existingState.error}`
+                    error: `Cannot append safely because the existing file size could not be determined for ${path8}. ${existingState.error}`
                   };
                 }
                 if (existingState.kind === "not_file") {
                   return {
-                    error: `Cannot append to ${path5} because it is not a file.`
+                    error: `Cannot append to ${path8} because it is not a file.`
                   };
                 }
                 if (existingState.kind === "file" && existingState.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
-                  await appendSandboxTextFile(sandbox, path5, text2);
+                  await appendSandboxTextFile(sandbox, path8, text2);
                   return {
-                    content: `File appended: ${path5}
+                    content: `File appended: ${path8}
 Existing file is ${formatBytes(existingState.sizeBytes)}, so the full diff preview was skipped to avoid loading the entire file into memory.`
                   };
                 }
                 let existingContent = "";
                 try {
-                  existingContent = await sandbox.files.read(path5, {
+                  existingContent = await sandbox.files.read(path8, {
                     user: "user"
                   });
                 } catch {
                 }
                 const newContent = existingContent + text2;
-                await sandbox.files.write(path5, newContent, {
+                await sandbox.files.write(path8, newContent, {
                   user: "user"
                 });
                 return {
-                  content: `File appended: ${path5}`,
+                  content: `File appended: ${path8}`,
                   originalContent: truncateOutput({
                     content: existingContent,
                     mode: "read-file"
@@ -68016,31 +68300,31 @@ Existing file is ${formatBytes(existingState.sizeBytes)}, so the full diff previ
                 if (!edits || edits.length === 0) {
                   return { error: "edits array is required for edit action" };
                 }
-                const existingState = await getSandboxFileState(sandbox, path5);
+                const existingState = await getSandboxFileState(sandbox, path8);
                 if (existingState.kind === "unknown") {
                   return {
-                    error: `Cannot edit ${path5} safely because the file size could not be determined. ${existingState.error}`
+                    error: `Cannot edit ${path8} safely because the file size could not be determined. ${existingState.error}`
                   };
                 }
                 if (existingState.kind === "missing") {
                   return {
-                    error: `Cannot edit file ${path5} - file is empty or does not exist`
+                    error: `Cannot edit file ${path8} - file is empty or does not exist`
                   };
                 }
                 if (existingState.kind === "not_file") {
-                  return { error: `Cannot edit ${path5} because it is not a file.` };
+                  return { error: `Cannot edit ${path8} because it is not a file.` };
                 }
                 if (existingState.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
                   return {
-                    error: `File ${path5} is too large for the edit action (${formatBytes(existingState.sizeBytes)}). Use a targeted shell command, restore the file from a clean source, or replace it with the write action instead of loading the whole file into memory.`
+                    error: `File ${path8} is too large for the edit action (${formatBytes(existingState.sizeBytes)}). Use a targeted shell command, restore the file from a clean source, or replace it with the write action instead of loading the whole file into memory.`
                   };
                 }
-                const originalContent = await sandbox.files.read(path5, {
+                const originalContent = await sandbox.files.read(path8, {
                   user: "user"
                 });
                 if (!originalContent) {
                   return {
-                    error: `Cannot edit file ${path5} - file is empty or does not exist`
+                    error: `Cannot edit file ${path8} - file is empty or does not exist`
                   };
                 }
                 const resolvedEdits = [];
@@ -68085,7 +68369,7 @@ ${hint}` : "")
                     }
                   }
                 }
-                await sandbox.files.write(path5, content, {
+                await sandbox.files.write(path8, content, {
                   user: "user"
                 });
                 const lines = content.split("\n");
@@ -68361,20 +68645,20 @@ var init_utils4 = __esm({
 
 // src/local-sandbox.ts
 function inferShellFlag(shell2) {
-  const base = import_node_path2.default.basename(shell2).toLowerCase();
+  const base = import_node_path5.default.basename(shell2).toLowerCase();
   if (base === "cmd" || base === "cmd.exe") return "/C";
   if (base === "powershell" || base === "powershell.exe" || base === "pwsh") {
     return "-Command";
   }
   return "-c";
 }
-var import_node_child_process, import_node_fs3, import_node_path2, import_node_os2, import_node_url, import_meta, LocalSandbox;
+var import_node_child_process2, import_node_fs6, import_node_path5, import_node_os2, import_node_url, import_meta, LocalSandbox;
 var init_local_sandbox = __esm({
   "src/local-sandbox.ts"() {
     "use strict";
-    import_node_child_process = require("node:child_process");
-    import_node_fs3 = require("node:fs");
-    import_node_path2 = __toESM(require("node:path"));
+    import_node_child_process2 = require("node:child_process");
+    import_node_fs6 = require("node:fs");
+    import_node_path5 = __toESM(require("node:path"));
     import_node_os2 = __toESM(require("node:os"));
     import_node_url = require("node:url");
     init_utils4();
@@ -68398,7 +68682,7 @@ var init_local_sandbox = __esm({
                   this.shellFlag,
                   command
                 );
-                child = (0, import_node_child_process.spawn)(this.shellBin, spawnSpec.args, {
+                child = (0, import_node_child_process2.spawn)(this.shellBin, spawnSpec.args, {
                   cwd,
                   env,
                   detached: !!opts?.background,
@@ -68472,15 +68756,15 @@ var init_local_sandbox = __esm({
         this.files = {
           write: async (filePath, content) => {
             const resolved = this.resolvePath(filePath);
-            await import_node_fs3.promises.mkdir(import_node_path2.default.dirname(resolved), { recursive: true });
+            await import_node_fs6.promises.mkdir(import_node_path5.default.dirname(resolved), { recursive: true });
             const data = typeof content === "string" ? content : content instanceof ArrayBuffer ? Buffer.from(content) : content;
-            await import_node_fs3.promises.writeFile(resolved, data);
+            await import_node_fs6.promises.writeFile(resolved, data);
           },
           read: async (filePath) => {
-            return import_node_fs3.promises.readFile(this.resolvePath(filePath), "utf8");
+            return import_node_fs6.promises.readFile(this.resolvePath(filePath), "utf8");
           },
           remove: async (filePath) => {
-            await import_node_fs3.promises.rm(this.resolvePath(filePath), {
+            await import_node_fs6.promises.rm(this.resolvePath(filePath), {
               recursive: true,
               force: true
             });
@@ -68488,8 +68772,8 @@ var init_local_sandbox = __esm({
           list: async (dirPath = ".") => {
             const resolved = this.resolvePath(dirPath);
             try {
-              const entries = await import_node_fs3.promises.readdir(resolved, { withFileTypes: true });
-              return entries.filter((e) => e.isFile()).map((e) => ({ name: import_node_path2.default.join(resolved, e.name) }));
+              const entries = await import_node_fs6.promises.readdir(resolved, { withFileTypes: true });
+              return entries.filter((e) => e.isFile()).map((e) => ({ name: import_node_path5.default.join(resolved, e.name) }));
             } catch {
               return [];
             }
@@ -68504,11 +68788,11 @@ var init_local_sandbox = __esm({
           this.shellBin = shell2.shell;
           this.shellFlag = shell2.shellFlag;
         }
-        const base = opts?.workdir || process.env.CLI_WORKDIR || import_node_path2.default.join(process.cwd(), "SPRIT");
-        this.workdir = import_node_path2.default.resolve(base).replace(/\\/g, "/");
+        const base = opts?.workdir || process.env.CLI_WORKDIR || import_node_path5.default.join(process.cwd(), "SPRIT");
+        this.workdir = import_node_path5.default.resolve(base).replace(/\\/g, "/");
       }
       async init() {
-        await import_node_fs3.promises.mkdir(this.workdir, { recursive: true });
+        await import_node_fs6.promises.mkdir(this.workdir, { recursive: true });
         await this.seedReconToolkit();
       }
       /**
@@ -68524,8 +68808,8 @@ var init_local_sandbox = __esm({
           const assetsDir = (0, import_node_url.fileURLToPath)(
             new URL("../assets/recon", import_meta.url)
           );
-          const destDir = import_node_path2.default.join(this.workdir, "recon");
-          await import_node_fs3.promises.mkdir(destDir, { recursive: true });
+          const destDir = import_node_path5.default.join(this.workdir, "recon");
+          await import_node_fs6.promises.mkdir(destDir, { recursive: true });
           const files = [
             ["recon_deep.py", true],
             ["console_recon.js", true],
@@ -68533,17 +68817,17 @@ var init_local_sandbox = __esm({
             ["scope.txt", false]
           ];
           for (const [name25, overwrite] of files) {
-            const dest = import_node_path2.default.join(destDir, name25);
+            const dest = import_node_path5.default.join(destDir, name25);
             if (!overwrite) {
               try {
-                await import_node_fs3.promises.access(dest);
+                await import_node_fs6.promises.access(dest);
                 continue;
               } catch {
               }
             }
             try {
-              const content = await import_node_fs3.promises.readFile(import_node_path2.default.join(assetsDir, name25));
-              await import_node_fs3.promises.writeFile(dest, content);
+              const content = await import_node_fs6.promises.readFile(import_node_path5.default.join(assetsDir, name25));
+              await import_node_fs6.promises.writeFile(dest, content);
             } catch {
             }
           }
@@ -68646,7 +68930,7 @@ EDITING SCRIPTS:
         const pid = child.pid;
         if (pid && import_node_os2.default.platform() === "win32") {
           try {
-            (0, import_node_child_process.spawn)("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            (0, import_node_child_process2.spawn)("taskkill", ["/PID", String(pid), "/T", "/F"], {
               windowsHide: true
             });
             return;
@@ -68659,15 +68943,15 @@ EDITING SCRIPTS:
         }
       }
       resolvePath(p) {
-        if (import_node_path2.default.isAbsolute(p)) return p;
-        return import_node_path2.default.join(this.workdir, p);
+        if (import_node_path5.default.isAbsolute(p)) return p;
+        return import_node_path5.default.join(this.workdir, p);
       }
       isBashLikeShell() {
-        const base = import_node_path2.default.basename(this.shellBin).toLowerCase();
+        const base = import_node_path5.default.basename(this.shellBin).toLowerCase();
         return base === "bash" || base === "bash.exe" || base === "sh";
       }
       isCmdShell() {
-        const base = import_node_path2.default.basename(this.shellBin).toLowerCase();
+        const base = import_node_path5.default.basename(this.shellBin).toLowerCase();
         return base === "cmd" || base === "cmd.exe";
       }
       getWindowsShellNotes() {
@@ -68871,7 +69155,7 @@ function formatToolCall(toolName, input) {
       return `${C2.cyan}executando${C2.reset} ${C2.bold}$ ${truncate3(cmd, 400)}${C2.reset}${bg}`;
     }
     case "file": {
-      const path5 = String(i.path ?? "");
+      const path8 = String(i.path ?? "");
       const brief = i.brief ? `${C2.dim} - ${truncate3(String(i.brief))}${C2.reset}` : "";
       const map2 = {
         write: `${C2.green}criando arquivo${C2.reset}`,
@@ -68882,7 +69166,7 @@ function formatToolCall(toolName, input) {
       };
       const action = typeof i.action === "string" ? i.action : "";
       const label = map2[action] ?? (action ? `${C2.blue}arquivo (${action})${C2.reset}` : `${C2.blue}preparando operacao de arquivo${C2.reset}`);
-      const target = path5 ? ` ${C2.bold}${path5}${C2.reset}` : "";
+      const target = path8 ? ` ${C2.bold}${path8}${C2.reset}` : "";
       return `${label}${target}${brief}`;
     }
     case "todo_write":
@@ -68958,7 +69242,7 @@ function killProxy(child) {
   started.delete(child);
   try {
     if (process.platform === "win32") {
-      (0, import_node_child_process2.spawnSync)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      (0, import_node_child_process3.spawnSync)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
         stdio: "ignore"
       });
     } else {
@@ -68989,12 +69273,12 @@ async function ensureProxyReady(id, log2) {
     };
   }
   let freshSetup = false;
-  if (!(0, import_node_fs4.existsSync)(dir)) {
+  if (!(0, import_node_fs7.existsSync)(dir)) {
     log2(`${def.label}: baixando o proxy (uma vez) em ${dir} \u2026`);
     const root = proxiesRoot();
-    (0, import_node_fs4.mkdirSync)(root, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(root, { recursive: true });
     const cloned = run("git", ["clone", def.repoUrl, dir], root);
-    if (!cloned.ok || !(0, import_node_fs4.existsSync)(dir)) {
+    if (!cloned.ok || !(0, import_node_fs7.existsSync)(dir)) {
       return {
         ok: false,
         message: `${def.label}: falha ao clonar o proxy (git).`
@@ -69002,7 +69286,7 @@ async function ensureProxyReady(id, log2) {
     }
     freshSetup = true;
   }
-  if (!(0, import_node_fs4.existsSync)(import_node_path3.default.join(dir, "node_modules"))) {
+  if (!(0, import_node_fs7.existsSync)(import_node_path6.default.join(dir, "node_modules"))) {
     log2(`${def.label}: instalando depend\xEAncias (pode demorar) \u2026`);
     if (!run("npm", ["install"], dir).ok) {
       return { ok: false, message: `${def.label}: 'npm install' falhou.` };
@@ -69020,11 +69304,11 @@ async function ensureProxyReady(id, log2) {
     }
   }
   log2(`${def.label}: iniciando o proxy\u2026`);
-  const child = (0, import_node_child_process2.spawn)(asShellCommand("npm", ["start"]), {
+  const child = (0, import_node_child_process3.spawn)(asShellCommand("npm", ["start"]), {
     cwd: dir,
     shell: true,
     stdio: ["ignore", "ignore", "ignore"],
-    env: childEnv()
+    env: { ...childEnv(), PORT: String(def.port) }
   });
   started.add(child);
   child.on("exit", () => started.delete(child));
@@ -69047,14 +69331,14 @@ async function ensureProxyReady(id, log2) {
     message: `${def.label}: o proxy n\xE3o respondeu em 90s. Tente de novo, ou rode 'npm run login' em ${dir}.`
   };
 }
-var import_node_os3, import_node_path3, import_node_fs4, import_node_child_process2, DEFS, PROXY_MODEL_KEYS, proxyIdForModelKey, proxiesRoot, dirFor, healthUrl, baseUrl, wait, started, exitHooksInstalled, quoteArg, asShellCommand, run, hasCommand;
+var import_node_os3, import_node_path6, import_node_fs7, import_node_child_process3, DEFS, PROXY_MODEL_KEYS, proxyIdForModelKey, proxiesRoot, dirFor, healthUrl, baseUrl, wait, started, exitHooksInstalled, quoteArg, asShellCommand, run, hasCommand;
 var init_proxy_manager2 = __esm({
   "src/proxy-manager.ts"() {
     "use strict";
     import_node_os3 = __toESM(require("node:os"));
-    import_node_path3 = __toESM(require("node:path"));
-    import_node_fs4 = require("node:fs");
-    import_node_child_process2 = require("node:child_process");
+    import_node_path6 = __toESM(require("node:path"));
+    import_node_fs7 = require("node:fs");
+    import_node_child_process3 = require("node:child_process");
     DEFS = {
       deepseek: {
         id: "deepseek",
@@ -69086,11 +69370,11 @@ var init_proxy_manager2 = __esm({
       if (key === PROXY_MODEL_KEYS.kimi) return "kimi";
       return null;
     };
-    proxiesRoot = () => import_node_path3.default.join(
-      process.env.CLAWFAST_HOME?.trim() || import_node_path3.default.join(import_node_os3.default.homedir(), ".clawfast"),
+    proxiesRoot = () => import_node_path6.default.join(
+      process.env.CLAWFAST_HOME?.trim() || import_node_path6.default.join(import_node_os3.default.homedir(), ".clawfast"),
       "proxies"
     );
-    dirFor = (def) => process.env[def.dirEnv]?.trim() || import_node_path3.default.join(proxiesRoot(), def.folder);
+    dirFor = (def) => process.env[def.dirEnv]?.trim() || import_node_path6.default.join(proxiesRoot(), def.folder);
     healthUrl = (def) => `http://localhost:${def.port}/health`;
     baseUrl = (def) => `http://localhost:${def.port}/v1`;
     wait = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -69099,7 +69383,7 @@ var init_proxy_manager2 = __esm({
     quoteArg = (s) => /[\s"&|<>^()]/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
     asShellCommand = (cmd, args) => [cmd, ...args.map(quoteArg)].join(" ");
     run = (cmd, args, cwd) => {
-      const res = (0, import_node_child_process2.spawnSync)(asShellCommand(cmd, args), {
+      const res = (0, import_node_child_process3.spawnSync)(asShellCommand(cmd, args), {
         cwd,
         shell: true,
         stdio: "inherit",
@@ -69109,7 +69393,7 @@ var init_proxy_manager2 = __esm({
     };
     hasCommand = (cmd) => {
       const probe = process.platform === "win32" ? "where" : "which";
-      return (0, import_node_child_process2.spawnSync)(asShellCommand(probe, [cmd]), {
+      return (0, import_node_child_process3.spawnSync)(asShellCommand(probe, [cmd]), {
         stdio: "ignore",
         shell: true
       }).status === 0;
@@ -69254,7 +69538,7 @@ async function createAgent() {
   const sandboxManager = new LocalSandboxManager(sandbox);
   const writer = createConsoleWriter();
   const render = createRenderer();
-  const initialModelName = CLI_MODEL_CHAIN[0] ?? "agent-model";
+  const initialModelName = CLI_MODEL_CHAIN[0] ?? "model-nvidia-minimax-m3";
   let currentModelName = initialModelName;
   let selectedModelKey = null;
   const context2 = {
@@ -69303,6 +69587,8 @@ async function createAgent() {
     system += pythonOnlyPolicy();
     system += deepReconPolicy(sandbox.getWorkdir());
     system += buildCliNotesSection();
+    system += buildSkillsIndexSection();
+    system += skillsScopePolicy();
     if (isWebSessionProxyModel(modelName)) {
       system += proxyToolProtocolPolicy();
     }
@@ -69340,25 +69626,18 @@ async function createAgent() {
   }
   function getUnavailableModelGroups() {
     const groups = [];
-    if (!hasEnvValue2("HUGGINGFACE_API_KEY") && !hasEnvValue2("HF_TOKEN")) {
+    if (!hasEnvValue2("NVIDIA_API_KEY")) {
       groups.push({
-        provider: "Hugging Face",
-        reason: "faltando HUGGINGFACE_API_KEY ou HF_TOKEN em .env.local",
+        provider: "NVIDIA build",
+        reason: "faltando NVIDIA_API_KEY em .env.local (https://build.nvidia.com/)",
         models: [
-          "model-hf-qwen3-6-35b-a3b",
-          "model-hf-glm-5-1-fp8",
-          "model-hf-deepseek-v4-flash"
+          "model-nvidia-minimax-m3",
+          "model-nvidia-kimi-k2.6",
+          "model-nvidia-glm-5.1",
+          "model-nvidia-qwen3.5-397b"
         ].map((key) => ({ key, label: labelFor(key) }))
       });
     }
-    groups.push({
-      provider: "Hugging Face chat router",
-      reason: "indisponivel no endpoint /v1/chat/completions com a configuracao atual",
-      models: ["model-hf-deepseek-v4-flash-nvfp4"].map((key) => ({
-        key,
-        label: labelFor(key)
-      }))
-    });
     if (!hasEnvValue2("OPENAI_API_KEY")) {
       groups.push({
         provider: "OpenAI",
@@ -69512,11 +69791,20 @@ ${seen}`);
   }
   async function send(userInput, signal) {
     history.push({ role: "user", content: userInput });
+    const matchedSkills = selectSkillsForInput(userInput);
+    const turnSystem = matchedSkills.length ? system + renderSkillBodies(matchedSkills) : system;
+    if (matchedSkills.length) {
+      render.info(
+        `\u25B8 skills ativadas: ${matchedSkills.map((s) => s.name).join(", ")}`
+      );
+    }
     let lastError = null;
     let autoContinues = 0;
     let bridgeSteps = 0;
-    const modelChain = getActiveModelChain();
+    const modelChain = [...getActiveModelChain()];
     const usingFixedModel = selectedModelKey !== null;
+    let rateLimitWaits = 0;
+    let addedRateLimitFallbacks = false;
     for (let idx = 0; idx < modelChain.length; idx++) {
       const modelKey = modelChain[idx];
       currentModelName = modelKey;
@@ -69534,7 +69822,7 @@ ${seen}`);
       try {
         const result = streamText({
           model: myProvider.languageModel(modelKey),
-          system,
+          system: turnSystem,
           messages: history,
           tools,
           stopWhen: stepCountIs(MAX_STEPS),
@@ -69652,6 +69940,17 @@ ${resultText}`
         }
         lastError = err ?? streamError;
         const msg = lastError instanceof Error ? lastError.message : String(lastError);
+        const rateLimited = isRateLimitError(msg);
+        if (rateLimited && !addedRateLimitFallbacks) {
+          const extras = CLI_MODEL_CHAIN.filter((k) => !modelChain.includes(k));
+          if (extras.length) {
+            modelChain.push(...extras);
+            addedRateLimitFallbacks = true;
+            render.info(
+              `\u25B8 ${labelFor(modelKey)} no limite (429) \u2014 tentando como conting\xEAncia: ${extras.map(labelFor).join(", ")}`
+            );
+          }
+        }
         const hasNext = idx + 1 < modelChain.length;
         const hint = loginRequiredHint(msg);
         if (hint) {
@@ -69664,6 +69963,22 @@ ${resultText}`
         while (history.length && history[history.length - 1]?.role !== "user") {
           history.pop();
         }
+        if (rateLimited && rateLimitWaits < MAX_RATE_LIMIT_WAITS) {
+          const waitMs = Math.min(3e3 * 2 ** rateLimitWaits, 15e3);
+          rateLimitWaits++;
+          render.info(
+            `\u25B8 rate limit \u2014 aguardando ${Math.round(waitMs / 1e3)}s antes da pr\xF3xima tentativa (Ctrl+C cancela)\u2026`
+          );
+          await sleep(waitMs, signal);
+          if (signal?.aborted) {
+            render.endTurn();
+            return;
+          }
+          if (!hasNext) {
+            idx = -1;
+            continue;
+          }
+        }
       }
     }
     render.error(
@@ -69676,6 +69991,9 @@ ${resultText}`
   function getSystemPromptAudit() {
     return systemPromptAudit;
   }
+  async function refreshSkills() {
+    await rebuildSystemPrompt(currentModelName);
+  }
   function isRunningCommand() {
     return sandbox.isProcessRunning();
   }
@@ -69691,19 +70009,20 @@ ${resultText}`
     sendStdin,
     getSystemPrompt,
     getSystemPromptAudit,
+    refreshSkills,
     getModelChoices,
     getModelSelection,
     setModelSelection,
     close
   };
 }
-var import_promises, import_node_path4, MAX_STEPS, MAX_OUTPUT_TOKENS, MAX_AUTO_CONTINUES, UNFINISHED_TAIL_RE, BENIGN_CLOSER_RE, TOOL_CALL_NUDGE, MAX_BRIDGE_STEPS, BRIDGE_RESULT_PREAMBLE, truncateBridgeSummary, isWebSessionProxyModel, proxyToolProtocolPolicy, SYSTEM_PROMPT_SOURCE, REQUIRED_SYSTEM_PROMPT_MARKERS, MODEL_LABELS, labelFor, loginRequiredHint, CLI_PYTHON_ONLY_POLICY, pythonOnlyPolicy, scriptFilePolicy, deepReconPolicy, hasEnvValue2, envFlagEnabled, CLI_PERSONALITIES, buildCliUserCustomization, buildCliNotesSection, cliGuardrailsConfig, maybeDumpSystemPrompt, auditSystemPrompt, assertFullSystemPrompt;
+var import_promises, import_node_path7, MAX_STEPS, MAX_OUTPUT_TOKENS, MAX_AUTO_CONTINUES, MAX_RATE_LIMIT_WAITS, isRateLimitError, sleep, UNFINISHED_TAIL_RE, BENIGN_CLOSER_RE, TOOL_CALL_NUDGE, MAX_BRIDGE_STEPS, BRIDGE_RESULT_PREAMBLE, truncateBridgeSummary, isWebSessionProxyModel, proxyToolProtocolPolicy, SYSTEM_PROMPT_SOURCE, REQUIRED_SYSTEM_PROMPT_MARKERS, MODEL_LABELS, labelFor, loginRequiredHint, CLI_PYTHON_ONLY_POLICY, pythonOnlyPolicy, scriptFilePolicy, deepReconPolicy, skillsScopePolicy, hasEnvValue2, envFlagEnabled, CLI_PERSONALITIES, buildCliUserCustomization, buildCliNotesSection, cliGuardrailsConfig, maybeDumpSystemPrompt, auditSystemPrompt, assertFullSystemPrompt;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_dist5();
     import_promises = require("node:fs/promises");
-    import_node_path4 = __toESM(require("node:path"));
+    import_node_path7 = __toESM(require("node:path"));
     init_providers();
     init_system_prompt();
     init_notes();
@@ -69720,10 +70039,27 @@ var init_agent = __esm({
     init_local_sandbox_manager();
     init_console_writer();
     init_render();
+    init_skills();
     init_proxy_manager2();
     MAX_STEPS = 100;
     MAX_OUTPUT_TOKENS = 16384;
     MAX_AUTO_CONTINUES = 3;
+    MAX_RATE_LIMIT_WAITS = 4;
+    isRateLimitError = (msg) => /\b429\b|too many requests|rate.?limit|resource_exhausted|quota|insufficient_quota/i.test(
+      msg
+    );
+    sleep = (ms, signal) => new Promise((resolve2) => {
+      if (signal?.aborted) return resolve2();
+      const timer2 = setTimeout(resolve2, ms);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer2);
+          resolve2();
+        },
+        { once: true }
+      );
+    });
     UNFINISHED_TAIL_RE = /(?::|\.\.\.|…)\s*$|\b(?:vou|irei|deixe-me|deixa eu|em seguida|pr[oó]ximo passo|agora (?:vou|irei|preciso)|let me|i(?:'|’)?ll|i will|i(?:'|’)?m going to|going to|next,? i)\b[^.!?\n]{0,120}[.!?]?\s*$/i;
     BENIGN_CLOSER_RE = /\b(?:let me know|just let me know|deixa eu saber|me avis(?:e|a)|qualquer (?:coisa|d[uú]vida)|fico (?:à|a) disposi[cç][aã]o)\b[^.!?:\n]{0,80}[.!?]?\s*$/i;
     TOOL_CALL_NUDGE = "Voc\xEA anunciou uma a\xE7\xE3o mas n\xE3o executou nenhuma ferramenta neste turno. Pare de descrever o que vai fazer e CHAME a ferramenta agora: use a ferramenta `file` (action write para criar, edit para alterar) para qualquer arquivo ou script, e `run_terminal_cmd` para rodar comandos. N\xC3O escreva o conte\xFAdo do arquivo na resposta nem cole markup de tool call \u2014 emita a chamada de ferramenta de verdade.";
@@ -69764,18 +70100,14 @@ Regras:
       "DANGEROUS MODE"
     ];
     MODEL_LABELS = {
-      "agent-model": "OpenRouter - glm-4.5-air:free",
-      "model-glm-4.5-air": "OpenRouter - glm-4.5-air:free",
-      "model-qwen3-coder": "OpenRouter - qwen3-coder:free",
+      "model-nvidia-minimax-m3": "NVIDIA - minimaxai/minimax-m3",
+      "model-nvidia-kimi-k2.6": "NVIDIA - moonshotai/kimi-k2.6",
+      "model-nvidia-glm-5.1": "NVIDIA - z-ai/glm-5.1",
+      "model-nvidia-qwen3.5-397b": "NVIDIA - qwen/qwen3.5-397b-a17b",
       "model-openai-chat-latest": "OpenAI - chat-latest",
-      "model-hf-qwen3-6-35b-a3b": "Hugging Face - Qwen3.6 35B A3B",
-      "model-hf-glm-5-1-fp8": "Hugging Face - GLM 5.1 FP8",
-      "model-hf-deepseek-v4-flash": "Hugging Face - DeepSeek V4 Flash",
-      "model-hf-deepseek-v4-flash-nvfp4": "Hugging Face - DeepSeek V4 Flash NVFP4",
       "model-deepseek-proxy": "DeepSeek - sessao web logada (deepsproxy)",
       "model-kimi-proxy": "Kimi - sessao web logada (kimiproxy)",
       "fallback-openai-chat-latest": "OpenAI - chat-latest",
-      "fallback-agent-model": "NVIDIA - nemotron-3-ultra-550b",
       "model-nvidia-nemotron": "NVIDIA - nemotron-3-ultra-550b"
     };
     labelFor = (key) => MODEL_LABELS[key] ?? key;
@@ -69845,6 +70177,17 @@ Workflow:
 
 You MAY extend the toolkit (edit recon/recon_deep.py via the file tool) when a task needs a capability it lacks \u2014 keep it Python and keep the scope gate intact. recon/console_recon.js is an in-page payload string injected by Python Playwright (page.evaluate), NOT a Node script \u2014 never run it with \`node\`.
 </deep_recon_tooling>`;
+    skillsScopePolicy = () => `
+
+<skills_scope>
+ABSOLUTE RULE FOR THIS LOCAL CLI SESSION \u2014 applies to EVERY model and EVERY task:
+
+Your skills are INTERNAL to you and live ONLY in ${skillsDir()}. The skills currently installed are listed in the <skills_disponiveis> block, and the full body of a matching skill is injected in <active_skills> when relevant.
+
+- To list, describe, or "analyze" YOUR skills, use <skills_disponiveis> / <active_skills>. If you need the raw text of one of your skills, read ONLY the .md files inside ${skillsDir()}.
+- NEVER treat any other skills directory on this machine as yours. Folders such as ~/.agents/skills, ~/.claude/skills, ~/.augment/skills, ~/.cursor, and any other agent/tool skill folder belong to OTHER tools and are OUT OF SCOPE \u2014 ignore them completely and never read, list, summarize, or load them as your skills.
+- Do NOT scan the filesystem hunting for "skills". When asked about your skills, answer from your internal skills above, not from a disk search.
+</skills_scope>`;
     hasEnvValue2 = (name25) => Boolean(process.env[name25]?.trim());
     envFlagEnabled = (value) => {
       const normalized = value?.trim().toLowerCase();
@@ -69902,7 +70245,7 @@ ${section}` : "";
         return null;
       }
       await (0, import_promises.mkdir)(workdir, { recursive: true });
-      const outputPath = import_node_path4.default.join(workdir, "system-prompt.txt");
+      const outputPath = import_node_path7.default.join(workdir, "system-prompt.txt");
       await (0, import_promises.writeFile)(outputPath, system, "utf8");
       return outputPath;
     };
@@ -69954,7 +70297,7 @@ function asciiTitle(text2) {
   }
   return out2;
 }
-function buildBanner(_systemPromptChars) {
+function buildBanner(_systemPromptChars, version3 = "1") {
   const user = (import_node_os4.default.userInfo().username || "hacker").toLowerCase();
   const host = (import_node_os4.default.hostname() || "localhost").split(".")[0].toLowerCase();
   const art = asciiTitle("CLAWFAST");
@@ -69978,7 +70321,7 @@ function buildBanner(_systemPromptChars) {
     { text: shortCwd() },
     { text: "" }
   ];
-  const title = `clawfast v1`;
+  const title = `clawfast v${version3}`;
   const topFill = "\u2500".repeat(Math.max(0, BOX_W - vlen(title) - 5));
   const top = `${C3.green}\u256D\u2500 ${C3.greenB}${C3.bold}${title}${C3.reset}${C3.green} ${topFill}\u256E${C3.reset}`;
   const bottom = `${C3.green}\u2570${"\u2500".repeat(BOX_W - 2)}\u256F${C3.reset}`;
@@ -70062,7 +70405,22 @@ async function main() {
   const agent = await createAgent2();
   const sys = agent.getSystemPrompt();
   stopBootSpinner();
-  process.stdout.write(buildBanner2(sys.length));
+  const version3 = clawfastVersion();
+  process.stdout.write(buildBanner2(sys.length, version3));
+  const updateNotice = getUpdateNotice(version3);
+  if (updateNotice) {
+    process.stdout.write(
+      `${ui2.C.yellow}\u2191 ${updateNotice}${ui2.C.reset}
+`
+    );
+  }
+  refreshUpdateCacheInBackground(version3);
+  if (consumePostUpdateLaunch(version3)) {
+    process.stdout.write(
+      `${ui2.C.greenB}Seja bem vindo ao submundo.${ui2.C.reset} ${ui2.C.dim}clawfast atualizado para ${version3} \u2014 rode ${ui2.C.reset}${ui2.C.cyan}/nov${ui2.C.reset}${ui2.C.dim} para ver as novidades.${ui2.C.reset}
+`
+    );
+  }
   const pasteInput = createPasteInput();
   const rl = import_node_readline3.default.createInterface({
     input: pasteInput.input,
@@ -70072,8 +70430,11 @@ async function main() {
   let closing = false;
   let commandQueue = Promise.resolve();
   let awaitingModelSelection = false;
+  let skillCreator = null;
   const prompt = () => {
-    rl.setPrompt(awaitingModelSelection ? modelPrompt() : shellPrompt2());
+    rl.setPrompt(
+      skillCreator ? skillPrompt(skillCreator.phase) : awaitingModelSelection ? modelPrompt() : shellPrompt2()
+    );
     rl.prompt();
   };
   let activeAbort = null;
@@ -70126,14 +70487,235 @@ ${ui2.C.dim}Ctrl+C de novo para fechar${ui2.C.reset}
   process.removeAllListeners("SIGINT");
   process.on("SIGINT", handleSigint);
   rl.on("SIGINT", handleSigint);
+  const printSkillList = () => {
+    const skills = listSkills();
+    if (skills.length === 0) {
+      process.stdout.write(
+        `
+${ui2.C.dim}nenhuma skill instalada. crie uma com /skillcreator${ui2.C.reset}
+`
+      );
+      return;
+    }
+    process.stdout.write(
+      `
+${ui2.C.cyan}skills instaladas${ui2.C.reset} ${ui2.C.dim}(${skillsDir()})${ui2.C.reset}
+`
+    );
+    for (const s of skills) {
+      const flags = s.always ? ` ${ui2.C.yellow}[sempre]${ui2.C.reset}` : "";
+      process.stdout.write(
+        `  ${ui2.C.green}${s.name}${ui2.C.reset}${flags} ${ui2.C.dim}\u2014${ui2.C.reset} ${s.description}
+`
+      );
+    }
+    process.stdout.write(
+      `${ui2.C.dim}remover: /skill delete <nome>${ui2.C.reset}
+`
+    );
+  };
+  const handleSkillCommand = (input) => {
+    if (input === "/skillcreator") {
+      skillCreator = {
+        phase: "name",
+        name: "",
+        description: "",
+        triggers: [],
+        bodyLines: []
+      };
+      process.stdout.write(
+        `
+${ui2.C.greenB}criar skill${ui2.C.reset} ${ui2.C.dim}(/cancelar para abortar)${ui2.C.reset}
+${ui2.C.dim}skills ficam disponiveis para TODOS os modelos; o conteudo completo so e carregado quando o pedido casa com a skill.${ui2.C.reset}
+${ui2.C.cyan}nome da skill?${ui2.C.reset} ${ui2.C.dim}(ex: xss-recon)${ui2.C.reset}
+`
+      );
+      return;
+    }
+    printSkillList();
+  };
+  const handleSkillSubcommand = async (input) => {
+    const rest = input.replace(/^\/skills?\s+/, "").trim();
+    const parts = rest.split(/\s+/);
+    const sub = (parts.shift() ?? "").toLowerCase();
+    const arg = parts.join(" ").trim();
+    if (sub === "list" || sub === "ls") {
+      printSkillList();
+      return;
+    }
+    if (sub === "delete" || sub === "rm" || sub === "remove") {
+      if (!arg) {
+        process.stdout.write(
+          `${ui2.C.yellow}uso: /skill delete <nome>${ui2.C.reset}
+`
+        );
+        return;
+      }
+      if (deleteSkill(arg)) {
+        await agent.refreshSkills();
+        process.stdout.write(
+          `${ui2.C.green}\u2713 skill '${slugify(arg)}' removida${ui2.C.reset}
+`
+        );
+      } else {
+        process.stdout.write(
+          `${ui2.C.yellow}skill '${arg}' nao encontrada${ui2.C.reset}
+`
+        );
+      }
+      return;
+    }
+    process.stdout.write(
+      `${ui2.C.yellow}subcomando desconhecido: ${sub}${ui2.C.reset}
+${ui2.C.dim}use: /skillcreator | /skills | /skill delete <nome>${ui2.C.reset}
+`
+    );
+  };
+  const printBodyTally = (sc) => {
+    const text2 = sc.bodyLines.join("\n");
+    const lines = text2 ? text2.split("\n").length : 0;
+    process.stdout.write(
+      `${ui2.C.dim}  capturado: ${lines} linhas, ${text2.length} chars \u2014 continue colando, /fim para salvar, /desfazer para remover o ultimo, /cancelar para abortar${ui2.C.reset}
+`
+    );
+  };
+  const handleSkillCreatorLine = async (line, input) => {
+    const sc = skillCreator;
+    if (!sc) return;
+    if (input === "/cancelar" || input === "/cancel") {
+      skillCreator = null;
+      process.stdout.write(
+        `
+${ui2.C.dim}criacao de skill cancelada${ui2.C.reset}
+`
+      );
+      return;
+    }
+    switch (sc.phase) {
+      case "name": {
+        const slug = slugify(input);
+        if (!slug) {
+          process.stdout.write(
+            `${ui2.C.yellow}nome invalido \u2014 tente de novo${ui2.C.reset}
+`
+          );
+          return;
+        }
+        sc.name = slug;
+        if (listSkills().some((s) => s.name === slug)) {
+          process.stdout.write(
+            `${ui2.C.yellow}ja existe uma skill '${slug}' \u2014 sera sobrescrita${ui2.C.reset}
+`
+          );
+        }
+        sc.phase = "desc";
+        process.stdout.write(
+          `${ui2.C.cyan}descricao curta (1 linha)?${ui2.C.reset}
+`
+        );
+        return;
+      }
+      case "desc": {
+        sc.description = input;
+        sc.phase = "triggers";
+        process.stdout.write(
+          `${ui2.C.cyan}palavras-gatilho?${ui2.C.reset} ${ui2.C.dim}(separadas por virgula; Enter usa o proprio nome)${ui2.C.reset}
+`
+        );
+        return;
+      }
+      case "triggers": {
+        const looksLikeBody = /[\r\n]/.test(input) || input.length > 200;
+        if (looksLikeBody) {
+          sc.triggers = [];
+          sc.phase = "body";
+          sc.bodyLines.push(line.replace(/\r$/, ""));
+          process.stdout.write(
+            `${ui2.C.yellow}isso parece a skill, nao gatilhos \u2014 capturei como conteudo.${ui2.C.reset}
+`
+          );
+          printBodyTally(sc);
+          return;
+        }
+        sc.triggers = input ? input.split(",").map((t) => t.trim()).filter(Boolean) : [];
+        sc.phase = "body";
+        process.stdout.write(
+          `${ui2.C.cyan}cole ou escreva a skill agora${ui2.C.reset} ${ui2.C.dim}(qualquer tamanho). termine com uma linha contendo so /fim${ui2.C.reset}
+`
+        );
+        return;
+      }
+      case "body": {
+        if (input === "/fim") {
+          const body = sc.bodyLines.join("\n").trim();
+          if (!body) {
+            process.stdout.write(
+              `${ui2.C.yellow}corpo vazio \u2014 cole algum conteudo ou /cancelar${ui2.C.reset}
+`
+            );
+            return;
+          }
+          const res = saveSkill({
+            name: sc.name,
+            description: sc.description,
+            triggers: sc.triggers,
+            body
+          });
+          skillCreator = null;
+          await agent.refreshSkills();
+          process.stdout.write(
+            `
+${ui2.C.green}\u2713 skill '${res.skill.name}' ${res.overwritten ? "atualizada" : "criada"}${ui2.C.reset} ${ui2.C.dim}(${res.file})${ui2.C.reset}
+${ui2.C.dim}ja disponivel para todos os modelos nesta sessao.${ui2.C.reset}
+`
+          );
+          return;
+        }
+        if (input === "/desfazer" || input === "/undo") {
+          if (sc.bodyLines.length === 0) {
+            process.stdout.write(
+              `${ui2.C.dim}nada para desfazer${ui2.C.reset}
+`
+            );
+          } else {
+            sc.bodyLines.pop();
+            process.stdout.write(
+              `${ui2.C.yellow}ultimo trecho removido.${ui2.C.reset}
+`
+            );
+            printBodyTally(sc);
+          }
+          return;
+        }
+        sc.bodyLines.push(line.replace(/\r$/, ""));
+        printBodyTally(sc);
+        return;
+      }
+    }
+  };
   const handleLine = async (line) => {
     if (closing) return;
     const input = line.trim();
+    if (skillCreator) {
+      await handleSkillCreatorLine(line, input);
+      if (!closing) prompt();
+      return;
+    }
     if (input === "/exit" || input === "/quit") {
       closing = true;
       rl.close();
       return;
     }
+    if (input === "/skillcreator" || input === "/skill" || input === "/skills") {
+      handleSkillCommand(input);
+      if (!closing) prompt();
+      return;
+    }
+    if (input.startsWith("/skill ") || input.startsWith("/skills ")) {
+      await handleSkillSubcommand(input);
+      if (!closing) prompt();
+      return;
+    }
     if (awaitingModelSelection) {
       if (!input || input === "cancelar" || input === "cancel" || input === "sair" || input === "q") {
         awaitingModelSelection = false;
@@ -70197,6 +70779,13 @@ ${ui2.C.dim}selecao de modelo cancelada${ui2.C.reset}
       );
       process.stdout.write(sys2 + "\n");
       process.stdout.write(`\x1B[90m\u2500\u2500\u2500\u2500 fim do system prompt \u2500\u2500\u2500\u2500\x1B[0m
+`);
+      if (!closing) prompt();
+      return;
+    }
+    if (input === "/nov" || input === "/novidades") {
+      process.stdout.write(`
+${ui2.C.cyan}${renderNews(clawfastVersion())}${ui2.C.reset}
 `);
       if (!closing) prompt();
       return;
@@ -70252,6 +70841,10 @@ ${ui2.C.dim}selecao de modelo cancelada${ui2.C.reset}
 function modelPrompt() {
   return "\n\x1B[96m\x1B[1mmodelo\x1B[0m\x1B[92m\x1B[1m>\x1B[0m ";
 }
+function skillPrompt(phase) {
+  const label = phase === "name" ? "nome" : phase === "desc" ? "descricao" : phase === "triggers" ? "gatilhos" : "skill";
+  return `\x1B[96m\x1B[1m${label}\x1B[0m\x1B[92m\x1B[1m>\x1B[0m `;
+}
 function formatModelSelection(result, options = {}) {
   const { C: C4 } = {
     C: {
@@ -70303,17 +70896,20 @@ var init_index = __esm({
     init_paste_input();
     init_boot_ui();
     init_config();
+    init_skills();
+    init_version();
+    init_update();
+    init_news();
     loadClawfastEnv();
     deepseekEnabled = /^(1|true|yes)$/i.test(process.env.DEEPSEEK_ENABLED?.trim() ?? "") || Boolean(process.env.DEEPSEEK_BASE_URL?.trim()) || Boolean(process.env.DEEPSEEK_API_KEY?.trim());
     configuredModelProviders = [
       deepseekEnabled ? "DeepSeek (proxy/web session)" : null,
-      process.env.OPENROUTER_API_KEY?.trim() ? "OpenRouter" : null,
-      process.env.HUGGINGFACE_API_KEY?.trim() || process.env.HF_TOKEN?.trim() ? "Hugging Face" : null,
+      process.env.NVIDIA_API_KEY?.trim() ? "NVIDIA build" : null,
       process.env.OPENAI_API_KEY?.trim() ? "OpenAI" : null
     ].filter((name25) => Boolean(name25));
     if (configuredModelProviders.length === 0) {
       console.error(
-        `Nenhuma chave de modelo configurada. Defina OPENROUTER_API_KEY (ou HUGGINGFACE_API_KEY/HF_TOKEN/OPENAI_API_KEY) em ${clawfastEnvPath()} ou como vari\xE1vel de ambiente.`
+        `Nenhuma chave de modelo configurada. Defina NVIDIA_API_KEY (ou OPENAI_API_KEY) em ${clawfastEnvPath()} ou como vari\xE1vel de ambiente.`
       );
       process.exit(1);
     }
@@ -70328,8 +70924,38 @@ var init_index = __esm({
 // boot.ts
 init_boot_ui();
 init_config();
+init_version();
+init_update();
 loadClawfastEnv();
+async function handleSubcommand() {
+  const arg = process.argv[2];
+  if (arg === "--version" || arg === "-v" || arg === "version") {
+    process.stdout.write(`clawfast ${clawfastVersion()}
+`);
+    process.exit(0);
+  }
+  if (arg === "update" || arg === "upgrade") {
+    process.stdout.write(`\x1B[92mAtualizando o clawfast\u2026\x1B[0m
+`);
+    const code = await runSelfUpdate();
+    if (code === 0) {
+      process.stdout.write(
+        `
+\x1B[92m\x1B[1mSeja bem vindo ao submundo.\x1B[0m
+`
+      );
+    } else {
+      process.stdout.write(
+        `
+\x1B[91mFalha ao atualizar (codigo ${code}).\x1B[0m Tente manualmente: \x1B[1mnpm install -g clawfast@latest\x1B[0m
+`
+      );
+    }
+    process.exit(code === 0 ? 0 : 1);
+  }
+}
 async function boot() {
+  await handleSubcommand();
   const hasKey = await ensureProviderKey();
   if (!hasKey) process.exit(1);
   startBootSpinner();