crucix 2.39.2 → 2.39.5

package/.env.example

@@ -15,6 +15,8 @@ FRED_API_KEY=
 FIRMS_MAP_KEY=
 # Energy Information Administration (free: api.eia.gov/register)
 EIA_API_KEY=
+# BLS Public Data (optional: data.bls.gov/registrationEngine). v1 is ~25/day; Crucix caches 12 hours. v2 is 500/day.
+BLS_API_KEY=
 # Financial Modeling Prep (free: site.financialmodelingprep.com/register, 250 calls/day): equities, indexes, forex in two
 # batch calls per sweep (192/day at the 15-minute sweep). FMP_DAILY_LIMIT caps the calls; without a key Yahoo covers it.
 FMP_API_KEY=
@@ -94,7 +96,7 @@ ANTHROPIC_BASE_URL=
 # Sent as Authorization: Bearer instead of x-api-key; use either this or LLM_API_KEY, not both
 ANTHROPIC_AUTH_TOKEN=
 LLM_IDEAS_MAX_TOKENS=4096
-LLM_IDEAS_TIMEOUT_MS=90000
+LLM_IDEAS_TIMEOUT_MS=180000
 LLM_ALERT_MAX_TOKENS=800
 LLM_ALERT_TIMEOUT_MS=30000
 # Cited briefings (POST /api/briefing): tokens 128-8192, timeout 1000-360000 ms; a failure falls back to the rule-based briefing

package/README.md

@@ -94,16 +94,31 @@ It was built for anyone who wants to understand what's actually happening in the
 
 ## Quick Start
 
+```powershell
+# Windows: standalone exe from GitHub Releases (no Node)
+irm https://github.com/arlinamid/Crucix/releases/latest/download/install.ps1 | iex
+```
+
+```bash
+# Linux / macOS
+curl -fsSL https://github.com/arlinamid/Crucix/releases/latest/download/install.sh | sh
+```
+
 ```bash
-# From npm (recommended): Node + runtime source, first run opens the setup wizard
+# From npm: Node + runtime source, first run opens the setup wizard
 npx crucix
 npm install -g crucix
+```
+
+Then:
+
+```bash
 crucix --version
 crucix install          # ~/.crucix (.env and runs/)
 crucix                  # dashboard; wizard if no .env yet
 ```
 
-That is not the standalone exe. `npm run install:local` (from a git checkout) builds `crucix.exe` and copies it to `%USERPROFILE%\.local\bin` / `~/.local/bin`. Check which one PATH hits with `crucix --version`.
+`npm run install:local` (from a git checkout) builds the exe yourself. Check which one PATH hits with `crucix --version`.
 
 Settings the wizard and **Settings → News feeds** save go to `%USERPROFILE%\.crucix` on Windows or `~/.crucix` on Linux/macOS. Set `CRUCIX_HOME` to choose another folder, or `CRUCIX_ENV_FILE` to name the `.env` itself.
 

package/apis/sources/acled.mjs

@@ -1,12 +1,13 @@
 import { readBoundedText } from '../utils/fetch.mjs';
 // ACLED — Armed Conflict Location & Event Data
 // Auth strategy (tries in order):
-//   1. Cookie-based session: POST /user/login?_format=json → session cookie
-//   2. OAuth Bearer token:   POST /oauth/token → Authorization header
+//   1. OAuth Bearer token:   POST /oauth/token (password grant + scope=authenticated)
+//   2. Cookie-based session: POST /user/login?_format=json → session cookie
 // Set ACLED_EMAIL and ACLED_PASSWORD in .env (your myACLED login credentials).
 // Data endpoint: GET https://acleddata.com/api/acled/read
 
 import { daysAgo } from '../utils/fetch.mjs';
+import { readQuota, writeQuota, clearQuota } from '../utils/quota-cache.mjs';
 import '../utils/env.mjs';
 
 const LOGIN_URL = 'https://acleddata.com/user/login?_format=json';
