fluxflow-cli 1.10.10 → 1.11.1

package/ARCHITECTURE.md

@@ -25,9 +25,9 @@ The execution flow of a single user prompt follows this loop:
 5. **Turn Management & Continuation**: The model is instructed to append `[turn: finish]` if its goal is complete, or `[turn: continue]` if it expects tool results.
    - If tools were called or `[turn: continue]` is present, the loop increments and re-prompts the model with the newly gathered `[TOOL RESULT]` data.
    - If `[turn: finish]` is detected and no further tools were called, the main loop terminates, passing the final synthesized context to the background Janitor process.
-6. **Loop Limits & Resilience**: To prevent infinite loops or excessive API usage, **Flux mode** is capped at 50 iterations per user prompt, while **Flow mode** is capped at 5.
+6. **Loop Limits & Resilience**: To prevent infinite loops or excessive API usage, **Flux mode** is capped at 70 iterations per user prompt, while **Flow mode** is capped at 7.
    - **Multi-Stage Failover**: The loop features a sophisticated 8-attempt retry engine with random backoff (800ms - 2s).
-   - **Critical Fallback Pivot**: If the primary model fails 5 consecutive times, the agent surgically pivots to a lighter, high-concurrency fallback model (`gemini-3.1-flash-lite`) for the final 3 attempts to ensure session navigation through API congestion.
+   - **Critical Fallback Pivot**: If the primary model fails 13 consecutive times, the agent surgically pivots to a lighter, high-concurrency fallback model (`gemini-3.1-flash-lite`) for the final 3 attempts to ensure session navigation through API congestion.
 
 ## Multimodal Pipeline
 

package/dist/fluxflow.js

