clementine-agent 1.18.58 → 1.18.59

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

@@ -7,6 +7,8 @@ import { type RunAgentResult } from './run-agent.js';
  *  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;

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,14 +83,23 @@ 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.
+    // 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,

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/package.json

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