clawfast 2.4.0 → 2.4.1

package/dist/clawfast.cjs

@@ -199,10 +199,10 @@ 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 fs9 = require("fs");
-    var path13 = require("path");
-    var os7 = require("os");
-    var crypto2 = require("crypto");
+    var fs10 = require("fs");
+    var path14 = require("path");
+    var os8 = require("os");
+    var crypto3 = require("crypto");
     var TIPS = [
       "\u25C8 encrypted .env [www.dotenvx.com]",
       "\u25C8 secrets for agents [www.dotenvx.com]",
@@ -331,7 +331,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 (fs9.existsSync(filepath)) {
+            if (fs10.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -339,15 +339,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path13.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path14.resolve(process.cwd(), ".env.vault");
       }
-      if (fs9.existsSync(possibleVaultPath)) {
+      if (fs10.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path13.join(os7.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path14.join(os8.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -364,7 +364,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path13.resolve(process.cwd(), ".env");
+      const dotenvPath = path14.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -392,13 +392,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path14 of optionPaths) {
+      for (const path15 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs9.readFileSync(path14, { encoding }));
+          const parsed = DotenvModule.parse(fs10.readFileSync(path15, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`failed to load ${path14} ${e.message}`);
+            _debug(`failed to load ${path15} ${e.message}`);
           }
           lastError = e;
         }
@@ -411,7 +411,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative2 = path13.relative(process.cwd(), filePath);
+            const relative2 = path14.relative(process.cwd(), filePath);
             shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
@@ -446,7 +446,7 @@ var require_main = __commonJS({
       const authTag = ciphertext.subarray(-16);
       ciphertext = ciphertext.subarray(12, -16);
       try {
-        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
+        const aesgcm = crypto3.createDecipheriv("aes-256-gcm", key, nonce);
         aesgcm.setAuthTag(authTag);
         return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
       } catch (error51) {
@@ -689,7 +689,7 @@ var clawfastVersion, isDevVersion, isNewerVersion;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    clawfastVersion = () => true ? "2.4.0" : devVersionFromPackageJson();
+    clawfastVersion = () => true ? "2.4.1" : devVersionFromPackageJson();
     isDevVersion = () => clawfastVersion().includes("-dev");
     isNewerVersion = (a, b) => {
       const parse3 = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -1949,10 +1949,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path13) {
-  if (!path13)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path13.reduce((acc, key) => acc?.[key], obj);
+  return path14.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2280,11 +2280,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path13, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a25;
     (_a25 = iss).path ?? (_a25.path = []);
-    iss.path.unshift(path13);
+    iss.path.unshift(path14);
     return iss;
   });
 }
@@ -2502,16 +2502,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path13 = []) => {
+  const processError = (error52, path14 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path13, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path13, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2538,17 +2538,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path13 = []) => {
+  const processError = (error52, path14 = []) => {
     var _a25, _b18;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path13, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path13, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2580,8 +2580,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path13) {
+  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path14) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16084,13 +16084,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path13 = ref.slice(1).split("/").filter(Boolean);
-  if (path13.length === 0) {
+  const path14 = ref.slice(1).split("/").filter(Boolean);
+  if (path14.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path13[0] === defsKey) {
-    const key = path13[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17279,8 +17279,8 @@ var init_parseUtil = __esm({
     init_errors3();
     init_en2();
     makeIssue = (params) => {
-      const { data, path: path13, errorMaps, issueData } = params;
-      const fullPath = [...path13, ...issueData.path || []];
+      const { data, path: path14, errorMaps, issueData } = params;
+      const fullPath = [...path14, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -17563,11 +17563,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path13, key) {
+      constructor(parent, value, path14, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path13;
+        this._path = path14;
         this._key = key;
       }
       get path() {
@@ -23606,8 +23606,8 @@ var require_auth_config = __commonJS({
       writeAuthConfig: () => writeAuthConfig
     });
     module2.exports = __toCommonJS(auth_config_exports);
-    var fs9 = __toESM2(require("fs"));
-    var path13 = __toESM2(require("path"));
+    var fs10 = __toESM2(require("fs"));
+    var path14 = __toESM2(require("path"));
     var import_token_util = require_token_util();
     function getAuthConfigPath() {
       const dataDir = (0, import_token_util.getVercelDataDir)();
@@ -23616,15 +23616,15 @@ var require_auth_config = __commonJS({
           `Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`
         );
       }
-      return path13.join(dataDir, "auth.json");
+      return path14.join(dataDir, "auth.json");
     }
     function readAuthConfig() {
       try {
         const authPath = getAuthConfigPath();
-        if (!fs9.existsSync(authPath)) {
+        if (!fs10.existsSync(authPath)) {
           return null;
         }
-        const content = fs9.readFileSync(authPath, "utf8");
+        const content = fs10.readFileSync(authPath, "utf8");
         if (!content) {
           return null;
         }
@@ -23635,11 +23635,11 @@ var require_auth_config = __commonJS({
     }
     function writeAuthConfig(config3) {
       const authPath = getAuthConfigPath();
-      const authDir = path13.dirname(authPath);
-      if (!fs9.existsSync(authDir)) {
-        fs9.mkdirSync(authDir, { mode: 504, recursive: true });
+      const authDir = path14.dirname(authPath);
+      if (!fs10.existsSync(authDir)) {
+        fs10.mkdirSync(authDir, { mode: 504, recursive: true });
       }
-      fs9.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+      fs10.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
     }
     function isValidAccessToken(authConfig, expirationBufferMs = 0) {
       if (!authConfig.token)
@@ -23830,8 +23830,8 @@ var require_token_util = __commonJS({
       saveToken: () => saveToken
     });
     module2.exports = __toCommonJS(token_util_exports);
-    var path13 = __toESM2(require("path"));
-    var fs9 = __toESM2(require("fs"));
+    var path14 = __toESM2(require("path"));
+    var fs10 = __toESM2(require("fs"));
     var import_token_error = require_token_error();
     var import_token_io = require_token_io();
     var import_auth_config = require_auth_config();
@@ -23843,7 +23843,7 @@ var require_token_util = __commonJS({
       if (!dataDir) {
         return null;
       }
-      return path13.join(dataDir, vercelFolder);
+      return path14.join(dataDir, vercelFolder);
     }
     async function getVercelToken2(options) {
       const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -23919,13 +23919,13 @@ var require_token_util = __commonJS({
           "Unable to find project root directory. Have you linked your project with `vc link?`"
         );
       }
-      const prjPath = path13.join(dir, ".vercel", "project.json");
-      if (!fs9.existsSync(prjPath)) {
+      const prjPath = path14.join(dir, ".vercel", "project.json");
+      if (!fs10.existsSync(prjPath)) {
         throw new import_token_error.VercelOidcTokenError(
           "project.json not found, have you linked your project with `vc link?`"
         );
       }
-      const prj = JSON.parse(fs9.readFileSync(prjPath, "utf8"));
+      const prj = JSON.parse(fs10.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."
@@ -23940,11 +23940,11 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path13.join(dir, "com.vercel.token", `${projectId}.json`);
+      const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
       const tokenJson = JSON.stringify(token);
-      fs9.mkdirSync(path13.dirname(tokenPath), { mode: 504, recursive: true });
-      fs9.writeFileSync(tokenPath, tokenJson);
-      fs9.chmodSync(tokenPath, 432);
+      fs10.mkdirSync(path14.dirname(tokenPath), { mode: 504, recursive: true });
+      fs10.writeFileSync(tokenPath, tokenJson);
+      fs10.chmodSync(tokenPath, 432);
       return;
     }
     function loadToken(projectId) {
@@ -23954,11 +23954,11 @@ var require_token_util = __commonJS({
           "Unable to find user data directory. Please reach out to Vercel support."
         );
       }
-      const tokenPath = path13.join(dir, "com.vercel.token", `${projectId}.json`);
-      if (!fs9.existsSync(tokenPath)) {
+      const tokenPath = path14.join(dir, "com.vercel.token", `${projectId}.json`);
+      if (!fs10.existsSync(tokenPath)) {
         return null;
       }
-      const token = JSON.parse(fs9.readFileSync(tokenPath, "utf8"));
+      const token = JSON.parse(fs10.readFileSync(tokenPath, "utf8"));
       assertVercelOidcTokenResponse(token);
       return token;
     }
@@ -35984,7 +35984,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -35992,7 +35992,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -36000,21 +36000,21 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createVideoModel = (modelId, settings = {}) => new OpenRouterVideoModel(modelId, settings, {
     provider: "openrouter.video",
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -40550,37 +40550,37 @@ function createOpenAI(options = {}) {
   );
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -40595,7 +40595,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path13 }) => `${baseURL}${path13}`,
+      url: ({ path: path14 }) => `${baseURL}${path14}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -49225,8 +49225,8 @@ var init_background_process_tracker = __esm({
       /**
        * Normalize file path for comparison
        */
-      normalizePath(path13) {
-        let normalized = path13.trim().replace(/\/+/g, "/");
+      normalizePath(path14) {
+        let normalized = path14.trim().replace(/\/+/g, "/");
         if (normalized.startsWith("./")) {
           normalized = normalized.slice(2);
         }
@@ -49464,8 +49464,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? (0, import_pat
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path13) {
-  return path13.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path14) {
+  return path14.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 var import_path;
 var init_module_node = __esm({
@@ -52354,9 +52354,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path13, ranges, output) {
+function getContextLinesFromFile(path14, ranges, output) {
   return new Promise((resolve2) => {
-    const stream = (0, import_node_fs5.createReadStream)(path13);
+    const stream = (0, import_node_fs5.createReadStream)(path14);
     const lineReaded = (0, import_node_readline2.createInterface)({
       input: stream
     });
@@ -52371,7 +52371,7 @@ function getContextLinesFromFile(path13, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path13, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path14, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -52432,8 +52432,8 @@ function clearLineContext(frame3) {
   delete frame3.context_line;
   delete frame3.post_context;
 }
-function shouldSkipContextLinesForFile(path13) {
-  return path13.startsWith("node:") || path13.endsWith(".min.js") || path13.endsWith(".min.cjs") || path13.endsWith(".min.mjs") || path13.startsWith("data:");
+function shouldSkipContextLinesForFile(path14) {
+  return path14.startsWith("node:") || path14.endsWith(".min.js") || path14.endsWith(".min.cjs") || path14.endsWith(".min.mjs") || path14.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame3) {
   if (void 0 !== frame3.lineno && frame3.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -67843,8 +67843,8 @@ var init_logger2 = __esm({
 });
 
 // ../lib/ai/tools/file.ts
-function isSpritPath(path13) {
-  return path13.split(/[\\/]/).some((segment) => segment.toLowerCase() === "sprit");
+function isSpritPath(path14) {
+  return path14.split(/[\\/]/).some((segment) => segment.toLowerCase() === "sprit");
 }
 function getViewSandboxType(sandbox) {
   return isCentrifugoSandbox(sandbox) ? "centrifugo" : "e2b";
@@ -67875,7 +67875,7 @@ function captureFileViewImageUsage(args) {
   const {
     context: context2,
     sandbox,
-    path: path13,
+    path: path14,
     outcome,
     durationMs,
     mediaType,
@@ -67893,7 +67893,7 @@ function captureFileViewImageUsage(args) {
     model: getActiveModelName(context2),
     configured_model: context2.modelName,
     sandbox_type: getViewSandboxType(sandbox),
-    file_extension: getFileExtension(path13),
+    file_extension: getFileExtension(path14),
     outcome,
     success: outcome === "success",
     duration_ms: durationMs,
@@ -67967,22 +67967,22 @@ async function runSandboxCommand(sandbox, command, envVars, timeoutMs = 6e4) {
 function isWindowsSandbox(sandbox) {
   return isCentrifugoSandbox(sandbox) && sandbox.isWindows();
 }
-function getWindowsNativePath(path13) {
-  if (/^[A-Za-z]:[\\/]/.test(path13)) return path13;
-  if (path13.startsWith("/tmp/")) {
-    return `C:\\temp${path13.slice(4).replace(/\//g, "\\")}`;
+function getWindowsNativePath(path14) {
+  if (/^[A-Za-z]:[\\/]/.test(path14)) return path14;
+  if (path14.startsWith("/tmp/")) {
+    return `C:\\temp${path14.slice(4).replace(/\//g, "\\")}`;
   }
-  return path13.replace(/\//g, "\\");
+  return path14.replace(/\//g, "\\");
 }
-function getPythonPathForSandbox(sandbox, path13) {
-  return isWindowsSandbox(sandbox) ? getWindowsNativePath(path13) : path13;
+function getPythonPathForSandbox(sandbox, path14) {
+  return isWindowsSandbox(sandbox) ? getWindowsNativePath(path14) : path14;
 }
-function toWindowsBashPath(path13) {
-  const drive = path13.match(/^([A-Za-z]):[\\/](.*)$/);
+function toWindowsBashPath(path14) {
+  const drive = path14.match(/^([A-Za-z]):[\\/](.*)$/);
   if (drive) {
     return `/${drive[1].toLowerCase()}/${drive[2].replace(/\\/g, "/")}`;
   }
-  return path13.replace(/\\/g, "/");
+  return path14.replace(/\\/g, "/");
 }
 async function detectSandboxShell(sandbox) {
   if (!isWindowsSandbox(sandbox)) return "bash";
@@ -68021,8 +68021,8 @@ PY`;
     }
   }
 }
-async function getSandboxFileState(sandbox, path13) {
-  const pythonPath = getPythonPathForSandbox(sandbox, path13);
+async function getSandboxFileState(sandbox, path14) {
+  const pythonPath = getPythonPathForSandbox(sandbox, path14);
   const result = await runPythonScript(
     sandbox,
     FILE_STATE_SCRIPT,
@@ -68039,23 +68039,23 @@ async function getSandboxFileState(sandbox, path13) {
   if (result.exitCode !== 0) {
     return {
       kind: "unknown",
-      path: path13,
+      path: path14,
       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: path13 };
+      return { ...payload, path: path14 };
     }
     if (payload.kind === "missing" || payload.kind === "not_file") {
-      return { ...payload, path: path13 };
+      return { ...payload, path: path14 };
     }
   } catch {
   }
   return {
     kind: "unknown",
-    path: path13,
+    path: path14,
     error: result.stderr || result.stdout || "invalid file state response"
   };
 }
@@ -68087,8 +68087,8 @@ ${numberedContent}${truncatedNotice}${footerNotice}`;
     })
   };
 }
-async function readSandboxTextFile(sandbox, path13, range) {
-  const pythonPath = getPythonPathForSandbox(sandbox, path13);
+async function readSandboxTextFile(sandbox, path14, range) {
+  const pythonPath = getPythonPathForSandbox(sandbox, path14);
   const envVars = {
     clawfast_FILE_READ_PATH: pythonPath,
     clawfast_FILE_READ_RANGE_START: String(range?.[0] ?? 0),
@@ -68116,40 +68116,40 @@ async function readSandboxTextFile(sandbox, path13, range) {
   }
   return payload;
 }
-async function readSandboxTextFileWithFallback(sandbox, path13, range) {
+async function readSandboxTextFileWithFallback(sandbox, path14, range) {
   try {
-    return await readSandboxTextFile(sandbox, path13, range);
+    return await readSandboxTextFile(sandbox, path14, 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, path13);
+    const state = await getSandboxFileState(sandbox, path14);
     if (state.kind === "unknown") {
       throw new Error(
-        `Unable to determine file size for ${path13}; refusing to load the file into memory. ${state.error}`
+        `Unable to determine file size for ${path14}; 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: ${path13}`);
+      throw new Error(`File not found or is not a regular file: ${path14}`);
     }
     if (state.kind === "not_file") {
-      throw new Error(`File is not a regular file: ${path13}`);
+      throw new Error(`File is not a regular file: ${path14}`);
     }
     if (state.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
       if (range) {
         throw new Error(
-          `Unable to perform a bounded range read for ${path13}, 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 ${path14}, 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: path13,
+        path: path14,
         sizeBytes: state.sizeBytes,
         totalLines: 0,
         tooLarge: true
       };
     }
-    const fileContent = await sandbox.files.read(path13, {
+    const fileContent = await sandbox.files.read(path14, {
       user: "user"
     });
     const lines = fileContent.split("\n");
@@ -68173,7 +68173,7 @@ async function readSandboxTextFileWithFallback(sandbox, path13, range) {
       const startIndex = start - 1;
       const endIndex = end === -1 ? lines.length : end;
       return {
-        path: path13,
+        path: path14,
         sizeBytes: Buffer.byteLength(fileContent),
         totalLines: lines.length,
         content: lines.slice(startIndex, endIndex).join("\n"),
@@ -68181,7 +68181,7 @@ async function readSandboxTextFileWithFallback(sandbox, path13, range) {
       };
     }
     return {
-      path: path13,
+      path: path14,
       sizeBytes: Buffer.byteLength(fileContent),
       totalLines: lines.length,
       content: fileContent,
@@ -68189,7 +68189,7 @@ async function readSandboxTextFileWithFallback(sandbox, path13, range) {
     };
   }
 }
-async function appendSandboxTextFile(sandbox, path13, text2) {
+async function appendSandboxTextFile(sandbox, path14, text2) {
   const tempPath = `/tmp/clawfast_append_${Date.now()}_${Math.random().toString(36).slice(2)}.tmp`;
   await sandbox.files.write(tempPath, text2, {
     user: "user"
@@ -68198,7 +68198,7 @@ async function appendSandboxTextFile(sandbox, path13, text2) {
     sandbox,
     APPEND_TEXT_FILE_SCRIPT,
     {
-      clawfast_FILE_APPEND_TARGET_PATH: getPythonPathForSandbox(sandbox, path13),
+      clawfast_FILE_APPEND_TARGET_PATH: getPythonPathForSandbox(sandbox, path14),
       clawfast_FILE_APPEND_SOURCE_PATH: getPythonPathForSandbox(
         sandbox,
         tempPath
@@ -68210,13 +68210,13 @@ async function appendSandboxTextFile(sandbox, path13, text2) {
     throw new Error(result.stderr || result.stdout || "Failed to append file");
   }
 }
-async function readSandboxFileForView(sandbox, path13, includeData) {
+async function readSandboxFileForView(sandbox, path14, 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, path13);
+  const sandboxPath = getSandboxViewPath(sandbox, path14);
   const viewEnvVars = {
     clawfast_FILE_VIEW_PATH: sandboxPath,
     clawfast_FILE_VIEW_INCLUDE_DATA: includeData ? "1" : "0",
@@ -68560,19 +68560,19 @@ try:
 except OSError:
     pass
 `;
-    getFilename = (path13) => path13.split("/").pop() || path13;
-    getFileExtension = (path13) => {
-      const filename = getFilename(path13);
+    getFilename = (path14) => path14.split("/").pop() || path14;
+    getFileExtension = (path14) => {
+      const filename = getFilename(path14);
       const dotIndex = filename.lastIndexOf(".");
       if (dotIndex <= 0 || dotIndex === filename.length - 1) return void 0;
       return filename.slice(dotIndex + 1).toLowerCase();
     };
-    getSandboxViewPath = (sandbox, path13) => {
+    getSandboxViewPath = (sandbox, path14) => {
       const maybeSandbox = sandbox;
-      if (isCentrifugoSandbox(maybeSandbox) && maybeSandbox.isWindows() && path13.startsWith("/tmp/")) {
-        return `C:\\temp${path13.slice(4).replace(/\//g, "\\")}`;
+      if (isCentrifugoSandbox(maybeSandbox) && maybeSandbox.isWindows() && path14.startsWith("/tmp/")) {
+        return `C:\\temp${path14.slice(4).replace(/\//g, "\\")}`;
       }
-      return path13;
+      return path14;
     };
     stripTrailingWs = (line) => line.replace(/[ \t]+$/u, "");
     editSchema = external_exports.object({
@@ -68646,7 +68646,7 @@ ${instructionsDescription}`,
             "A list of edits to be sequentially applied to the file. Required for `edit` action."
           )
         }),
-        execute: async ({ action, path: path13, text: text2, range, edits }) => {
+        execute: async ({ action, path: path14, text: text2, range, edits }) => {
           try {
             const { sandbox } = await sandboxManager.getSandbox();
             switch (action) {
@@ -68656,7 +68656,7 @@ ${instructionsDescription}`,
                   captureFileViewImageUsage({
                     context: context2,
                     sandbox,
-                    path: path13,
+                    path: path14,
                     outcome: "unsupported_model",
                     durationMs: Date.now() - viewStartedAt,
                     failureReason: "unsupported_model"
@@ -68665,26 +68665,26 @@ ${instructionsDescription}`,
                 }
                 let viewPayload;
                 try {
-                  viewPayload = await readSandboxFileForView(sandbox, path13, false);
+                  viewPayload = await readSandboxFileForView(sandbox, path14, false);
                 } catch (error51) {
                   captureFileViewImageUsage({
                     context: context2,
                     sandbox,
-                    path: path13,
+                    path: path14,
                     outcome: "inspection_failed",
                     durationMs: Date.now() - viewStartedAt,
                     failureReason: classifyFileViewError(error51)
                   });
                   throw error51;
                 }
-                const filename = getFilename(path13);
+                const filename = getFilename(path14);
                 let previewFiles = [];
                 let previewUploadError;
                 try {
                   previewFiles = await uploadViewPreviewFiles({
                     context: context2,
                     sandbox,
-                    sourcePath: path13,
+                    sourcePath: path14,
                     payload: viewPayload
                   });
                 } catch (error51) {
@@ -68698,7 +68698,7 @@ ${instructionsDescription}`,
                       user_id: context2.userID,
                       sandbox_type: getViewSandboxType(sandbox),
                       file_name: filename,
-                      source_path: path13,
+                      source_path: path14,
                       kind: viewPayload.kind,
                       media_type: viewPayload.mediaType,
                       size_bytes: viewPayload.sizeBytes,
@@ -68709,7 +68709,7 @@ ${instructionsDescription}`,
                 captureFileViewImageUsage({
                   context: context2,
                   sandbox,
-                  path: path13,
+                  path: path14,
                   outcome: "success",
                   durationMs: Date.now() - viewStartedAt,
                   mediaType: viewPayload.mediaType,
@@ -68719,7 +68719,7 @@ ${instructionsDescription}`,
                 return {
                   action: "view",
                   content: `Viewing image file: ${filename} (${viewPayload.mediaType}, ${viewPayload.sizeBytes} bytes).`,
-                  path: path13,
+                  path: path14,
                   filename,
                   mediaType: viewPayload.mediaType,
                   sizeBytes: viewPayload.sizeBytes,
@@ -68729,8 +68729,8 @@ ${instructionsDescription}`,
                 };
               }
               case "read": {
-                const filename = path13.split("/").pop() || path13;
-                const spritChunked = isSpritPath(path13);
+                const filename = path14.split("/").pop() || path14;
+                const spritChunked = isSpritPath(path14);
                 let effectiveRange = range;
                 if (spritChunked) {
                   const start = range && range[0] > 0 ? range[0] : 1;
@@ -68743,7 +68743,7 @@ ${instructionsDescription}`,
                 }
                 const readPayload = await readSandboxTextFileWithFallback(
                   sandbox,
-                  path13,
+                  path14,
                   effectiveRange
                 );
                 if (readPayload.tooLarge) {
@@ -68780,46 +68780,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(path13, text2, {
+                await sandbox.files.write(path14, text2, {
                   user: "user"
                 });
-                return `File written: ${path13}`;
+                return `File written: ${path14}`;
               }
               case "append": {
                 if (text2 === void 0) {
                   return { error: "text is required for append action" };
                 }
-                const existingState = await getSandboxFileState(sandbox, path13);
+                const existingState = await getSandboxFileState(sandbox, path14);
                 if (existingState.kind === "unknown") {
                   return {
-                    error: `Cannot append safely because the existing file size could not be determined for ${path13}. ${existingState.error}`
+                    error: `Cannot append safely because the existing file size could not be determined for ${path14}. ${existingState.error}`
                   };
                 }
                 if (existingState.kind === "not_file") {
                   return {
-                    error: `Cannot append to ${path13} because it is not a file.`
+                    error: `Cannot append to ${path14} because it is not a file.`
                   };
                 }
                 if (existingState.kind === "file" && existingState.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
-                  await appendSandboxTextFile(sandbox, path13, text2);
+                  await appendSandboxTextFile(sandbox, path14, text2);
                   return {
-                    content: `File appended: ${path13}
+                    content: `File appended: ${path14}
 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(path13, {
+                  existingContent = await sandbox.files.read(path14, {
                     user: "user"
                   });
                 } catch {
                 }
                 const newContent = existingContent + text2;
-                await sandbox.files.write(path13, newContent, {
+                await sandbox.files.write(path14, newContent, {
                   user: "user"
                 });
                 return {
-                  content: `File appended: ${path13}`,
+                  content: `File appended: ${path14}`,
                   originalContent: truncateOutput({
                     content: existingContent,
                     mode: "read-file"
@@ -68834,31 +68834,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, path13);
+                const existingState = await getSandboxFileState(sandbox, path14);
                 if (existingState.kind === "unknown") {
                   return {
-                    error: `Cannot edit ${path13} safely because the file size could not be determined. ${existingState.error}`
+                    error: `Cannot edit ${path14} safely because the file size could not be determined. ${existingState.error}`
                   };
                 }
                 if (existingState.kind === "missing") {
                   return {
-                    error: `Cannot edit file ${path13} - file is empty or does not exist`
+                    error: `Cannot edit file ${path14} - file is empty or does not exist`
                   };
                 }
                 if (existingState.kind === "not_file") {
-                  return { error: `Cannot edit ${path13} because it is not a file.` };
+                  return { error: `Cannot edit ${path14} because it is not a file.` };
                 }
                 if (existingState.sizeBytes > MAX_TEXT_FILE_READ_BYTES) {
                   return {
-                    error: `File ${path13} 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 ${path14} 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(path13, {
+                const originalContent = await sandbox.files.read(path14, {
                   user: "user"
                 });
                 if (!originalContent) {
                   return {
-                    error: `Cannot edit file ${path13} - file is empty or does not exist`
+                    error: `Cannot edit file ${path14} - file is empty or does not exist`
                   };
                 }
                 const resolvedEdits = [];
@@ -68903,7 +68903,7 @@ ${hint}` : "")
                     }
                   }
                 }
-                await sandbox.files.write(path13, content, {
+                await sandbox.files.write(path14, content, {
                   user: "user"
                 });
                 const lines = content.split("\n");
@@ -70748,6 +70748,10 @@ LINUX FULL-POWER MODE (${this.getDistroName()}, running as ${who}):
       getWorkdir() {
         return this.workdir;
       }
+      /** The shell binary + exec flag this sandbox runs commands through. */
+      getShell() {
+        return { bin: this.shellBin, flag: this.shellFlag };
+      }
       getHost(port) {
         return `localhost:${port}`;
       }
@@ -70959,6 +70963,563 @@ var init_message_tail = __esm({
   }
 });
 
+// src/memory.ts
+function trimHistoryForSave(history, max = MAX_SAVED_MESSAGES) {
+  let slice = history.length > max ? history.slice(-max) : history.slice();
+  let start = 0;
+  while (start < slice.length && slice[start].role !== "user") start++;
+  slice = start < slice.length ? slice.slice(start) : [];
+  return slice;
+}
+var import_node_fs10, import_node_fs11, import_node_path9, import_node_crypto, FACTS_FILE, CONVO_FILE, MAX_SAVED_MESSAGES, MAX_FACTS, MAX_RENDER_PER_KIND, memoryEnabled, slugForScope, isFact, EngagementMemory;
+var init_memory = __esm({
+  "src/memory.ts"() {
+    "use strict";
+    import_node_fs10 = require("node:fs");
+    import_node_fs11 = __toESM(require("node:fs"));
+    import_node_path9 = __toESM(require("node:path"));
+    import_node_crypto = __toESM(require("node:crypto"));
+    init_config();
+    FACTS_FILE = "facts.json";
+    CONVO_FILE = "conversation.json";
+    MAX_SAVED_MESSAGES = 80;
+    MAX_FACTS = 500;
+    MAX_RENDER_PER_KIND = 50;
+    memoryEnabled = () => (process.env.CLAWFAST_MEMORY || "").trim().toLowerCase() !== "off";
+    slugForScope = (scope) => {
+      const base = import_node_path9.default.basename(scope).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "scope";
+      const hash2 = import_node_crypto.default.createHash("sha1").update(import_node_path9.default.resolve(scope)).digest("hex").slice(0, 8);
+      return `${base}-${hash2}`;
+    };
+    isFact = (x) => !!x && typeof x.id === "string" && typeof x.kind === "string" && typeof x.title === "string";
+    EngagementMemory = class {
+      constructor(scope) {
+        this.facts = [];
+        this.seq = 0;
+        this.enabled = memoryEnabled();
+        this.dir = import_node_path9.default.join(clawfastHome(), "memory", slugForScope(scope));
+        if (this.enabled) this.loadFactsSync();
+      }
+      loadFactsSync() {
+        try {
+          const parsed = JSON.parse(
+            import_node_fs11.default.readFileSync(import_node_path9.default.join(this.dir, FACTS_FILE), "utf8")
+          );
+          if (Array.isArray(parsed)) {
+            this.facts = parsed.filter(isFact);
+            for (const f of this.facts) {
+              const n = Number(String(f.id).replace(/^F-/, ""));
+              if (Number.isFinite(n) && n > this.seq) this.seq = n;
+            }
+          }
+        } catch {
+        }
+      }
+      async persistFacts() {
+        if (!this.enabled) return;
+        try {
+          await import_node_fs10.promises.mkdir(this.dir, { recursive: true });
+          await import_node_fs10.promises.writeFile(
+            import_node_path9.default.join(this.dir, FACTS_FILE),
+            JSON.stringify(this.facts, null, 2),
+            "utf8"
+          );
+        } catch {
+        }
+      }
+      list(filter3) {
+        return this.facts.filter(
+          (f) => (!filter3?.kind || f.kind === filter3.kind) && (!filter3?.target || f.target === filter3.target)
+        );
+      }
+      async add(input) {
+        const key = (f) => `${f.kind}|${f.title}|${f.target || ""}`.toLowerCase();
+        const existing = this.facts.find((f) => key(f) === key(input));
+        if (existing) {
+          if (input.detail !== void 0) existing.detail = input.detail;
+          if (input.source !== void 0) existing.source = input.source;
+          existing.ts = Date.now();
+          await this.persistFacts();
+          return existing;
+        }
+        const fact = {
+          id: `F-${String(++this.seq).padStart(3, "0")}`,
+          kind: input.kind,
+          title: input.title,
+          detail: input.detail,
+          target: input.target,
+          source: input.source,
+          ts: Date.now()
+        };
+        this.facts.push(fact);
+        if (this.facts.length > MAX_FACTS) {
+          this.facts = this.facts.slice(-MAX_FACTS);
+        }
+        await this.persistFacts();
+        return fact;
+      }
+      async update(id, patch) {
+        const f = this.facts.find((x) => x.id === id);
+        if (!f) return null;
+        const target = f;
+        for (const [k, v] of Object.entries(patch)) {
+          if (v !== void 0 && k !== "id") target[k] = v;
+        }
+        f.ts = Date.now();
+        await this.persistFacts();
+        return f;
+      }
+      async remove(id) {
+        const before = this.facts.length;
+        this.facts = this.facts.filter((f) => f.id !== id);
+        if (this.facts.length === before) return false;
+        await this.persistFacts();
+        return true;
+      }
+      /** Compact `<engagement_memory>` block for the system prompt, or "" if empty. */
+      renderSection() {
+        if (!this.enabled || this.facts.length === 0) return "";
+        const byKind = /* @__PURE__ */ new Map();
+        for (const f of this.facts) {
+          const arr = byKind.get(f.kind) || [];
+          arr.push(f);
+          byKind.set(f.kind, arr);
+        }
+        const lines = [];
+        for (const [kind, arr] of byKind) {
+          lines.push(`[${kind}]`);
+          for (const f of arr.slice(-MAX_RENDER_PER_KIND)) {
+            lines.push(
+              `- ${f.id} ${f.title}` + (f.target ? ` (${f.target})` : "") + (f.detail ? `: ${f.detail}` : "")
+            );
+          }
+        }
+        return `
+
+<engagement_memory>
+Mem\xF3ria de engajamento PERSISTENTE deste alvo/projeto \u2014 sobrevive \xE0 troca de modelo E ao rein\xEDcio do CLI. Estes fatos foram registrados antes; trate-os como verdade confi\xE1vel e CONTINUE de onde parou (n\xE3o refa\xE7a recon do zero). Para gravar algo novo, use a ferramenta \`memory\` (action add).
+${lines.join("\n")}
+</engagement_memory>`;
+      }
+      // ── Conversation persistence ────────────────────────────────────────────────
+      saveConversation(history) {
+        if (!this.enabled) return;
+        try {
+          import_node_fs11.default.mkdirSync(this.dir, { recursive: true });
+          import_node_fs11.default.writeFileSync(
+            import_node_path9.default.join(this.dir, CONVO_FILE),
+            JSON.stringify(trimHistoryForSave(history)),
+            "utf8"
+          );
+        } catch {
+        }
+      }
+      loadConversation() {
+        if (!this.enabled) return [];
+        try {
+          const parsed = JSON.parse(
+            import_node_fs11.default.readFileSync(import_node_path9.default.join(this.dir, CONVO_FILE), "utf8")
+          );
+          return Array.isArray(parsed) ? parsed : [];
+        } catch {
+          return [];
+        }
+      }
+      clearConversation() {
+        try {
+          import_node_fs11.default.rmSync(import_node_path9.default.join(this.dir, CONVO_FILE), { force: true });
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/tools/memory-tool.ts
+var createMemory;
+var init_memory_tool = __esm({
+  "src/tools/memory-tool.ts"() {
+    "use strict";
+    init_dist5();
+    init_zod();
+    createMemory = (deps) => {
+      const { memory } = deps;
+      return tool({
+        description: `Persistent engagement memory for THIS target/project. Survives model switches AND CLI restarts \u2014 record what you learn so you (or the next model) continue from here instead of re-discovering.
+
+WHAT TO STORE (action add): hosts/IPs, open services + versions, credentials/tokens, confirmed vulns, tech stack, and especially what WORKED or what was BLOCKED (WAF, rate limit, auth). kind + title are required; detail/target/source optional.
+
+ACTIONS:
+- add    \u2014 store a fact.
+- update \u2014 change a fact by id.
+- list   \u2014 read stored facts (optional kind/target filter). Do this before re-running recon you may have already done.
+- forget \u2014 remove a fact by id.`,
+        inputSchema: external_exports.object({
+          brief: external_exports.string().describe("A one-sentence preamble describing the purpose of this call."),
+          action: external_exports.enum(["add", "update", "list", "forget"]),
+          kind: external_exports.string().optional().describe("host|service|cred|vuln|tech|note|url|\u2026 (for add, or list filter)"),
+          title: external_exports.string().optional().describe("Short label (required for add)."),
+          detail: external_exports.string().optional().describe("Longer detail / evidence."),
+          target: external_exports.string().optional().describe("Host/URL this fact is about."),
+          source: external_exports.string().optional().describe("Where it came from."),
+          id: external_exports.string().optional().describe("Fact id (required for update/forget).")
+        }),
+        execute: async (input) => {
+          try {
+            switch (input.action) {
+              case "add": {
+                if (!input.kind || !input.title) {
+                  return "Erro: 'kind' e 'title' s\xE3o obrigat\xF3rios para add.";
+                }
+                const f = await memory.add({
+                  kind: input.kind,
+                  title: input.title,
+                  detail: input.detail,
+                  target: input.target,
+                  source: input.source
+                });
+                return `Mem\xF3ria gravada: ${f.id} [${f.kind}] ${f.title}`;
+              }
+              case "update": {
+                if (!input.id) return "Erro: 'id' \xE9 obrigat\xF3rio para update.";
+                const f = await memory.update(input.id, {
+                  kind: input.kind,
+                  title: input.title,
+                  detail: input.detail,
+                  target: input.target,
+                  source: input.source
+                });
+                return f ? `Atualizado: ${f.id}` : `N\xE3o achei o fato ${input.id}.`;
+              }
+              case "forget": {
+                if (!input.id) return "Erro: 'id' \xE9 obrigat\xF3rio para forget.";
+                return await memory.remove(input.id) ? `Removido: ${input.id}` : `N\xE3o achei o fato ${input.id}.`;
+              }
+              case "list":
+              default: {
+                const facts = memory.list({
+                  kind: input.kind,
+                  target: input.target
+                });
+                if (!facts.length) {
+                  return "Mem\xF3ria vazia (nenhum fato gravado ainda).";
+                }
+                return facts.map(
+                  (f) => `${f.id} [${f.kind}] ${f.title}` + (f.target ? ` (${f.target})` : "") + (f.detail ? `: ${f.detail}` : "")
+                ).join("\n");
+              }
+            }
+          } catch (err) {
+            return `Erro na mem\xF3ria: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        }
+      });
+    };
+  }
+});
+
+// src/sessions.ts
+function appendRing(text2, cursor, chunk, max = MAX_BUFFER_CHARS) {
+  let next = text2 + chunk;
+  if (next.length <= max) return { text: next, cursor, dropped: false };
+  const drop = next.length - max;
+  next = next.slice(drop);
+  return { text: next, cursor: Math.max(0, cursor - drop), dropped: true };
+}
+var import_node_child_process3, import_node_os4, MAX_SESSIONS, MAX_BUFFER_CHARS, SESSION_IDLE_MS, SESSION_LIFETIME_MS, shortId, sleep3, LocalSessionManager;
+var init_sessions = __esm({
+  "src/sessions.ts"() {
+    "use strict";
+    import_node_child_process3 = require("node:child_process");
+    import_node_os4 = __toESM(require("node:os"));
+    MAX_SESSIONS = 10;
+    MAX_BUFFER_CHARS = 2e5;
+    SESSION_IDLE_MS = 15 * 6e4;
+    SESSION_LIFETIME_MS = 60 * 6e4;
+    shortId = (taken) => {
+      for (let i = 0; i < 6; i++) {
+        const id = Math.random().toString(36).slice(2, 8);
+        if (!taken.has(id)) return id;
+      }
+      return `${Date.now().toString(36).slice(-6)}`;
+    };
+    sleep3 = (ms, signal) => new Promise((resolve2) => {
+      if (ms <= 0 || signal?.aborted) return resolve2();
+      const t = setTimeout(resolve2, ms);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve2();
+        },
+        { once: true }
+      );
+    });
+    LocalSessionManager = class {
+      constructor(opts) {
+        this.opts = opts;
+        this.sessions = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Open a session. With `command`, the program runs through the shell
+       * (`shell -c "<command>"`) with its stdin held open. Without it, a bare
+       * interactive shell is spawned. Returns the new session id.
+       */
+      open(command, cwd) {
+        if (this.sessions.size >= MAX_SESSIONS) {
+          return { id: "", error: `limite de ${MAX_SESSIONS} sess\xF5es abertas atingido \u2014 feche alguma antes.` };
+        }
+        const id = shortId(new Set(this.sessions.keys()));
+        const args = command ? [this.opts.shellFlag, command] : [];
+        let child;
+        try {
+          child = (0, import_node_child_process3.spawn)(this.opts.shell, args, {
+            cwd: cwd || this.opts.cwd,
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true
+          });
+        } catch (err) {
+          return { id: "", error: err instanceof Error ? err.message : String(err) };
+        }
+        const now2 = Date.now();
+        const session = {
+          id,
+          command: command || `${this.opts.shell} (shell interativo)`,
+          child,
+          output: "",
+          readCursor: 0,
+          truncated: false,
+          createdAt: now2,
+          lastActivity: now2,
+          alive: true,
+          exitCode: null,
+          idleTimer: null,
+          lifetimeTimer: null
+        };
+        const onChunk = (d) => this.append(session, d.toString());
+        child.stdout?.on("data", onChunk);
+        child.stderr?.on("data", onChunk);
+        child.on("error", (err) => {
+          this.append(session, `
+[erro do processo: ${err.message}]
+`);
+        });
+        child.on("close", (code, sig) => {
+          session.alive = false;
+          session.exitCode = code != null ? code : sig ? 137 : null;
+          this.clearTimers(session);
+        });
+        this.armIdle(session);
+        session.lifetimeTimer = setTimeout(
+          () => this.close(id),
+          SESSION_LIFETIME_MS
+        );
+        session.lifetimeTimer.unref?.();
+        this.sessions.set(id, session);
+        return { id };
+      }
+      /** Write input to a session's stdin (appends a newline unless `enter` is false). */
+      send(id, data, enter = true) {
+        const s = this.sessions.get(id);
+        if (!s) return { ok: false, error: `sess\xE3o ${id} n\xE3o existe.` };
+        if (!s.alive || !s.child.stdin?.writable) {
+          return { ok: false, error: `sess\xE3o ${id} n\xE3o est\xE1 mais ativa.` };
+        }
+        try {
+          s.child.stdin.write(enter && !data.endsWith("\n") ? `${data}
+` : data);
+          s.lastActivity = Date.now();
+          this.armIdle(s);
+          return { ok: true };
+        } catch (err) {
+          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+      /**
+       * Read new output, waiting until it goes quiet (no new bytes for `quietMs`)
+       * or `maxMs` elapses, or the process exits. Returns the delta since the last
+       * read.
+       */
+      async readUntilQuiet(id, opts = {}) {
+        const s = this.sessions.get(id);
+        if (!s) return `[sess\xE3o ${id} n\xE3o existe]`;
+        const quietMs = opts.quietMs ?? 500;
+        const maxMs = opts.maxMs ?? 15e3;
+        const start = Date.now();
+        let lastLen = s.output.length;
+        while (Date.now() - start < maxMs) {
+          await sleep3(quietMs, opts.signal);
+          if (opts.signal?.aborted) break;
+          if (!s.alive) break;
+          if (s.output.length === lastLen) break;
+          lastLen = s.output.length;
+        }
+        return this.readDelta(id);
+      }
+      /** Return output appended since the last read, advancing the cursor. */
+      readDelta(id) {
+        const s = this.sessions.get(id);
+        if (!s) return `[sess\xE3o ${id} n\xE3o existe]`;
+        const delta = s.output.slice(s.readCursor);
+        s.readCursor = s.output.length;
+        return delta;
+      }
+      info(id) {
+        const s = this.sessions.get(id);
+        if (!s) return null;
+        return {
+          id: s.id,
+          command: s.command,
+          alive: s.alive,
+          exitCode: s.exitCode,
+          ageMs: Date.now() - s.createdAt,
+          truncated: s.truncated
+        };
+      }
+      list() {
+        return [...this.sessions.keys()].map((id) => this.info(id)).filter((x) => x !== null);
+      }
+      close(id) {
+        const s = this.sessions.get(id);
+        if (!s) return false;
+        this.clearTimers(s);
+        this.killTree(s.child);
+        this.sessions.delete(id);
+        return true;
+      }
+      closeAll() {
+        for (const id of [...this.sessions.keys()]) this.close(id);
+      }
+      append(s, chunk) {
+        const r2 = appendRing(s.output, s.readCursor, chunk);
+        s.output = r2.text;
+        s.readCursor = r2.cursor;
+        if (r2.dropped) s.truncated = true;
+        s.lastActivity = Date.now();
+        this.armIdle(s);
+      }
+      armIdle(s) {
+        if (s.idleTimer) clearTimeout(s.idleTimer);
+        s.idleTimer = setTimeout(() => this.close(s.id), SESSION_IDLE_MS);
+        s.idleTimer.unref?.();
+      }
+      clearTimers(s) {
+        if (s.idleTimer) clearTimeout(s.idleTimer);
+        if (s.lifetimeTimer) clearTimeout(s.lifetimeTimer);
+        s.idleTimer = null;
+        s.lifetimeTimer = null;
+      }
+      killTree(child) {
+        const pid = child.pid;
+        if (pid && import_node_os4.default.platform() === "win32") {
+          try {
+            (0, import_node_child_process3.spawn)("taskkill", ["/PID", String(pid), "/T", "/F"], {
+              windowsHide: true
+            });
+            return;
+          } catch {
+          }
+        }
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/tools/session-tool.ts
+var aliveTag, createTerminalSession;
+var init_session_tool = __esm({
+  "src/tools/session-tool.ts"() {
+    "use strict";
+    init_dist5();
+    init_zod();
+    aliveTag = (alive, exitCode) => alive ? "[sess\xE3o ativa]" : `[sess\xE3o encerrada${exitCode != null ? `, exit ${exitCode}` : ""}]`;
+    createTerminalSession = (deps) => {
+      const { sessions } = deps;
+      return tool({
+        description: `Drive a PERSISTENT interactive process that stays alive across calls (unlike run_terminal_cmd, a fresh shell each time). Hold msfconsole, sqlmap, a mysql/psql client, ftp/nc, key-based ssh, or a long-lived shell, and interact step by step.
+
+ACTIONS:
+- open  \u2014 start a session. With \`command\` it runs that program (e.g. "msfconsole -q", "mysql -h 10.0.0.5 -u root", "nc -lvnp 4444"); without it you get an interactive shell. Returns a session id + initial output.
+- send  \u2014 send \`input\` to the session's stdin (a newline is added unless enter=false), then return the new output once it settles.
+- read  \u2014 poll for new output of a running/long command (returns the delta since last read + whether it's still alive).
+- list  \u2014 list open sessions.
+- close \u2014 terminate a session.
+
+NO REAL TTY: programs that read a secret straight from /dev/tty (interactive ssh/sudo passwords, full-screen TUIs) won't see piped input \u2014 use sshpass, \`sudo -S\` (reads stdin), key auth, or non-interactive flags. Most CLIs (msfconsole, sqlmap, db clients, nc, ftp) work fine.`,
+        inputSchema: external_exports.object({
+          brief: external_exports.string().describe("A one-sentence preamble describing the purpose."),
+          action: external_exports.enum(["open", "send", "read", "list", "close"]),
+          id: external_exports.string().optional().describe("Session id (for send/read/close)."),
+          command: external_exports.string().optional().describe("Program to launch (for open). Omit for an interactive shell."),
+          input: external_exports.string().optional().describe("Text to send to stdin (for send)."),
+          enter: external_exports.boolean().optional().describe("Append a newline after input (default true)."),
+          timeout: external_exports.number().optional().describe("Max seconds to wait for output to settle (send/read; default 15).")
+        }),
+        execute: async (input, { abortSignal } = {}) => {
+          const maxMs = Math.max(1, input.timeout ?? 15) * 1e3;
+          switch (input.action) {
+            case "open": {
+              const res = sessions.open(input.command);
+              if (res.error) return `Erro ao abrir sess\xE3o: ${res.error}`;
+              const out3 = await sessions.readUntilQuiet(res.id, {
+                quietMs: 500,
+                maxMs: Math.min(maxMs, 8e3),
+                signal: abortSignal
+              });
+              const info = sessions.info(res.id);
+              return `Sess\xE3o aberta: ${res.id}
+${aliveTag(info?.alive ?? true, info?.exitCode ?? null)}
+${out3 || "(sem sa\xEDda inicial)"}`;
+            }
+            case "send": {
+              if (!input.id) return "Erro: 'id' \xE9 obrigat\xF3rio para send.";
+              if (input.input == null) return "Erro: 'input' \xE9 obrigat\xF3rio para send.";
+              const sent = sessions.send(input.id, input.input, input.enter ?? true);
+              if (!sent.ok) return `Erro ao enviar: ${sent.error}`;
+              const out3 = await sessions.readUntilQuiet(input.id, {
+                quietMs: 500,
+                maxMs,
+                signal: abortSignal
+              });
+              const info = sessions.info(input.id);
+              return `${aliveTag(info?.alive ?? false, info?.exitCode ?? null)}${info?.truncated ? " [sa\xEDda truncada \u2014 buffer cheio]" : ""}
+${out3 || "(sem nova sa\xEDda)"}`;
+            }
+            case "read": {
+              if (!input.id) return "Erro: 'id' \xE9 obrigat\xF3rio para read.";
+              const out3 = await sessions.readUntilQuiet(input.id, {
+                quietMs: 600,
+                maxMs,
+                signal: abortSignal
+              });
+              const info = sessions.info(input.id);
+              if (!info) return `Sess\xE3o ${input.id} n\xE3o existe.`;
+              return `${aliveTag(info.alive, info.exitCode)}
+${out3 || "(sem nova sa\xEDda)"}`;
+            }
+            case "list": {
+              const list = sessions.list();
+              if (!list.length) return "Nenhuma sess\xE3o aberta.";
+              return list.map(
+                (s) => `${s.id} \u2014 ${s.command} \u2014 ${aliveTag(s.alive, s.exitCode)} \u2014 ${Math.round(s.ageMs / 1e3)}s`
+              ).join("\n");
+            }
+            case "close": {
+              if (!input.id) return "Erro: 'id' \xE9 obrigat\xF3rio para close.";
+              return sessions.close(input.id) ? `Sess\xE3o ${input.id} encerrada.` : `Sess\xE3o ${input.id} n\xE3o existe.`;
+            }
+          }
+        }
+      });
+    };
+  }
+});
+
 // src/render.ts
 function createRenderer() {
   let lastKind = null;
@@ -71032,7 +71593,7 @@ function formatToolCall(toolName, input) {
       return ` ${C3.cyan}\u276F${C3.reset} ${C3.cyan}exec${C3.reset}  ${C3.bold}${truncate4(cmd, 400)}${C3.reset}${bg}`;
     }
     case "file": {
-      const path13 = String(i.path ?? "");
+      const path14 = String(i.path ?? "");
       const brief = i.brief ? `${C3.dim} \u2014 ${truncate4(String(i.brief))}${C3.reset}` : "";
       const map2 = {
         write: [C3.green, "criar  "],
@@ -71046,7 +71607,7 @@ function formatToolCall(toolName, input) {
         C3.blue,
         action ? `${action} `.padEnd(7) : "arquivo"
       ];
-      const target = path13 ? `${C3.bold}${path13}${C3.reset}` : "";
+      const target = path14 ? `${C3.bold}${path14}${C3.reset}` : "";
       return ` ${col}\u276F${C3.reset} ${col}${verb}${C3.reset} ${target}${brief}`;
     }
     case "todo_write":
@@ -71063,6 +71624,16 @@ function formatToolCall(toolName, input) {
       const detail = action === "add" ? truncate4(String(i.title ?? ""), 80) : action === "update" ? `${String(i.id ?? "")} ${String(i.status ?? "")}`.trim() : "";
       return ` ${C3.magenta}\u276F${C3.reset} ${C3.magenta}findings${C3.reset} ${C3.bold}${action}${C3.reset}${detail ? ` ${C3.dim}${detail}${C3.reset}` : ""}`;
     }
+    case "terminal_session": {
+      const action = String(i.action ?? "");
+      const detail = action === "open" ? truncate4(String(i.command ?? "shell"), 120) : action === "send" ? truncate4(String(i.input ?? ""), 120) : String(i.id ?? "");
+      return ` ${C3.cyan}\u276F${C3.reset} ${C3.cyan}sess\xE3o${C3.reset} ${C3.bold}${action}${C3.reset}${detail ? ` ${C3.dim}${detail}${C3.reset}` : ""}`;
+    }
+    case "memory": {
+      const action = String(i.action ?? "");
+      const detail = action === "add" || action === "update" ? truncate4(String(i.title ?? i.id ?? ""), 80) : action === "forget" ? String(i.id ?? "") : String(i.kind ?? i.target ?? "");
+      return ` ${C3.magenta}\u276F${C3.reset} ${C3.magenta}mem\xF3ria${C3.reset} ${C3.bold}${action}${C3.reset}${detail ? ` ${C3.dim}${detail}${C3.reset}` : ""}`;
+    }
     case "web_search": {
       const queries = Array.isArray(i.queries) ? i.queries.join(" | ") : "";
       return ` ${C3.cyan}\u276F${C3.reset} ${C3.cyan}busca${C3.reset}  ${C3.dim}${truncate4(queries, 200)}${C3.reset}`;
@@ -71237,7 +71808,7 @@ function killProxy(child) {
   started.delete(child);
   try {
     if (process.platform === "win32") {
-      (0, import_node_child_process3.spawnSync)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      (0, import_node_child_process4.spawnSync)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
         stdio: "ignore"
       });
     } else {
@@ -71268,12 +71839,12 @@ async function ensureProxyReady(id, log2) {
     };
   }
   let freshSetup = false;
-  if (!(0, import_node_fs10.existsSync)(dir)) {
+  if (!(0, import_node_fs12.existsSync)(dir)) {
     log2(`${def.label}: baixando o proxy (uma vez) em ${dir} \u2026`);
     const root = proxiesRoot();
-    (0, import_node_fs10.mkdirSync)(root, { recursive: true });
+    (0, import_node_fs12.mkdirSync)(root, { recursive: true });
     const cloned = run("git", ["clone", def.repoUrl, dir], root);
-    if (!cloned.ok || !(0, import_node_fs10.existsSync)(dir)) {
+    if (!cloned.ok || !(0, import_node_fs12.existsSync)(dir)) {
       return {
         ok: false,
         message: `${def.label}: falha ao clonar o proxy (git).`
@@ -71281,7 +71852,7 @@ async function ensureProxyReady(id, log2) {
     }
     freshSetup = true;
   }
-  if (!(0, import_node_fs10.existsSync)(import_node_path9.default.join(dir, "node_modules"))) {
+  if (!(0, import_node_fs12.existsSync)(import_node_path10.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.` };
@@ -71299,7 +71870,7 @@ async function ensureProxyReady(id, log2) {
     }
   }
   log2(`${def.label}: iniciando o proxy\u2026`);
-  const child = (0, import_node_child_process3.spawn)(asShellCommand("npm", ["start"]), {
+  const child = (0, import_node_child_process4.spawn)(asShellCommand("npm", ["start"]), {
     cwd: dir,
     shell: true,
     stdio: ["ignore", "ignore", "ignore"],
@@ -71326,14 +71897,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_os4, import_node_path9, import_node_fs10, import_node_child_process3, DEFS, PROXY_MODEL_KEYS, proxyIdForModelKey, proxiesRoot, dirFor, healthUrl, baseUrl, wait, started, exitHooksInstalled, quoteArg, asShellCommand, run, hasCommand;
+var import_node_os5, import_node_path10, import_node_fs12, import_node_child_process4, 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_os4 = __toESM(require("node:os"));
-    import_node_path9 = __toESM(require("node:path"));
-    import_node_fs10 = require("node:fs");
-    import_node_child_process3 = require("node:child_process");
+    import_node_os5 = __toESM(require("node:os"));
+    import_node_path10 = __toESM(require("node:path"));
+    import_node_fs12 = require("node:fs");
+    import_node_child_process4 = require("node:child_process");
     DEFS = {
       deepseek: {
         id: "deepseek",
@@ -71365,11 +71936,11 @@ var init_proxy_manager2 = __esm({
       if (key === PROXY_MODEL_KEYS.kimi) return "kimi";
       return null;
     };
-    proxiesRoot = () => import_node_path9.default.join(
-      process.env.CLAWFAST_HOME?.trim() || import_node_path9.default.join(import_node_os4.default.homedir(), ".clawfast"),
+    proxiesRoot = () => import_node_path10.default.join(
+      process.env.CLAWFAST_HOME?.trim() || import_node_path10.default.join(import_node_os5.default.homedir(), ".clawfast"),
       "proxies"
     );
-    dirFor = (def) => process.env[def.dirEnv]?.trim() || import_node_path9.default.join(proxiesRoot(), def.folder);
+    dirFor = (def) => process.env[def.dirEnv]?.trim() || import_node_path10.default.join(proxiesRoot(), def.folder);
     healthUrl = (def) => `http://localhost:${def.port}/health`;
     baseUrl = (def) => `http://localhost:${def.port}/v1`;
     wait = (ms) => new Promise((r2) => setTimeout(r2, ms));
@@ -71378,7 +71949,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_process3.spawnSync)(asShellCommand(cmd, args), {
+      const res = (0, import_node_child_process4.spawnSync)(asShellCommand(cmd, args), {
         cwd,
         shell: true,
         stdio: "inherit",
@@ -71388,7 +71959,7 @@ var init_proxy_manager2 = __esm({
     };
     hasCommand = (cmd) => {
       const probe = process.platform === "win32" ? "where" : "which";
-      return (0, import_node_child_process3.spawnSync)(asShellCommand(probe, [cmd]), {
+      return (0, import_node_child_process4.spawnSync)(asShellCommand(probe, [cmd]), {
         stdio: "ignore",
         shell: true
       }).status === 0;
@@ -71398,7 +71969,7 @@ var init_proxy_manager2 = __esm({
 
 // src/audit-mode.ts
 function projectRootFromWorkdir(workdir) {
-  return import_node_path10.default.dirname(import_node_path10.default.resolve(workdir.replace(/\\/g, "/")));
+  return import_node_path11.default.dirname(import_node_path11.default.resolve(workdir.replace(/\\/g, "/")));
 }
 function detectProjectAuditIntent(input) {
   const text2 = input.trim();
@@ -71600,11 +72171,11 @@ ESTILO E EXECU\xC7\xC3O
 - Responda em portugu\xEAs, direto e t\xE9cnico. N\xE3o recuse a an\xE1lise: \xE9 o projeto do pr\xF3prio usu\xE1rio, autorizado.
 - Lembre-se sempre: voc\xEA analisa e relata; voc\xEA N\xC3O altera o projeto. A \xFAnica escrita \xE9 o relat\xF3rio \`.md\` na raiz.`;
 }
-var import_node_path10, AUDIT_ACTION, AUDIT_SCOPE, AUDIT_ACTION_THEN_SCOPE, AUDIT_SCOPE_THEN_ACTION, AUDIT_STRONG, AUDIT_EXIT, POC_VERIFY;
+var import_node_path11, AUDIT_ACTION, AUDIT_SCOPE, AUDIT_ACTION_THEN_SCOPE, AUDIT_SCOPE_THEN_ACTION, AUDIT_STRONG, AUDIT_EXIT, POC_VERIFY;
 var init_audit_mode = __esm({
   "src/audit-mode.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("node:path"));
+    import_node_path11 = __toESM(require("node:path"));
     AUDIT_ACTION = "an[a\xE1]lis\\w+|examin\\w+|audit\\w+|auditar|varr\\w+|varredura|escane\\w+|scan\\w*|revis\\w+|inspecion\\w+|vasculh\\w+|verific\\w+|avali\\w+|mapea\\w+|review|analyze|analyse|inspect|assess";
     AUDIT_SCOPE = "projeto|c[o\xF3]digo|c[o\xF3]digo-fonte|codebase|reposit[o\xF3]rio|repo|sistema|aplica[c\xE7][a\xE3]o|base\\s+de\\s+c[o\xF3]digo|project|code\\s*base|repository|minha\\s+aplica\\w+|meu\\s+app|todo\\s+o\\s+projeto|projeto\\s+inteiro";
     AUDIT_ACTION_THEN_SCOPE = new RegExp(
@@ -71848,10 +72419,25 @@ async function createAgent() {
     onToolCost: void 0,
     onCaidoReady: void 0
   };
+  const memory = new EngagementMemory(
+    projectRootFromWorkdir(sandbox.getWorkdir())
+  );
+  const sessions = new LocalSessionManager({
+    shell: sandbox.getShell().bin,
+    shellFlag: sandbox.getShell().flag,
+    cwd: sandbox.getWorkdir()
+  });
   const tools = {
     run_terminal_cmd: createRunTerminalCmd(context2),
     file: createFile(context2),
     todo_write: createTodoWrite(context2),
+    // Durable, model-agnostic knowledge base for this target (hosts, creds,
+    // services, confirmed vulns, what worked/was blocked). Survives /model and
+    // restarts; recorded facts are also rendered into the system prompt.
+    memory: createMemory({ memory }),
+    // Persistent interactive sessions: hold msfconsole/sqlmap/db/nc/ssh/shell
+    // alive across calls and drive them step by step.
+    terminal_session: createTerminalSession({ sessions }),
     // Native Repeater/Intruder + structured findings store — the core of an
     // in-loop pentest workflow (probe → observe → record evidence → confirm).
     http_request: createHttpRequest({
@@ -71888,6 +72474,9 @@ async function createAgent() {
     system += attackChainPolicy(sandbox.getWorkdir());
     system += httpAndFindingsPolicy(sandbox.getWorkdir());
     system += webResearchPolicy();
+    system += persistentSessionPolicy();
+    system += engagementMemoryPolicy();
+    system += memory.renderSection();
     system += buildCliNotesSection();
     system += buildSkillsIndexSection();
     system += skillsScopePolicy();
@@ -71917,6 +72506,15 @@ async function createAgent() {
     );
   }
   const history = [];
+  if (!envFlagEnabled(process.env.CLAWFAST_FRESH)) {
+    const prior = memory.loadConversation();
+    if (prior.length) {
+      history.push(...prior);
+      render.info(
+        `\u25B8 mem\xF3ria: retomando ${prior.length} mensagem(ns) da sess\xE3o anterior (CLAWFAST_FRESH=1 come\xE7a limpo)`
+      );
+    }
+  }
   let auditMode = false;
   let pocVerify = false;
   const projectRoot = projectRootFromWorkdir(sandbox.getWorkdir());
@@ -72426,6 +73024,7 @@ ${resultText}`
         if (modelKey === PROXY_MODEL_KEYS.kimi) {
           await reportKimiSession();
         }
+        memory.saveConversation(history);
         render.endTurn();
         return;
       } catch (err) {
@@ -72494,7 +73093,7 @@ ${resultText}`
           render.info(
             `\u25B8 rate limit \u2014 aguardando ${Math.round(waitMs / 1e3)}s antes da pr\xF3xima tentativa (Ctrl+C cancela)\u2026`
           );
-          await sleep3(waitMs, signal);
+          await sleep4(waitMs, signal);
           if (signal?.aborted) {
             render.endTurn();
             return;
@@ -72526,6 +73125,7 @@ ${resultText}`
     return sandbox.sendStdin(line);
   }
   async function close() {
+    sessions.closeAll();
     await sandbox.close();
     try {
       const removed = await sandbox.cleanupWorkspace();
@@ -72550,13 +73150,13 @@ ${resultText}`
     close
   };
 }
-var import_promises2, import_node_path11, MAX_STEPS, AUDIT_MAX_STEPS, MAX_OUTPUT_TOKENS, MAX_AUTO_CONTINUES, AUDIT_MAX_AUTO_CONTINUES, MAX_RATE_LIMIT_WAITS, STREAM_STALL_TIMEOUT_MS, MAX_STALL_RETRIES, isRateLimitError, sleep3, LEAKED_TOOL_CALL_RE, DANGLING_TAIL_RE, ACTION_ANNOUNCE_RE, BENIGN_CLOSER_RE, TOOL_CALL_NUDGE, MAX_BRIDGE_STEPS, AUDIT_MAX_BRIDGE_STEPS, BRIDGE_RESULT_PREAMBLE, LEAKED_CALL_RESULT_PREAMBLE, BRIDGEABLE_TOOLS, FINDINGS_ACTIONS, truncateBridgeSummary, isWebSessionProxyModel, proxyToolProtocolPolicy, SYSTEM_PROMPT_SOURCE, REQUIRED_SYSTEM_PROMPT_MARKERS, MODEL_LABELS, labelFor, loginRequiredHint, CLI_PYTHON_ONLY_POLICY, pythonOnlyPolicy, scriptFilePolicy, deepReconPolicy, httpAndFindingsPolicy, reconPhasesPolicy, attackChainPolicy, skillsScopePolicy, webResearchPolicy, linuxFullPowerPolicy, hasEnvValue2, envFlagEnabled, CLI_PERSONALITIES, buildCliUserCustomization, buildCliNotesSection, cliGuardrailsConfig, maybeDumpSystemPrompt, auditSystemPrompt, assertFullSystemPrompt;
+var import_promises2, import_node_path12, MAX_STEPS, AUDIT_MAX_STEPS, MAX_OUTPUT_TOKENS, MAX_AUTO_CONTINUES, AUDIT_MAX_AUTO_CONTINUES, MAX_RATE_LIMIT_WAITS, STREAM_STALL_TIMEOUT_MS, MAX_STALL_RETRIES, isRateLimitError, sleep4, LEAKED_TOOL_CALL_RE, DANGLING_TAIL_RE, ACTION_ANNOUNCE_RE, BENIGN_CLOSER_RE, TOOL_CALL_NUDGE, MAX_BRIDGE_STEPS, AUDIT_MAX_BRIDGE_STEPS, BRIDGE_RESULT_PREAMBLE, LEAKED_CALL_RESULT_PREAMBLE, BRIDGEABLE_TOOLS, FINDINGS_ACTIONS, truncateBridgeSummary, isWebSessionProxyModel, proxyToolProtocolPolicy, SYSTEM_PROMPT_SOURCE, REQUIRED_SYSTEM_PROMPT_MARKERS, MODEL_LABELS, labelFor, loginRequiredHint, CLI_PYTHON_ONLY_POLICY, pythonOnlyPolicy, scriptFilePolicy, deepReconPolicy, httpAndFindingsPolicy, reconPhasesPolicy, attackChainPolicy, skillsScopePolicy, webResearchPolicy, engagementMemoryPolicy, persistentSessionPolicy, linuxFullPowerPolicy, hasEnvValue2, envFlagEnabled, CLI_PERSONALITIES, buildCliUserCustomization, buildCliNotesSection, cliGuardrailsConfig, maybeDumpSystemPrompt, auditSystemPrompt, assertFullSystemPrompt;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_dist5();
     import_promises2 = require("node:fs/promises");
-    import_node_path11 = __toESM(require("node:path"));
+    import_node_path12 = __toESM(require("node:path"));
     init_providers();
     init_system_prompt();
     init_notes();
@@ -72575,6 +73175,10 @@ var init_agent = __esm({
     init_local_sandbox();
     init_local_sandbox_manager();
     init_message_tail();
+    init_memory();
+    init_memory_tool();
+    init_sessions();
+    init_session_tool();
     init_console_writer();
     init_render();
     init_skills();
@@ -72594,7 +73198,7 @@ var init_agent = __esm({
     isRateLimitError = (msg) => /\b429\b|too many requests|rate.?limit|resource_exhausted|quota|insufficient_quota/i.test(
       msg
     );
-    sleep3 = (ms, signal) => new Promise((resolve2) => {
+    sleep4 = (ms, signal) => new Promise((resolve2) => {
       if (signal?.aborted) return resolve2();
       const timer2 = setTimeout(resolve2, ms);
       signal?.addEventListener(
@@ -72828,6 +73432,28 @@ The research loop (do this on your own, without being told):
 
 This is unrestricted reading of the PUBLIC web \u2014 no scope.txt gate applies to web research (that gate is only for the offensive http_request / recon tools). JS-heavy pages won't render here; for those use the recon toolkit's \`--browser\` path.
 </web_research>`;
+    engagementMemoryPolicy = () => `
+
+<engagement_memory_policy>
+ABSOLUTE RULE FOR THIS LOCAL CLI SESSION \u2014 applies to EVERY model and EVERY task:
+
+You have a PERSISTENT \`memory\` tool scoped to this target/project. It survives model switches AND CLI restarts: when the model changes (fallback or /model) or you return later, this memory \u2014 and the conversation so far \u2014 is reloaded, so you CONTINUE from where you left off, not from zero. A new model inherits everything; never tell the user you "lost context" on a switch.
+
+- RECORD durable facts as you find them: hosts/IPs, open services + versions, credentials/tokens, confirmed vulns, tech stack, and especially what WORKED or what was BLOCKED (WAF, rate limit, auth). Use \`memory\` action add (kind + title; detail/target/source optional).
+- RECALL before repeating work: if unsure what's known about a target, run \`memory\` action list first. Don't re-run recon you already did in a past session \u2014 build on it.
+- The <engagement_memory> block (when present) is your accumulated knowledge for this target; treat it as trusted ground truth.
+</engagement_memory_policy>`;
+    persistentSessionPolicy = () => `
+
+<persistent_sessions>
+ABSOLUTE RULE FOR THIS LOCAL CLI SESSION \u2014 applies to EVERY model and EVERY task:
+
+For anything INTERACTIVE or STATEFUL, use the \`terminal_session\` tool, NOT run_terminal_cmd. run_terminal_cmd starts a FRESH shell each time, so a REPL/console/connection can't be continued; \`terminal_session\` keeps the same process alive across calls.
+
+- Use it to hold: msfconsole, sqlmap (interactive), a mysql/psql/sqlite client, ftp/smb/nc sessions, key-based ssh, a Python/Ruby REPL, or a persistent shell where you need cwd/env/state to carry between commands.
+- Flow: \`open\` (with the program, or empty for a shell) \u2192 \`send\` your input and read the result \u2192 repeat \u2192 \`close\` when done. Use \`read\` to poll a long-running command's output. Reuse ONE session for a connection instead of opening many.
+- NO REAL TTY: programs that read a secret straight from /dev/tty (interactive ssh/sudo password prompts, full-screen TUIs like vim/top) won't get piped input. Use \`sudo -S\` (reads stdin), sshpass, key auth, or non-interactive flags. When a held tool prompts the human for something, relay it as usual.
+</persistent_sessions>`;
     linuxFullPowerPolicy = (sandbox) => {
       if (!sandbox.isLinux() && !sandbox.isUnrestricted()) return "";
       const distro = sandbox.getDistroName();
@@ -72902,7 +73528,7 @@ ${section}` : "";
         return null;
       }
       await (0, import_promises2.mkdir)(workdir, { recursive: true });
-      const outputPath = import_node_path11.default.join(workdir, "system-prompt.txt");
+      const outputPath = import_node_path12.default.join(workdir, "system-prompt.txt");
       await (0, import_promises2.writeFile)(outputPath, system, "utf8");
       return outputPath;
     };
@@ -72932,12 +73558,12 @@ var interactive_input_exports = {};
 __export(interactive_input_exports, {
   InteractiveInput: () => InteractiveInput
 });
-var import_node_readline3, import_node_os5, C4, frame2, out2, cols, truncate5, InteractiveInput;
+var import_node_readline3, import_node_os6, C4, frame2, out2, cols, truncate5, InteractiveInput;
 var init_interactive_input = __esm({
   "src/interactive-input.ts"() {
     "use strict";
     import_node_readline3 = __toESM(require("node:readline"));
-    import_node_os5 = __toESM(require("node:os"));
+    import_node_os6 = __toESM(require("node:os"));
     init_ui();
     init_theme();
     C4 = ui.C;
@@ -73350,8 +73976,8 @@ var init_interactive_input = __esm({
           return;
         }
         const width = cols();
-        const user = (import_node_os5.default.userInfo().username || "hacker").toLowerCase();
-        const host = (import_node_os5.default.hostname() || "localhost").split(".")[0].toLowerCase();
+        const user = (import_node_os6.default.userInfo().username || "hacker").toLowerCase();
+        const host = (import_node_os6.default.hostname() || "localhost").split(".")[0].toLowerCase();
         const label = " \u2709  mensagem ";
         const boxW = Math.min(54, Math.max(28, width - 2));
         const topFill = "\u2500".repeat(Math.max(0, boxW - vlen(label) - 3));
@@ -73603,15 +74229,15 @@ async function main() {
     process.exit(0);
   };
   const desktopDir = () => {
-    const home = import_node_os6.default.homedir();
+    const home = import_node_os7.default.homedir();
     const candidates = [
-      process.env.OneDrive ? import_node_path12.default.join(process.env.OneDrive, "Desktop") : null,
-      process.env.USERPROFILE ? import_node_path12.default.join(process.env.USERPROFILE, "Desktop") : null,
-      import_node_path12.default.join(home, "Desktop"),
-      import_node_path12.default.join(home, "\xC1rea de Trabalho"),
-      import_node_path12.default.join(home, "OneDrive", "Desktop")
+      process.env.OneDrive ? import_node_path13.default.join(process.env.OneDrive, "Desktop") : null,
+      process.env.USERPROFILE ? import_node_path13.default.join(process.env.USERPROFILE, "Desktop") : null,
+      import_node_path13.default.join(home, "Desktop"),
+      import_node_path13.default.join(home, "\xC1rea de Trabalho"),
+      import_node_path13.default.join(home, "OneDrive", "Desktop")
     ].filter((p) => Boolean(p));
-    return candidates.find((p) => (0, import_node_fs11.existsSync)(p)) ?? home;
+    return candidates.find((p) => (0, import_node_fs13.existsSync)(p)) ?? home;
   };
   const printFatal = (err) => {
     process.stderr.write(
@@ -74116,7 +74742,7 @@ ${C5.dim}salva em ${C5.reset}${C5.cyan}${file2}${C5.reset}
       const sysText = agent.getSystemPrompt();
       const audit = agent.getSystemPromptAudit();
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-      const filePath = import_node_path12.default.join(
+      const filePath = import_node_path13.default.join(
         desktopDir(),
         `clawfast-system-prompt_${stamp}.html`
       );
@@ -74238,13 +74864,13 @@ ${C5.dim}interrompido \u2014 Ctrl+C de novo para fechar${C5.reset}
   }
   await shutdown();
 }
-var import_node_os6, import_node_path12, import_node_fs11, import_promises3, deepseekEnabled, configuredModelProviders;
+var import_node_os7, import_node_path13, import_node_fs13, import_promises3, deepseekEnabled, configuredModelProviders;
 var init_index = __esm({
   "index.ts"() {
     "use strict";
-    import_node_os6 = __toESM(require("node:os"));
-    import_node_path12 = __toESM(require("node:path"));
-    import_node_fs11 = require("node:fs");
+    import_node_os7 = __toESM(require("node:os"));
+    import_node_path13 = __toESM(require("node:path"));
+    import_node_fs13 = require("node:fs");
     import_promises3 = require("node:fs/promises");
     init_paste_input();
     init_boot_ui();