@@ -728,7 +728,8 @@ var init_AskUserModal = __esm({
 // src/utils/crypto.js
 import fs from "fs";
 import path from "path";
-var XOR_KEY, xorTransform, readEncryptedJson, writeEncryptedJson;
+import crypto from "crypto";
+var XOR_KEY, xorTransform, AES_ALGORITHM, AES_KEY, encryptAes, decryptAes, readEncryptedJson, writeEncryptedJson, readAesEncryptedJson, writeAesEncryptedJson;
 var init_crypto = __esm({
   "src/utils/crypto.js"() {
     XOR_KEY = 66;
@@ -740,12 +741,45 @@ var init_crypto = __esm({
       }
       return result;
     };
+    AES_ALGORITHM = "aes-256-cbc";
+    AES_KEY = crypto.createHash("sha256").update("fluxflow-cli-sanctuary-key").digest();
+    encryptAes = (text) => {
+      const iv = crypto.randomBytes(16);
+      const cipher = crypto.createCipheriv(AES_ALGORITHM, AES_KEY, iv);
+      let encrypted = cipher.update(text, "utf8", "hex");
+      encrypted += cipher.final("hex");
+      return iv.toString("hex") + ":" + encrypted;
+    };
+    decryptAes = (encryptedText) => {
+      const parts = encryptedText.split(":");
+      if (parts.length !== 2) {
+        throw new Error("Invalid AES format");
+      }
+      const iv = Buffer.from(parts[0], "hex");
+      const ciphertext = parts[1];
+      const decipher = crypto.createDecipheriv(AES_ALGORITHM, AES_KEY, iv);
+      let decrypted = decipher.update(ciphertext, "hex", "utf8");
+      decrypted += decipher.final("utf8");
+      return decrypted;
+    };
     readEncryptedJson = (filePath, defaultValue = {}) => {
       try {
         if (!fs.existsSync(filePath)) return defaultValue;
-        const encryptedData = fs.readFileSync(filePath);
-        const decryptedData = xorTransform(encryptedData).toString();
-        return JSON.parse(decryptedData);
+        const rawContent = fs.readFileSync(filePath);
+        const fileContent = rawContent.toString("utf8").trim();
+        if (fileContent.startsWith("{") || fileContent.startsWith("[")) {
+          return JSON.parse(fileContent);
+        }
+        try {
+          const decrypted = decryptAes(fileContent);
+          return JSON.parse(decrypted);
+        } catch (aesErr) {
+        }
+        const decryptedDataXor = xorTransform(rawContent).toString("utf8");
+        if (decryptedDataXor.startsWith("{") || decryptedDataXor.startsWith("[")) {
+          return JSON.parse(decryptedDataXor);
+        }
+        throw new Error("Unsupported or corrupt encryption format");
       } catch (err) {
         console.error(`Vault Read Error [${path.basename(filePath)}]:`, err.message);
         return defaultValue;
@@ -756,12 +790,14 @@ var init_crypto = __esm({
         const dir = path.dirname(filePath);
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         const jsonData = JSON.stringify(data, null, 2);
-        const encryptedData = xorTransform(jsonData);
-        fs.writeFileSync(filePath, encryptedData);
+        const encrypted = encryptAes(jsonData);
+        fs.writeFileSync(filePath, encrypted, "utf8");
       } catch (err) {
         console.error(`Vault Write Error [${path.basename(filePath)}]:`, err.message);
       }
     };
+    readAesEncryptedJson = readEncryptedJson;
+    writeAesEncryptedJson = writeEncryptedJson;
   }
 });
 
@@ -781,6 +817,7 @@ __export(paths_exports, {
 import os2 from "os";
 import path2 from "path";
 import fs2 from "fs";
+import crypto2 from "crypto";
 var FLUXFLOW_DIR, SETTINGS_FILE, externalDir, DATA_DIR, LOGS_DIR, SECRET_DIR, HISTORY_FILE, USAGE_FILE, MEMORIES_FILE, TEMP_MEM_FILE;
 var init_paths = __esm({
   "src/utils/paths.js"() {
@@ -789,10 +826,27 @@ var init_paths = __esm({
     externalDir = null;
     try {
       if (fs2.existsSync(SETTINGS_FILE)) {
-        const settings = JSON.parse(fs2.readFileSync(SETTINGS_FILE, "utf8"));
-        const sys = settings.systemSettings || {};
-        if (sys.useExternalData && sys.externalDataPath) {
-          externalDir = sys.externalDataPath;
+        const fileContent = fs2.readFileSync(SETTINGS_FILE, "utf8").trim();
+        let settings;
+        if (fileContent.startsWith("{")) {
+          settings = JSON.parse(fileContent);
+        } else {
+          const parts = fileContent.split(":");
+          if (parts.length === 2) {
+            const iv = Buffer.from(parts[0], "hex");
+            const ciphertext = parts[1];
+            const key = crypto2.createHash("sha256").update("fluxflow-cli-sanctuary-key").digest();
+            const decipher = crypto2.createDecipheriv("aes-256-cbc", key, iv);
+            let decrypted = decipher.update(ciphertext, "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            settings = JSON.parse(decrypted);
+          }
+        }
+        if (settings) {
+          const sys = settings.systemSettings || {};
+          if (sys.useExternalData && sys.externalDataPath) {
+            externalDir = sys.externalDataPath;
+          }
         }
       }
     } catch (e) {
@@ -801,7 +855,7 @@ var init_paths = __esm({
     LOGS_DIR = path2.join(DATA_DIR, "logs");
     SECRET_DIR = path2.join(DATA_DIR, "secret");
     HISTORY_FILE = path2.join(SECRET_DIR, "history.json");
-    USAGE_FILE = path2.join(SECRET_DIR, "usage.json");
+    USAGE_FILE = path2.join(FLUXFLOW_DIR, "usage.json");
     MEMORIES_FILE = path2.join(SECRET_DIR, "memories.json");
     TEMP_MEM_FILE = path2.join(SECRET_DIR, "memory-temp.json");
   }
@@ -1095,7 +1149,7 @@ Current date and Time: ${(/* @__PURE__ */ new Date()).toLocaleString([], { year:
 import fs5 from "fs-extra";
 import path4 from "path";
 import { nanoid } from "nanoid";
-var WRITE_LOCK, withLock, loadHistory, saveChat, saveChatTitle, deleteChat, generateChatId, cleanupOldHistory, getTruncatedHistory;
+var WRITE_LOCK, withLock, loadHistory, saveChat, saveChatTitle, deleteChat, generateChatId, cleanupOldHistory, parseCustomDate, cleanupLogFile, cleanupOldLogs, getTruncatedHistory;
 var init_history = __esm({
   "src/utils/history.js"() {
     init_crypto();
@@ -1117,7 +1171,7 @@ var init_history = __esm({
     loadHistory = async () => {
       if (await fs5.pathExists(HISTORY_FILE)) {
         try {
-          return await fs5.readJson(HISTORY_FILE);
+          return readEncryptedJson(HISTORY_FILE, {});
         } catch (e) {
           return {};
         }
@@ -1135,8 +1189,7 @@ var init_history = __esm({
           messages: persistentMessages,
           updatedAt: Date.now()
         };
-        await fs5.ensureDir(path4.dirname(HISTORY_FILE));
-        await fs5.writeJson(HISTORY_FILE, history, { spaces: 2 });
+        writeEncryptedJson(HISTORY_FILE, history);
       });
     };
     saveChatTitle = async (id, title) => {
@@ -1148,15 +1201,14 @@ var init_history = __esm({
         } else {
           history[id] = { name: title, messages: [], updatedAt: Date.now() };
         }
-        await fs5.ensureDir(path4.dirname(HISTORY_FILE));
-        await fs5.writeJson(HISTORY_FILE, history, { spaces: 2 });
+        writeEncryptedJson(HISTORY_FILE, history);
       });
     };
     deleteChat = async (id) => {
       return withLock(async () => {
         const history = await loadHistory();
         delete history[id];
-        await fs5.writeJson(HISTORY_FILE, history, { spaces: 2 });
+        writeEncryptedJson(HISTORY_FILE, history);
         const temp = readEncryptedJson(TEMP_MEM_FILE, {});
         if (temp[id]) {
           delete temp[id];
@@ -1183,6 +1235,125 @@ var init_history = __esm({
       }
       return deletedCount;
     };
+    parseCustomDate = (dateStr) => {
+      const cleanStr = dateStr.replace(/[\[\]]/g, "").trim();
+      const parsed = new Date(cleanStr);
+      if (!isNaN(parsed.getTime())) return parsed.getTime();
+      const parts = cleanStr.split(/,\s*|\s+/);
+      if (parts.length === 0) return null;
+      const datePart = parts[0];
+      const timePart = parts[1] || "";
+      const ampm = parts[2] || "";
+      const dateNums = datePart.split(/[-/.]/).map(Number);
+      if (dateNums.length !== 3) return null;
+      let year, month, day;
+      if (dateNums[0] > 1e3) {
+        year = dateNums[0];
+        month = dateNums[1];
+        day = dateNums[2];
+      } else if (dateNums[2] > 1e3) {
+        year = dateNums[2];
+        if (dateNums[0] > 12) {
+          day = dateNums[0];
+          month = dateNums[1];
+        } else if (dateNums[1] > 12) {
+          day = dateNums[1];
+          month = dateNums[0];
+        } else {
+          month = dateNums[0];
+          day = dateNums[1];
+        }
+      } else {
+        return null;
+      }
+      let hours = 0, minutes = 0, seconds = 0;
+      if (timePart) {
+        const timeNums = timePart.split(":").map(Number);
+        hours = timeNums[0] || 0;
+        minutes = timeNums[1] || 0;
+        seconds = timeNums[2] || 0;
+        if (ampm.toLowerCase() === "pm" && hours < 12) {
+          hours += 12;
+        } else if (ampm.toLowerCase() === "am" && hours === 12) {
+          hours = 0;
+        }
+      }
+      const d = new Date(year, month - 1, day, hours, minutes, seconds);
+      return isNaN(d.getTime()) ? null : d.getTime();
+    };
+    cleanupLogFile = async (filePath) => {
+      try {
+        if (!await fs5.pathExists(filePath)) return;
+        const content = await fs5.readFile(filePath, "utf8");
+        if (!content.trim()) return;
+        const lines = content.split("\n");
+        const entries = [];
+        let currentEntry = null;
+        const entryStartRegex = /^\s*(?:DEBUG|ERROR|SEARCH|PUPPETEER)\b/i;
+        for (const line of lines) {
+          if (entryStartRegex.test(line)) {
+            if (currentEntry) {
+              entries.push(currentEntry);
+            }
+            currentEntry = { header: line, body: [] };
+          } else {
+            if (currentEntry) {
+              currentEntry.body.push(line);
+            } else {
+              entries.push({ header: line, body: [] });
+            }
+          }
+        }
+        if (currentEntry) {
+          entries.push(currentEntry);
+        }
+        const threshold = 7 * 24 * 60 * 60 * 1e3;
+        const now = Date.now();
+        const keptEntries = [];
+        const timestampRegex = /(\d{1,4}[-/.]\d{1,4}[-/.]\d{1,4}(?:,\s*|\s+)?(?:\d{1,2}:\d{2}:\d{2}(?:\s*[aApP][mM])?)?)/;
+        for (const entry of entries) {
+          const entryText = entry.header + (entry.body.length > 0 ? "\n" + entry.body.join("\n") : "");
+          const match = entryText.match(timestampRegex);
+          if (match) {
+            const timeMs = parseCustomDate(match[1]);
+            if (timeMs && now - timeMs > threshold) {
+              continue;
+            }
+          }
+          keptEntries.push(entryText);
+        }
+        const finalContent = keptEntries.join("\n").trim();
+        if (finalContent) {
+          await fs5.writeFile(filePath, finalContent + "\n", "utf8");
+        } else {
+          await fs5.writeFile(filePath, "", "utf8");
+        }
+      } catch (e) {
+      }
+    };
+    cleanupOldLogs = async (logsDir) => {
+      try {
+        if (!await fs5.pathExists(logsDir)) return;
+        const cleanRecursive = async (dir) => {
+          const files = await fs5.readdir(dir);
+          for (const file of files) {
+            const fullPath = path4.join(dir, file);
+            const stat = await fs5.stat(fullPath);
+            if (stat.isDirectory()) {
+              await cleanRecursive(fullPath);
+              const subFiles = await fs5.readdir(fullPath);
+              if (subFiles.length === 0) {
+                await fs5.remove(fullPath);
+              }
+            } else if (file.endsWith(".log")) {
+              await cleanupLogFile(fullPath);
+            }
+          }
+        };
+        await cleanRecursive(logsDir);
+      } catch (e) {
+      }
+    };
     getTruncatedHistory = (history, exchangesToRemove = 4) => {
       if (history.length <= 1) return history;
       const welcome = history[0];
@@ -1197,10 +1368,11 @@ var init_history = __esm({
 // src/utils/usage.js
 import fs6 from "fs-extra";
 import path5 from "path";
-var cachedUsage, writeTimeout, lastWriteTime, isDirty, defaultStats, loadUsageFromFile, flushUsage, queueFlush, initUsage, forceFlushUsage, getDailyUsage, incrementUsage, addToUsage, checkQuota, checkImageQuota, getImageQuotaStats, recordImageGeneration;
+var cachedUsage, writeTimeout, lastWriteTime, isDirty, defaultStats, loadUsageFromFile, flushUsage, queueFlush, initUsage, forceFlushUsage, getDailyUsage, incrementUsage, addToUsage, checkQuota, getImageQuotaBuckets, getImageQuotaLimit, checkImageQuota, getImageQuotaStats, recordImageGeneration;
 var init_usage = __esm({
   "src/utils/usage.js"() {
     init_paths();
+    init_crypto();
     cachedUsage = null;
     writeTimeout = null;
     lastWriteTime = 0;
@@ -1220,7 +1392,13 @@ var init_usage = __esm({
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       try {
         if (await fs6.exists(USAGE_FILE)) {
-          const data = await fs6.readJson(USAGE_FILE);
+          const rawContent = (await fs6.readFile(USAGE_FILE, "utf8")).trim();
+          let data;
+          if (rawContent.startsWith("{") || rawContent.startsWith("[")) {
+            data = JSON.parse(rawContent);
+          } else {
+            data = JSON.parse(decryptAes(rawContent));
+          }
           if (data && data.date === today && data.stats) {
             const mergedStats = { ...defaultStats, ...data.stats };
             if (!Array.isArray(mergedStats.imageCalls)) {
@@ -1243,7 +1421,12 @@ var init_usage = __esm({
         let diskData = null;
         try {
           if (await fs6.exists(USAGE_FILE)) {
-            diskData = await fs6.readJson(USAGE_FILE);
+            const rawContent = (await fs6.readFile(USAGE_FILE, "utf8")).trim();
+            if (rawContent.startsWith("{") || rawContent.startsWith("[")) {
+              diskData = JSON.parse(rawContent);
+            } else {
+              diskData = JSON.parse(decryptAes(rawContent));
+            }
           }
         } catch (e) {
         }
@@ -1267,7 +1450,8 @@ var init_usage = __esm({
           }
         }
         const tempFile = USAGE_FILE + ".tmp";
-        await fs6.writeJson(tempFile, cachedUsage, { spaces: 2 });
+        const encryptedStr = encryptAes(JSON.stringify(cachedUsage, null, 2));
+        await fs6.writeFile(tempFile, encryptedStr, "utf8");
         const fd = await fs6.open(tempFile, "r+");
         await fs6.fsync(fd);
         await fs6.close(fd);
@@ -1346,6 +1530,111 @@ var init_usage = __esm({
       }
       return true;
     };
+    getImageQuotaBuckets = (imageCalls) => {
+      const hourMs = 60 * 60 * 1e3;
+      if (!imageCalls || imageCalls.length === 0) {
+        return [];
+      }
+      const sortedCalls = [...imageCalls].sort((a, b) => a.timestamp - b.timestamp);
+      const buckets = [];
+      for (const call of sortedCalls) {
+        if (buckets.length > 0) {
+          const lastBucket = buckets[buckets.length - 1];
+          if (call.timestamp >= lastBucket.start && call.timestamp < lastBucket.end) {
+            lastBucket.calls.push(call);
+            lastBucket.spent += call.cost;
+            continue;
+          }
+        }
+        buckets.push({
+          start: call.timestamp,
+          end: call.timestamp + hourMs,
+          calls: [call],
+          spent: call.cost
+        });
+      }
+      return buckets;
+    };
+    getImageQuotaLimit = (imageCalls, now) => {
+      const hourMs = 60 * 60 * 1e3;
+      if (!imageCalls || imageCalls.length === 0) {
+        return 0.025;
+      }
+      const buckets = getImageQuotaBuckets(imageCalls);
+      if (buckets.length === 0) {
+        return 0.025;
+      }
+      const history = [];
+      for (const bucket of buckets) {
+        let limit = 0.025;
+        if (history.length > 0) {
+          const prev1 = history[history.length - 1];
+          let consecutiveMax = false;
+          if (history.length >= 2) {
+            const prev2 = history[history.length - 2];
+            if (prev1.ratio >= 0.8 && prev2.ratio >= 0.8) {
+              consecutiveMax = true;
+            }
+          }
+          if (consecutiveMax) {
+            limit = 0.015;
+          } else {
+            const prevLimit2 = prev1.limit;
+            const prevRatio2 = prev1.ratio;
+            if (prevRatio2 >= 0.8) {
+              limit = prevLimit2 === 0.015 ? 0.015 : prevLimit2;
+            } else if (prevRatio2 < 0.4) {
+              limit = Math.min(0.025, prevLimit2 + 5e-3);
+            } else if (prevRatio2 >= 0.4 && prevRatio2 < 0.6) {
+              limit = Math.min(0.025, prevLimit2 + 4e-3);
+            } else {
+              limit = Math.min(0.025, prevLimit2 + 2e-3);
+            }
+          }
+        }
+        const ratio = limit > 0 ? bucket.spent / limit : 0;
+        history.push({ limit, spent: bucket.spent, ratio });
+      }
+      const lastBucket = buckets[buckets.length - 1];
+      if (now < lastBucket.end) {
+        return history[history.length - 1].limit;
+      }
+      let currentLimit = history[history.length - 1].limit;
+      let prevLimit = currentLimit;
+      let prevRatio = history[history.length - 1].ratio;
+      let simulatedTime = lastBucket.end;
+      let consecutiveMaxCount = 0;
+      for (let k = history.length - 1; k >= 0; k--) {
+        if (history[k].ratio >= 0.8) {
+          consecutiveMaxCount++;
+        } else {
+          break;
+        }
+      }
+      while (simulatedTime <= now) {
+        let limit = 0.025;
+        const consecutiveMax = consecutiveMaxCount >= 2;
+        if (consecutiveMax) {
+          limit = 0.015;
+        } else {
+          if (prevRatio >= 0.8) {
+            limit = prevLimit === 0.015 ? 0.015 : prevLimit;
+          } else if (prevRatio < 0.4) {
+            limit = Math.min(0.025, prevLimit + 5e-3);
+          } else if (prevRatio >= 0.4 && prevRatio < 0.6) {
+            limit = Math.min(0.025, prevLimit + 4e-3);
+          } else {
+            limit = Math.min(0.025, prevLimit + 2e-3);
+          }
+        }
+        prevLimit = limit;
+        prevRatio = 0;
+        consecutiveMaxCount = 0;
+        simulatedTime += hourMs;
+        currentLimit = limit;
+      }
+      return currentLimit;
+    };
     checkImageQuota = async (settings) => {
       const imageSettings = settings.imageSettings || { keyType: "Default", quality: "Low-High" };
       if (imageSettings.keyType !== "Default") return true;
@@ -1364,10 +1653,16 @@ var init_usage = __esm({
         stats.imageCalls = [];
       }
       const now = Date.now();
-      const oneHourAgo = now - 60 * 60 * 1e3;
-      const activeCalls = stats.imageCalls.filter((c) => c.timestamp >= oneHourAgo);
-      const totalSpent = activeCalls.reduce((sum, c) => sum + c.cost, 0);
-      return totalSpent + currentCost <= 0.02;
+      const buckets = getImageQuotaBuckets(stats.imageCalls);
+      let totalSpent = 0;
+      if (buckets.length > 0) {
+        const lastBucket = buckets[buckets.length - 1];
+        if (now >= lastBucket.start && now < lastBucket.end) {
+          totalSpent = lastBucket.spent;
+        }
+      }
+      const currentLimit = getImageQuotaLimit(stats.imageCalls, now);
+      return totalSpent + currentCost <= currentLimit;
     };
     getImageQuotaStats = async () => {
       const stats = await getDailyUsage();
@@ -1375,24 +1670,28 @@ var init_usage = __esm({
         stats.imageCalls = [];
       }
       const now = Date.now();
-      const oneHourAgo = now - 60 * 60 * 1e3;
-      const activeCalls = stats.imageCalls.filter((c) => c.timestamp >= oneHourAgo);
-      const totalSpent = activeCalls.reduce((sum, c) => sum + c.cost, 0);
-      const remaining = Math.max(0, 0.02 - totalSpent);
+      const buckets = getImageQuotaBuckets(stats.imageCalls);
+      let activeCalls = [];
+      let totalSpent = 0;
       let nextResetMin = 0;
-      let reclaimCost = 0;
-      if (activeCalls.length > 0) {
-        const earliestCall = activeCalls.reduce((min, c) => c.timestamp < min.timestamp ? c : min, activeCalls[0]);
-        const nextResetTimestamp = earliestCall.timestamp + 60 * 60 * 1e3;
-        nextResetMin = Math.max(0, Math.ceil((nextResetTimestamp - now) / (60 * 1e3)));
-        reclaimCost = earliestCall.cost;
+      if (buckets.length > 0) {
+        const lastBucket = buckets[buckets.length - 1];
+        if (now >= lastBucket.start && now < lastBucket.end) {
+          activeCalls = lastBucket.calls;
+          totalSpent = lastBucket.spent;
+          nextResetMin = Math.max(0, Math.ceil((lastBucket.end - now) / (60 * 1e3)));
+        }
       }
+      const currentLimit = getImageQuotaLimit(stats.imageCalls, now);
+      const remaining = Math.max(0, currentLimit - totalSpent);
+      const reclaimCost = totalSpent;
       return {
         totalSpent,
         remaining,
         activeCallsCount: activeCalls.length,
         nextResetMin,
-        reclaimCost
+        reclaimCost,
+        limit: currentLimit
       };
     };
     recordImageGeneration = async (settings) => {
@@ -2667,6 +2966,7 @@ var DEFAULT_SETTINGS, loadSettings, migrateToExternal, saveSettings;
 var init_settings = __esm({
   "src/utils/settings.js"() {
     init_paths();
+    init_crypto();
     DEFAULT_SETTINGS = {
       mode: "Flux",
       thinkingLevel: "Medium",
@@ -2704,14 +3004,14 @@ var init_settings = __esm({
       let settingsObj = { ...DEFAULT_SETTINGS };
       try {
         if (await fs14.exists(SETTINGS_FILE)) {
-          const saved = await fs14.readJson(SETTINGS_FILE);
+          const saved = readAesEncryptedJson(SETTINGS_FILE);
           if (saved.imageSettings && saved.imageSettings.apiKey) {
             try {
               const legacyKey = saved.imageSettings.apiKey;
               const { saveSecret: saveSecret2 } = await Promise.resolve().then(() => (init_secrets(), secrets_exports));
               await saveSecret2("POLLINATIONS_API_KEY", legacyKey);
               saved.imageSettings.apiKey = "";
-              await fs14.writeJson(SETTINGS_FILE, saved, { spaces: 2 });
+              writeAesEncryptedJson(SETTINGS_FILE, saved);
             } catch (e) {
             }
           }
@@ -2738,7 +3038,7 @@ var init_settings = __esm({
       if (settingsObj.showFullThinking === false) {
         settingsObj.showFullThinking = true;
         try {
-          await fs14.writeJson(SETTINGS_FILE, settingsObj, { spaces: 2 });
+          writeAesEncryptedJson(SETTINGS_FILE, settingsObj);
         } catch (e) {
         }
       }
@@ -2780,7 +3080,7 @@ var init_settings = __esm({
           updated.imageSettings = { ...updated.imageSettings, apiKey: "" };
         }
         await fs14.ensureDir(path13.dirname(SETTINGS_FILE));
-        await fs14.writeJson(SETTINGS_FILE, updated, { spaces: 2 });
+        writeAesEncryptedJson(SETTINGS_FILE, updated);
         return true;
       } catch (err) {
         console.error("Failed to save settings:", err);
@@ -2790,6 +3090,14 @@ var init_settings = __esm({
   }
 });
 
+// src/utils/fallback_key.js
+var FALLBACK_IMAGE_KEY;
+var init_fallback_key = __esm({
+  "src/utils/fallback_key.js"() {
+    FALLBACK_IMAGE_KEY = "pk_oH8wkUdQaQK1cmst";
+  }
+});
+
 // src/tools/generate_image.js
 import fs15 from "fs-extra";
 import path14 from "path";
@@ -2799,6 +3107,7 @@ var init_generate_image = __esm({
     init_arg_parser();
     init_settings();
     init_usage();
+    init_fallback_key();
     injectPngMetadata = (buffer, metadata = {}) => {
       try {
         if (buffer.length < 8 || buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) {
@@ -2871,7 +3180,7 @@ var init_generate_image = __esm({
           return `ERROR: Insufficient Quota for selected quality. Either tell user reduce quality or wait for next refresh cycle (${stats.nextResetMin || 60}m).`;
         }
         const imageSettings = settings.imageSettings || { keyType: "Default", quality: "Low-High", apiKey: "" };
-        const apiKey = imageSettings.keyType === "Custom" && imageSettings.apiKey ? imageSettings.apiKey : "pk_5i7Doib5fATyAN4i";
+        const apiKey = imageSettings.keyType === "Custom" && imageSettings.apiKey ? imageSettings.apiKey : FALLBACK_IMAGE_KEY;
         const qualityMap = {
           "Low": "flux",
           "Low-High": "zimage",
@@ -3162,17 +3471,6 @@ ${originalTextProcessed.length > 1500 ? "... (truncated) ...\n\n" : ""}
           if (fullContent) {
             finalSynthesis = fullContent;
             if (lastUsage) await addToUsage("tokens", lastUsage.totalTokenCount || 0);
-            const date = (/* @__PURE__ */ new Date()).toLocaleString();
-            const janitorLogDir = path15.join(LOGS_DIR, "janitor");
-            if (!fs16.existsSync(janitorLogDir)) fs16.mkdirSync(janitorLogDir, { recursive: true });
-            fs16.appendFileSync(path15.join(janitorLogDir, "debug.log"), `
-
----------------------------------------------------
-
-
-DEBUG [${date}]: ${finalSynthesis}
-
-`);
           } else {
             throw new Error("No synthesis generated by Janitor.");
           }
@@ -3650,7 +3948,7 @@ ${thinkingLevel != "Fast" ? "[SYSTEM] **STRICTLY FOLLOW THINKING POLICY AS STRIC
                   const potentialTool = NORMALIZE_MAP[rawToolName] || rawToolName;
                   const partialArgs = toolContext.args || "";
                   let detail = null;
-                  if (["write_file", "update_file", "view_file", "read_folder", "write_pdf", "write_docx", "search_keyword"].includes(potentialTool)) {
+                  if (["write_file", "update_file", "view_file", "read_folder", "write_pdf", "write_docx", "search_keyword", "generate_image"].includes(potentialTool)) {
                     const pArgs = parseArgs(partialArgs);
                     const filePath = pArgs.path || pArgs.targetFile || pArgs.TargetFile || pArgs.directory;
                     const keyword = pArgs.keyword;
@@ -4759,6 +5057,7 @@ function App() {
       if (saved.systemSettings?.autoDeleteHistory) {
         cleanupOldHistory(saved.systemSettings.autoDeleteHistory);
       }
+      cleanupOldLogs(LOGS_DIR);
       performVersionCheck(false, freshSettings);
       await initUsage();
       setIsInitializing(false);
@@ -4859,7 +5158,7 @@ function App() {
               cmd: "key",
               desc: "Set API key strategy",
               subs: [
-                { cmd: "default", desc: "Default (Quota: 20 credits/hr)" },
+                { cmd: "default", desc: "Default (Quota: Dynamic 25 max/hr)" },
                 { cmd: "custom", desc: "Custom Key" }
               ]
             },
@@ -5064,7 +5363,7 @@ ${hintText}`, color: "magenta" }];
                     id: Date.now(),
                     role: "system",
                     isImageStats: true,
-                    text: `\u2022 Hourly Limit: 20 credits
+                    text: `\u2022 Hourly Limit: ${Number((stats.limit * 1e3).toFixed(0))} credits
 \u2022 Spent (Last 1hr): ${Number((stats.totalSpent * 1e3).toFixed(0))} credits
 \u2022 Remaining: ${Number((stats.remaining * 1e3).toFixed(0))} credits
 \u2022 Requests (Last 1hr): ${stats.activeCallsCount} requests

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fluxflow-cli",
-	"version": "1.10.10",
+	"version": "1.11.1",
 	"description": "A high-fidelity agentic terminal assistant for the Flux Era.",
 	"keywords": [
 		"ai",