clementine-agent 1.18.37 → 1.18.39

package/dist/agent/assistant.js

@@ -417,7 +417,17 @@ const SESSIONS_FILE = path.join(BASE_DIR, '.sessions.json');
 const MAX_SESSION_EXCHANGES = 40;
 const SESSION_EXPIRY_MS = 24 * 60 * 60 * 1000;
 const AUTO_MEMORY_MIN_LENGTH = 80;
-const AUTO_MEMORY_MODEL = MODELS.sonnet;
+// Model used by the post-exchange memory extractor + the conversation
+// summarizer. Both are routine "read this exchange, extract facts, call
+// memory_write with structured JSON" tasks — Haiku handles them fine and
+// they fire on EVERY substantive exchange, so the multiplier matters.
+// Override with CLEMENTINE_AUTO_MEMORY_MODEL=sonnet if you observe
+// extraction quality drop.
+const AUTO_MEMORY_MODEL = process.env.CLEMENTINE_AUTO_MEMORY_MODEL?.includes('sonnet')
+    ? MODELS.sonnet
+    : process.env.CLEMENTINE_AUTO_MEMORY_MODEL?.includes('opus')
+        ? MODELS.opus
+        : MODELS.haiku;
 const OWNER = OWNER_NAME || 'the user';
 const MCP_SERVER_SCRIPT = path.join(PKG_DIR, 'dist', 'tools', 'mcp-server.js');
 const TOOLS_SERVER = `${ASSISTANT_NAME.toLowerCase()}-tools`;
@@ -4623,6 +4633,12 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     const blocks = getContentBlocks(message);
                     summaryText += extractText(blocks);
                 }
