clementine-agent 1.18.7 → 1.18.9

package/dist/agent/assistant.d.ts

@@ -251,8 +251,10 @@ export declare class PersonalAssistant {
     /** Fire-and-forget: extract a reusable skill from a successful execution. */
     private extractSkillFromExecution;
     private preRotationFlush;
-    private lastExtractionTime;
-    private worthExtracting;
+    private lastExtractionTimes;
+    private memoryExtractionKey;
+    private assessMemoryExtraction;
+    private logMemoryExtractionSkip;
     private spawnMemoryExtraction;
     private static readonly MEMORY_TOOL_NAMES;
     private extractMemory;

package/dist/agent/assistant.js

@@ -1998,8 +1998,27 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 : isHeartbeat
                     ? getHeartbeatSecurityPrompt()
                     : getSecurityPrompt();
-        // Fallback model: auto-fallback on rate limits (avoid self-referencing)
-        const resolvedModel = resolveModel(model) ?? MODEL;
+        // Model routing: keep default/profile/explicit model choices for normal
+        // work, but send no-tool/no-memory interactive fast-path turns to Haiku.
+        // This preserves Sonnet for memory/tool/task work while avoiding a 30s
+        // Sonnet round trip for "hey", "thanks", and simple acknowledgements.
+        const requestedModel = model ?? profile?.model ?? null;
+        const lightweightModelEligible = !requestedModel
+            && !isHeartbeat
+            && !isCron
+            && !isPlanStep
+            && !isUnleashed
+            && toolsDisabledForCall
+            && turnPolicy?.retrievalTier === 'none'
+            && turnPolicy.effort === 'low';
+        const resolvedModel = resolveModel(requestedModel) ?? (lightweightModelEligible ? MODELS.haiku : MODEL);
+        const modelRouteReason = model
+            ? 'explicit'
+            : profile?.model
+                ? 'profile'
+                : lightweightModelEligible
+                    ? 'lightweight-fast-path'
+                    : 'default';
         const fallback = resolvedModel !== MODELS.sonnet ? MODELS.sonnet : undefined;
         // Capture source at build time so concurrent queries don't race on the global
         const capturedSource = sourceOverride;
@@ -2037,7 +2056,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         const composioConnectedSlugs = Object.keys(composioMcpServers);
         const { stable, volatile: volatilePromptPart } = this.buildSystemPrompt({
-            isHeartbeat, cronTier: isPlanStep ? null : cronTier, retrievalContext, profile, sessionKey, model, verboseLevel, intentClassification,
+            isHeartbeat, cronTier: isPlanStep ? null : cronTier, retrievalContext, profile, sessionKey, model: resolvedModel, verboseLevel, intentClassification,
             contextTier: turnPolicy?.retrievalTier ?? (retrievalContext ? 'full' : 'core'),
             toolsAvailable: !toolsDisabledForCall,
             composioConnectedSlugs,
@@ -2207,6 +2226,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         const clementineToolAllowlistCount = clementineToolAllowlist === '*'
             ? CLEMENTINE_ALL_TOOL_NAMES.length
             : clementineToolAllowlist.split(',').filter(Boolean).length;
+        const loggedToolRoute = toolsDisabledForCall ? emptyToolRoute() : toolRoute;
         if (allowedTools.length > TOOL_SURFACE_WARN_THRESHOLD) {
             logger.warn({
                 sessionKey,
@@ -2218,16 +2238,20 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }, 'SDK allowed tool surface above warning threshold');
         }
         logger.info({
-            bundles: toolRoute.bundles,
-            fullSurface: toolRoute.fullSurface,
-            allExternalMcpServers: toolRoute.externalMcpServers === undefined,
-            allComposioToolkits: toolRoute.composioToolkits === undefined,
-            externalMcpServers: toolRoute.externalMcpServers,
-            composioToolkits: toolRoute.composioToolkits,
+            bundles: loggedToolRoute.bundles,
+            candidateBundles: toolsDisabledForCall && toolRoute.bundles.length > 0 ? toolRoute.bundles : undefined,
+            fullSurface: loggedToolRoute.fullSurface,
+            candidateFullSurface: toolsDisabledForCall && toolRoute.fullSurface ? true : undefined,
+            allExternalMcpServers: !toolsDisabledForCall && toolRoute.externalMcpServers === undefined,
+            allComposioToolkits: !toolsDisabledForCall && toolRoute.composioToolkits === undefined,
+            externalMcpServers: toolsDisabledForCall ? [] : toolRoute.externalMcpServers,
+            composioToolkits: toolsDisabledForCall ? [] : toolRoute.composioToolkits,
             mcpServerNames,
             allowedToolCount: toolsDisabledForCall ? 0 : allowedTools.length,
             clementineToolAllowlistCount: toolsDisabledForCall ? 0 : clementineToolAllowlistCount,
-            clementineToolAllowlistMode: clementineToolAllowlist === '*' ? 'all' : 'scoped',
+            clementineToolAllowlistMode: toolsDisabledForCall ? 'disabled' : clementineToolAllowlist === '*' ? 'all' : 'scoped',
+            model: resolvedModel,
+            modelRouteReason,
             toolsDisabledForCall,
             isolateClaudeConfig,
             inheritFullClaudeEnv: shouldInheritClaudeEnv,
@@ -2848,12 +2872,16 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 logger.warn({ err, sessionKey: key }, 'Transcript save failed');
             }
         }
-        // Fire background memory extraction (non-blocking)
-        if (text.length >= AUTO_MEMORY_MIN_LENGTH &&
-            responseText &&
-            !responseText.startsWith('Error:') &&
-            this.worthExtracting(text, responseText)) {
-            this.spawnMemoryExtraction(text, responseText, key, profile).catch(err => logger.debug({ err }, 'Memory extraction failed'));
+        // Fire background memory extraction (non-blocking). Skips are logged with
+        // structured reasons so memory gaps are diagnosable without reading chats.
+        if (responseText && !responseText.startsWith('Error:')) {
+            const extractionDecision = this.assessMemoryExtraction(text, responseText, key, profile);
+            if (extractionDecision.ok) {
+                this.spawnMemoryExtraction(text, responseText, key, profile).catch(err => logger.debug({ err }, 'Memory extraction failed'));
+            }
+            else {
+                this.logMemoryExtractionSkip(extractionDecision.reason, text, responseText, key, profile);
+            }
         }
         // Score outcome-driven salience: for the chunks we retrieved this turn,
         // check which actually showed up in the response and adjust their
@@ -3065,6 +3093,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         ? ((sdkOptions.allowedTools ?? [])
                             .filter(t => typeof t === 'string' && t.startsWith(`mcp__${TOOLS_SERVER}__`)).length)
                         : 0;
+                    const lightweightTraceEligible = !model
+                        && !profile?.model
+                        && sdkOptions.model === MODELS.haiku
+                        && effectiveTurnPolicy?.disableAllTools
+                        && rawContext.tier === 'none'
+                        && effectiveTurnPolicy.effort === 'low';
+                    const modelRouteReason = model
+                        ? 'explicit'
+                        : profile?.model
+                            ? 'profile'
+                            : lightweightTraceEligible
+                                ? 'lightweight-fast-path'
+                                : 'default';
                     const serverCount = sdkOptions.mcpServers ? Object.keys(sdkOptions.mcpServers).length : 0;
                     logAuditJsonl({
                         event_type: 'turn_trace',
@@ -3083,6 +3124,8 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         estimated_tokens: totalEstimate,
                         remaining_tokens: remainingTokens,
                         max_turns: sdkOptions.maxTurns,
+                        model: sdkOptions.model,
+                        model_route_reason: modelRouteReason,
                         effort: sdkOptions.effort,
                     });
                 }
@@ -4149,14 +4192,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         catch { /* non-fatal */ }
     }
     // ── Auto-Memory Extraction ────────────────────────────────────────
-    lastExtractionTime = 0;
-    worthExtracting(prompt, response) {
-        if (response.length < 100)
-            return false;
-        // Skip very short acknowledgment responses
-        if (response.length < 100)
-            return false;
-        // Only skip pure greetings with no substance at all
+    lastExtractionTimes = new Map();
+    memoryExtractionKey(sessionKey, profile) {
+        return `${profile?.slug ?? 'global'}:${sessionKey ?? 'no-session'}`;
+    }
+    assessMemoryExtraction(prompt, response, sessionKey, profile) {
+        if (!this.memoryStore)
+            return { ok: false, reason: 'no_memory_store' };
+        // Only skip pure greetings with no substance at all. Check this before
+        // length so "hey" is diagnosable as intent, not generic shortness.
         const pureGreetings = [
             'hello', 'hi', 'hey', 'thanks', 'thank you',
             'ok', 'okay', 'sure', 'got it', 'sounds good',
@@ -4164,20 +4208,54 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         ];
         const lower = prompt.toLowerCase().trim();
         if (pureGreetings.some((g) => lower === g || lower === g + '!' || lower === g + '.')) {
-            return false;
+            return { ok: false, reason: 'pure_greeting' };
+        }
+        if (prompt.length < AUTO_MEMORY_MIN_LENGTH || response.length < 100) {
+            return { ok: false, reason: 'too_short' };
         }
-        // Rate limit: max 1 extraction per 45 seconds per session
+        // Rate limit per session/agent. The old process-wide throttle meant one
+        // active chat could suppress memory extraction for unrelated agents.
         const now = Date.now();
-        if (now - this.lastExtractionTime < 45_000)
-            return false;
-        this.lastExtractionTime = now;
-        return true;
+        const key = this.memoryExtractionKey(sessionKey, profile);
+        const last = this.lastExtractionTimes.get(key) ?? 0;
+        if (now - last < 45_000)
+            return { ok: false, reason: 'rate_limited' };
+        this.lastExtractionTimes.set(key, now);
+        return { ok: true };
+    }
+    logMemoryExtractionSkip(reason, userMessage, assistantResponse, sessionKey, profile) {
+        logger.debug({
+            reason,
+            sessionKey,
+            agentSlug: profile?.slug,
+            promptChars: userMessage.length,
+            responseChars: assistantResponse.length,
+        }, 'Auto-memory extraction skipped');
+        if (!this.memoryStore)
+            return;
+        try {
+            this.memoryStore.logExtraction({
+                sessionKey: sessionKey ?? 'unknown',
+                userMessage: userMessage.slice(0, 500),
+                toolName: 'auto_memory_skip',
+                toolInput: JSON.stringify({
+                    reason,
+                    promptChars: userMessage.length,
+                    responseChars: assistantResponse.length,
+                }),
+                extractedAt: new Date().toISOString(),
+                status: `skipped:${reason}`,
+                agentSlug: profile?.slug,
+            });
+        }
+        catch { /* telemetry only */ }
     }
     async spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile) {
         // Guard: skip memory extraction if the user message looks like injection
         const memScan = scanner.scan(userMessage);
         if (memScan.verdict === 'block') {
             logger.info('Skipping memory extraction — message was flagged as injection');
+            this.logMemoryExtractionSkip('injection_blocked', userMessage, assistantResponse, sessionKey, profile);
             return;
         }
         let currentMemory = '';

package/dist/agent/self-improve.d.ts

@@ -10,6 +10,37 @@
  */
 import type { SelfImproveConfig, SelfImproveExperiment, SelfImproveState } from '../types.js';
 import type { PersonalAssistant } from './assistant.js';
+export declare const USER_MODEL_SLOT_KEYS: readonly ["user_facts", "goals", "relationships", "agent_persona"];
+export type UserModelSlotKey = typeof USER_MODEL_SLOT_KEYS[number];
+export interface SelfImproveEvidenceSnapshot {
+    feedbackCreatedAt?: string[];
+    reflectionCreatedAt?: string[];
+    cronErrorStartedAt?: string[];
+    cronReflectionAt?: string[];
+    triggerUpdatedAt?: string[];
+    triggerCount?: number;
+    userModelNeedsSeed?: boolean;
+}
+export declare function isPlateauExperiment(entry: Partial<SelfImproveExperiment>): boolean;
+export declare function latestPlateauTime(history: Array<Partial<SelfImproveExperiment>>): number;
+export declare function newestSelfImproveEvidenceTime(evidence: SelfImproveEvidenceSnapshot): number;
+export declare function shouldSkipSelfImproveForPlateau(history: Array<Partial<SelfImproveExperiment>>, evidence: SelfImproveEvidenceSnapshot): {
+    skip: boolean;
+    reason?: string;
+};
+export declare function shouldAppendPlateauMarker(history: Array<Partial<SelfImproveExperiment>>, nowMs?: number, windowMs?: number): boolean;
+export declare function reconcileSelfImproveStateSnapshot(state: SelfImproveState, actualPending: number, opts?: {
+    nowMs?: number;
+    maxDurationMs?: number;
+    graceMs?: number;
+}): {
+    state: SelfImproveState;
+    changed: boolean;
+    diagnostics: string[];
+};
+export declare function normalizeUserModelSlots(slots: unknown): Partial<Record<UserModelSlotKey, string>>;
+export declare function sanitizeUserModelFrontmatter(frontmatterYaml: string): string;
+export declare function buildUserModelMarkdown(frontmatterYaml: string, slots: Partial<Record<UserModelSlotKey, string>>, updatedAt?: string): string;
 export declare class SelfImproveLoop {
     private config;
     private assistant;
@@ -18,6 +49,9 @@ export declare class SelfImproveLoop {
     /** Run a focused self-improvement cycle for a specific agent. */
     runForAgent(agentSlug: string, onProposal?: (experiment: SelfImproveExperiment) => Promise<void>): Promise<SelfImproveState>;
     private gatherMetrics;
+    private evidenceSnapshot;
+    private pendingTriggerEvidence;
+    private userModelNeedsSeed;
     private hypothesize;
     private readCurrentState;
     private evaluate;