clementine-agent 1.18.178 → 1.18.180

package/dist/cli/dashboard.js

@@ -19,7 +19,7 @@ import { TunnelManager } from './tunnel.js';
 import { AgentManager } from '../agent/agent-manager.js';
 import { discoverMcpServers, getClaudeIntegrations, KNOWN_MCP_DESCRIPTIONS } from '../agent/mcp-bridge.js';
 import { buildBuilderEnrichedMessage, builderSessionKey } from '../dashboard/builder/prompt.js';
-import { AGENTS_DIR, MEMORY_FILE, SESSIONS_FILE, TIMEZONE, applyOneMillionContextRecovery, currentTimeZone, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
+import { AGENTS_DIR, MEMORY_FILE, SESSIONS_FILE, TIMEZONE, applyOneMillionContextRecovery, currentTimeZone, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, setEnvOverride, } from '../config.js';
 import { parseTasks } from '../tools/shared.js';
 // 1.18.160 — also pull parseCronJobs + parseAgentCronJobs so getCronJobs()
 // returns the same merged set the runtime fires (CRON.md + agent CRON +
@@ -8724,6 +8724,11 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             content = content.trimEnd() + `\n${key}=${value}\n`;
         }
         writeFileSync(ENV_PATH, content, { mode: 0o600 });
+        // Always mirror the disk write into the live env cache. Without this,
+        // BUDGET.* and any other getEnv-backed config stays at the value it
+        // was first read with — that's how "Saved $0 in the dashboard" can
+        // coexist with "Hit the $1.00 cron budget cap" in the same minute.
+        setEnvOverride(key, value);
     }
     function deleteEnvValue(key) {
         if (!existsSync(ENV_PATH))
@@ -8731,6 +8736,9 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         const re = new RegExp(`^${key}=.*\n?`, 'm');
         const content = readFileSync(ENV_PATH, 'utf-8').replace(re, '');
         writeFileSync(ENV_PATH, content, { mode: 0o600 });
+        // Mirror the delete so live readers don't keep seeing the cached value.
+        setEnvOverride(key, '');
+        delete process.env[key];
     }
     const DASHBOARD_BUDGET_ROWS = [
         { key: 'BUDGET_CHAT_USD', value: '5', label: 'Chat', hint: 'Per interactive chat turn' },
@@ -8786,8 +8794,9 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             return { ok: false, error: 'Budget cap is too high for the dashboard. Use the CLI if you really need a cap above $1000.' };
         }
         const normalized = n === 0 ? '0' : String(Math.round(n * 100) / 100);
+        // `writeEnvValue` mirrors into the live env cache, so BUDGET.* (now
+        // backed by getters) sees the new value on the very next tool call.
         writeEnvValue(key, normalized);
