clementine-agent 1.18.57 → 1.18.59

package/dist/agent/run-agent-cron.d.ts

@@ -25,6 +25,7 @@ import { type RunAgentResult } from './run-agent.js';
 export interface CronPostTaskHooks {
     triggerCronReflection: (jobName: string, jobPrompt: string, deliverable: string, successCriteria?: string[]) => Promise<void>;
     triggerSkillExtractionFromExecution: (source: 'unleashed' | 'cron' | 'chat', jobName: string, prompt: string, output: string, durationMs: number, agentSlug?: string) => Promise<void>;
+    triggerMemoryExtractionPostExchange: (userMessage: string, assistantResponse: string, sessionKey?: string, profile?: AgentProfile) => Promise<void>;
 }
 export interface RunAgentCronOptions {
     /** Job name from CRON.md. Used for telemetry, progress lookup, skill match. */

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

@@ -319,11 +319,13 @@ export async function runAgentCron(opts) {
             logger.debug({ err, job: opts.jobName }, 'runAgentCron: transcript mirror failed (non-fatal)');
         }
     }
-    // ── Post-task hooks: reflection + skill extraction ────────────────
-    // Both fire-and-forget — never block the cron deliverable on these.
-    // They are the same passes the legacy runCronJob fires; without them
-    // the new path would lose the success-grading + procedural-memory
-    // growth that makes Clementine self-improving.
+    // ── Post-task hooks: reflection + skill extraction + memory ──────
+    // All fire-and-forget — never block the cron deliverable on these.
+    // Reflection grades the run, skill extraction banks repeatable
+    // procedures, memory extraction distills facts the agent learned
+    // (e.g. "Mark Finizio is now the buyer at FamilyCenter") into the
+    // agent's MEMORY.md. The legacy runCronJob fired reflection +
+    // skill but never memory extraction; that gap is closed now.
     if (opts.postTaskHooks && deliverable && deliverable.trim() !== '__NOTHING__') {
         const durationMs = Date.now() - startedAt;
         opts.postTaskHooks
@@ -332,6 +334,9 @@ export async function runAgentCron(opts) {
         opts.postTaskHooks
             .triggerSkillExtractionFromExecution('cron', opts.jobName, opts.jobPrompt, deliverable, durationMs, agentSlug)
             .catch(err => logger.debug({ err, job: opts.jobName }, 'runAgentCron: skill extraction failed (non-fatal)'));
+        opts.postTaskHooks
+            .triggerMemoryExtractionPostExchange(opts.jobPrompt, deliverable, `cron:${opts.jobName}`, opts.profile ?? undefined)
+            .catch(err => logger.debug({ err, job: opts.jobName }, 'runAgentCron: memory extraction failed (non-fatal)'));
     }
     return {
         ...result,

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

@@ -81,17 +81,13 @@ export async function runAgentHeartbeat(opts) {
         allowedTools: [],
         abortSignal: opts.abortSignal,
     });
-    // Mirror the heartbeat into transcripts so dedup + recall work.
-    // Skip pure __NOTHING__ outputs since they carry no information.
-    const text = result.text?.trim() ?? '';
-    if (opts.memoryStore && text && text !== '__NOTHING__') {
-        try {
-            opts.memoryStore.saveTurn(sessionKey, 'heartbeat', text, opts.model ?? MODELS.haiku);
-        }
-        catch {
-            /* non-fatal */
-        }
-    }
+    // Heartbeat output is NOT mirrored to transcripts. Heartbeats fire
+    // up to 28x/day per agent and most output is low-value (status
+    // pings, dedup'd reminders). The heartbeat dedup that prior versions
+    // wanted recall for actually lives in the prompt itself (the
+    // dedupContext block + the __NOTHING__ sentinel), not in DB queries.
+    // Saving rows here just polluted FTS and the dashboard memory panel
+    // for no recall benefit.
     return result;
 }
 //# sourceMappingURL=run-agent-heartbeat.js.map

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

@@ -2,6 +2,14 @@ import type { AgentProfile } from '../types.js';
 import type { AgentManager } from './agent-manager.js';
 import type { MemoryStore } from '../memory/store.js';
 import { type RunAgentResult } from './run-agent.js';
