@circuitwall/jarela 2.3.0 → 2.5.0

package/.next/standalone/.next/server/chunks/46.js

@@ -64,6 +64,9 @@ function runMigrations(db) {
     -- (getMessages, getRecentMessagesWindow, getMessagesPage, clear).
     -- Without this every read full-scans the messages table.
     CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_messages_thread_seq ON messages(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
+    CREATE INDEX IF NOT EXISTS idx_threads_updated ON threads(updated_at DESC);
     CREATE TABLE IF NOT EXISTS runtime_operations (
       id TEXT PRIMARY KEY,
       kind TEXT NOT NULL,
@@ -87,6 +90,9 @@ function runMigrations(db) {
       created_at INTEGER NOT NULL,
       UNIQUE(kind,operation_id,agent_id,thread_id)
     );
+    CREATE INDEX IF NOT EXISTS idx_runtime_operations_thread_state ON runtime_operations(thread_id,state);
+    CREATE INDEX IF NOT EXISTS idx_signal_events_thread ON signal_events(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_signal_events_operation ON signal_events(operation_id);
     CREATE TABLE IF NOT EXISTS signal_deliveries (
       event_id TEXT PRIMARY KEY REFERENCES signal_events(id) ON DELETE CASCADE,
       wake_eligible INTEGER NOT NULL DEFAULT 0,
@@ -101,6 +107,7 @@ function runMigrations(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_signal_events_target ON signal_events(agent_id,thread_id,seq);
     CREATE INDEX IF NOT EXISTS idx_signal_deliveries_due ON signal_deliveries(state,available_at);
+    CREATE INDEX IF NOT EXISTS idx_signal_deliveries_lease ON signal_deliveries(state,lease_until);
     CREATE TABLE IF NOT EXISTS background_tool_results (
       key TEXT PRIMARY KEY REFERENCES runtime_operations(id) ON DELETE CASCADE,
       thread_id TEXT NOT NULL REFERENCES threads(thread_id) ON DELETE CASCADE,
@@ -112,6 +119,7 @@ function runMigrations(db) {
       expires_at INTEGER NOT NULL
     );
     CREATE INDEX IF NOT EXISTS idx_background_results_owner ON background_tool_results(thread_id,expires_at);
+    CREATE INDEX IF NOT EXISTS idx_background_results_expiry ON background_tool_results(expires_at);
     CREATE TABLE IF NOT EXISTS memory_store (
       namespace  TEXT NOT NULL,
       key        TEXT NOT NULL,
@@ -120,6 +128,8 @@ function runMigrations(db) {
       updated_at TEXT NOT NULL,
       PRIMARY KEY (namespace, key)
     );
+    CREATE INDEX IF NOT EXISTS idx_memory_namespace_updated ON memory_store(namespace,updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_memory_updated ON memory_store(updated_at DESC);
     CREATE TABLE IF NOT EXISTS model_configs (
       name       TEXT PRIMARY KEY,
       provider   TEXT NOT NULL,
@@ -693,6 +703,7 @@ function ensureMessageUsageTable(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_message_usage_created_at ON message_usage(created_at);
     CREATE INDEX IF NOT EXISTS idx_message_usage_agent_id   ON message_usage(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_message_usage_thread_created ON message_usage(thread_id,created_at DESC);
   `);
 }
 function ensureEmbeddingColumns(db) {
@@ -732,6 +743,8 @@ function ensureMessageEmbeddingJobsTable(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_message_embedding_jobs_due
       ON message_embedding_jobs(state, available_at_ms, lease_until_ms);
+    CREATE INDEX IF NOT EXISTS idx_message_embedding_jobs_lease
+      ON message_embedding_jobs(state, lease_until_ms);
     INSERT OR IGNORE INTO message_embedding_jobs (message_id, created_at, updated_at)
       SELECT msg_id, created_at, created_at FROM messages WHERE embedding IS NULL;
   `);
@@ -6155,9 +6168,11 @@ function claimMessageEmbeddingJobs(limit = 16, leaseMs = 5 * 60000, nowMs = Date
     });
 }
 function nextMessageEmbeddingDelayMs(nowMs = Date.now()) {
-    const row = (0,_lib_db__WEBPACK_IMPORTED_MODULE_2__/* .getDb */ .Lf)().prepare(`SELECT MIN(CASE WHEN state='pending' THEN available_at_ms ELSE lease_until_ms END) AS next_at_ms
-     FROM message_embedding_jobs
-     WHERE state IN ('pending','processing')`).get();
+    const row = (0,_lib_db__WEBPACK_IMPORTED_MODULE_2__/* .getDb */ .Lf)().prepare(`SELECT MIN(next_at_ms) AS next_at_ms FROM (
+       SELECT MIN(available_at_ms) AS next_at_ms FROM message_embedding_jobs WHERE state='pending'
+       UNION ALL
+       SELECT MIN(lease_until_ms) AS next_at_ms FROM message_embedding_jobs WHERE state='processing'
+     )`).get();
     return typeof row?.next_at_ms === "number" ? Math.max(0, row.next_at_ms - nowMs) : null;
 }
 function completeMessageEmbeddingJob(job, embedding, modelSignature) {
@@ -8680,7 +8695,25 @@ async function applyProxyConfigFromDb() {
 // ---------------------------------------------------------------------
 function buildProxyUrl(scheme, host, port, username, password) {
     const auth = username ? `${encodeURIComponent(username)}${password ? `:${encodeURIComponent(password)}` : ""}@` : "";
-    return `${scheme}://${auth}${host}:${port}`;
+    const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `${scheme}://${auth}${urlHost}:${port}`;
+}
+// undici's EnvHttpProxyAgent has no implicit loopback exemption, so without
+// these a configured proxy would also receive local traffic (Ollama, the
+// WhatsApp bridge sidecar, the app's own loopback API).
+const LOOPBACK_NO_PROXY = [
+    "localhost",
+    "127.0.0.1",
+    "::1"
+];
+function mergeNoProxy(noProxy) {
+    const entries = (noProxy ?? "").split(/[,\s]+/).map((entry)=>entry.trim()).filter(Boolean);
+    return [
+        ...new Set([
+            ...entries,
+            ...LOOPBACK_NO_PROXY
+        ])
+    ].join(",");
 }
 function installProxy(url, noProxy, caBundle) {
     // Set process.env so EnvHttpProxyAgent honors NO_PROXY semantics
@@ -8688,27 +8721,31 @@ function installProxy(url, noProxy, caBundle) {
     // We still treat the boot-time env snapshot as authoritative for the
     // "env beats DB" rule — this mutation only happens after we've
     // confirmed the user did NOT set HTTP_PROXY at launch.
+    const merged = mergeNoProxy(noProxy);
     process.env.HTTP_PROXY = url;
     process.env.HTTPS_PROXY = url;
-    if (noProxy && noProxy.trim().length > 0) {
-        process.env.NO_PROXY = noProxy.trim();
-    } else {
-        delete process.env.NO_PROXY;
-    }
+    process.env.NO_PROXY = merged;
     // ADR-0012: when the user pasted a corporate root CA, inject it on
     // both TLS legs — the proxy hop (proxyTls) for https-scheme proxies
     // signed by the corporate root, and the upstream tunnel (requestTls)
     // for proxies that MITM outbound HTTPS with the same internal CA.
     // Same blob is correct: the corporate trust chain typically signs
     // both ends.
-    const opts = caBundle ? {
-        requestTls: {
-            ca: caBundle
-        },
-        proxyTls: {
-            ca: caBundle
-        }
-    } : {};
+    // Pass the values explicitly too: undici prefers lowercase http_proxy /
+    // no_proxy from the environment over the uppercase ones set above.
+    const opts = {
+        httpProxy: url,
+        httpsProxy: url,
+        noProxy: merged,
+        ...caBundle ? {
+            requestTls: {
+                ca: caBundle
+            },
+            proxyTls: {
+                ca: caBundle
+            }
+        } : {}
+    };
     (0,external_undici_.setGlobalDispatcher)(new external_undici_.EnvHttpProxyAgent(opts));
 }
 function resetToBaseline() {
@@ -10776,9 +10813,11 @@ function getIntegrationMeta(name) {
 /* harmony export */   qt: () => (/* binding */ saveProxyConfig),
 /* harmony export */   xl: () => (/* binding */ getProxyConfigRaw)
 /* harmony export */ });
-/* harmony import */ var _lib_db__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
-/* harmony import */ var _lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10938);
-/* harmony import */ var _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(78228);
+/* harmony import */ var node_net__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77030);
+/* harmony import */ var node_net__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_net__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _lib_db__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(46);
+/* harmony import */ var _lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10938);
+/* harmony import */ var _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(78228);
 // Proxy configuration store (ADR-0009, extended ADR-0012).
 //
 // Single-row table proxy_config. Non-secret columns are plaintext for
@@ -10798,6 +10837,7 @@ function getIntegrationMeta(name) {
 
 
 
+
 const DEFAULT_STATUS = {
     mode: "off",
     scheme: "http",
@@ -10818,7 +10858,7 @@ function getProxyConfigStatus() {
         host: row.host,
         port: row.port,
         username: row.username,
-        password: row.password ? _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_2__/* .SECRET_MASK */ .Q6 : null,
+        password: row.password ? _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_3__/* .SECRET_MASK */ .Q6 : null,
         no_proxy: row.no_proxy,
         ca_bundle: row.ca_bundle,
         updated_at: row.updated_at
@@ -10836,7 +10876,7 @@ function getProxyConfigRaw() {
         host: row.host,
         port: row.port,
         username: row.username,
-        password: row.password ? (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__/* .decryptIfNeeded */ .qU)(row.password) : null,
+        password: row.password ? (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_2__/* .decryptIfNeeded */ .qU)(row.password) : null,
         no_proxy: row.no_proxy,
         ca_bundle: row.ca_bundle,
         updated_at: row.updated_at
@@ -10848,15 +10888,26 @@ function saveProxyConfig(input) {
     };
     const scheme = input.scheme === "https" ? "https" : "http";
     // Manual mode requires host + port. system / off don't.
+    let host = nullable(input.host);
     if (input.mode === "manual") {
-        if (!input.host || !input.host.trim()) return {
+        if (!host) return {
             error: "host is required in manual mode"
         };
-        if (input.port == null || !Number.isFinite(input.port) || input.port <= 0 || input.port > 65535) {
+        const normalisedHost = normaliseProxyHost(host);
+        if (!normalisedHost) {
             return {
-                error: "port must be between 1 and 65535"
+                error: "host must be a hostname or IP address, without scheme, port, path or credentials"
             };
         }
+        host = normalisedHost;
+        if (input.port == null) return {
+            error: "port must be between 1 and 65535"
+        };
+    }
+    if (input.port != null && (!Number.isInteger(input.port) || input.port <= 0 || input.port > 65535)) {
+        return {
+            error: "port must be between 1 and 65535"
+        };
     }
     // CA bundle: empty/null clears; non-empty must look like PEM.
     let storedCaBundle = null;
@@ -10871,15 +10922,15 @@ function saveProxyConfig(input) {
     // Preserve existing password when the UI echoes back the masked sentinel.
     const existing = readRow();
     let storedPassword = null;
-    if (input.password === _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_2__/* .SECRET_MASK */ .Q6) {
+    if (input.password === _lib_stores_integrations__WEBPACK_IMPORTED_MODULE_3__/* .SECRET_MASK */ .Q6) {
         storedPassword = existing?.password ?? null;
     } else if (input.password && input.password.length > 0) {
-        storedPassword = (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__/* .encrypt */ .w)(input.password);
+        storedPassword = (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_2__/* .encrypt */ .w)(input.password);
     } else {
         storedPassword = null;
     }
     const now = new Date().toISOString();
-    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_1__/* .getDb */ .Lf)();
     db.prepare(`INSERT INTO proxy_config (id, mode, scheme, host, port, username, password, no_proxy, ca_bundle, updated_at)
      VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(id) DO UPDATE SET
@@ -10891,16 +10942,16 @@ function saveProxyConfig(input) {
        password = excluded.password,
        no_proxy = excluded.no_proxy,
        ca_bundle = excluded.ca_bundle,
-       updated_at = excluded.updated_at`).run(input.mode, scheme, nullable(input.host), input.port ?? null, nullable(input.username), storedPassword, nullable(input.no_proxy), storedCaBundle, now);
+       updated_at = excluded.updated_at`).run(input.mode, scheme, host, input.port ?? null, nullable(input.username), storedPassword, nullable(input.no_proxy), storedCaBundle, now);
     return getProxyConfigStatus();
 }
 function deleteProxyConfig() {
-    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_1__/* .getDb */ .Lf)();
     const r = db.prepare("DELETE FROM proxy_config WHERE id = 1").run();
     return r.changes > 0;
 }
 function readRow() {
-    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_1__/* .getDb */ .Lf)();
     const r = db.prepare("SELECT mode, scheme, host, port, username, password, no_proxy, ca_bundle, updated_at FROM proxy_config WHERE id = 1").get();
     return r ?? null;
 }
@@ -10913,6 +10964,15 @@ function normaliseMode(m) {
 function normaliseScheme(s) {
     return s === "https" ? "https" : "http";
 }
+// The dispatcher builds `${scheme}://${auth}${host}:${port}`, so a pasted URL
+// or host:port would produce an unusable proxy URL. IPv6 is stored unbracketed;
+// the dispatcher adds the brackets.
+function normaliseProxyHost(host) {
+    const unbracketed = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+    if (/^[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/.test(unbracketed)) return unbracketed;
+    if ((0,node_net__WEBPACK_IMPORTED_MODULE_0__.isIPv6)(unbracketed)) return unbracketed;
+    return null;
+}
 function nullable(v) {
     if (v == null) return null;
     const trimmed = v.trim();

package/.next/standalone/.next/server/chunks/466.js

@@ -734,11 +734,44 @@ async function parseJsonResponse(res) {
     const stream = source.pipeThrough(new DecompressionStream("gzip"));
     return JSON.parse(await new Response(stream).text());
 }
+const STARTUP_TTL_MS = 5000;
+const startupReads = new Map();
+function startupRead(path) {
+    const now = Date.now();
+    for (const [key, entry] of startupReads){
+        if (entry.settledAt !== null && (now < entry.settledAt || now - entry.settledAt >= STARTUP_TTL_MS)) {
+            startupReads.delete(key);
+        }
+    }
+    const cached = startupReads.get(path);
+    if (cached) return cached.promise.then((value)=>structuredClone(value));
+    // Bound retained startup data when agents are switched rapidly.
+    const oldestKey = startupReads.keys().next().value;
+    if (startupReads.size >= 16 && oldestKey !== undefined) startupReads.delete(oldestKey);
+    const entry = {
+        promise: Promise.resolve(undefined),
+        settledAt: null
+    };
+    entry.promise = request(path, {
+        startup: true
+    }).then((value)=>{
+        entry.settledAt = Date.now();
+        return value;
+    }).catch((error)=>{
+        if (startupReads.get(path) === entry) startupReads.delete(path);
+        throw error;
+    });
+    startupReads.set(path, entry);
+    return entry.promise.then((value)=>structuredClone(value));
+}
 async function request(path, init) {
+    const mutation = !!init?.method && init.method !== "GET";
+    if (mutation) startupReads.clear();
+    else if (!init?.startup) startupReads.delete(path);
     const cfg = (0,_runtime_config__WEBPACK_IMPORTED_MODULE_0__/* .runtimeConfig */ .Z)();
     const maxAttempts = Math.max(1, cfg.httpMaxAttempts);
     const timeoutMs = init?.timeoutMs ?? cfg.httpRequestTimeoutMs;
-    const { timeoutMs: _ignoreTimeoutMs, ...fetchInit } = init ?? {};
+    const { timeoutMs: _ignoreTimeoutMs, startup: _ignoreStartup, ...fetchInit } = init ?? {};
     const callerSignal = fetchInit.signal ?? null;
     let lastErr = null;
     for(let attempt = 1; attempt <= maxAttempts; attempt++){
@@ -792,6 +825,7 @@ async function request(path, init) {
             if (attempt < maxAttempts && isRetryable(err)) continue;
             throw err;
         } finally{
+            if (mutation) startupReads.clear();
             clearTimeout(timer);
             callerSignal?.removeEventListener("abort", onCallerAbort);
         }
@@ -802,7 +836,10 @@ async function request(path, init) {
 const api = {
     agents: {
         list: (opts)=>cachedList(agentListCache, ()=>request("/agents"), setAgentListCache, opts?.force === true),
-        get: (id)=>request(`/agents/${encodeURIComponent(id)}`),
+        get: (id, opts)=>{
+            const path = `/agents/${encodeURIComponent(id)}`;
+            return opts?.startup ? startupRead(path) : request(path);
+        },
         create: async (data)=>{
             const created = await request("/agents", {
                 method: "POST",
@@ -834,7 +871,10 @@ const api = {
             }
             return res;
         },
-        getThread: (id)=>request(`/agents/${encodeURIComponent(id)}/thread`),
+        getThread: (id, opts)=>{
+            const path = `/agents/${encodeURIComponent(id)}/thread`;
+            return opts?.startup ? startupRead(path) : request(path);
+        },
         compact: (id, options)=>request(`/agents/${encodeURIComponent(id)}/compact`, // Conversation summarization can take longer than normal API calls,
             // so avoid tripping the default HTTP timeout for large threads.
             {
@@ -1053,8 +1093,12 @@ const api = {
             // user+assistant pair instead of re-pulling the whole most-recent page.
             if (opts?.after !== undefined) p.set("after", String(opts.after));
             const qs = p.toString() ? `?${p}` : "";
-            return request(`/threads/${thread_id}${qs}`);
+            const path = `/threads/${thread_id}${qs}`;
+            return opts?.startup ? startupRead(path) : request(path);
         },
+        metadata: (thread_id, signal)=>request(`/threads/${thread_id}?view=metadata`, {
+                signal
+            }),
         delete: (thread_id)=>request(`/threads/${thread_id}`, {
                 method: "DELETE"
             }),
@@ -1253,7 +1297,7 @@ const api = {
         }
     },
     profile: {
-        get: ()=>request("/profile"),
+        get: (opts)=>opts?.startup ? startupRead("/profile") : request("/profile"),
         update: (data)=>request("/profile", {
                 method: "PUT",
                 body: JSON.stringify(data)
@@ -1737,6 +1781,7 @@ const api = {
  *  caller is expected to follow up with `subscribeRun()` to receive the
  *  chunk stream. Idempotent in the sense that two simultaneous submissions
  *  for the same thread will see one 202 and one 409 (`run_in_flight`). */ async function submitRun(thread_id, message, signal, stream_options, attachments, channels, hot_since_seq) {
+    startupReads.clear();
     const payload = {
         message,
         stream_options,
@@ -1752,7 +1797,7 @@ const api = {
         },
         body: JSON.stringify(runPayload),
         signal
-    });
+    }).finally(()=>startupReads.clear());
     // 2xx = accepted (currently always 202); 409 = already running. We treat
     // every other status as a hard error so the consumer's catch fires.
     if (res.status === 202) {
@@ -9841,6 +9886,7 @@ const Select = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_1___default().forwar
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Dg: () => (/* binding */ getAppAccentColor),
 /* harmony export */   E2: () => (/* binding */ UPSTREAM_URL),
 /* harmony export */   SN: () => (/* binding */ getAppIssueUrl),
 /* harmony export */   YC: () => (/* binding */ UPSTREAM_NAME),
@@ -9849,7 +9895,7 @@ const Select = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_1___default().forwar
 /* harmony export */   lE: () => (/* binding */ getAppLogoDark),
 /* harmony export */   qc: () => (/* binding */ getAppIcons)
 /* harmony export */ });
-/* unused harmony exports getAppShortName, getAppDescription, getAppAccentColor, getAppAccentHoverColor */
+/* unused harmony exports getAppShortName, getAppDescription, getAppAccentHoverColor */
 // Branding knobs sourced from NEXT_PUBLIC_* env vars so forks can rebrand
 // the app without patching source. NEXT_PUBLIC_* is the right
 // channel here because Next.js inlines these at build time, which lets

package/.next/standalone/.next/server/chunks/4955.js

@@ -18,6 +18,8 @@ exports.modules = {
 
 const CHARS_PER_TOKEN = 4;
 const DEFAULT_WINDOW_DAYS = 30;
+const METRICS_CACHE_MS = 5000;
+let metricsCache = null;
 function recalculateSnapshotCost(input, tables) {
     const rates = (0,_pricing__WEBPACK_IMPORTED_MODULE_2__/* .modelRatesFor */ .En)(tables, input.provider, input.modelId);
     if (rates.inputPer1M == null && rates.outputPer1M == null) return input.recordedCostUsd;
@@ -30,7 +32,17 @@ async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS) {
     const now = new Date();
     const boundedDays = Number.isFinite(days) ? Math.min(120, Math.max(7, Math.floor(days))) : DEFAULT_WINDOW_DAYS;
     const since = new Date(now.getTime() - boundedDays * 24 * 60 * 60 * 1000).toISOString();
-    const usageRows = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare(`SELECT m.created_at, m.role, m.content, m.tool_events, m.thread_id, t.agent_id,
+    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+    const tables = (0,_pricing__WEBPACK_IMPORTED_MODULE_2__/* .getPricingTables */ .iH)();
+    // total_changes covers this connection; data_version covers other writers.
+    const { changes } = db.prepare("SELECT total_changes() AS changes").get();
+    const { data_version: dataVersion } = db.prepare("PRAGMA data_version").get();
+    if (metricsCache?.db === db && metricsCache.changes === changes && metricsCache.dataVersion === dataVersion && metricsCache.tables === tables && metricsCache.metrics.days === boundedDays && metricsCache.metrics.generated_at.slice(0, 10) === now.toISOString().slice(0, 10) && now.getTime() - metricsCache.createdAt >= 0 && now.getTime() - metricsCache.createdAt < METRICS_CACHE_MS) {
+        return metricsCache.metrics;
+    }
+    const usageRows = db.prepare(`SELECT m.created_at, m.role,
+              CASE WHEN mu.input_tokens IS NULL THEN m.content ELSE '' END AS content,
+              m.tool_events, m.thread_id, t.agent_id,
               a.name AS agent_name, mc.provider AS provider,
               mc.model_id AS model_id,
                   COALESCE(ta.model_config_name, a.model_config_name, dmc.name) AS model_config_name,
@@ -80,7 +92,6 @@ async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS) {
             snapshotThreadIds.add(r.thread_id);
         }
     }
-    const tables = (0,_pricing__WEBPACK_IMPORTED_MODULE_2__/* .getPricingTables */ .iH)();
     const { byProvider, generatedAt } = tables;
     const dayMap = seedDayBuckets(now, boundedDays);
     const agentMap = new Map();
@@ -396,7 +407,7 @@ async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS) {
             by_model: dayModels
         };
     }
-    return {
+    const metrics = {
         generated_at: now.toISOString(),
         days: boundedDays,
         summary: {
@@ -452,6 +463,15 @@ async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS) {
             notes: "Dashboard cost is recalculated from captured provider token usage and the latest matching rates. The original per-turn cost snapshots remain unchanged; legacy rows use content-length token estimates."
         }
     };
+    metricsCache = {
+        db,
+        changes,
+        dataVersion,
+        tables,
+        createdAt: now.getTime(),
+        metrics
+    };
+    return metrics;
 }
 function seedDayBuckets(now, days) {
     const out = new Map();
@@ -882,6 +902,13 @@ function readSnapshotSync() {
     try {
         const p = snapshotPath();
         const stat = (0,external_node_fs_.statSync)(p);
+        if (cached?.path === p && cached.mtimeMs === stat.mtimeMs) {
+            return {
+                path: p,
+                snapshot: null,
+                mtimeMs: stat.mtimeMs
+            };
+        }
         const raw = (0,external_node_fs_.readFileSync)(p, "utf8");
         return {
             path: p,

package/.next/standalone/.next/server/chunks/5585.js

@@ -335,12 +335,35 @@ function createRuntimeRequire(anchor) {
 function managedPackagePath(packageName) {
     return (0,node_path__WEBPACK_IMPORTED_MODULE_0__.join)((0,_langchain_packages__WEBPACK_IMPORTED_MODULE_1__/* .getPackagesDir */ .V_)(), "node_modules", packageName);
 }
+function resolveOptionalPackage(packageName) {
+    const managedReq = createRuntimeRequire((0,node_path__WEBPACK_IMPORTED_MODULE_0__.join)((0,_langchain_packages__WEBPACK_IMPORTED_MODULE_1__/* .getPackagesDir */ .V_)(), "_anchor"));
+    try {
+        return {
+            req: managedReq,
+            path: managedReq.resolve(managedPackagePath(packageName))
+        };
+    } catch  {
+    // Workspace builds expose bundled @circuitwall packages from the app root.
+    }
+    if (process.env.JARELA_PACKAGES_DIR?.trim()) return null;
+    if (!packageName.startsWith("@circuitwall/")) return null;
+    const appReq = createRuntimeRequire((0,node_path__WEBPACK_IMPORTED_MODULE_0__.join)(process.cwd(), "package.json"));
+    try {
+        return {
+            req: appReq,
+            path: appReq.resolve(packageName)
+        };
+    } catch  {
+        return null;
+    }
+}
 function loadOptionalPackage(packageName) {
     const override = testOverrides.get(packageName);
     if (override) return override;
+    const resolved = resolveOptionalPackage(packageName);
+    if (!resolved) return null;
     try {
-        const req = createRuntimeRequire((0,node_path__WEBPACK_IMPORTED_MODULE_0__.join)((0,_langchain_packages__WEBPACK_IMPORTED_MODULE_1__/* .getPackagesDir */ .V_)(), "_anchor"));
-        return req(managedPackagePath(packageName));
+        return resolved.req(resolved.path);
     } catch (err) {
         // Keep the optional boundary non-fatal, but leave the actual load failure
         // visible so missing peer dependencies are diagnosable from server logs.
@@ -372,9 +395,10 @@ function optionalFunction(packageName, exportName, fallback) {
     };
 }
 function isOptionalPackageInstalled(packageName) {
+    const resolved = resolveOptionalPackage(packageName);
+    if (!resolved) return false;
     try {
-        const req = createRuntimeRequire((0,node_path__WEBPACK_IMPORTED_MODULE_0__.join)((0,_langchain_packages__WEBPACK_IMPORTED_MODULE_1__/* .getPackagesDir */ .V_)(), "_anchor"));
-        req(managedPackagePath(packageName));
+        resolved.req(resolved.path);
         return true;
     } catch (err) {
         console.error(`[optional-package] failed to load ${packageName}: ${err instanceof Error ? err.message : String(err)}`);

package/.next/standalone/.next/server/chunks/5908.js

@@ -202,58 +202,79 @@ function containsText(source, needle, ignoreCase) {
     if (!ignoreCase) return source.includes(needle);
     return source.toLowerCase().includes(needle.toLowerCase());
 }
-function dedupeLines(source, opts) {
-    const lines = source.split(/\r?\n/);
-    const keyed = lines.map((line)=>{
-        const normalized = opts.trim ? line.trim() : line;
-        return opts.ignoreCase ? normalized.toLowerCase() : normalized;
-    });
-    const keep = new Set();
-    const visit = opts.keep === "first" ? [
-        ...keyed.keys()
-    ] : [
-        ...keyed.keys()
+const FENCE_RE = /^\s{0,3}(`{3,}|~{3,})/;
+const HORIZONTAL_RULE_RE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+/**
+ * Drop duplicate segments from `parts`, which alternates content (even
+ * indexes) and the original separator that follows it (odd indexes).
+ * Separators are preserved verbatim, so only removed segments change the
+ * text. `keyOf` returns null for a segment that must always be kept.
+ */ function dedupeSegments(parts, keyOf, keep) {
+    const contentIdx = parts.map((_, i)=>i).filter((i)=>i % 2 === 0);
+    const visit = keep === "first" ? contentIdx : [
+        ...contentIdx
     ].reverse();
     const seen = new Set();
+    const dropped = new Set();
     for (const idx of visit){
-        const key = keyed[idx];
-        if (opts.skipBlank && key.length === 0) {
-            keep.add(idx);
-            continue;
-        }
-        if (seen.has(key)) continue;
-        seen.add(key);
-        keep.add(idx);
+        const key = keyOf(idx);
+        if (key === null) continue;
+        if (seen.has(key)) dropped.add(idx);
+        else seen.add(key);
+    }
+    if (dropped.size === 0) return {
+        text: parts.join(""),
+        removed: 0
+    };
+    let text = "";
+    let emitted = false;
+    for (const idx of contentIdx){
+        if (dropped.has(idx)) continue;
+        if (emitted && idx > 0) text += parts[idx - 1];
+        text += parts[idx];
+        emitted = true;
     }
-    const next = lines.filter((_, idx)=>keep.has(idx));
     return {
-        text: next.join("\n"),
-        removed: lines.length - next.length
+        text,
+        removed: dropped.size
     };
 }
+function dedupeLines(source, opts) {
+    const parts = source.split(/(\r?\n)/);
+    // Fence markers, fenced code and horizontal rules repeat by design; a
+    // closing ``` is always a "duplicate" of the opening one.
+    const protectedIdx = new Set();
+    let fence = null;
+    for(let i = 0; i < parts.length; i += 2){
+        const marker = FENCE_RE.exec(parts[i])?.[1];
+        if (fence !== null) {
+            protectedIdx.add(i);
+            if (marker && marker[0] === fence[0] && marker.length >= fence.length && /^\s*[`~]+\s*$/.test(parts[i])) fence = null;
+        } else if (marker) {
+            protectedIdx.add(i);
+            fence = marker;
+        } else if (HORIZONTAL_RULE_RE.test(parts[i])) {
+            protectedIdx.add(i);
+        }
+    }
+    return dedupeSegments(parts, (i)=>{
+        if (protectedIdx.has(i)) return null;
+        const normalized = opts.trim ? parts[i].trim() : parts[i];
+        if (opts.skipBlank && normalized.length === 0) return null;
+        return opts.ignoreCase ? normalized.toLowerCase() : normalized;
+    }, opts.keep);
+}
 function dedupeParagraphs(source, opts) {
-    const paragraphs = source.split(/\n\s*\n/).map((p)=>p.trim()).filter((p)=>p.length > 0);
-    const keys = paragraphs.map((p)=>{
-        const base = opts.trim ? p.trim() : p;
+    const tail = /\s*$/.exec(source)?.[0] ?? "";
+    const parts = source.slice(0, source.length - tail.length).split(/(\r?\n(?:[ \t]*\r?\n)+)/);
+    const out = dedupeSegments(parts, (i)=>{
+        if (parts[i].trim().length === 0) return null;
+        const base = opts.trim ? parts[i].trim() : parts[i];
         return opts.ignoreCase ? base.toLowerCase() : base;
-    });
-    const keep = new Set();
-    const visit = opts.keep === "first" ? [
-        ...keys.keys()
-    ] : [
-        ...keys.keys()
-    ].reverse();
-    const seen = new Set();
-    for (const idx of visit){
-        const key = keys[idx];
-        if (seen.has(key)) continue;
-        seen.add(key);
-        keep.add(idx);
-    }
-    const next = paragraphs.filter((_, idx)=>keep.has(idx));
+    }, opts.keep);
     return {
-        text: next.join("\n\n"),
-        removed: paragraphs.length - next.length
+        text: out.text + tail,
+        removed: out.removed
     };
 }