clementine-agent 1.18.35 → 1.18.37

package/dist/agent/assistant.js

@@ -33,7 +33,7 @@ import { searchSkills as searchSkillsSync } from './skill-extractor.js';
 import { classifyIntent, getStrategyGuidance } from './intent-classifier.js';
 import { getEventLog } from './session-event-log.js';
 import { applyServiceDedup, routeToolSurface, TOOL_SURFACE_HARD_LIMIT, TOOL_SURFACE_WARN_THRESHOLD } from './tool-router.js';
-import { isRestrictedToolset, toolsetAllowsLocalWrites } from './toolsets.js';
+import { isRestrictedToolset, toolsetAllowsLocalWrites, toolsetDisablesAllTools } from './toolsets.js';
 import { looksLikeApprovalPrompt } from './local-turn.js';
 import { decideTurn } from './turn-policy.js';
 import { loadClementineJson } from '../config/clementine-json.js';
@@ -1446,8 +1446,17 @@ Large tool outputs blow the context window and rotate your session mid-task —
             if (agentsEntry)
                 parts.push(agentsEntry.content);
         }
+        // ── Per-session-volatile content goes to volatileParts (post-cache-boundary) ──
+        // Anthropic's prompt-caching guidance is explicit: cache is a prefix
+        // hash, so anything that changes between turns must sit AFTER the
+        // breakpoint. The blocks below — retrieved context, working memory,
+        // MEMORY.md, today's notes, yesterday's summary, recent conversations —
+        // all change within a single 5-minute cache TTL window during an
+        // active session. Putting them in the stable prefix caused ~80 KB of
+        // cache_creation per session-content change. After this refactor the
+        // stable prefix stays byte-identical across calls.
         if (retrievalContext) {
-            parts.push(`## Relevant Context (retrieved)\n\n${retrievalContext}\n\n` +
+            volatileParts.push(`## Relevant Context (retrieved)\n\n${retrievalContext}\n\n` +
                 `*When retrieved context contains information from previous conversations relevant to the current topic, naturally reference it. ` +
                 `If the user mentions a person and memory shows their last known status or project, weave that in conversationally. ` +
                 `Only reference if genuinely relevant — do not force callbacks to old context.*`);
@@ -1460,7 +1469,7 @@ Large tool outputs blow the context window and rotate your session mid-task —
                     const wmContent = fs.readFileSync(_wmFileFallback, 'utf-8').trim();
                     if (wmContent) {
                         const truncated = isAutonomous ? wmContent.slice(0, 1500) : wmContent;
-                        parts.push(`## Working Memory (scratchpad)\n\n${truncated}`);
+                        volatileParts.push(`## Working Memory (scratchpad)\n\n${truncated}`);
                     }
                 }
                 catch { /* non-critical */ }
@@ -1470,10 +1479,10 @@ Large tool outputs blow the context window and rotate your session mid-task —
                 // Autonomous runs get truncated memory — just enough for context
                 if (isAutonomous) {
                     const truncated = memoryEntry.content.slice(0, 2000);
-                    parts.push(`## Current Memory\n\n${truncated}${memoryEntry.content.length > 2000 ? '\n...(truncated)' : ''}`);
+                    volatileParts.push(`## Current Memory\n\n${truncated}${memoryEntry.content.length > 2000 ? '\n...(truncated)' : ''}`);
                 }
                 else {
-                    parts.push(`## Current Memory\n\n${memoryEntry.content}`);
+                    volatileParts.push(`## Current Memory\n\n${memoryEntry.content}`);
                 }
             }
         }
@@ -1484,12 +1493,12 @@ Large tool outputs blow the context window and rotate your session mid-task —
             this.promptCache.watch(agentMemPath);
             const agentMemEntry = this.promptCache.get(agentMemPath);
             if (agentMemEntry) {
-                parts.push(`## Agent Memory (${profile.slug})\n\n${agentMemEntry.content}`);
+                volatileParts.push(`## Agent Memory (${profile.slug})\n\n${agentMemEntry.content}`);
             }
         }
         const todayEntry = !skipAmbientContext ? this.promptCache.get(todayPath) : null;
         if (todayEntry) {
-            parts.push(`## Today's Notes (${todayISO()})\n\n${todayEntry.content}`);
+            volatileParts.push(`## Today's Notes (${todayISO()})\n\n${todayEntry.content}`);
         }
         // Skip yesterday's notes and recent conversation summaries for autonomous runs
         if (!isAutonomous && !skipAmbientContext) {
@@ -1501,7 +1510,7 @@ Large tool outputs blow the context window and rotate your session mid-task —
                     const yEntry = this.promptCache.get(yPath);
                     if (yEntry && yEntry.content.includes('## Summary')) {
                         const summary = yEntry.content.slice(yEntry.content.indexOf('## Summary'));
-                        parts.push(`## Yesterday's Summary (${yesterdayISO()})\n\n${summary}`);
+                        volatileParts.push(`## Yesterday's Summary (${yesterdayISO()})\n\n${summary}`);
                     }
                 }
             }