-        process.env[key] = normalized;
         return { ok: true, value: normalized };
     }
     function readRecentDashboardChatFailures(limit = 5) {
@@ -9046,7 +9055,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             }
             res.json({
                 ok: true,
-                message: `${key} set to ${formatDashboardBudgetValue(result.value)}. Restart Clementine to apply to running workers.`,
+                message: `${key} set to ${formatDashboardBudgetValue(result.value)}. Applied to running workers immediately.`,
             });
         }
         catch (err) {
@@ -9060,11 +9069,11 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             let message;
             if (preset === 'defaults' || preset === 'standard') {
                 writes = DASHBOARD_BUDGET_ROWS.map(row => ({ key: row.key, value: row.value }));
-                message = 'Restored the standard spend caps. Restart Clementine to apply to running workers.';
+                message = 'Restored the standard spend caps. Applied to running workers immediately.';
             }
             else if (preset === 'uncapped' || preset === 'off' || preset === 'none') {
                 writes = DASHBOARD_BUDGET_ROWS.map(row => ({ key: row.key, value: '0' }));
-                message = 'Removed spend caps by setting all budget values to 0. Restart Clementine for the change to take effect on running workers. (1M context mode is separate — use Force 200K or Safe Recovery for 1M errors.)';
+                message = 'Removed spend caps by setting all budget values to 0. Applied to running workers immediately. (1M context mode is separate — use Force 200K or Safe Recovery for 1M errors.)';
             }
             else {
                 res.status(400).json({ error: 'preset must be defaults or uncapped' });

package/dist/config.d.ts

@@ -40,6 +40,17 @@ export declare function usesOneMillionContext(model: string | null | undefined,
 export declare function getEnv(key: string, fallback?: string): string;
 /** Merged view of process.env overlaid with .env. Use for classifyIntegrations / summarizeIntegrationStatus. */
 export declare function envSnapshot(): Record<string, string | undefined>;
+/**
+ * Hot-update a config value at runtime. Call this from any code path that
+ * persists a config change (e.g. dashboard `/api/budgets/set`) so the
+ * in-module `env` cache stays in sync with what's on disk + in process.env.
+ *
+ * Without this, `getEnv` keeps returning the value that was read from .env
+ * at module init and frozen objects like BUDGET stay stale until the
+ * daemon restarts — that's how a "Budgets at zero in the dashboard" UI can
+ * coexist with a `Hit the $1.00 cron budget cap` error on the same minute.
+ */
+export declare function setEnvOverride(key: string, value: string): void;
 /** Test-only: clear the keychain ref cache so re-resolution can be tested. */
 export declare function _resetKeychainRefCache(): void;
 /**
@@ -83,14 +94,14 @@ export declare const ASSISTANT_EXPERIENCE: {
 export declare const shellEscape: typeof _shellEscape;
 export declare const MODELS: Models;
 export declare const BUDGET: {
-    heartbeat: number;
-    cronT1: number;
-    cronT2: number;
-    chat: number;
-    unleashedPhase: undefined;
-    memoryExtraction: undefined;
-    summarization: undefined;
-    reflection: undefined;
+    readonly heartbeat: number;
+    readonly cronT1: number;
+    readonly cronT2: number;
+    readonly chat: number;
+    readonly unleashedPhase: number | undefined;
+    readonly memoryExtraction: number | undefined;
+    readonly summarization: number | undefined;
+    readonly reflection: number | undefined;
 };
 export declare const MEMORY_JANITOR: {
     consolidatedExpireDays: number;

package/dist/config.js

@@ -285,6 +285,20 @@ export function getEnv(key, fallback = '') {
 export function envSnapshot() {
     return { ...process.env, ...env };
 }
+/**
+ * Hot-update a config value at runtime. Call this from any code path that
+ * persists a config change (e.g. dashboard `/api/budgets/set`) so the
+ * in-module `env` cache stays in sync with what's on disk + in process.env.
+ *
+ * Without this, `getEnv` keeps returning the value that was read from .env
+ * at module init and frozen objects like BUDGET stay stale until the
+ * daemon restarts — that's how a "Budgets at zero in the dashboard" UI can
+ * coexist with a `Hit the $1.00 cron budget cap` error on the same minute.
+ */
+export function setEnvOverride(key, value) {
+    env[key] = value;
+    process.env[key] = value;
+}
 /** Test-only: clear the keychain ref cache so re-resolution can be tested. */
 export function _resetKeychainRefCache() {
     resolvedKeychainRefs.clear();
@@ -379,11 +393,14 @@ export const MODELS = {
 // User-tunable via `clementine config set BUDGET_<NAME>_USD <value>`
 // (writes to ~/.clementine/.env, survives npm update -g) or via
 // `budgets.*` keys in clementine.json.
+// Live getters — each property re-reads .env + process.env on access so a
+// dashboard write (via setEnvOverride) takes effect on the *next* tool call
+// without needing a daemon restart. Defaults match the previous fixed values.
 export const BUDGET = {
-    heartbeat: getEnvOrJsonNumber('BUDGET_HEARTBEAT_USD', json.budgets?.heartbeat, 0.25), // per heartbeat (Haiku)
-    cronT1: getEnvOrJsonNumber('BUDGET_CRON_T1_USD', json.budgets?.cronT1, 0.75), // per tier-1 cron job
-    cronT2: getEnvOrJsonNumber('BUDGET_CRON_T2_USD', json.budgets?.cronT2, 1.50), // per tier-2 cron job
-    chat: getEnvOrJsonNumber('BUDGET_CHAT_USD', json.budgets?.chat, 5.00), // per interactive chat
+    get heartbeat() { return getEnvOrJsonNumber('BUDGET_HEARTBEAT_USD', json.budgets?.heartbeat, 0.25); },
+    get cronT1() { return getEnvOrJsonNumber('BUDGET_CRON_T1_USD', json.budgets?.cronT1, 0.75); },
+    get cronT2() { return getEnvOrJsonNumber('BUDGET_CRON_T2_USD', json.budgets?.cronT2, 1.50); },
+    get chat() { return getEnvOrJsonNumber('BUDGET_CHAT_USD', json.budgets?.chat, 5.00); },
     unleashedPhase: undefined,
     memoryExtraction: undefined,
     summarization: undefined,

package/dist/gateway/cron-scheduler.d.ts

@@ -186,6 +186,17 @@ export declare class CronScheduler {
      */
     private dispatchContextForJobName;
     private dispatchContextForBackgroundTask;
+    /**
+     * Mirror a background-task message (start / done / failed) into the
+     * originating chat session's memory. Without this, bg: tasks finish,
+     * deliver their result to Discord/Slack, and then the very next chat
+     * turn comes back to an assistant that has zero memory of any of it —
+     * the user asks "fix the site you just deployed" and gets "I don't see
+     * any record of a Netlify site." injectContext writes into both the
+     * pending-context map (visible to the next SDK turn) and the memory
+     * store (searchable later by the assistant).
+     */
+    private mirrorBackgroundTaskToChat;
     /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
     private dispatchContextForWorkflow;
     private runJob;

package/dist/gateway/cron-scheduler.js

@@ -944,6 +944,30 @@ export class CronScheduler {
             ctx.agentSlug = task.fromAgent;
         return ctx;
     }
+    /**
+     * Mirror a background-task message (start / done / failed) into the
+     * originating chat session's memory. Without this, bg: tasks finish,
+     * deliver their result to Discord/Slack, and then the very next chat
+     * turn comes back to an assistant that has zero memory of any of it —
+     * the user asks "fix the site you just deployed" and gets "I don't see
+     * any record of a Netlify site." injectContext writes into both the
+     * pending-context map (visible to the next SDK turn) and the memory
+     * store (searchable later by the assistant).
+     */
+    mirrorBackgroundTaskToChat(sessionKey, userTextPlaceholder, assistantText) {
+        if (!sessionKey)
+            return;
+        try {
+            this.gateway.injectContext(sessionKey, userTextPlaceholder, assistantText, {
+                pending: false,
+                model: 'bg-task',
+                countExchange: true,
+            });
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'Failed to mirror background task message into chat memory');
+        }
+    }
     /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
     dispatchContextForWorkflow(name) {
         const wf = this.workflowDefs.find(w => w.name === name);
@@ -1915,9 +1939,15 @@ export class CronScheduler {
                 lastNotifiedAt: new Date().toISOString(),
                 progressMessageCount: 0,
             });
+            const startMessage = `**Background task ${started.id} started** — ${started.prompt.slice(0, 120).replace(/\s+/g, ' ')}${started.prompt.length > 120 ? '...' : ''}\n\nI'll update you every 15 minutes or when it finishes.`;
             this.dispatcher
-                .send(`**Background task ${started.id} started** — ${started.prompt.slice(0, 120).replace(/\s+/g, ' ')}${started.prompt.length > 120 ? '...' : ''}\n\nI'll update you every 15 minutes or when it finishes.`, this.dispatchContextForBackgroundTask(started))
+                .send(startMessage, this.dispatchContextForBackgroundTask(started))
                 .catch((err) => logger.debug({ err, id: started.id }, 'Failed to dispatch background task start'));
+            // Mirror the start announcement into the originating chat session's
+            // memory so the assistant remembers it has a task running. Without
+            // this, the next chat turn the user sends comes back to a session
+            // that has no idea any bg: work was ever queued.
+            this.mirrorBackgroundTaskToChat(started.sessionKey, `[Background task ${started.id} queued: ${started.prompt.slice(0, 200)}]`, startMessage);
             // Don't await — fire-and-forget. The 3s tick continues to scan.
             const maxHours = Math.max(0.05, started.maxMinutes / 60);
             const progressTimer = setInterval(() => {
@@ -1956,9 +1986,14 @@ export class CronScheduler {
                 const completed = loadBackgroundTask(started.id) ?? started;
                 const deliveryHead = `**Background task ${started.id} done** — ${started.prompt.slice(0, 100).replace(/\s+/g, ' ')}${started.prompt.length > 100 ? '...' : ''}\n\n`;
                 const body = (result ?? '').slice(0, 1500);
+                const deliveryMessage = deliveryHead + body;
                 this.dispatcher
-                    .send(deliveryHead + body, this.dispatchContextForBackgroundTask(completed))
+                    .send(deliveryMessage, this.dispatchContextForBackgroundTask(completed))
                     .catch((err) => logger.debug({ err, id: started.id }, 'Failed to dispatch background task result'));
+                // Mirror into chat memory so a follow-up like "fix the site"
+                // doesn't get a blank stare — the assistant needs to remember
+                // it just deployed something and where it lives.
+                this.mirrorBackgroundTaskToChat(completed.sessionKey, `[Background task ${completed.id} delivered: ${started.prompt.slice(0, 200)}]`, deliveryMessage);
             }).catch((err) => {
                 clearInterval(progressTimer);
                 const errStr = String(err).slice(0, 500);
@@ -1969,9 +2004,13 @@ export class CronScheduler {
                     logger.warn({ err: saveErr, id: started.id }, 'Failed to mark background task failed');
                 }
                 const failed = loadBackgroundTask(started.id) ?? started;
+                const failMessage = `**Background task ${started.id} failed** — ${errStr.slice(0, 200)}`;
                 this.dispatcher
-                    .send(`**Background task ${started.id} failed** — ${errStr.slice(0, 200)}`, this.dispatchContextForBackgroundTask(failed))
+                    .send(failMessage, this.dispatchContextForBackgroundTask(failed))
                     .catch(() => { });
+                // Mirror failures too — the next chat turn should know the task
+                // died rather than silently pretending it never happened.
+                this.mirrorBackgroundTaskToChat(failed.sessionKey, `[Background task ${failed.id} failed: ${started.prompt.slice(0, 200)}]`, failMessage);
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.178",
+  "version": "1.18.180",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",