+                else if (message.type === 'result') {
+                    // Make session-summarization cost visible in usage_log. Without
+                    // this, every session rotation spawned a Sonnet summarize call
+                    // that didn't appear in any metric.
+                    this.logQueryResult(message, 'summarize', `summarize:${sessionKey}`);
+                }
             }
             if (summaryText.trim()) {
                 if (this.memoryStore) {
@@ -4993,6 +5009,13 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             });
             const collectedText = [];
             for await (const message of stream) {
+                if (message.type === 'result') {
+                    // Auto-memory extraction fires after every substantive
+                    // exchange. Before this log call, its cost was invisible in
+                    // usage_log — a per-user-message Sonnet pass running silently.
+                    this.logQueryResult(message, 'auto_memory', `auto-memory:${sessionKey ?? 'unknown'}`, undefined, profile?.slug);
+                    continue;
+                }
                 if (message.type === 'assistant') {
                     const blocks = getContentBlocks(message);
                     for (const block of blocks) {
@@ -5651,6 +5674,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     const blocks = getContentBlocks(message);
                     responseText += extractText(blocks);
                 }
+                else if (message.type === 'result') {
+                    // Cron reflection (post-task quality check) fires after every
+                    // cron run. Cheap (Haiku, 1 turn, ~1KB) but should be visible.
+                    this.logQueryResult(message, 'cron_reflection', `reflection:${jobName}`, jobName);
+                }
             }
             if (responseText.trim()) {
                 const reflection = JSON.parse(responseText.trim());

package/dist/agent/fanout-policy.d.ts

@@ -56,4 +56,23 @@ export declare function buildFanoutDirectiveForText(text: string): {
     directive: string;
     report: FanoutSignalReport;
 };
+export interface PreLlmPlanDecision {
+    shouldRouteToPlanner: boolean;
+    reason: string;
+    signals: FanoutSignal[];
+    actionVerbs: string[];
+}
+export interface PreLlmPlanOptions {
+    /** Result of intent classifier — routing skips followup/chat regardless of content. */
+    intentType?: 'task' | 'followup' | 'chat' | 'lookup' | string;
+    /** Pre-LLM minimum length. Short queries can't be plan-worthy. */
+    minLength?: number;
+    /** Conservative AND-threshold: require ≥N fanout signals AND ≥1 action verb. */
+    minFanoutSignals?: number;
+}
+/**
+ * Decide whether the user's text should bypass the main agent and run
+ * directly through the planner orchestrator. Conservative by design.
+ */
+export declare function detectPreLlmPlanIntent(text: string, opts?: PreLlmPlanOptions): PreLlmPlanDecision;
 //# sourceMappingURL=fanout-policy.d.ts.map

package/dist/agent/fanout-policy.js

@@ -130,4 +130,92 @@ export function buildFanoutDirectiveForText(text) {
         report,
     };
 }
+// ── Pre-LLM plan intent detection ─────────────────────────────────────
+//
+// detectFanoutSignals + the directive injection (above) are SOFT
+// enforcement: we tell the agent "fan out for this." If the agent
+// honors it, we win. If not, we still pay for a Sonnet turn that
+// thrashes.
+//
+// Pre-LLM plan intent detection is HARD enforcement: when a user's
+// query clearly maps to multi-step parallel work, route through the
+// orchestrator BEFORE the main agent ever runs. The orchestrator
+// decomposes into parallel Haiku/Sonnet sub-agents, each in its own
+// context. The user's main agent never sees the big tool responses
+// — it never gets a chance to thrash.
+//
+// Conservative gate: false positives waste a planner LLM call (~$0.05)
+// + sub-agent calls. False negatives mean the existing soft-enforcement
+// path runs, which is the status quo. So we tune for false positives.
+const INFORMATIONAL_QUERY_PATTERN = /^\s*(what|tell\s+me|show\s+me|is\s|are\s|do\s+you|how\s+(does|is|do)|why\s|when\s|where\s|who\s|did\s|have\s+you|can\s+you\s+(see|tell|show|describe|explain)|describe|explain|summarize)\b/i;
+const ACTION_VERB_PATTERNS = [
+    {
+        // "research my top 10 prospects", "draft each prospect", "process all leads"
+        pattern: /\b(research|analyze|process|review|draft|write|send|email|message|outreach)\s+(each|all|every|those|these|my|our|the\s+\w+|\d+|\w+\s+(of\s+)?(my|our|the)\s+\w+)/i,
+        reason: 'multi-target action verb (research/analyze/draft/etc. on a collection)',
+    },
+    {
+        // "for each prospect, draft a follow-up"
+        pattern: /\bfor\s+(each|every|all)\b.*\b(do|run|send|draft|process|email|call|review|analyze|build|create|fetch)/i,
+        reason: '"for each X, do Y" pattern',
+    },
+    {
+        // "build a comprehensive content intelligence brief" — allow up to 4
+        // words between the verb and the deliverable noun.
+        pattern: /\b(build|prepare|produce|run|generate)\s+(a\s+|an\s+)?(\w+\s+){0,4}(brief|report|summary|analysis|comparison|recap|breakdown|dashboard|deck|index|list)\b/i,
+        reason: 'compound deliverable (brief/report/analysis)',
+    },
+    {
+        pattern: /\b(go\s+through|walk\s+through|process)\s+(every|all|each|my|the)\s+\w+/i,
+        reason: '"go through everyone/everything" pattern',
+    },
+];
+/**
+ * Decide whether the user's text should bypass the main agent and run
+ * directly through the planner orchestrator. Conservative by design.
+ */
+export function detectPreLlmPlanIntent(text, opts = {}) {
+    const minLength = opts.minLength ?? 40;
+    const minFanoutSignals = opts.minFanoutSignals ?? 2;
+    const trimmed = (text ?? '').trim();
+    // Hard skips: intent says "not a task" → don't override.
+    if (opts.intentType === 'followup' || opts.intentType === 'chat') {
+        return { shouldRouteToPlanner: false, reason: `intent_is_${opts.intentType}`, signals: [], actionVerbs: [] };
+    }
+    if (trimmed.length < minLength) {
+        return { shouldRouteToPlanner: false, reason: 'too_short', signals: [], actionVerbs: [] };
+    }
+    // Information-seeking patterns: "what/tell me/show me/etc." Let the
+    // agent answer directly even if collective wording is present
+    // ("tell me about all my prospects" is a status request, not work).
+    if (INFORMATIONAL_QUERY_PATTERN.test(trimmed)) {
+        return { shouldRouteToPlanner: false, reason: 'informational_query', signals: [], actionVerbs: [] };
+    }
+    // Action-verb match: text must contain an explicit "do X for many" verb.
+    const matchedVerbs = [];
+    for (const { pattern, reason } of ACTION_VERB_PATTERNS) {
+        if (pattern.test(trimmed))
+            matchedVerbs.push(reason);
+    }
+    if (matchedVerbs.length === 0) {
+        return { shouldRouteToPlanner: false, reason: 'no_action_verb', signals: [], actionVerbs: [] };
+    }
+    // Fanout signals (existing detector — covers numeric counts,
+    // collective+quantifier patterns, "for each", comprehensive research, etc.).
+    const fanoutReport = detectFanoutSignals(trimmed);
+    if (fanoutReport.signals.length < minFanoutSignals) {
+        return {
+            shouldRouteToPlanner: false,
+            reason: `weak_fanout_signal_count_${fanoutReport.signals.length}_below_${minFanoutSignals}`,
+            signals: fanoutReport.signals,
+            actionVerbs: matchedVerbs,
+        };
+    }
+    return {
+        shouldRouteToPlanner: true,
+        reason: `fanout=${fanoutReport.signals.length}+verbs=${matchedVerbs.length}`,
+        signals: fanoutReport.signals,
+        actionVerbs: matchedVerbs,
+    };
+}
 //# sourceMappingURL=fanout-policy.js.map

package/dist/gateway/router.js

@@ -23,6 +23,7 @@ import { assessActionResponse, buildActionEnforcementPrompt, buildApprovalFollow
 import { updateClementineJson } from '../config/clementine-json.js';
 import { buildCronDiagnosticResponse } from './cron-diagnostic-turn.js';
 import { classifyIntent } from '../agent/intent-classifier.js';
+import { detectPreLlmPlanIntent } from '../agent/fanout-policy.js';
 import { decideTurn } from '../agent/turn-policy.js';
 import { recordProactiveNotificationEvent, } from './notification-context.js';
 import { isInternalSyntheticPrompt, resolveRecentOperationalContext } from './recent-context.js';
@@ -2087,6 +2088,60 @@ export class Gateway {
                     delete sessState.pendingInterrupt;
                 }
                 try {
+                    // ── Pre-LLM plan routing (Gap #3 from orchestration audit) ──
+                    // When the user's text clearly maps to multi-step parallel
+                    // work, route through the orchestrator BEFORE the main agent
+                    // runs. This is HARD enforcement — independent of whether
+                    // the agent self-detects via [PLAN_NEEDED:]. Saves a Sonnet
+                    // turn that would likely thrash, and the planner's parallel
+                    // sub-agents (Haiku-default) keep big tool responses out of
+                    // the user's main context.
+                    //
+                    // Conservative gate: requires explicit action verbs +
+                    // multiple fanout signals + non-informational intent. False
+                    // positives waste a planner LLM call (~$0.05); false
+                    // negatives let the existing soft-enforcement path run, which
+                    // is the status quo. Trusted personal sessions only — we
+                    // don't surprise random Discord users with auto-orchestration.
+                    if (this.isTrustedPersonalSession(sessionKey)
+                        && !sessState.pendingInterrupt /* don't override mid-thought continuations */) {
+                        const planIntentDecision = detectPreLlmPlanIntent(originalText, {
+                            intentType: classifyIntent(originalText)?.type,
+                        });
+                        if (planIntentDecision.shouldRouteToPlanner) {
+                            logger.info({
+                                sessionKey: effectiveSessionKey,
+                                reason: planIntentDecision.reason,
+                                signals: planIntentDecision.signals.map(s => s.pattern),
+                                actionVerbs: planIntentDecision.actionVerbs,
+                                originalTextPreview: originalText.slice(0, 200),
+                            }, 'Pre-LLM plan routing: bypassing main agent for orchestrator');
+                            if (wrappedOnText) {
+                                try {
+                                    await wrappedOnText('Detected a multi-step task — decomposing into parallel sub-agents…\n\n');
+                                }
+                                catch { /* streaming is best-effort */ }
+                            }
+                            try {
+                                const planResult = await this.handlePlan(effectiveSessionKey, originalText, undefined, // chat path doesn't need structured progress callbacks
+                                undefined);
+                                clearTimeout(chatTimer);
+                                clearTimeout(hardWallTimer);
+                                logger.info({
+                                    sessionKey: effectiveSessionKey,
+                                    totalMs: Date.now() - tInnerStart,
+                                    routedVia: 'pre_llm_planner',
+                                    responseLen: planResult.length,
+                                }, 'chat:latency');
+                                return planResult;
+                            }
+                            catch (err) {
+                                logger.warn({ err, sessionKey: effectiveSessionKey }, 'Pre-LLM plan routing failed — falling back to direct agent');
+                                // Fall through to the regular agent path so the user
+                                // still gets a response.
+                            }
+                        }
+                    }
                     // No artificial turn cap — let the agent work until done.
                     // Primary guardrail is cost budget (maxBudgetUsd in buildOptions).
                     // Wall clock (CHAT_MAX_WALL_MS) and StallGuard are safety nets.

package/package.json

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