@@ -1513,7 +1522,7 @@ Large tool outputs blow the context window and rotate your session mid-task —
                             const ts = (s.createdAt ?? 'unknown').slice(0, 16);
                             return `### ${ts}\n${s.summary}`;
                         });
-                        parts.push('## Recent Conversations\n\n' + lines.join('\n\n'));
+                        volatileParts.push('## Recent Conversations\n\n' + lines.join('\n\n'));
                     }
                 }
                 catch {
@@ -1522,8 +1531,10 @@ Large tool outputs blow the context window and rotate your session mid-task —
             }
         }
         if (isAutonomous) {
-            // Minimal vault reference for heartbeats/cron — they know their tools
-            parts.push(`Vault: \`${vault}\`. Key files: MEMORY.md, ${todayISO()}.md (today), TASKS.md. Use MCP tools (memory_read/write, task_list/add/update, note_take).`);
+            // Minimal vault reference for heartbeats/cron — they know their tools.
+            // No date reference here: today's date string in the stable prefix
+            // would invalidate the prompt cache once per day.
+            parts.push(`Vault: \`${vault}\`. Key files: MEMORY.md, today's daily note, TASKS.md. Use MCP tools (memory_read/write, task_list/add/update, note_take).`);
             // Deviation rules — tiered autonomy for handling unexpected work during cron/heartbeat
             parts.push(`## Deviation Rules (Tiered Autonomy)
 
@@ -1554,7 +1565,7 @@ Obsidian vault with YAML frontmatter, [[wikilinks]], #tags.
 **File tools:** Read, Write, Edit, Glob, Grep for direct access.
 
 **Folders:** 00-System (SOUL/MEMORY/AGENTS.md), 01-Daily-Notes (YYYY-MM-DD.md), 02-People, 03-Projects, 04-Topics, 05-Tasks/TASKS.md, 06-Templates, 07-Inbox.
-**Key files:** MEMORY.md (long-term), ${todayISO()}.md (today), TASKS.md (tasks).
+**Key files:** MEMORY.md (long-term), today's daily note, TASKS.md (tasks).
 
 **Task IDs:** \`{T-001}\`, subtasks \`{T-001.1}\`. Recurring tasks auto-create next copy on completion.
 
@@ -1629,21 +1640,19 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                 parts.push(`Linked projects:\n${projectDetails.join('\n')}`);
             }
         }
-        // Inject hot corrections (explicit behavioral corrections from recent sessions)
+        // Recent Corrections + feedback signals — both refresh as the user
+        // gives feedback during a session. Putting them in volatile keeps the
+        // stable prefix cache-stable across feedback turns. Same per-message
+        // anti-pattern that OpenClaw issue #20894 documented as a 100x cost
+        // amplifier.
         if (this.hotCorrections.length > 0 && !lightweightTurn) {
             const recentCutoff = Date.now() - 24 * 60 * 60 * 1000; // last 24 hours
             const recent = this.hotCorrections.filter(c => new Date(c.timestamp).getTime() > recentCutoff);
             if (recent.length > 0) {
                 const lines = recent.map(c => `- [${c.category}] ${c.correction}`);
-                parts.push(`## Recent Corrections (apply immediately)\n\n${lines.join('\n')}`);
+                volatileParts.push(`## Recent Corrections (apply immediately)\n\n${lines.join('\n')}`);
             }
         }
-        // Inject recent feedback signals (closes the feedback → behavior loop).
-        // Without this block, user thumbs-down + comments live in the feedback
-        // table and never reach the agent's awareness — only the skill-suppress
-        // filter consumed them. We surface aggregates + the last few commented
-        // negatives so the agent can self-adjust on the next turn. Skipped when
-        // there's nothing to report (no noise).
         if (this.memoryStore?.getRecentFeedbackSignals && !lightweightTurn) {
             try {
                 const sig = this.memoryStore.getRecentFeedbackSignals({ days: 14, limit: 3 });
@@ -1659,7 +1668,7 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                             lines.push(`- (${n.channel}) ${comment}`);
                         }
                     }
