clementine-agent 1.18.57 → 1.18.58

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-team-task.d.ts

@@ -2,6 +2,12 @@ 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>;
+}
 export interface RunAgentTeamTaskOptions {
     fromName: string;
     fromSlug: string;
@@ -17,6 +23,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

@@ -82,6 +82,15 @@ export async function runAgentTeamTask(opts) {
             /* non-fatal */
         }
     }
+    // Auto-memory extraction — distill any new facts the recipient
+    // learned during the task into their MEMORY.md. Fire-and-forget,
+    // scoped to the recipient's profile so writes route to
+    // agents/<slug>/MEMORY.md, not the global one.
+    if (opts.postTaskHooks && result.text?.trim()) {
+        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)'));
+    }
     return {
         ...result,
         builtPrompt,

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.58",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",