clementine-agent 1.18.58 → 1.18.60

package/dist/agent/run-agent-cron.js

@@ -17,7 +17,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, VAULT_DIR, CRON_PROGRESS_DIR, } from '../config.js';
+import { BASE_DIR, VAULT_DIR, CRON_PROGRESS_DIR, BUDGET, } from '../config.js';
 import { runAgent } from './run-agent.js';
 import { buildExtraMcpForRunAgent } from './run-agent-mcp.js';
 import { buildAutonomousMemoryContext } from './run-agent-context.js';
@@ -281,7 +281,12 @@ export async function runAgentCron(opts) {
         profile: opts.profile,
     });
     // ── Run via canonical runAgent ────────────────────────────────────
-    const maxBudget = opts.maxBudgetUsd ?? (tier >= 2 ? 3.0 : 1.0);
+    // Per-tier cap from config (BUDGET.cronT1 / BUDGET.cronT2). Sourced
+    // from env / clementine.json / dashboard writes. 0 means uncapped —
+    // we pass undefined so runAgent omits the SDK option entirely.
+    // Caller can still override via opts.maxBudgetUsd.
+    const configuredCap = tier >= 2 ? BUDGET.cronT2 : BUDGET.cronT1;
+    const maxBudget = opts.maxBudgetUsd ?? (configuredCap > 0 ? configuredCap : undefined);
     const effort = tier >= 2 ? 'high' : 'medium';
     logger.info({
         job: opts.jobName,
@@ -302,7 +307,7 @@ export async function runAgentCron(opts) {
         memoryStore: opts.memoryStore,
         model: opts.model,
         effort,
-        maxBudgetUsd: maxBudget,
+        ...(maxBudget !== undefined ? { maxBudgetUsd: maxBudget } : {}),
         maxTurns: opts.maxTurns,
         abortSignal: opts.abortSignal,
         extraMcpServers: mcp.servers,

package/dist/agent/run-agent-heartbeat.js

@@ -14,7 +14,7 @@
  * through the canonical runAgent() instead of buildOptions+query.
  */
 import pino from 'pino';
-import { OWNER_NAME, MODELS, } from '../config.js';
+import { OWNER_NAME, MODELS, BUDGET, } from '../config.js';
 const OWNER = OWNER_NAME || 'the user';
 function formatDate(d) {
     return d.toLocaleDateString('en-US', {
@@ -65,6 +65,10 @@ export async function runAgentHeartbeat(opts) {
         profile: opts.profile?.slug,
         promptChars: prompt.length,
     }, 'runAgentHeartbeat: dispatching to runAgent (no tools)');
+    // Heartbeat cap from config (BUDGET.heartbeat). Sourced from env /
+    // clementine.json / dashboard writes. 0 = uncapped — runAgent
+    // omits the SDK option in that case.
+    const heartbeatBudget = opts.maxBudgetUsd ?? (BUDGET.heartbeat > 0 ? BUDGET.heartbeat : undefined);
     const sessionKey = `heartbeat:${opts.profile?.slug ?? 'clementine'}`;
     const result = await runAgent(prompt, {
         sessionKey,
@@ -73,7 +77,7 @@ export async function runAgentHeartbeat(opts) {
         memoryStore: opts.memoryStore,
         model: opts.model ?? MODELS.haiku,
         effort: 'low',
-        maxBudgetUsd: opts.maxBudgetUsd ?? 0.15,
+        ...(heartbeatBudget !== undefined ? { maxBudgetUsd: heartbeatBudget } : {}),
         maxTurns: 1,
         // No tools — heartbeats are decision-only. Empty list bypasses the
         // CORE_TOOLS_FOR_AGENT_PARENT default and stops the SDK from
@@ -81,17 +85,13 @@ export async function runAgentHeartbeat(opts) {
         allowedTools: [],
         abortSignal: opts.abortSignal,
     });
-    // Mirror the heartbeat into transcripts so dedup + recall work.
-    // Skip pure __NOTHING__ outputs since they carry no information.
-    const text = result.text?.trim() ?? '';
-    if (opts.memoryStore && text && text !== '__NOTHING__') {
-        try {
-            opts.memoryStore.saveTurn(sessionKey, 'heartbeat', text, opts.model ?? MODELS.haiku);
-        }
-        catch {
-            /* non-fatal */
-        }
-    }
+    // Heartbeat output is NOT mirrored to transcripts. Heartbeats fire
+    // up to 28x/day per agent and most output is low-value (status
+    // pings, dedup'd reminders). The heartbeat dedup that prior versions
+    // wanted recall for actually lives in the prompt itself (the
+    // dedupContext block + the __NOTHING__ sentinel), not in DB queries.
+    // Saving rows here just polluted FTS and the dashboard memory panel
+    // for no recall benefit.
     return result;
 }
 //# sourceMappingURL=run-agent-heartbeat.js.map

package/dist/agent/run-agent-team-task.d.ts

@@ -7,6 +7,8 @@ import { type RunAgentResult } from './run-agent.js';
  *  the full assistant graph. */
 export interface TeamTaskPostHooks {
     triggerMemoryExtractionPostExchange: (userMessage: string, assistantResponse: string, sessionKey?: string, profile?: AgentProfile) => Promise<void>;
+    triggerSkillExtractionFromExecution: (source: 'unleashed' | 'cron' | 'chat', jobName: string, prompt: string, output: string, durationMs: number, agentSlug?: string) => Promise<void>;
+    triggerCronReflection: (jobName: string, jobPrompt: string, deliverable: string, successCriteria?: string[]) => Promise<void>;
 }
 export interface RunAgentTeamTaskOptions {
     fromName: string;

package/dist/agent/run-agent-team-task.js

@@ -56,6 +56,7 @@ export async function runAgentTeamTask(opts) {
         promptChars: builtPrompt.length,
     }, 'runAgentTeamTask: dispatching to runAgent');
     const sessionKey = `team-task:${opts.fromSlug}->${opts.profile.slug}`;
+    const startedAt = Date.now();
     const result = await runAgent(builtPrompt, {
         sessionKey,
         source: 'team-task',
@@ -82,14 +83,23 @@ export async function runAgentTeamTask(opts) {
             /* non-fatal */
         }
     }
-    // Auto-memory extraction — distill any new facts the recipient
-    // learned during the task into their MEMORY.md. Fire-and-forget,
-    // scoped to the recipient's profile so writes route to
-    // agents/<slug>/MEMORY.md, not the global one.
+    // Post-task hooks: memory + skill extraction + reflection. All
+    // fire-and-forget. Mirrors the cron wrapper's three-hook pattern.
+    // Team tasks often produce repeatable procedures (e.g. "draft a
+    // follow-up email after a discovery call") and reflection grades
+    // whether the response actually fulfilled the request.
     if (opts.postTaskHooks && result.text?.trim()) {
+        const durationMs = Date.now() - startedAt;
         opts.postTaskHooks
             .triggerMemoryExtractionPostExchange(opts.content, result.text, sessionKey, opts.profile)
             .catch(err => logger.debug({ err, fromSlug: opts.fromSlug, toSlug: opts.profile.slug }, 'runAgentTeamTask: memory extraction failed (non-fatal)'));
+        opts.postTaskHooks
+            .triggerSkillExtractionFromExecution('cron', // 'cron' covers autonomous-task skill source category
+        taskName, opts.content, result.text, durationMs, opts.profile.slug)
+            .catch(err => logger.debug({ err, fromSlug: opts.fromSlug, toSlug: opts.profile.slug }, 'runAgentTeamTask: skill extraction failed (non-fatal)'));
+        opts.postTaskHooks
+            .triggerCronReflection(taskName, opts.content, result.text)
+            .catch(err => logger.debug({ err, fromSlug: opts.fromSlug, toSlug: opts.profile.slug }, 'runAgentTeamTask: reflection failed (non-fatal)'));
     }
     return {
         ...result,

package/dist/agent/run-agent.js

@@ -62,8 +62,15 @@ function buildRunAgentEnv() {
     return env;
 }
 const logger = pino({ name: 'clementine.run-agent' });
+// Last-resort fallbacks for callers that pass NO maxBudgetUsd. The
+// production callers (`runAgent` from gateway/router, runAgentCron,
+// runAgentHeartbeat) read `BUDGET.*` from src/config.ts — which is
+// itself sourced from env / clementine.json / dashboard writes — and
+// pass it explicitly. Chat is intentionally omitted: the chat path
+// must always go through `BUDGET.chat` (0 = uncapped), never a silent
+// hardcoded floor. If `source: 'chat'` ever lands here without an
+// explicit budget, we treat it as uncapped.
 const DEFAULT_BUDGETS = {
-    chat: 0.50,
     cron: 1.00,
     heartbeat: 0.25,
     'team-task': 1.00,
@@ -97,7 +104,13 @@ const CORE_TOOLS_FOR_AGENT_PARENT = [
 export async function runAgent(prompt, opts) {
     const source = opts.source ?? 'chat';
     const effort = opts.effort ?? DEFAULT_EFFORTS[source] ?? 'medium';
-    const maxBudgetUsd = opts.maxBudgetUsd ?? DEFAULT_BUDGETS[source] ?? 0.50;
+    // 0 (or undefined) means "no cap" — matches the dashboard's
+    // "Remove spend caps" preset contract. We omit `maxBudgetUsd` from
+    // sdkOptions entirely in that case so the SDK runs uncapped.
+    const requestedBudget = opts.maxBudgetUsd ?? DEFAULT_BUDGETS[source];
+    const maxBudgetUsd = typeof requestedBudget === 'number' && requestedBudget > 0
+        ? requestedBudget
+        : undefined;
     const startedAt = Date.now();
     // Build the AgentDefinition map. Caller can override; otherwise we
     // use the standard system subagents + hired-agent profiles.
@@ -187,8 +200,8 @@ export async function runAgent(prompt, opts) {
         allowDangerouslySkipPermissions: true,
         cwd: BASE_DIR,
         env: subprocessEnv,
-        maxBudgetUsd,
         effort,
+        ...(maxBudgetUsd !== undefined ? { maxBudgetUsd } : {}),
         ...(opts.maxTurns ? { maxTurns: opts.maxTurns } : {}),
         ...(opts.model ? { model: opts.model } : {}),
         ...(opts.resumeSessionId ? { resume: opts.resumeSessionId } : {}),
@@ -201,7 +214,7 @@ export async function runAgent(prompt, opts) {
         profile: opts.profile?.slug,
         forceSubagent: opts.forceSubagent,
         effort,
-        maxBudgetUsd,
+        maxBudgetUsd: maxBudgetUsd ?? 'uncapped',
         agentCount: Object.keys(agents).length,
         allowedToolCount: allowedTools.length,
     }, 'runAgent: starting query');
@@ -212,76 +225,93 @@ export async function runAgent(prompt, opts) {
     let subtype = 'unknown';
     let usage;
     const stream = query({ prompt: effectivePrompt, options: sdkOptions });
-    for await (const message of stream) {
-        if (message.type === 'system' && message.subtype === 'init') {
-            sessionId = message.session_id ?? '';
-            logger.debug({ sessionKey: opts.sessionKey, sdkSessionId: sessionId }, 'runAgent: SDK session initialized');
-            continue;
-        }
-        if (message.type === 'assistant') {
-            const am = message;
-            const blocks = (am.message?.content ?? []);
-            for (const block of blocks) {
-                if (block.type === 'text' && typeof block.text === 'string') {
-                    finalText += block.text;
-                    if (opts.onText) {
-                        try {
-                            await opts.onText(block.text);
+    try {
+        for await (const message of stream) {
+            if (message.type === 'system' && message.subtype === 'init') {
+                sessionId = message.session_id ?? '';
+                logger.debug({ sessionKey: opts.sessionKey, sdkSessionId: sessionId }, 'runAgent: SDK session initialized');
+                continue;
+            }
+            if (message.type === 'assistant') {
+                const am = message;
+                const blocks = (am.message?.content ?? []);
+                for (const block of blocks) {
+                    if (block.type === 'text' && typeof block.text === 'string') {
+                        finalText += block.text;
+                        if (opts.onText) {
+                            try {
+                                await opts.onText(block.text);
+                            }
+                            catch { /* streaming is best-effort */ }
                         }
-                        catch { /* streaming is best-effort */ }
                     }
-                }
-                else if (block.type === 'tool_use' && typeof block.name === 'string') {
-                    if (opts.onToolActivity) {
-                        try {
-                            await opts.onToolActivity({ tool: block.name, input: block.input ?? {} });
+                    else if (block.type === 'tool_use' && typeof block.name === 'string') {
+                        if (opts.onToolActivity) {
+                            try {
+                                await opts.onToolActivity({ tool: block.name, input: block.input ?? {} });
+                            }
+                            catch { /* best-effort */ }
                         }
-                        catch { /* best-effort */ }
                     }
                 }
+                continue;
             }
-            continue;
-        }
-        if (message.type === 'result') {
-            const result = message;
-            sessionId = sessionId || (result.session_id ?? '');
-            subtype = result.subtype ?? 'unknown';
-            numTurns = result.num_turns ?? numTurns;
-            totalCostUsd = result.total_cost_usd ?? 0;
-            const u = result.usage;
-            if (u)
-                usage = u;
-            if (subtype === 'success') {
-                // success carries `result` field with the final text.
-                const r = result.result;
-                if (r)
-                    finalText = r;
-            }
-            // Mirror cost to usage_log. Same shape as the existing
-            // logQueryResult, but standalone so we don't depend on
-            // PersonalAssistant's instance state.
-            const modelUsage = result.modelUsage;
-            if (opts.memoryStore && modelUsage) {
-                try {
-                    opts.memoryStore.logUsage({
-                        sessionKey: `${source}:${opts.sessionKey}`,
-                        source: `runagent.${source}`,
-                        modelUsage,
-                        numTurns,
-                        durationMs: Date.now() - startedAt,
-                        agentSlug: opts.profile?.slug,
-                        totalCostUsd: totalCostUsd,
-                    });
+            if (message.type === 'result') {
+                const result = message;
+                sessionId = sessionId || (result.session_id ?? '');
+                subtype = result.subtype ?? 'unknown';
+                numTurns = result.num_turns ?? numTurns;
+                totalCostUsd = result.total_cost_usd ?? 0;
+                const u = result.usage;
+                if (u)
+                    usage = u;
+                if (subtype === 'success') {
+                    // success carries `result` field with the final text.
+                    const r = result.result;
+                    if (r)
+                        finalText = r;
                 }
-                catch (err) {
-                    logger.debug({ err }, 'runAgent: usage logging failed (non-fatal)');
+                // Mirror cost to usage_log. Same shape as the existing
+                // logQueryResult, but standalone so we don't depend on
+                // PersonalAssistant's instance state.
+                const modelUsage = result.modelUsage;
+                if (opts.memoryStore && modelUsage) {
+                    try {
+                        opts.memoryStore.logUsage({
+                            sessionKey: `${source}:${opts.sessionKey}`,
+                            source: `runagent.${source}`,
+                            modelUsage,
+                            numTurns,
+                            durationMs: Date.now() - startedAt,
+                            agentSlug: opts.profile?.slug,
+                            totalCostUsd: totalCostUsd,
+                        });
+                    }
+                    catch (err) {
+                        logger.debug({ err }, 'runAgent: usage logging failed (non-fatal)');
+                    }
                 }
+                continue;
             }
-            continue;
+            // Other message types (UserMessage with tool_result, StreamEvent,
+            // SDKCompactBoundaryMessage) — observed but not acted on. The SDK
+            // handles compaction internally; we just let it run.
+        }
+    }
+    catch (err) {
+        // Translate the SDK's budget-exhaustion throw into a message that
+        // tells the user (a) what cap tripped and (b) how to raise it.
+        // The raw SDK string ("Claude Code returned an error result:
+        // Reached maximum budget ($0.5)") leaks through the channel layer
+        // as a generic "Something went wrong:" with no actionable hint.
+        const msg = String(err?.message ?? err);
+        if (/Reached maximum budget|error_max_budget_usd/i.test(msg)) {
+            const cap = maxBudgetUsd?.toFixed(2) ?? '?';
+            const envKey = `BUDGET_${source.toUpperCase().replace(/-/g, '_')}_USD`;
+            throw new Error(`Hit the $${cap} ${source} budget cap before finishing. ` +
+                `Raise it in the dashboard (Budgets & Costs) or set ${envKey}=0 to remove caps.`);
         }
-        // Other message types (UserMessage with tool_result, StreamEvent,
-        // SDKCompactBoundaryMessage) — observed but not acted on. The SDK
-        // handles compaction internally; we just let it run.
+        throw err;
     }
     logger.info({
         sessionKey: opts.sessionKey,

package/dist/cli/dashboard.js

@@ -281,8 +281,48 @@ async function searchMemory(query, limit = 20, filters = {}) {
        WHERE ${where.join(' AND ')}
        ORDER BY ${orderBy}
        LIMIT ?`;
-        const rows = db.prepare(sql).all(...params, limit);
-        return { results: rows, dbExists: true };
+        const chunkRows = db.prepare(sql).all(...params, limit);
+        // Also surface transcripts from chat / cron / team-task. These
+        // are written by saveTurn and would otherwise be invisible to the
+        // main search panel (only the per-session viewer surfaced them).
+        // chunkType filter is chunk-only — if set, skip transcripts.
+        let transcriptRows = [];
+        if (words.length > 0 && !filters.chunkType && !filters.pinnedOnly) {
+            try {
+                const ftsQuery = words.map((w) => `"${w.replace(/"/g, '')}"`).join(' OR ');
+                const tWhere = ['transcripts_fts MATCH ?'];
+                const tParams = [ftsQuery];
+                if (filters.sinceDays && filters.sinceDays > 0) {
+                    tWhere.push("t.created_at >= datetime('now', ?)");
+                    tParams.push(`-${filters.sinceDays} days`);
+                }
+                const tSql = `SELECT t.id, t.session_key, t.role, t.content, t.model, t.created_at,
+                        bm25(transcripts_fts) as score
+                 FROM transcripts_fts f JOIN transcripts t ON t.id = f.rowid
+                 WHERE ${tWhere.join(' AND ')}
+                 ORDER BY bm25(transcripts_fts)
+                 LIMIT ?`;
+                transcriptRows = db.prepare(tSql).all(...tParams, Math.min(limit, 10))
+                    .map(r => ({
+                    id: `transcript:${r.id}`,
+                    source_file: `transcripts/${r.session_key}`,
+                    section: `${r.role} @ ${r.created_at}`,
+                    content: r.content,
+                    chunk_type: 'transcript',
+                    updated_at: r.created_at,
+                    salience: 0,
+                    pinned: 0,
+                    score: r.score,
+                }));
+            }
+            catch { /* transcripts FTS may be empty/unavailable — non-fatal */ }
+        }
+        // Merge: transcripts interleaved by score with chunks. FTS bm25
+        // is comparable across both since they use the same tokenizer.
+        const merged = [...chunkRows, ...transcriptRows]
+            .sort((a, b) => Number(a.score ?? 0) - Number(b.score ?? 0))
+            .slice(0, limit);
+        return { results: merged, dbExists: true };
     }
     catch (err) {
         return { results: [], dbExists: true, error: String(err) };
@@ -6909,7 +6949,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             }
             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. This does not change 1M context mode; use Force 200K or Safe Recovery for 1M errors. Restart Clementine to apply to running workers.';
+                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.)';
             }
             else {
                 res.status(400).json({ error: 'preset must be defaults or uncapped' });

package/dist/gateway/router.js

@@ -10,7 +10,7 @@ import pino from 'pino';
 import { oneMillionContextRecoveryMessage, PersonalAssistant, } from '../agent/assistant.js';
 import { runWithTrace, logAuditJsonl } from '../agent/hooks.js';
 import { SelfImproveLoop } from '../agent/self-improve.js';
-import { MODELS, AGENTS_DIR, TEAM_COMMS_LOG, BASE_DIR, SEEN_CHANNELS_FILE, AUTO_DELEGATE_ENABLED, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, } from '../config.js';
+import { MODELS, BUDGET, AGENTS_DIR, TEAM_COMMS_LOG, BASE_DIR, SEEN_CHANNELS_FILE, AUTO_DELEGATE_ENABLED, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, } from '../config.js';
 import { scanner } from '../security/scanner.js';
 import { lanes } from './lanes.js';
 import { AgentManager } from '../agent/agent-manager.js';
@@ -1820,7 +1820,13 @@ export class Gateway {
                     // Builder cost knobs: Haiku is plenty for JSON drafting,
                     // tight budget, no tools surfaced in the system prompt.
                     const builderModel = isBuilderSession ? MODELS.haiku : effectiveModel;
-                    const builderBudget = isBuilderSession ? 0.10 : undefined;
+                    // Builder stays tight ($0.10 — Haiku JSON drafting only).
+                    // Regular chat reads BUDGET.chat from config (env / clementine.json /
+                    // dashboard writes). 0 = uncapped — the runAgent layer omits the
+                    // SDK option entirely in that case.
+                    const chatBudget = isBuilderSession
+                        ? 0.10
+                        : (BUDGET.chat > 0 ? BUDGET.chat : undefined);
                     const builderAllowedTools = isBuilderSession ? [] : undefined;
                     logger.info({
                         sessionKey: effectiveSessionKey,
@@ -1841,7 +1847,7 @@ export class Gateway {
                         memoryStore: this.assistant.getMemoryStore?.() ?? null,
                         ...(builderModel ? { model: builderModel } : {}),
                         ...(maxTurns ? { maxTurns } : {}),
-                        ...(builderBudget !== undefined ? { maxBudgetUsd: builderBudget } : {}),
+                        ...(chatBudget !== undefined ? { maxBudgetUsd: chatBudget } : {}),
                         ...(builderAllowedTools ? { allowedTools: builderAllowedTools } : {}),
                         ...(chatSystemAppend ? { systemPromptAppend: chatSystemAppend } : {}),
                         ...(priorSdkSessionId ? { resumeSessionId: priorSdkSessionId } : {}),

package/package.json

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