-                    parts.push(`## Recent feedback signals\n\n${lines.join('\n')}`);
+                    volatileParts.push(`## Recent feedback signals\n\n${lines.join('\n')}`);
                 }
             }
             catch { /* non-fatal */ }
@@ -1708,7 +1717,9 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                             skillBlock += `\n\n**Reference files:**\n${attParts.join('\n\n')}`;
                         }
                     }
-                    parts.push(skillBlock);
+                    // Skill matches depend on the user's last message + the live
+                    // suppression list; both refresh per turn. Volatile.
+                    volatileParts.push(skillBlock);
                 }
             }
             catch { /* non-fatal — skills dir may not exist */ }
@@ -1730,7 +1741,9 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                     parts.push(`## Agent-Specific Preferences (${profile.slug})\n\n${agentPrefs.data.preferences}`);
                 }
             }
-            // User Theory of Mind — structured user model
+            // User Theory of Mind — structured user model. The model file
+            // updates as the user's preferences/priorities are learned, so
+            // its content is volatile within a session.
             const userModelFile = path.join(VAULT_DIR, '00-System', 'USER_MODEL.md');
             this.promptCache.watch(userModelFile);
             const userModel = this.promptCache.get(userModelFile);
@@ -1740,7 +1753,7 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                 const comm = userModel.data.communication ? `Communication: ${Object.entries(userModel.data.communication).map(([k, v]) => `${k}=${v}`).join(', ')}` : '';
                 const modelParts = [expertise, priorities, comm].filter(Boolean);
                 if (modelParts.length > 0) {
-                    parts.push(`## User Context\n\n${modelParts.join('\n')}`);
+                    volatileParts.push(`## User Context\n\n${modelParts.join('\n')}`);
                 }
             }
             // Proactive feedback capture