+/** Minimal post-task hook interface. The PersonalAssistant implements
+ *  this directly; passing it through keeps the wrapper decoupled from
+ *  the full assistant graph. */
+export interface TeamTaskPostHooks {
+    triggerMemoryExtractionPostExchange: (userMessage: string, assistantResponse: string, sessionKey?: string, profile?: AgentProfile) => Promise<void>;
+    triggerSkillExtractionFromExecution: (source: 'unleashed' | 'cron' | 'chat', jobName: string, prompt: string, output: string, durationMs: number, agentSlug?: string) => Promise<void>;
+    triggerCronReflection: (jobName: string, jobPrompt: string, deliverable: string, successCriteria?: string[]) => Promise<void>;
+}
 export interface RunAgentTeamTaskOptions {
     fromName: string;
     fromSlug: string;
@@ -17,6 +25,9 @@ export interface RunAgentTeamTaskOptions {
     maxBudgetUsd?: number;
     /** Optional max-turns cap. Default: undefined (SDK runs until done, bounded by budget). */
     maxTurns?: number;
+    /** Post-task hooks (memory extraction). Pass the PersonalAssistant.
+     *  Optional so the helper still works in tests. */
+    postTaskHooks?: TeamTaskPostHooks | null;
 }
 export interface RunAgentTeamTaskResult extends RunAgentResult {
     builtPrompt: string;

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

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

package/dist/cli/dashboard.js

@@ -281,8 +281,48 @@ async function searchMemory(query, limit = 20, filters = {}) {
        WHERE ${where.join(' AND ')}
        ORDER BY ${orderBy}
        LIMIT ?`;
-        const rows = db.prepare(sql).all(...params, limit);
-        return { results: rows, dbExists: true };
+        const chunkRows = db.prepare(sql).all(...params, limit);
+        // Also surface transcripts from chat / cron / team-task. These
+        // are written by saveTurn and would otherwise be invisible to the
+        // main search panel (only the per-session viewer surfaced them).
+        // chunkType filter is chunk-only — if set, skip transcripts.
+        let transcriptRows = [];
+        if (words.length > 0 && !filters.chunkType && !filters.pinnedOnly) {
+            try {
+                const ftsQuery = words.map((w) => `"${w.replace(/"/g, '')}"`).join(' OR ');
+                const tWhere = ['transcripts_fts MATCH ?'];
+                const tParams = [ftsQuery];
+                if (filters.sinceDays && filters.sinceDays > 0) {
+                    tWhere.push("t.created_at >= datetime('now', ?)");
+                    tParams.push(`-${filters.sinceDays} days`);
+                }
+                const tSql = `SELECT t.id, t.session_key, t.role, t.content, t.model, t.created_at,
+                        bm25(transcripts_fts) as score
+                 FROM transcripts_fts f JOIN transcripts t ON t.id = f.rowid
+                 WHERE ${tWhere.join(' AND ')}
+                 ORDER BY bm25(transcripts_fts)
+                 LIMIT ?`;
+                transcriptRows = db.prepare(tSql).all(...tParams, Math.min(limit, 10))
+                    .map(r => ({
+                    id: `transcript:${r.id}`,
+                    source_file: `transcripts/${r.session_key}`,
+                    section: `${r.role} @ ${r.created_at}`,
+                    content: r.content,
+                    chunk_type: 'transcript',
+                    updated_at: r.created_at,
+                    salience: 0,
+                    pinned: 0,
+                    score: r.score,
+                }));
+            }
+            catch { /* transcripts FTS may be empty/unavailable — non-fatal */ }
+        }
+        // Merge: transcripts interleaved by score with chunks. FTS bm25
+        // is comparable across both since they use the same tokenizer.
+        const merged = [...chunkRows, ...transcriptRows]
+            .sort((a, b) => Number(a.score ?? 0) - Number(b.score ?? 0))
+            .slice(0, limit);
+        return { results: merged, dbExists: true };
     }
     catch (err) {
         return { results: [], dbExists: true, error: String(err) };

package/dist/gateway/episodic-consolidation.js

@@ -16,8 +16,9 @@
  */
 import { createHash } from 'node:crypto';
 import Anthropic from '@anthropic-ai/sdk';
+import { query } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { MODELS } from '../config.js';
+import { MODELS, BASE_DIR, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY } from '../config.js';
 import { fingerprintCommitment, parseRelativeDue, } from './commitments.js';
 const logger = pino({
     name: 'clementine.episodic-consolidation',
@@ -140,11 +141,65 @@ export function fingerprintLearnedFact(kind, text) {
 function getAnthropicClient(opts) {
     if (opts.anthropicClient)
         return opts.anthropicClient;
-    const apiKey = process.env.ANTHROPIC_API_KEY;
+    const apiKey = process.env.ANTHROPIC_API_KEY ?? ANTHROPIC_API_KEY;
     if (!apiKey)
         return null;
     return new Anthropic({ apiKey });
 }
+/**
+ * One-shot LLM call via the SDK's `query()`. OAuth-aware (uses
+ * CLAUDE_CODE_OAUTH_TOKEN when no API key is set), so works on
+ * installs that haven't configured ANTHROPIC_API_KEY. Returns the
+ * concatenated assistant text — empty string on failure.
+ *
+ * Used as a fallback when no Anthropic SDK client is available
+ * (i.e. the prior path returned null and the entire consolidation
+ * pass silently no-op'd).
+ */
+async function runConsolidationViaSdk(systemPrompt, userPrompt, model) {
+    const env = {
+        PATH: process.env.PATH ?? '',
+        HOME: process.env.HOME ?? '',
+        CLEMENTINE_HOME: BASE_DIR,
+    };
+    const oauth = CLAUDE_CODE_OAUTH_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    const apiKey = ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+    if (oauth)
+        env.CLAUDE_CODE_OAUTH_TOKEN = oauth;
+    else if (apiKey)
+        env.ANTHROPIC_API_KEY = apiKey;
+    let text = '';
+    try {
+        const stream = query({
+            prompt: userPrompt,
+            options: {
+                systemPrompt,
+                model,
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                allowedTools: [],
+                cwd: BASE_DIR,
+                env,
+                maxTurns: 1,
+                maxBudgetUsd: 0.10,
+            },
+        });
+        for await (const message of stream) {
+            if (message.type === 'assistant') {
+                const blocks = (message.message?.content ?? []);
+                for (const block of blocks) {
+                    if (block.type === 'text' && typeof block.text === 'string')
+                        text += block.text;
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'SDK consolidation call failed');
+        return '';
+    }
+    return text;
+}
 /**
  * Consolidate a single candidate session range. Returns the new episode id
  * + chunk id on success, or null on failure (the caller bumps the failure
@@ -155,10 +210,10 @@ export async function consolidateOneSession(store, candidate, opts = {}) {
     if (turns.length === 0)
         return null;
     const client = getAnthropicClient(opts);
-    if (!client) {
-        logger.debug({ sessionKey: candidate.sessionKey }, 'No Anthropic client available — skipping consolidation');
-        return null;
-    }
+    // No client means no API key. We still try via the SDK's query()
+    // which uses OAuth when available — that's the canonical path for
+    // installs that haven't configured ANTHROPIC_API_KEY. Tests that
+    // pass an explicit anthropicClient will still hit the direct path.
     // Pull a small snapshot of existing learned facts so the LLM can
     // detect contradictions and emit supersedes hints. Best-effort —
     // empty list is fine for first-ever consolidation.
@@ -169,18 +224,28 @@ export async function consolidateOneSession(store, candidate, opts = {}) {
         }
     }
     catch { /* fact snapshot is best-effort */ }
+    const userPrompt = buildUserPrompt(turns.map(t => ({ role: t.role, content: t.content, createdAt: t.createdAt })), existingFactsForPrompt);
+    const model = opts.model ?? MODELS.haiku;
     let extraction = null;
     try {
-        const response = await client.messages.create({
-            model: opts.model ?? MODELS.haiku,
-            max_tokens: 1500,
-            system: SYSTEM_PROMPT,
-            messages: [{
-                    role: 'user',
-                    content: buildUserPrompt(turns.map(t => ({ role: t.role, content: t.content, createdAt: t.createdAt })), existingFactsForPrompt),
-                }],
-        });
-        const text = (response.content ?? []).map((b) => b.type === 'text' ? (b.text ?? '') : '').join('');
+        let text = '';
+        if (client) {
+            const response = await client.messages.create({
+                model,
+                max_tokens: 1500,
+                system: SYSTEM_PROMPT,
+                messages: [{ role: 'user', content: userPrompt }],
+            });
+            text = (response.content ?? []).map((b) => b.type === 'text' ? (b.text ?? '') : '').join('');
+        }
+        else {
+            // No API client — fall through to the SDK (OAuth-aware).
+            text = await runConsolidationViaSdk(SYSTEM_PROMPT, userPrompt, model);
+        }
+        if (!text) {
+            logger.debug({ sessionKey: candidate.sessionKey }, 'Empty consolidation response — skipping');
+            return null;
+        }
         extraction = parseEpisodeJson(text);
     }
     catch (err) {

package/dist/gateway/heartbeat-scheduler.d.ts

@@ -42,6 +42,8 @@ export declare class HeartbeatScheduler {
     private runLog;
     private lastDenseBackfillAt;
     private denseBackfillInFlight;
+    private lastTranscriptDenseBackfillAt;
+    private transcriptDenseBackfillInFlight;
     private lastSalienceDecayDate;
     private lastMemoryPulseDate;
     private lastEpisodicConsolidationAt;
@@ -70,6 +72,14 @@ export declare class HeartbeatScheduler {
      * Coverage climbs over hours/days without user action.
      */
     private maybeIdleDenseBackfill;
+    /**
+     * Sibling of maybeIdleDenseBackfill that targets the transcripts table.
+     * Same gates (cooldown + chat-lane idle + dense model ready), separate
+     * in-flight + cadence so the two backfills don't starve each other.
+     * Without this, new chat/cron/heartbeat turns get FTS5-indexed but
+     * never embedded, and the dense leg of recall silently returns 0 hits.
+     */
+    private maybeIdleTranscriptDenseBackfill;
     /**
      * Episodic consolidation pass. Turns idle session transcript ranges into
      * durable episodes via a small Haiku call per session. Same shape as

package/dist/gateway/heartbeat-scheduler.js

@@ -52,6 +52,8 @@ export class HeartbeatScheduler {
     runLog = new CronRunLog();
     lastDenseBackfillAt = 0;
     denseBackfillInFlight = false;
+    lastTranscriptDenseBackfillAt = 0;
+    transcriptDenseBackfillInFlight = false;
     lastSalienceDecayDate = '';
     lastMemoryPulseDate = '';
     lastEpisodicConsolidationAt = 0;
@@ -155,6 +157,14 @@ export class HeartbeatScheduler {
         this.maybeIdleDenseBackfill().catch(err => {
             logger.debug({ err }, 'Idle dense backfill failed (non-fatal)');
         });
+        // Transcript dense backfill — separate cadence from chunks. Transcript
+        // turns from chat/cron/heartbeat/team-task accumulate continuously
+        // and need their own dense vectors so the recall block's dense leg
+        // returns hits for them too. Without this, hybrid recall silently
+        // degrades to lexical-only for transcripts.
+        this.maybeIdleTranscriptDenseBackfill().catch(err => {
+            logger.debug({ err }, 'Idle transcript dense backfill failed (non-fatal)');
+        });
         // Daily salience decay — fades stale, unaccessed chunks so retrieval
         // doesn't keep boosting facts that aren't earning their context budget.
         // Pinned + soft-deleted + superseded chunks are exempt. One UPDATE per
@@ -823,6 +833,45 @@ export class HeartbeatScheduler {
             this.denseBackfillInFlight = false;
         }
     }
+    /**
+     * Sibling of maybeIdleDenseBackfill that targets the transcripts table.
+     * Same gates (cooldown + chat-lane idle + dense model ready), separate
+     * in-flight + cadence so the two backfills don't starve each other.
+     * Without this, new chat/cron/heartbeat turns get FTS5-indexed but
+     * never embedded, and the dense leg of recall silently returns 0 hits.
+     */
+    async maybeIdleTranscriptDenseBackfill() {
+        if (this.transcriptDenseBackfillInFlight)
+            return;
+        const sinceLastMs = Date.now() - this.lastTranscriptDenseBackfillAt;
+        if (sinceLastMs < 10 * 60 * 1000)
+            return;
+        const { lanes } = await import('./lanes.js');
+        if (lanes.status().chat.active > 0)
+            return;
+        const store = this.gateway.getMemoryStore();
+        if (!store)
+            return;
+        const s = store;
+        if (typeof s.backfillTranscriptDenseEmbeddings !== 'function')
+            return;
+        const embeddings = await import('../memory/embeddings.js');
+        if (!embeddings.isDenseReady()) {
+            embeddings.probeDenseReady().catch(() => { });
+            return;
+        }
+        this.transcriptDenseBackfillInFlight = true;
+        this.lastTranscriptDenseBackfillAt = Date.now();
+        try {
+            const result = await s.backfillTranscriptDenseEmbeddings({ limit: 50 });
+            if (result.embedded > 0) {
+                logger.info({ embedded: result.embedded, failed: result.failed, model: result.model }, 'Idle transcript dense backfill batch complete');
+            }
+        }
+        finally {
+            this.transcriptDenseBackfillInFlight = false;
+        }
+    }
     /**
      * Episodic consolidation pass. Turns idle session transcript ranges into
      * durable episodes via a small Haiku call per session. Same shape as

package/dist/gateway/router.js

@@ -2064,6 +2064,10 @@ export class Gateway {
                 agentManager: this.getAgentManager(),
                 memoryStore: this.assistant.getMemoryStore?.() ?? null,
                 abortSignal: abortController?.signal,
+                // Post-task auto-memory extraction so anything the recipient
+                // learned during the task (new contact, preference, status)
+                // distills into their agents/<slug>/MEMORY.md.
+                postTaskHooks: this.assistant,
             });
             scanner.refreshIntegrity();
             logger.info({

package/package.json

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