@@ -15,6 +16,31 @@ const API_BASE  = 'https://acleddata.com/api/acled/read';
 
 // Session cache
 let sessionCache = { cookies: null, token: null, method: null, expires: 0 };
+let lastGood = { at: 0, result: null };
+let hydrated = false;
+const LAST_GOOD_MS = 6 * 60 * 60 * 1000;
+const ACLED_HEADERS = {
+  'User-Agent': 'Crucix/2.2',
+  Accept: 'application/json',
+};
+
+function hydrateQuota() {
+  if (hydrated) return;
+  hydrated = true;
+  const saved = readQuota('acled');
+  if (Number(saved?.at) > 0 && saved.result) lastGood = { at: saved.at, result: saved.result };
+}
+
+export function resetState({ disk = true } = {}) {
+  sessionCache = { cookies: null, token: null, method: null, expires: 0 };
+  lastGood = { at: 0, result: null };
+  hydrated = false;
+  if (disk) clearQuota('acled');
+}
+
+function isChallenge(status, text) {
+  return status === 403 && /just a moment|cf-browser-verification|attention required/i.test(text || '');
+}
 
 // Strategy 1: Cookie-based session login (mirrors browser login)
 async function loginCookie(email, password) {
@@ -22,7 +48,7 @@ async function loginCookie(email, password) {
   try {
     const res = await fetch(LOGIN_URL, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers: { ...ACLED_HEADERS, 'Content-Type': 'application/json' },
       body: JSON.stringify({ name: email, pass: password }),
       redirect: 'manual',
       signal,
@@ -58,21 +84,30 @@ async function loginOAuth(email, password) {
       password: password,
       grant_type: 'password',
       client_id: 'acled',
+      scope: 'authenticated',
     });
 
     const res = await fetch(TOKEN_URL, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      headers: { ...ACLED_HEADERS, 'Content-Type': 'application/x-www-form-urlencoded' },
       body: body.toString(),
       signal,
     });
 
+    const text = await readBoundedText(res, 64 * 1024);
+    if (isChallenge(res.status, text)) {
+      return { error: `Cloudflare challenge (HTTP ${res.status}); ACLED is blocking scripted login`, blocked: true };
+    }
     if (!res.ok) {
-      await res.body?.cancel();
-      return { error: `OAuth failed (HTTP ${res.status})` };
+      let detail = '';
+      try {
+        const fail = JSON.parse(text);
+        detail = fail.error_description || fail.error || fail.message || '';
+      } catch { /* HTML or empty */ }
+      return { error: `OAuth failed (HTTP ${res.status}${detail ? `: ${String(detail).slice(0, 120)}` : ''})` };
     }
 
-    const data = JSON.parse(await readBoundedText(res));
+    const data = JSON.parse(text);
     if (!data.access_token) {
       return { error: 'OAuth response missing access_token' };
     }
@@ -109,6 +144,9 @@ async function authenticate() {
   }
   errors.push(`OAuth: ${oauthResult.error}`);
   if (debug) console.error(`[ACLED DEBUG] OAuth failed: ${oauthResult.error}`);
+  if (oauthResult.blocked) {
+    return { error: `All ACLED auth methods failed.\n${errors.join('\n')}` };
+  }
 
   // Fall back to cookie-based session
   const cookieResult = await loginCookie(email, password);
@@ -124,7 +162,7 @@ async function authenticate() {
 
 // Build headers based on auth method
 function authHeaders(session) {
-  const headers = { 'User-Agent': 'Crucix/1.0', 'Content-Type': 'application/json' };
+  const headers = { ...ACLED_HEADERS, 'Content-Type': 'application/json' };
   if (session.method === 'cookie' && session.cookies) {
     headers['Cookie'] = session.cookies;
   } else if (session.method === 'oauth' && session.token) {
@@ -228,7 +266,8 @@ function groupBy(events, field) {
 }
 
 // Briefing — last 7 days of global conflict events
-export async function briefing() {
+export async function briefing({ now = Date.now() } = {}) {
+  hydrateQuota();
   if (!process.env.ACLED_EMAIL || !process.env.ACLED_PASSWORD) {
     return {
       source: 'ACLED',
@@ -248,7 +287,10 @@ export async function briefing() {
   });
 
   if (data?.error) {
-    return { source: 'ACLED', timestamp: new Date().toISOString(), error: data.error };
+    if (lastGood.result && now - lastGood.at < LAST_GOOD_MS) {
+      return { ...lastGood.result, stale: true, message: data.error };
+    }
+    return { source: 'ACLED', timestamp: new Date(now).toISOString(), error: data.error };
   }
 
   let events = data?.data || [];
@@ -292,9 +334,9 @@ export async function briefing() {
       notes:      e.notes?.slice(0, 200),
     }));
 
-  return {
+  const result = {
     source: 'ACLED',
-    timestamp: new Date().toISOString(),
+    timestamp: new Date(now).toISOString(),
     period: { start, end },
     totalEvents: events.length,
     totalFatalities,
@@ -303,6 +345,9 @@ export async function briefing() {
     topCountries,
     deadliestEvents,
   };
+  lastGood = { at: now, result };
+  writeQuota('acled', lastGood);
+  return result;
 }
 
 if (process.argv[1]?.endsWith('acled.mjs')) {

package/apis/sources/bls.mjs

@@ -1,12 +1,35 @@
 import { readBoundedText } from '../utils/fetch.mjs';
 // BLS — Bureau of Labor Statistics
 // CPI, unemployment, nonfarm payrolls, PPI. No auth required (v1 API).
-// v2 with registration key supports more requests; v1 is rate-limited but functional.
+// v2 with registration key supports more requests; v1 is ~25 queries/day. A 12-hour
+// cache keeps a 15-minute sweep under that cap (CPI/labor series update monthly).
 
 import { safeFetch, daysAgo } from '../utils/fetch.mjs';
+import { readQuota, writeQuota, clearQuota } from '../utils/quota-cache.mjs';
 
 const V1_BASE = 'https://api.bls.gov/publicAPI/v1/timeseries/data/';
 const V2_BASE = 'https://api.bls.gov/publicAPI/v2/timeseries/data/';
+export const CACHE_MS = 12 * 60 * 60 * 1000;
+
+let lastGood = { at: 0, result: null };
+let hydrated = false;
+
+function hydrateQuota() {
+  if (hydrated) return;
+  hydrated = true;
+  const saved = readQuota('bls');
+  if (Number(saved?.at) > 0 && saved.result) lastGood = { at: saved.at, result: saved.result };
+}
+
+export function resetState({ disk = true } = {}) {
+  lastGood = { at: 0, result: null };
+  hydrated = false;
+  if (disk) clearQuota('bls');
+}
+
+function cached(message) {
+  return { ...lastGood.result, stale: true, message };
+}
 
 // Key economic series
 const SERIES = {
@@ -92,18 +115,26 @@ function momChange(seriesData) {
 }
 
 // Briefing — pull latest CPI, unemployment, payrolls
-export async function briefing(apiKey) {
+export async function briefing(apiKey, { now = Date.now() } = {}) {
+  hydrateQuota();
+  if (lastGood.result && now >= lastGood.at && now - lastGood.at < CACHE_MS) {
+    return cached(`Cached BLS result; next request after ${new Date(lastGood.at + CACHE_MS).toISOString()}`);
+  }
+
   const seriesIds = Object.keys(SERIES);
   const resp = await getSeries(seriesIds, { apiKey });
 
   if (resp.error) {
+    if (lastGood.result) return cached(resp.error);
     return { source: 'BLS', error: resp.error, timestamp: new Date().toISOString() };
   }
 
   if (resp.status !== 'REQUEST_SUCCEEDED' || !resp.Results?.series?.length) {
+    const error = resp.message?.[0] || 'BLS API returned no data';
+    if (lastGood.result) return cached(error);
     return {
       source: 'BLS',
-      error: resp.message?.[0] || 'BLS API returned no data',
+      error,
       rawStatus: resp.status,
       timestamp: new Date().toISOString(),
     };
@@ -151,12 +182,15 @@ export async function briefing(apiKey) {
     }
   }
 
-  return {
+  const result = {
     source: 'BLS',
-    timestamp: new Date().toISOString(),
+    timestamp: new Date(now).toISOString(),
     indicators,
     signals,
   };
+  lastGood = { at: now, result };
+  writeQuota('bls', lastGood);
+  return result;
 }
 
 if (process.argv[1]?.endsWith('bls.mjs')) {

package/apis/sources/epa.mjs

@@ -4,8 +4,33 @@
 // Complements Safecast (citizen science) with official government readings.
 
 import { safeFetch } from '../utils/fetch.mjs';
+import { readQuota, writeQuota, clearQuota } from '../utils/quota-cache.mjs';
 
 const BASE = 'https://enviro.epa.gov/enviro/efservice';
+const BLOCK_MS = 6 * 60 * 60 * 1000; // EPA's WAF 403 does not clear within a sweep; do not retry for 6 hours
+
+let blockedUntil = 0;
+let lastGood = null;
+let hydrated = false;
+
+function hydrateQuota() {
+  if (hydrated) return;
+  hydrated = true;
+  const saved = readQuota('epa');
+  if (Number(saved?.blockedUntil) > 0) blockedUntil = Number(saved.blockedUntil);
+  if (saved?.lastGood) lastGood = saved.lastGood;
+}
+
+function persistQuota() {
+  writeQuota('epa', { blockedUntil, lastGood });
+}
+
+export function resetState({ disk = true } = {}) {
+  blockedUntil = 0;
+  lastGood = null;
+  hydrated = false;
+  if (disk) clearQuota('epa');
+}
 
 // RadNet analytical results endpoint
 const RADNET_ANALYTICAL = `${BASE}/RADNET_ANALYTICAL_RESULTS`;
@@ -123,14 +148,31 @@ function checkReading(reading) {
   return null;
 }
 
+function denied(now, error) {
+  return lastGood
+    ? { ...lastGood, stale: true, timestamp: lastGood.timestamp, message: error }
+    : { source: 'EPA RadNet', timestamp: new Date(now).toISOString(), error, readings: [], signals: ['Radiation readings unavailable'] };
+}
+
 // Briefing — get recent radiation readings from EPA network, flag anomalies
-export async function briefing() {
+export async function briefing({ now = Date.now() } = {}) {
+  hydrateQuota();
+  if (now < blockedUntil) {
+    return denied(now, `EPA RadNet provider access denied (HTTP 403); retry after ${new Date(blockedUntil).toISOString()}`);
+  }
+
   const readings = [];
   const signals = [];
 
   // Fetch recent analytical results (broad pull)
   const recentData = await getAnalyticalResults({ rows: 100 });
-  if (recentData.error) return { source: 'EPA RadNet', timestamp: new Date().toISOString(), error: recentData.status === 403 ? 'EPA RadNet provider access denied (HTTP 403)' : recentData.error, readings: [], signals: ['Radiation readings unavailable'] };
+  if (recentData.error) {
+    if (recentData.status === 403) {
+      blockedUntil = now + BLOCK_MS;
+      persistQuota();
+    }
+    return denied(now, recentData.status === 403 ? 'EPA RadNet provider access denied (HTTP 403)' : recentData.error);
+  }
   const recentRecords = Array.isArray(recentData) ? recentData : [];
 
   // Compact all readings
@@ -194,9 +236,9 @@ export async function briefing() {
     ])
   );
 
-  return {
+  const result = {
     source: 'EPA RadNet',
-    timestamp: new Date().toISOString(),
+    timestamp: new Date(now).toISOString(),
     totalReadings: readings.length,
     ...(analyteResults.some(r => r.error) ? { error: 'Some EPA analyte requests failed' } : {}),
     readings: readings.slice(0, 50), // cap for briefing size
@@ -210,6 +252,11 @@ export async function briefing() {
     thresholds: THRESHOLDS,
     note: 'RadNet data may lag by hours to days. Near-real-time gamma data updates more frequently.',
   };
+  if (!result.error) {
+    lastGood = result;
+    persistQuota();
+  }
+  return result;
 }
 
 // Run standalone

package/apis/sources/opensky.mjs

@@ -7,6 +7,7 @@
 // clientId/clientSecret of credentials.json go into OPENSKY_CLIENT_ID/OPENSKY_CLIENT_SECRET.
 
 import { safeFetch, readBoundedText } from '../utils/fetch.mjs';
+import { readQuota, writeQuota, clearQuota } from '../utils/quota-cache.mjs';
 import '../utils/env.mjs';
 
 const BASE = 'https://opensky-network.org/api';
@@ -30,12 +31,28 @@ let tokenCache = { token: null, expiresAt: 0 };
 let tokenRequest = null;                  // in-flight token request shared by the parallel hotspots
 let lastRound = { at: 0, result: null };  // last round that got data (and so spent credits)
 let blockedUntil = 0;                     // set by HTTP 429 from X-Rate-Limit-Retry-After-Seconds
+let hydrated = false;
 
-export function resetState() {
+function persistQuota() {
+  writeQuota('opensky', { blockedUntil, lastRound });
+}
+
+function hydrateQuota() {
+  if (hydrated) return;
+  hydrated = true;
+  const saved = readQuota('opensky');
+  if (!saved) return;
+  if (Number(saved.blockedUntil) > 0) blockedUntil = Number(saved.blockedUntil);
+  if (Number(saved.lastRound?.at) > 0 && saved.lastRound.result) lastRound = saved.lastRound;
+}
+
+export function resetState({ disk = true } = {}) {
   tokenCache = { token: null, expiresAt: 0 };
   tokenRequest = null;
   lastRound = { at: 0, result: null };
   blockedUntil = 0;
+  hydrated = false;
+  if (disk) clearQuota('opensky');
 }
 
 function credentials() {
@@ -177,6 +194,7 @@ function blocked(now) {
 
 // Briefing — check hotspot regions for flight activity
 export async function briefing({ now = Date.now() } = {}) {
+  hydrateQuota();
   if (now < blockedUntil) return blocked(now);
   const deadline = Date.now() + ROUND_BUDGET_MS;
   const creds = credentials();
@@ -239,7 +257,10 @@ export async function briefing({ now = Date.now() } = {}) {
   if (hotspotErrors.length < results.length) lastRound = { at: now, result };
   if (limits.length) {
     blockedUntil = now + Math.min(MAX_BLOCK_MS, Math.max(...limits));
+    persistQuota();
     if (hotspotErrors.length === results.length) return blocked(now);
+  } else if (hotspotErrors.length < results.length) {
+    persistQuota();
   }
   return result;
 }

package/apis/sources/space.mjs

@@ -2,9 +2,30 @@
 // No API key required. Uses CelesTrak for public TLE data and launch info.
 // Tracks: Recent launches, ISS position, satellite decay alerts, space debris.
 
+import { Agent } from 'undici';
 import { safeFetch } from '../utils/fetch.mjs';
+import { readQuota, writeQuota, clearQuota } from '../utils/quota-cache.mjs';
 
 const CELESTRAK_BASE = 'https://celestrak.org';
+const CACHE_MS = 2 * 60 * 60 * 1000; // GP data updates about every two hours
+const LAST_GOOD_MS = 24 * 60 * 60 * 1000;
+const celestrakAgent = new Agent({ connect: { timeout: 20000, family: 4 }, connections: 3 });
+
+let lastGood = { at: 0, result: null };
+let hydrated = false;
+
+function hydrateQuota() {
+  if (hydrated) return;
+  hydrated = true;
+  const saved = readQuota('celestrak');
+  if (Number(saved?.at) > 0 && saved.result) lastGood = { at: saved.at, result: saved.result };
+}
+
+export function resetState({ disk = true } = {}) {
+  lastGood = { at: 0, result: null };
+  hydrated = false;
+  if (disk) clearQuota('celestrak');
+}
 
 // Satellite categories for monitoring
 const SAT_CATEGORIES = {
@@ -20,7 +41,9 @@ const SAT_CATEGORIES = {
 async function getTLEs(category) {
   const path = SAT_CATEGORIES[category];
   if (!path) return { error: 'Invalid category' };
-  const data = await safeFetch(`${CELESTRAK_BASE}${path}`, { timeout: 20000 });
+  const data = await safeFetch(`${CELESTRAK_BASE}${path}`, {
+    timeout: 25000, retries: 0, dispatcher: celestrakAgent,
+  });
   return data;
 }
 
@@ -95,16 +118,12 @@ async function getMilitaryCount() {
   return { count: data.length, byCountry };
 }
 
-// Get mega-constellation stats (Starlink, OneWeb)
-async function getConstellationStats() {
-  const [starlink, oneweb] = await Promise.all([
-    getTLEs('starlink'),
-    getTLEs('oneweb'),
-  ]);
-
+// Mega-lists (Starlink especially) trip CelesTrak's usage limits. Reuse the last counted totals.
+function getConstellationStats() {
+  const saved = readQuota('celestrak-constellations');
   return {
-    starlink: Array.isArray(starlink) ? starlink.length : 0,
-    oneweb: Array.isArray(oneweb) ? oneweb.length : 0,
+    starlink: Number(saved?.starlink) || 0,
+    oneweb: Number(saved?.oneweb) || 0,
   };
 }
 
@@ -137,21 +156,28 @@ function generateSignals(data) {
 }
 
 // Briefing export
-export async function briefing() {
+export async function briefing({ now = Date.now() } = {}) {
+  hydrateQuota();
+  if (lastGood.result && now >= lastGood.at && now - lastGood.at < CACHE_MS) {
+    return { ...lastGood.result, stale: true, message: `Cached CelesTrak result; next request after ${new Date(lastGood.at + CACHE_MS).toISOString()}` };
+  }
   try {
-    const [launches, stations, military, constellations] = await Promise.all([
+    const [launches, stations, military] = await Promise.all([
       getRecentLaunches(),
       getStationData(),
       getMilitaryCount(),
-      getConstellationStats(),
     ]);
+    const constellations = getConstellationStats();
 
     const hasData = !launches.error || !stations.error;
 
     if (!hasData) {
+      if (lastGood.result && now - lastGood.at < LAST_GOOD_MS) {
+        return { ...lastGood.result, stale: true, message: launches.error || stations.error || 'Failed to fetch space data' };
+      }
       return {
         source: 'Space/CelesTrak',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date(now).toISOString(),
         status: 'error',
         error: launches.error || stations.error || 'Failed to fetch space data',
       };
@@ -160,9 +186,9 @@ export async function briefing() {
     const data = { launches, stations, military, constellations };
     const signals = generateSignals(data);
 
-    return {
+    const result = {
       source: 'Space/CelesTrak',
-      timestamp: new Date().toISOString(),
+      timestamp: new Date(now).toISOString(),
       status: 'active',
       recentLaunches: launches.recentLaunches || [],
       totalNewObjects: launches.totalObjects || 0,
@@ -174,10 +200,16 @@ export async function briefing() {
       constellations: constellations || {},
       signals,
     };
+    lastGood = { at: now, result };
+    writeQuota('celestrak', lastGood);
+    return result;
   } catch (e) {
+    if (lastGood.result && now - lastGood.at < LAST_GOOD_MS) {
+      return { ...lastGood.result, stale: true, message: e.message };
+    }
     return {
       source: 'Space/CelesTrak',
-      timestamp: new Date().toISOString(),
+      timestamp: new Date(now).toISOString(),
       status: 'error',
       error: e.message,
     };

package/apis/utils/fetch.mjs

@@ -32,7 +32,8 @@ export async function readBoundedText(response, maxBytes = 10 * 1024 * 1024) {
 
 export async function safeFetch(url, opts = {}) {
   const { timeout = 15000, retries = 1, headers = {}, maxBytes = 10 * 1024 * 1024,
-    format = 'json', method = 'GET', body, retryDelay = 2000, maxRetryDelay = 30000, retryAfterHeader = 'retry-after' } = opts;
+    format = 'json', method = 'GET', body, retryDelay = 2000, maxRetryDelay = 30000, retryAfterHeader = 'retry-after',
+    dispatcher } = opts;
   let lastError;
   let lastStatus;
   let lastRetryAfterMs = null;
@@ -45,6 +46,7 @@ export async function safeFetch(url, opts = {}) {
       const response = await fetch(url, {
         signal: controller.signal, method, body,
         headers: { 'User-Agent': 'Crucix/2.2', ...headers },
+        ...(dispatcher ? { dispatcher } : {}),
       });
       lastStatus = response.status;
       if (!response.ok) {
@@ -63,7 +65,9 @@ export async function safeFetch(url, opts = {}) {
       try { return JSON.parse(text); }
       catch { return { error: 'Invalid JSON response', status: response.status }; }
     } catch (error) {
-      lastError = controller.signal.aborted ? new Error(`Request timed out after ${timeout}ms`) : error;
+      const cause = error?.cause?.code || (typeof error?.cause?.message === 'string' ? error.cause.message : '');
+      lastError = controller.signal.aborted ? new Error(`Request timed out after ${timeout}ms`)
+        : new Error(cause && !String(error.message).includes(cause) ? `${error.message} (${cause})` : error.message);
     } finally { clearTimeout(timer); }
     if (!retryable || attempt === retries) break;
     await new Promise(resolve => setTimeout(resolve, Math.min(maxRetryDelay, waitMs)));

package/apis/utils/freshness.mjs

@@ -32,7 +32,7 @@ export const POLICIES = Object.freeze({
   'FAA-Airports': { maxAgeMs: 3*HOUR, observationMaxAgeMs: 3*HOUR },
   Regulators: { maxAgeMs: 168*HOUR, observationMaxAgeMs: 336*HOUR },
   'Eurostat-HU': { maxAgeMs: 2160*HOUR, observationMaxAgeMs: 4320*HOUR },
-  'Launch-Library': { maxAgeMs: 12*HOUR, observationMaxAgeMs: 720*HOUR },
+  'Launch-Library': { maxAgeMs: 72*HOUR, observationMaxAgeMs: 720*HOUR },
   Maritime: { maxAgeMs: 25*60000, observationMaxAgeMs: 25*60000 },
 });
 

package/apis/utils/quota-cache.mjs

@@ -0,0 +1,42 @@
+// Small JSON files in CRUCIX_HOME/cache so daily quotas survive a process restart.
+// Tests use isolate-profile.mjs, so writes stay in a temp home.
+
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { crucixHome } from '../../lib/user-paths.mjs';
+
+const NAME = /^[a-z0-9-]{1,40}$/;
+const MAX_BYTES = 256 * 1024;
+
+export function quotaCachePath(name, options) {
+  if (!NAME.test(name)) throw new Error(`invalid quota cache name: ${name}`);
+  return join(crucixHome(options), 'cache', `${name}.json`);
+}
+
+export function readQuota(name, options) {
+  try {
+    const raw = readFileSync(quotaCachePath(name, options), 'utf8');
+    if (raw.length > MAX_BYTES) return null;
+    const data = JSON.parse(raw);
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeQuota(name, value, options) {
+  try {
+    const dir = join(crucixHome(options), 'cache');
+    mkdirSync(dir, { recursive: true });
+    const text = JSON.stringify(value);
+    if (text.length > MAX_BYTES) return false;
+    writeFileSync(quotaCachePath(name, options), text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function clearQuota(name, options) {
+  try { unlinkSync(quotaCachePath(name, options)); } catch { /* missing is fine */ }
+}