clementine-agent 1.0.68 → 1.0.70

package/dist/agent/assistant.d.ts

@@ -40,6 +40,21 @@ export declare function getLinkedProjects(): ProjectMeta[];
 export declare function addProject(projectPath: string, description?: string, keywords?: string[]): void;
 /** Remove a project from the linked projects list. Returns true if removed. */
 export declare function removeProject(projectPath: string): boolean;
+export interface ProactiveGoalInput {
+    goal: {
+        title: string;
+        priority?: string;
+        owner?: string;
+        nextActions?: string[];
+    };
+}
+/**
+ * Build the compact "active goals" block that gets injected when no goal
+ * keyword matches the user's prompt. Pure so it can be tested without the
+ * full Assistant/vault setup.
+ */
+export declare function buildActiveGoalsBlock(goals: ProactiveGoalInput[], agentSlug?: string | null, maxEntries?: number): string;
+export declare function chunkReferencedInResponse(chunkContent: string, responseLower: string): boolean;
 export declare class PersonalAssistant {
     static readonly MAX_SESSION_EXCHANGES = 40;
     private sessions;
@@ -69,6 +84,14 @@ export declare class PersonalAssistant {
     private _compactedSessions;
     /** Last auto-matched project per session — exposed for CLI display. */
     private _lastMatchedProject;
+    /**
+     * Chunks retrieved on the most recent turn per session, kept so the
+     * post-response outcome scorer can check which actually got referenced.
+     * Cleared after each scoring pass.
+     */
+    private _lastRetrievedChunks;
+    /** Lazy-built SessionStore adapter that mirrors SDK transcripts to SQLite. */
+    private _sessionStore;
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
     private hotCorrections;
     constructor();
@@ -91,6 +114,12 @@ export declare class PersonalAssistant {
     /** Inject a background work result into the session so the next chat naturally references it. */
     injectPendingContext(sessionKey: string, userPrompt: string, result: string): void;
     private initMemoryStore;
+    /**
+     * Return the cached SessionStore adapter. Null until initMemoryStore
+     * completes, in which case the SDK falls back to local-only sessions —
+     * no crash on cold boot.
+     */
+    private getSessionStore;
     /**
      * Seed the in-memory hotCorrections ring buffer from persisted behavioral
      * patterns (corrections that recurred across ≥2 sessions in the last 30d).
@@ -123,6 +152,13 @@ export declare class PersonalAssistant {
      * or empty string if no goals match.
      */
     private matchGoals;
+    /**
+     * Compact always-on block of active goals. Used when no keyword match
+     * fires so the agent still sees what it's supposed to be working on.
+     * Scoped: for agent sessions, includes that agent's goals plus any
+     * clementine-owned goals it might contribute to.
+     */
+    private formatActiveGoalsBlock;
     chat(text: string, sessionKey?: string | null, options?: {
         onText?: OnTextCallback;
         onToolActivity?: OnToolActivityCallback;
@@ -134,6 +170,12 @@ export declare class PersonalAssistant {
         verboseLevel?: VerboseLevel;
         abortController?: AbortController;
     }): Promise<[string, string]>;
+    /**
+     * Compare retrieved chunks against the response text and record which
+     * were referenced. Uses a distinctive-token overlap heuristic — cheap,
+     * deterministic, no extra LLM calls. Called right after a turn completes.
+     */
+    private scoreRetrievalOutcomes;
     private static readonly RATE_LIMIT_MAX_RETRIES;
     private static readonly RATE_LIMIT_BACKOFF;
     private runQuery;

package/dist/agent/assistant.js

@@ -11,9 +11,9 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { query as rawQuery, listSubagents, getSubagentMessages, } from '@anthropic-ai/claude-agent-sdk';
+import { query as rawQuery, listSubagents, getSubagentMessages, SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, PROFILES_DIR, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
+import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, PROFILES_DIR, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, TASK_BUDGET_TOKENS, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
 import { DEFAULT_CHANNEL_CAPABILITIES } from '../types.js';
 import { enforceToolPermissions, getSecurityPrompt, getHeartbeatSecurityPrompt, getCronSecurityPrompt, getHeartbeatDisallowedTools, logToolUse, setProfileTier, setProfileAllowedTools, setAgentDir, setSendPolicy, setInteractionSource, logAuditJsonl, } from './hooks.js';
 import { scanner } from '../security/scanner.js';
@@ -242,6 +242,9 @@ const query = ((args) => {
             if (typeof opts.systemPrompt === 'string') {
                 newOpts.systemPrompt = stripLoneSurrogates(opts.systemPrompt);
             }
+            else if (Array.isArray(opts.systemPrompt)) {
+                newOpts.systemPrompt = opts.systemPrompt.map((s) => typeof s === 'string' ? stripLoneSurrogates(s) : s);
+            }
             if (typeof opts.appendSystemPrompt === 'string') {
                 newOpts.appendSystemPrompt = stripLoneSurrogates(opts.appendSystemPrompt);
             }
@@ -636,6 +639,72 @@ export function removeProject(projectPath) {
     _projectsMetaCacheTime = 0; // invalidate cache
     return true;
 }
+// ── Retrieval Outcome Heuristic ─────────────────────────────────────
+/**
+ * Decide whether a retrieved memory chunk shows up in the assistant's
+ * response. We key on distinctive tokens (multi-letter capitalized words,
+ * numbers of 2+ digits) that are unlikely to appear in the response unless
+ * the chunk's content actually influenced what was said.
+ *
+ * Intentionally a cheap local heuristic — no LLM call. False positives are
+ * tolerable since the outcome score is bounded and averaged over many
+ * observations.
+ */
+const OUTCOME_STOPWORDS = new Set([
+    'there', 'these', 'those', 'their', 'where', 'which', 'while',
+    'would', 'could', 'should', 'about', 'being', 'after', 'before',
+    'again', 'against', 'because',
+]);
+/**
+ * Build the compact "active goals" block that gets injected when no goal
+ * keyword matches the user's prompt. Pure so it can be tested without the
+ * full Assistant/vault setup.
+ */
+export function buildActiveGoalsBlock(goals, agentSlug, maxEntries = 6) {
+    if (goals.length === 0)
+        return '';
+    const filtered = goals.filter(({ goal }) => {
+        if (!agentSlug)
+            return true;
+        return goal.owner === agentSlug || goal.owner === 'clementine';
+    });
+    if (filtered.length === 0)
+        return '';
+    const rank = { high: 0, medium: 1, low: 2 };
+    const sorted = [...filtered].sort((a, b) => {
+        const ra = rank[a.goal.priority ?? 'medium'] ?? 1;
+        const rb = rank[b.goal.priority ?? 'medium'] ?? 1;
+        return ra - rb;
+    });
+    const top = sorted.slice(0, maxEntries);
+    const lines = top.map(({ goal }) => {
+        const next = goal.nextActions?.[0];
+        const nextBit = next ? ` → ${String(next).slice(0, 80)}` : '';
+        return `- [${goal.priority ?? 'medium'}] ${goal.title}${nextBit}`;
+    });
+    return `\n\n## Active Goals (background context)\n${lines.join('\n')}\n`;
+}
+export function chunkReferencedInResponse(chunkContent, responseLower) {
+    if (!chunkContent || !responseLower)
+        return false;
+    const distinctive = new Set();
+    const capMatches = chunkContent.match(/\b[A-Z][a-zA-Z]{3,}\b/g) ?? [];
+    for (const m of capMatches) {
+        const lower = m.toLowerCase();
+        if (!OUTCOME_STOPWORDS.has(lower))
+            distinctive.add(lower);
+    }
+    const numMatches = chunkContent.match(/\b\d{2,}\b/g) ?? [];
+    for (const m of numMatches)
+        distinctive.add(m);
+    if (distinctive.size === 0)
+        return false;
+    for (const tok of distinctive) {
+        if (responseLower.includes(tok))
+            return true;
+    }
+    return false;
+}
 // ── PersonalAssistant ───────────────────────────────────────────────
 export class PersonalAssistant {
     static MAX_SESSION_EXCHANGES = MAX_SESSION_EXCHANGES;
@@ -666,6 +735,14 @@ export class PersonalAssistant {
     _compactedSessions = new Set();
     /** Last auto-matched project per session — exposed for CLI display. */
     _lastMatchedProject = new Map();
+    /**
+     * Chunks retrieved on the most recent turn per session, kept so the
+     * post-response outcome scorer can check which actually got referenced.
+     * Cleared after each scoring pass.
+     */
+    _lastRetrievedChunks = new Map();
+    /** Lazy-built SessionStore adapter that mirrors SDK transcripts to SQLite. */
+    _sessionStore = null;
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
     hotCorrections = [];
     constructor() {
@@ -816,11 +893,27 @@ export class PersonalAssistant {
             this.memoryStore = new MemoryStore(MEMORY_DB_PATH, VAULT_DIR);
             this.memoryStore.initialize();
             this.primeHotCorrections();
+            // Build the SDK SessionStore adapter now that the store is live.
+            try {
+                const { createMemorySessionStore } = await import('./session-store-adapter.js');
+                this._sessionStore = createMemorySessionStore(this.memoryStore);
+            }
+            catch (err) {
+                logger.warn({ err }, 'SessionStore adapter init failed — SDK will use local-only sessions');
+            }
         }
         catch (err) {
             logger.warn({ err }, 'Memory store init failed — falling back to static prompts');
         }
     }
+    /**
+     * Return the cached SessionStore adapter. Null until initMemoryStore
+     * completes, in which case the SDK falls back to local-only sessions —
+     * no crash on cold boot.
+     */
+    getSessionStore() {
+        return this._sessionStore;
+    }
     /**
      * Seed the in-memory hotCorrections ring buffer from persisted behavioral
      * patterns (corrections that recurred across ≥2 sessions in the last 30d).
@@ -1637,22 +1730,29 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // Capture source at build time so concurrent queries don't race on the global
         const capturedSource = sourceOverride;
         // Build combined system prompt (custom + security rules).
-        // Split is kept intentional: the stable prefix (SOUL/AGENTS/personality/
-        // skills) is deterministic per-session; the volatile suffix (integration
-        // status, current date/time) changes per-turn. Putting volatile content
-        // STRICTLY at the end gives Claude Code's internal prompt cache the best
-        // chance at reusing the stable prefix across turns. The SDK's public
-        // systemPrompt option only accepts a string, not the Messages-API content
-        // array with explicit cache_control, so we rely on the SDK to do the
-        // right thing with the layout it receives.
+        // Stable prefix (SOUL/AGENTS/personality/skills + security rules) is
+        // deterministic per-session and cacheable across turns; the volatile
+        // suffix (retrieved memory, active goals, current date/time, integration
+        // status) changes per-turn and must NOT be in the cached prefix.
+        //
+        // The SDK's string[] systemPrompt with SYSTEM_PROMPT_DYNAMIC_BOUNDARY
+        // (added in @anthropic-ai/claude-agent-sdk 0.2.119) tells the prompt
+        // cache exactly where the boundary is, so cross-turn cache hits work
+        // even when our per-turn goals/memory block changes.
         const { stable, volatile: volatilePromptPart } = this.buildSystemPrompt({
             isHeartbeat, cronTier: isPlanStep ? null : cronTier, retrievalContext, profile, sessionKey, model, verboseLevel, intentClassification,
         });
-        const fullSystemPrompt = [
-            stable,
-            securityPrompt,
-            volatilePromptPart,
-        ].filter(s => s && s.trim().length > 0).join('\n\n');
+        const stablePrefixParts = [stable, securityPrompt]
+            .filter(s => s && s.trim().length > 0);
+        const volatileSuffix = volatilePromptPart && volatilePromptPart.trim().length > 0
+            ? volatilePromptPart
+            : '';
+        // 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.
+        const fullSystemPrompt = volatileSuffix
+            ? [...stablePrefixParts, SYSTEM_PROMPT_DYNAMIC_BOUNDARY, volatileSuffix]
+            : stablePrefixParts.join('\n\n');
         // ── Compute effort level ──────────────────────────────────────
         const computedEffort = effort ?? (isHeartbeat && !isCron ? 'low'
             : isCron && (cronTier ?? 0) < 2 ? 'low'
@@ -1669,10 +1769,31 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 : isCron ? BUDGET.cronT2
                     : BUDGET.chat);
         void computedBudget; // reserved for future cost telemetry — not enforced
+        // ── Task budget (tokens) ──────────────────────────────────────
+        // Soft brake — the SDK tells the model its remaining token budget so it
+        // paces tool use. Prevents runaway loops in autonomous contexts without
+        // killing long, legitimate work. Interactive chat stays uncapped.
+        const computedTaskBudget = isPlanStep
+            ? TASK_BUDGET_TOKENS.planStep
+            : isUnleashed
+                ? TASK_BUDGET_TOKENS.unleashedPhase
+                : isCron && (cronTier ?? 0) < 2
+                    ? TASK_BUDGET_TOKENS.cronT1
+                    : isCron
+                        ? TASK_BUDGET_TOKENS.cronT2
+                        : isHeartbeat
+                            ? TASK_BUDGET_TOKENS.heartbeat
+                            : TASK_BUDGET_TOKENS.chat;
         // ── Compute adaptive thinking ─────────────────────────────────
         const supportsThinking = !resolvedModel.includes('haiku');
         const needsThinking = !isHeartbeat && (isPlanStep || isUnleashed || !isCron);
         const computedThinking = thinking ?? (supportsThinking && needsThinking ? { type: 'adaptive' } : undefined);
+        // Haiku rejects user-configurable task budgets with a 400 ("This model
+        // does not support user-configurable task budgets"). Only pass
+        // taskBudget to models that accept it — otherwise every Haiku cron
+        // run dies on arrival and (historically) got mis-classified as a
+        // permanent "budget exceeded" failure.
+        const supportsTaskBudget = !resolvedModel.includes('haiku');
         // 1M context beta: enable for Sonnet when toggled and context-heavy work benefits
         const isSonnet = resolvedModel.includes('sonnet');
         const computedBetas = ENABLE_1M_CONTEXT && isSonnet
@@ -1691,12 +1812,17 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // Permission mode: always 'bypassPermissions' — this is a daemon/harness with no interactive
         // terminal, so 'auto' mode (which requires plan support + human approval) doesn't apply.
         const effectivePermissionMode = 'bypassPermissions';
+        // SessionStore adapter: mirror SDK transcripts into our SQLite store.
+        // Resume then works from the durable store, not just local JSONL.
+        const sessionStore = this.getSessionStore();
         return {
             systemPrompt: fullSystemPrompt,
             model: resolvedModel,
             ...(fallback ? { fallbackModel: fallback } : {}),
             permissionMode: effectivePermissionMode,
             allowDangerouslySkipPermissions: true,
+            ...(sessionStore ? { sessionStore } : {}),
+            ...(computedTaskBudget && supportsTaskBudget ? { taskBudget: { total: computedTaskBudget } } : {}),
             // SDK field semantics (per node_modules/@anthropic-ai/claude-agent-sdk/sdk.d.ts):
             //   - `tools`        → which built-in tools the model can see (Read, Bash, Task, …)
             //   - `mcpServers`   → MCP servers to spawn; all their declared tools are exposed automatically
@@ -1802,6 +1928,17 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         // Non-fatal
                     }
                 }
+                // Stash chunks for post-response outcome scoring. Only populate if
+                // we have a sessionKey to key against — chunks with no session can't
+                // be attributed to a response.
+                if (sessionKey) {
+                    const stash = results
+                        .filter((r) => typeof r.chunkId === 'number' && r.chunkId !== 0 && typeof r.content === 'string')
+                        .map((r) => ({ id: r.chunkId, content: r.content }));
+                    if (stash.length > 0) {
+                        this._lastRetrievedChunks.set(sessionKey, stash);
+                    }
+                }
             }
             // Resolve skill + graph context in parallel (independent of each other)
             const [skillContext, graphContext] = await Promise.all([
@@ -1949,6 +2086,20 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             return '';
         }
     }
+    /**
+     * Compact always-on block of active goals. Used when no keyword match
+     * fires so the agent still sees what it's supposed to be working on.
+     * Scoped: for agent sessions, includes that agent's goals plus any
+     * clementine-owned goals it might contribute to.
+     */
+    formatActiveGoalsBlock(agentSlug) {
+        try {
+            return buildActiveGoalsBlock(this.loadGoalsFromCache(), agentSlug);
+        }
+        catch {
+            return '';
+        }
+    }
     // ── Chat ──────────────────────────────────────────────────────────
     async chat(text, sessionKey, options) {
         const onText = options?.onText;
@@ -2182,8 +2333,38 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             this.worthExtracting(text, responseText)) {
             this.spawnMemoryExtraction(text, responseText, key, profile).catch(err => logger.debug({ err }, 'Memory extraction failed'));
         }
+        // Score outcome-driven salience: for the chunks we retrieved this turn,
+        // check which actually showed up in the response and adjust their
+        // `last_outcome_score`. Fire-and-forget; failure is non-fatal.
+        if (key && responseText && !isApiError) {
+            this.scoreRetrievalOutcomes(key, responseText);
+        }
         return [responseText, sessionId];
     }
+    /**
+     * Compare retrieved chunks against the response text and record which
+     * were referenced. Uses a distinctive-token overlap heuristic — cheap,
+     * deterministic, no extra LLM calls. Called right after a turn completes.
+     */
+    scoreRetrievalOutcomes(sessionKey, responseText) {
+        const stash = this._lastRetrievedChunks.get(sessionKey);
+        if (!stash || stash.length === 0)
+            return;
+        this._lastRetrievedChunks.delete(sessionKey);
+        if (!this.memoryStore || typeof this.memoryStore.recordOutcome !== 'function')
+            return;
+        try {
+            const responseLower = responseText.toLowerCase();
+            const outcomes = stash.map(({ id, content }) => {
+                const referenced = chunkReferencedInResponse(content, responseLower);
+                return { chunkId: id, referenced };
+            });
+            this.memoryStore.recordOutcome(outcomes, sessionKey);
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'Outcome scoring failed');
+        }
+    }
     // ── Run Query ─────────────────────────────────────────────────────
     static RATE_LIMIT_MAX_RETRIES = 3;
     static RATE_LIMIT_BACKOFF = [5000, 15000, 30000];
@@ -2237,11 +2418,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             const projDesc = matchedProject.description ? ` — ${matchedProject.description}` : '';
             retrievalContext = `## Active Project: ${projName}${projDesc}\n\nYou are operating in the context of the **${projName}** project at \`${matchedProject.path}\`. You have access to this project's tools, MCP servers, and configuration.\n\n${retrievalContext}`;
         }
-        // Inject matching goal context so the agent is goal-aware without tool calls
+        // Inject matching goal context so the agent is goal-aware without tool calls.
+        // If no keyword match, fall back to a compact always-on block so active
+        // goals stay in context even when the user message doesn't mention them —
+        // this is what keeps multi-session work coherent across tangential turns.
         const goalContext = this.matchGoals(prompt);
         if (goalContext) {
             retrievalContext += goalContext;
         }
+        else {
+            const proactive = this.formatActiveGoalsBlock(profile?.slug);
+            if (proactive)
+                retrievalContext += proactive;
+        }
         // Timeout: abort the query after timeoutMs to prevent hour-long stalls.
         // Works with or without an existing abortController from the gateway.
         let timeoutHandle;
@@ -2269,8 +2458,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 if (sessionKey && this.sessions.has(sessionKey)) {
                     sdkOptions.resume = this.sessions.get(sessionKey);
                 }
-                // Context window guard: estimate token usage and bail if too tight
-                const systemPromptText = typeof sdkOptions.systemPrompt === 'string' ? sdkOptions.systemPrompt : '';
+                // Context window guard: estimate token usage and bail if too tight.
+                // systemPrompt may be a plain string or a string[] with a boundary
+                // sentinel — sum across the array elements so the estimate is honest.
+                const sp = sdkOptions.systemPrompt;
+                const systemPromptText = typeof sp === 'string'
+                    ? sp
+                    : Array.isArray(sp)
+                        ? sp.filter((s) => typeof s === 'string' && s !== SYSTEM_PROMPT_DYNAMIC_BOUNDARY).join('\n\n')
+                        : '';
                 const systemPromptTokens = estimateTokens(systemPromptText);
                 const promptTokens = estimateTokens(prompt);
                 const totalEstimate = systemPromptTokens + promptTokens;
@@ -2404,7 +2600,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                 const errorText = 'errors' in result ? result.errors.join('; ') : ('result' in result ? result.result : '');
                                 if (errorText) {
                                     const lower = errorText.toLowerCase();
-                                    if (lower.includes('max_budget_usd') || lower.includes('budget')) {
+                                    // Strict match — only fire on the actual dollar-budget
+                                    // marker. The bare word "budget" was matching Anthropic's
+                                    // unrelated "does not support user-configurable task
+                                    // budgets" 400, which killed Haiku chats.
+                                    if (lower.includes('max_budget_usd')) {
                                         logger.warn({ sessionKey }, 'Chat query hit budget cap');
                                         responseText = responseText || (`I hit the $${BUDGET.chat.toFixed(2)} cost cap for this query. Options:\n` +
                                             `• Break it into smaller requests\n` +
@@ -3050,7 +3250,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     cwd: BASE_DIR,
                     env: SAFE_ENV,
                     effort: 'low',
-                    maxBudgetUsd: BUDGET.summarization,
+                    // Budgets are opt-in. If BUDGET.summarization is undefined we
+                    // must NOT include the key — some SDK codepaths treat a present
+                    // undefined as a budget=0 cap.
+                    ...(BUDGET.summarization ? { maxBudgetUsd: BUDGET.summarization } : {}),
                 },
             });
             for await (const message of stream) {
@@ -3368,7 +3571,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     cwd: BASE_DIR,
                     env: SAFE_ENV,
                     effort: 'low',
-                    maxBudgetUsd: BUDGET.memoryExtraction,
+                    ...(BUDGET.memoryExtraction ? { maxBudgetUsd: BUDGET.memoryExtraction } : {}),
                 },
             });
             const collectedText = [];
@@ -3812,11 +4015,16 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         const result = message;
                         // Capture terminal reason for execution advisor
                         this._lastTerminalReason = result.terminal_reason ?? undefined;
-                        // Detect budget exceeded — treat as permanent error so cron doesn't retry
+                        // Detect ACTUAL dollar-budget cap — treat as permanent so cron
+                        // doesn't retry when we've intentionally capped spend. Use a
+                        // strict marker ("max_budget_usd") because the bare word
+                        // "budget" was catching Anthropic's unrelated "does not support
+                        // user-configurable task budgets" error and pinning perfectly
+                        // healthy Haiku jobs as permanent failures.
                         if (result.is_error && 'result' in result) {
                             const exitText = String(result.result ?? '');
-                            if (exitText.includes('max_budget_usd') || exitText.includes('budget')) {
-                                logger.warn({ job: jobName }, 'Cron job hit budget cap — treating as permanent error');
+                            if (exitText.includes('max_budget_usd')) {
+                                logger.warn({ job: jobName }, 'Cron job hit dollar budget cap — treating as permanent error');
                                 throw new Error(`Budget exceeded for cron job '${jobName}'`);
                             }
                         }
@@ -3919,7 +4127,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     cwd: BASE_DIR,
                     env: SAFE_ENV,
                     effort: 'low',
-                    maxBudgetUsd: BUDGET.reflection,
+                    ...(BUDGET.reflection ? { maxBudgetUsd: BUDGET.reflection } : {}),
                     outputFormat: {
                         type: 'json_schema',
                         schema: {
@@ -4065,7 +4273,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 model: model ?? null,
                 enableTeams: true,
                 isUnleashed: true,
-                maxBudgetUsd: BUDGET.unleashedPhase,
+                // buildOptions intentionally drops this before reaching the SDK
+                // (line ~2100 comment). Passing it here only matters if someone
+                // later re-enables the SDK knob.
+                ...(BUDGET.unleashedPhase ? { maxBudgetUsd: BUDGET.unleashedPhase } : {}),
                 stallGuard: phaseGuard,
                 profile: unleashedProfile,
             });
@@ -4255,11 +4466,12 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         // Capture terminal reason for execution advisor
                         this._lastTerminalReason = result.terminal_reason ?? undefined;
                         this.logQueryResult(result, 'unleashed', `unleashed:${jobName}`, jobName);
-                        // Detect budget exceeded
+                        // Detect dollar-budget exceeded (strict marker — see cron
+                        // handler above for the reasoning).
                         if (result.is_error && 'result' in result) {
                             const exitText = String(result.result ?? '');
-                            if (exitText.includes('max_budget_usd') || exitText.includes('budget')) {
-                                logger.warn({ job: jobName, phase }, 'Unleashed phase hit budget cap');
+                            if (exitText.includes('max_budget_usd')) {
+                                logger.warn({ job: jobName, phase }, 'Unleashed phase hit dollar budget cap');
                                 appendProgress({ event: 'budget_exceeded', phase });
                             }
                         }

package/dist/agent/session-store-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SessionStore adapter: mirrors the Claude Agent SDK's JSONL session
+ * transcript into Clementine's SQLite memory store so resume works from
+ * the durable store instead of local files.
+ *
+ * Introduced after upgrading to @anthropic-ai/claude-agent-sdk 0.2.119.
+ * The SDK still writes to local disk first (durability is guaranteed
+ * before our adapter sees the batch); this adapter is the secondary
+ * copy and is the source of truth for long-term resume.
+ */
+import { type SessionStore } from '@anthropic-ai/claude-agent-sdk';
+import type { MemoryStoreType } from '../tools/shared.js';
+export declare function createMemorySessionStore(store: MemoryStoreType): SessionStore;
+//# sourceMappingURL=session-store-adapter.d.ts.map

package/dist/agent/session-store-adapter.js

@@ -0,0 +1,69 @@
+/**
+ * SessionStore adapter: mirrors the Claude Agent SDK's JSONL session
+ * transcript into Clementine's SQLite memory store so resume works from
+ * the durable store instead of local files.
+ *
+ * Introduced after upgrading to @anthropic-ai/claude-agent-sdk 0.2.119.
+ * The SDK still writes to local disk first (durability is guaranteed
+ * before our adapter sees the batch); this adapter is the secondary
+ * copy and is the source of truth for long-term resume.
+ */
+import { foldSessionSummary, } from '@anthropic-ai/claude-agent-sdk';
+function subkey(key) {
+    return key.subpath ?? '';
+}
+export function createMemorySessionStore(store) {
+    const s = store;
+    return {
+        async append(key, entries) {
+            if (entries.length === 0)
+                return;
+            const sub = subkey(key);
+            // Persist the raw entries first so load() is coherent even if the
+            // summary sidecar fold throws.
+            s.appendSessionEntries(key.sessionId, key.projectKey, sub, entries);
+            // Maintain the incrementally-folded summary for cheap listing.
+            try {
+                const existing = s
+                    .listSdkSessionSummaries(key.projectKey)
+                    .find(row => row.sessionId === key.sessionId && row.subpath === sub);
+                const prev = existing
+                    ? {
+                        sessionId: existing.sessionId,
+                        mtime: existing.mtime,
+                        data: existing.data,
+                    }
+                    : undefined;
+                const next = foldSessionSummary(prev, key, entries);
+                s.upsertSessionSummary(key.sessionId, sub, key.projectKey, Date.now(), next.data);
+            }
+            catch {
+                // Non-fatal — summary is a convenience, not a correctness concern.
+            }
+        },
+        async load(key) {
+            const rows = s.loadSessionEntries(key.sessionId, subkey(key));
+            if (rows === null)
+                return null;
+            return rows;
+        },
+        async listSessions(projectKey) {
+            return s.listSdkSessions(projectKey);
+        },
+        async listSessionSummaries(projectKey) {
+            return s
+                .listSdkSessionSummaries(projectKey)
+                .filter(r => r.subpath === '')
+                .map(r => ({ sessionId: r.sessionId, mtime: r.mtime, data: r.data }));
+        },
+        async delete(key) {
+            // SDK passes per-key deletes; we scope the delete to all subpaths
+            // under the session so a top-level delete wipes subagent trails too.
+            s.deleteSdkSession(key.sessionId);
+        },
+        async listSubkeys(key) {
+            return s.listSdkSessionSubkeys(key.sessionId);
+        },
+    };
+}
+//# sourceMappingURL=session-store-adapter.js.map

package/dist/brain/adapters/common.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Clementine — Adapter common helpers.
+ */
+/** Truncated SHA-256 content hash, hex, first 16 chars. */
+export declare function contentHash(text: string): string;
+/** Build a stable externalId fallback from (source-hint, index, content). */
+export declare function fallbackExternalId(hint: string, index: number, content: string): string;
+/** Detect whether a value looks like a stable identifier column. */
+export declare function looksLikeIdKey(key: string): boolean;
+/** Pick a likely id column from a record's keys (for structured adapters). */
+export declare function pickIdField(keys: string[]): string | null;
+//# sourceMappingURL=common.d.ts.map

package/dist/brain/adapters/common.js

@@ -0,0 +1,29 @@
+/**
+ * Clementine — Adapter common helpers.
+ */
+import { createHash } from 'node:crypto';
+/** Truncated SHA-256 content hash, hex, first 16 chars. */
+export function contentHash(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+/** Build a stable externalId fallback from (source-hint, index, content). */
+export function fallbackExternalId(hint, index, content) {
+    return `${hint}-${index}-${contentHash(content)}`;
+}
+/** Detect whether a value looks like a stable identifier column. */
+export function looksLikeIdKey(key) {
+    const lower = key.toLowerCase();
+    return (lower === 'id' ||
+        lower.endsWith('_id') ||
+        lower.endsWith('id') && lower.length <= 6 ||
+        lower === 'uuid' || lower === 'guid' || lower === 'uid' ||
+        lower === 'email' || lower === 'message_id' || lower === 'sfid');
+}
+/** Pick a likely id column from a record's keys (for structured adapters). */
+export function pickIdField(keys) {
+    for (const k of keys)
+        if (looksLikeIdKey(k))
+            return k;
+    return null;
+}
+//# sourceMappingURL=common.js.map

package/dist/brain/adapters/csv.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clementine — CSV adapter.
+ *
+ * Streams rows from a CSV file (comma- or tab-separated). Each row is a
+ * RawRecord with stringified JSON content so the downstream pipeline can
+ * template/distill it the same way as any other structured source.
+ */
+import type { RawRecord } from '../../types.js';
+export declare function parseCsv(filePath: string): AsyncIterable<RawRecord>;
+//# sourceMappingURL=csv.d.ts.map