@@ -2011,7 +2024,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
     async buildOptions(opts = {}) {
         const { isHeartbeat = false, cronTier = null, maxTurns = null, model = null, enableTeams = true, retrievalContext = '', profile = null, sessionKey = null, streaming = false, isPlanStep = false, isUnleashed = false, sourceOverride, disableAllTools = false, verboseLevel, abortController, effort, maxBudgetUsd, toolScopeText, thinking, outputFormat, stallGuard, intentClassification, turnPolicy, contextRoutingText, toolset = 'auto', } = opts;
         const isCron = cronTier !== null;
-        const toolsDisabledForCall = disableAllTools || (isHeartbeat && !isCron);
+        const toolsDisabledForCall = disableAllTools
+            || (isHeartbeat && !isCron)
+            || toolsetDisablesAllTools(toolset);
         const promptScopeText = toolScopeText ?? '';
         const profileScopeText = [profile?.description, profile?.systemPromptBody]
             .filter(Boolean)
@@ -2300,6 +2315,26 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         const volatileSuffix = volatilePromptPart && volatilePromptPart.trim().length > 0
             ? volatilePromptPart
             : '';
+        // Debug-mode: log a short hash of the stable prefix + volatile suffix
+        // per query. When CLEMENTINE_DEBUG_CACHE=1, mismatched stable hashes
+        // across consecutive turns of the same session indicate a regression
+        // where volatile content silently leaked back into the cached prefix.
+        // No-op (no allocation) in normal mode.
+        if (process.env.CLEMENTINE_DEBUG_CACHE === '1') {
+            const { createHash } = await import('node:crypto');
+            const stableHash = createHash('sha1').update(stablePrefixParts.join('\n\n---\n\n')).digest('hex').slice(0, 8);
+            const volatileHash = volatileSuffix
+                ? createHash('sha1').update(volatileSuffix).digest('hex').slice(0, 8)
+                : 'empty';
+            logger.info({
+                sessionKey,
+                stable_prefix_hash: stableHash,
+                volatile_suffix_hash: volatileHash,
+                stable_chars: stablePrefixParts.reduce((n, s) => n + s.length, 0),
+                volatile_chars: volatileSuffix.length,
+                allowed_tool_count: allowedTools.length,
+            }, 'cache_debug: prompt structure for this query');
+        }
         // If there is no volatile content, a plain string keeps the call simple
         // and behaves identically for the cache. Only use the array form when
         // we actually have dynamic content to split off.
@@ -2572,15 +2607,25 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             && !isPlanStep
             && (toolRoute.inheritFullClaudeEnv || toolRoute.fullSurface);
         const isolateClaudeConfig = !toolRoute.fullSurface;
+        // Sort tool surface for deterministic cache key. The Anthropic prompt
+        // cache hashes the entire tools/system prefix; insertion-order
+        // serialization is fragile if routing logic ever pushes in a
+        // different order between calls — silent cache miss. Sorting also
+        // lets multiple jobs that arrived at the same tool set (via
+        // different routing paths) share a cache entry.
+        if (!toolsDisabledForCall) {
+            allowedTools.sort();
+        }
         const mcpServerNames = toolsDisabledForCall
             ? []
-            : [TOOLS_SERVER, ...Object.keys(externalMcpServers), ...Object.keys(composioMcpServers)];
+            : [TOOLS_SERVER, ...Object.keys(externalMcpServers).sort(), ...Object.keys(composioMcpServers).sort()];
         const clementineToolPrefix = `mcp__${TOOLS_SERVER}__`;
         const clementineToolAllowlist = toolRoute.fullSurface
             ? '*'
             : allowedTools
                 .filter(t => t.startsWith(clementineToolPrefix))
                 .map(t => t.slice(clementineToolPrefix.length))
+                .sort()
                 .join(',');
         const clementineToolAllowlistCount = clementineToolAllowlist === '*'
             ? CLEMENTINE_ALL_TOOL_NAMES.length

package/dist/agent/fanout-policy.js

@@ -85,6 +85,7 @@ export function buildAlwaysOnParallelizationHint() {
     return [
         '## Sub-agent fan-out',
         'When you process multiple items, spawn ONE Agent sub-agent per batch of 3–5 items. Sub-agents return ONE-LINE summaries (no raw tool output). Do not iterate sequentially in this conversation — that fills your context and aborts the run.',
+        'Cost: pass `model: "haiku"` to Agent for routine extraction, summarization, or per-item lookups. Use Sonnet only when the sub-agent must reason across many sources or write something durable.',
     ].join('\n');
 }
 /**
@@ -109,6 +110,7 @@ export function buildFanoutDirective(signals) {
         'Use the `Agent` tool to spawn parallel sub-agents. Each sub-agent runs in its own isolated context, so big tool responses live and die there — your context only sees the summary.',
         '',
         '- **Batch size**: 3–5 items per sub-agent (or one slice of work per sub-agent for research tasks)',
+        '- **Sub-agent model**: pass `model: "haiku"` to the Agent tool by default — sub-agents that just extract fields, summarize a single email, or pull a single record do not need Sonnet. Reserve Sonnet for sub-agents that must reason across multiple sources or write something durable.',
         '- **Sub-agent prompt MUST include**: the narrow task, the exact return format (e.g. `Return ONE LINE: <id> | <status> | <next-action>`), and an explicit "do not include raw tool output" directive',
         '- **Parent context keeps**: only the sub-agent return strings, not their tool transcripts',
         '',

package/dist/agent/toolsets.d.ts

@@ -1,4 +1,4 @@
-export type ToolsetName = 'auto' | 'safe' | 'diagnostic' | 'communications' | 'memory' | 'full';
+export type ToolsetName = 'auto' | 'safe' | 'diagnostic' | 'communications' | 'memory' | 'none' | 'full';
 export interface ToolsetPreset {
     name: ToolsetName;
     label: string;
@@ -11,4 +11,10 @@ export declare function getToolsetPreset(name: ToolsetName): ToolsetPreset;
 export declare function formatToolsetChoices(): string;
 export declare function isRestrictedToolset(name: ToolsetName): boolean;
 export declare function toolsetAllowsLocalWrites(name: ToolsetName): boolean;
+/**
+ * "none" toolset: not just restricted, but actively disables ALL tools
+ * including the core Clementine MCP server. Used by builder/JSON-gen
+ * chats where tool schemas in the system prompt are pure cost overhead.
+ */
+export declare function toolsetDisablesAllTools(name: ToolsetName): boolean;
 //# sourceMappingURL=toolsets.d.ts.map

package/dist/agent/toolsets.js

@@ -29,6 +29,12 @@ export const TOOLSET_PRESETS = [
         description: 'Memory, transcript, and relationship tools only unless explicitly changed.',
         directive: 'Toolset memory: use memory_read, memory_search, memory_recall, transcript_search, working_memory, and user_model. Avoid external integrations and local shell/file writes.',
     },
+    {
+        name: 'none',
+        label: 'None',
+        description: 'No tools at all — pure-LLM conversation. Used by builders and JSON-generating chats where tool schemas are dead weight in the system prompt.',
+        directive: 'Toolset none: do not call any tools. Respond from the prompt context only. Generate JSON, summaries, or text directly.',
+    },
     {
         name: 'full',
         label: 'Full',
@@ -60,9 +66,17 @@ export function formatToolsetChoices() {
         .join('\n');
 }
 export function isRestrictedToolset(name) {
-    return name === 'safe' || name === 'diagnostic' || name === 'memory';
+    return name === 'safe' || name === 'diagnostic' || name === 'memory' || name === 'none';
 }
 export function toolsetAllowsLocalWrites(name) {
     return name === 'auto' || name === 'full';
 }
+/**
+ * "none" toolset: not just restricted, but actively disables ALL tools
+ * including the core Clementine MCP server. Used by builder/JSON-gen
+ * chats where tool schemas in the system prompt are pure cost overhead.
+ */
+export function toolsetDisablesAllTools(name) {
+    return name === 'none';
+}
 //# sourceMappingURL=toolsets.js.map

package/dist/cli/dashboard.js

@@ -8053,6 +8053,12 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         }
         try {
             const gateway = await getGateway();
+            // Builder generates JSON artifacts — no tool calls. Pin the session
+            // toolset to 'none' so buildOptions strips all MCP servers and tool
+            // schemas from the system prompt. Without this, every tiny builder
+            // turn writes 60–280 KB of cache_creation for tool schemas the
+            // model never uses.
+            gateway.setSessionToolset(sessionKey, 'none');
             const response = await gateway.handleMessage(sessionKey, enrichedMessage);
             // Parse any json-artifact blocks from the response
             let artifact = null;
@@ -8180,6 +8186,9 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         try {
             writeEvent('progress', { status: 'thinking…' });
             const gateway = await getGateway();
+            // Builder generates JSON artifacts — no tool calls. Pin to 'none'
+            // toolset so the SDK system prompt drops the tool inventory.
+            gateway.setSessionToolset(sessionKey, 'none');
             let lastText = '';
             const response = await gateway.handleMessage(sessionKey, enrichedMessage, async (text) => {
                 lastText = text ?? '';

package/dist/gateway/agent-heartbeat-scheduler.js

@@ -171,7 +171,15 @@ export class AgentHeartbeatScheduler {
         catch {
             signals.latestGoalUpdate = '';
         }
-        // 3. Latest cron run for any of this agent's crons (file mtime is enough)
+        // 3. Latest cron run for any of this agent's crons (file mtime is enough).
+        //
+        // INFO ONLY — kept in `signals` for the LLM prompt context, but NOT
+        // included in the fingerprint hash below. A cron firing is expected
+        // background activity, not a "wake up Sonnet" signal. Including it
+        // caused every cron run to bump the fingerprint → fire a $1+ Sonnet
+        // pass that just confirmed "yep, the cron ran, nothing else to do."
+        // Actionable wake-ups are pendingTasks growing and goal-state changes;
+        // those still trip the fingerprint below.
         try {
             const runsDir = path.join(this.baseDir, 'cron', 'runs');
             let latestMs = 0;
@@ -195,8 +203,15 @@ export class AgentHeartbeatScheduler {
         catch {
             signals.latestCronRunMs = 0;
         }
+        // Fingerprint only includes ACTIONABLE signals. latestCronRunMs is
+        // info-only and explicitly excluded.
+        const fingerprintSource = {
+            slug: signals.slug,
+            pendingTasks: signals.pendingTasks,
+            latestGoalUpdate: signals.latestGoalUpdate,
+        };
         const fingerprint = createHash('sha1')
-            .update(JSON.stringify(signals))
+            .update(JSON.stringify(fingerprintSource))
             .digest('hex')
             .slice(0, 16);
         return { fingerprint, signals };

package/dist/gateway/cron-scheduler.js

@@ -23,7 +23,7 @@ import { listBackgroundTasks, markDone as markBgTaskDone, markFailed as markBgTa
 import { outcomeStatusFromGoalDisposition, recentDecisions, recordDecisionOutcome, } from '../agent/proactive-ledger.js';
 import { formatCreditBlock, getBackgroundCreditBlock, isCreditBalanceError, markBackgroundCreditBlocked, } from './credit-guard.js';
 import { isRunHealthFailure } from './job-health.js';
-import { analyzeLongTaskPreflight, compactLongTaskPreflight, formatLongTaskPromptPrefix, } from './long-task-preflight.js';
+import { analyzeLongTaskPreflight, compactLongTaskPreflight, shouldDowngradeUnleashed, formatLongTaskPromptPrefix, } from './long-task-preflight.js';
 const logger = pino({ name: 'clementine.cron' });
 /** Default timeout for standard cron jobs (10 minutes). */
 const CRON_STANDARD_TIMEOUT_MS = 10 * 60 * 1000;
@@ -1061,6 +1061,34 @@ export class CronScheduler {
             // Sonnet runs every job by default. Opus 1M is opt-in: set
             // `model: claude-opus-4-7[1m]` in CRON.md per-job, or flip
             // CLEMENTINE_1M_CONTEXT_MODE=on for global enable.
+            // ── Auto-downgrade unleashed → standard ────────────────────────
+            // CRON.md `mode: unleashed` is a CEILING, not a floor. If the
+            // job's history shows it's a quiet probe that completes in 1
+            // phase with __NOTHING__ or short output, the multi-phase
+            // wrapper is wasteful overhead — each phase is a fresh SDK
+            // query with full system prompt + tool schemas in cache_creation.
+            // For a "did anything new come in?" cron firing every 2 hours,
+            // that's 12+ unleashed runs/day at ~$1/each instead of standard
+            // mode at ~$0.05/each.
+            if (job.mode === 'unleashed') {
+                const downgrade = shouldDowngradeUnleashed(this.runLog.readRecent(job.name, 5));
+                if (downgrade.downgrade) {
+                    job = { ...job, mode: 'standard' };
+                    logger.info({
+                        job: job.name,
+                        reason: downgrade.reason,
+                        quietRatio: downgrade.quietRatio,
+                        avgDurationMs: downgrade.avgDurationMs,
+                    }, 'Cron mode downgraded unleashed → standard based on run history');
+                    this.logAutonomy('mode_downgrade', job, {
+                        from: 'unleashed',
+                        to: 'standard',
+                        reason: downgrade.reason,
+                        quietRatio: downgrade.quietRatio,
+                        avgDurationMs: downgrade.avgDurationMs,
+                    });
+                }
+            }
             let longTaskPreflight;
             const preflight = analyzeLongTaskPreflight(job, jobPrompt, this.runLog.readRecent(job.name, 5));
             if (preflight.risk !== 'normal') {

package/dist/gateway/long-task-preflight.d.ts

@@ -15,6 +15,15 @@ export interface LongTaskPreflightOptions {
     opusModel?: string;
     sonnetModel?: string;
 }
+export interface UnleashedDowngradeDecision {
+    downgrade: boolean;
+    reason: string;
+    /** Quiet ratio observed in the sample (for telemetry). */
+    quietRatio?: number;
+    /** Average duration of recent runs in ms (for telemetry). */
+    avgDurationMs?: number;
+}
+export declare function shouldDowngradeUnleashed(recentRuns: CronRunEntry[], now?: number): UnleashedDowngradeDecision;
 export declare function analyzeLongTaskPreflight(job: CronJobDefinition, prompt: string, recentRuns?: CronRunEntry[], opts?: LongTaskPreflightOptions): LongTaskPreflightDecision;
 export declare function formatLongTaskPromptPrefix(decision: LongTaskPreflightDecision): string;
 export declare function compactLongTaskPreflight(decision: LongTaskPreflightDecision): LongTaskPreflightSnapshot;

package/dist/gateway/long-task-preflight.js

@@ -48,6 +48,88 @@ function recentContextFailures(recentRuns, now = Date.now()) {
     }
     return [...new Set(reasons)];
 }
+// ── Auto-downgrade unleashed → standard for quiet/probe jobs ──────────
+//
+// `mode: unleashed` wraps a job in multi-phase machinery: each phase is a
+// fresh SDK query with the full system prompt + tool schemas, and the
+// orchestrator chains phases until TASK_COMPLETE or max-phases. That
+// machinery is essential for genuinely-long tasks (sasha briefs, market
+// outreach), but it's pure overhead on quiet probe jobs that finish in
+// 1 phase with `__NOTHING__` or a short output.
+//
+// Detect that pattern from history and downgrade the next run to
+// standard mode. Single SDK call, single cache write, fraction of the
+// cost. The user's CRON.md `mode: unleashed` becomes a "ceiling" rather
+// than a forced floor — actual mode chosen dynamically per-run.
+//
+// Conservative by design: requires 3+ prior runs of evidence, refuses
+// to downgrade if any recent run hit context overflow (the unleashed
+// wrapper might be actively saving us), and only triggers on jobs that
+// historically complete fast with short or empty output.
+const UNLEASHED_DOWNGRADE_SAMPLE_SIZE = 5;
+const UNLEASHED_DOWNGRADE_MIN_HISTORY = 3;
+const UNLEASHED_DOWNGRADE_QUIET_RATIO = 0.6;
+const UNLEASHED_DOWNGRADE_MAX_DURATION_MS = 90_000;
+const UNLEASHED_DOWNGRADE_AVG_DURATION_MS = 60_000;
+const UNLEASHED_DOWNGRADE_QUIET_PREVIEW_CHARS = 200;
+export function shouldDowngradeUnleashed(recentRuns, now = Date.now()) {
+    const sample = recentRuns
+        .slice(0, UNLEASHED_DOWNGRADE_SAMPLE_SIZE)
+        .filter(r => r.status === 'ok' || r.status === 'error');
+    if (sample.length < UNLEASHED_DOWNGRADE_MIN_HISTORY) {
+        return { downgrade: false, reason: 'insufficient_history' };
+    }
+    // Refuse to downgrade if any recent run hit a context-window failure —
+    // the unleashed multi-phase wrapper might be the only thing keeping
+    // this job from thrashing on a single huge SDK query. Pair this guard
+    // with the existing fanout-policy directive (1.18.35) so by the next
+    // few runs the agent has learned to fan out and the wrapper can be
+    // shed safely.
+    const cutoff = now - RECENT_CONTEXT_FAILURE_WINDOW_MS;
+    const hadOverflow = sample.some(r => {
+        const startedMs = Date.parse(r.startedAt);
+        if (!Number.isFinite(startedMs) || startedMs < cutoff)
+            return false;
+        return r.terminalReason === 'rapid_refill_breaker'
+            || r.terminalReason === 'prompt_too_long';
+    });
+    if (hadOverflow) {
+        return { downgrade: false, reason: 'recent_context_overflow_protect_unleashed' };
+    }
+    // Quiet pattern: most recent runs returned __NOTHING__ or a short
+    // output. These jobs don't need multi-phase orchestration.
+    const quietCount = sample.filter(r => {
+        const preview = (r.outputPreview ?? '').trim();
+        if (!preview)
+            return false;
+        if (/__nothing__/i.test(preview))
+            return true;
+        return preview.length < UNLEASHED_DOWNGRADE_QUIET_PREVIEW_CHARS;
+    }).length;
+    const quietRatio = quietCount / sample.length;
+    if (quietRatio >= UNLEASHED_DOWNGRADE_QUIET_RATIO) {
+        return {
+            downgrade: true,
+            reason: `quiet_pattern_${Math.round(quietRatio * 100)}pct`,
+            quietRatio,
+        };
+    }
+    // Fast-completion pattern: every run finishes well under the standard
+    // cron timeout, average is short. Multi-phase wrapper is overhead.
+    const durations = sample.map(r => r.durationMs || 0).filter(d => d > 0);
+    if (durations.length === sample.length) {
+        const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+        const allFast = durations.every(d => d < UNLEASHED_DOWNGRADE_MAX_DURATION_MS);
+        if (allFast && avgDuration < UNLEASHED_DOWNGRADE_AVG_DURATION_MS) {
+            return {
+                downgrade: true,
+                reason: `fast_completion_avg_${Math.round(avgDuration / 1000)}s`,
+                avgDurationMs: Math.round(avgDuration),
+            };
+        }
+    }
+    return { downgrade: false, reason: 'workload_warrants_unleashed' };
+}
 function classifyRisk(args) {
     const { inputTokens, projectedTokens, signalCount, recentContextIssue, job, oneMillionAvailable } = args;
     if (inputTokens >= 185_000)

package/package.json

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