clementine-agent 1.18.26 → 1.18.27

package/dist/agent/assistant.d.ts

@@ -33,6 +33,7 @@ export declare function contextThrashRecoveryNotice(): string;
 export declare function buildContextThrashRecoveryPrompt(userRequest: string, priorFailureText?: string): string;
 /** Format a millisecond duration as a human-friendly "X ago" string. */
 export declare function formatTimeAgo(ms: number): string;
+export declare function scrubInternalContextBlocks(text: string): string;
 export declare function looksLikeOneMillionContextError(value: unknown): boolean;
 export declare function oneMillionContextRecoveryMessage(): string;
 export declare function looksLikeProviderApiErrorResponse(value: unknown): boolean;
@@ -123,7 +124,7 @@ export declare class PersonalAssistant {
         }>;
         updatedAt: string;
     };
-    /** Inject a background work result into the session so the next chat naturally references it. */
+    /** Inject a background work result into the session as silent follow-up context. */
     injectPendingContext(sessionKey: string, userPrompt: string, result: string): void;
     private initMemoryStore;
     /**
@@ -321,7 +322,9 @@ export declare class PersonalAssistant {
      * a query.  Used to give the DM session visibility of cron/heartbeat outputs
      * so follow-up conversation has context.
      */
-    injectContext(sessionKey: string, userText: string, assistantText: string): void;
+    injectContext(sessionKey: string, userText: string, assistantText: string, opts?: {
+        pending?: boolean;
+    }): void;
     getRecentActivity(sinceIso: string, maxEntries?: number): Array<{
         sessionKey: string;
         role: string;

package/dist/agent/assistant.js

@@ -373,6 +373,13 @@ function getContextWindow(model) {
 function capContextBlock(text, maxChars) {
     return capOutput(String(text ?? ''), maxChars);
 }
+export function scrubInternalContextBlocks(text) {
+    return text
+        .replace(/\[Context governance:[^\]]*\][\s\S]*?\[\/Context governance:[^\]]*\]\s*/gi, '')
+        .replace(/\[Active working set\][\s\S]*?\[\/Active working set\]\s*/gi, '')
+        .replace(/\[Recent proactive notification context\][\s\S]*?\[\/Recent proactive notification context\]\s*/gi, '')
+        .trim();
+}
 function capContextItem(text) {
     return capContextBlock(text, CRON_PROGRESS_ITEM_MAX_CHARS).replace(/\s+/g, ' ').trim();
 }
@@ -1182,7 +1189,7 @@ export class PersonalAssistant {
     getMcpStatus() {
         return { servers: this._lastMcpStatus, updatedAt: this._lastMcpStatusTime };
     }
-    /** Inject a background work result into the session so the next chat naturally references it. */
+    /** Inject a background work result into the session as silent follow-up context. */
     injectPendingContext(sessionKey, userPrompt, result) {
         const pending = this.pendingContext.get(sessionKey) ?? [];
         pending.push({ user: userPrompt.slice(0, 500), assistant: result.slice(0, 2000) });
@@ -3043,7 +3050,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     contextLines.push(`[${user}]\n${assistant}`);
                 }
                 effectivePrompt =
-                    `[Since we last talked, you did some background work. Naturally mention what happened — lead with anything that needs attention, briefly note routine completions. Don't dump raw tool calls or list job names. Be conversational.\nBackground:\n${contextLines.join('\n\n')}]\n\n${effectivePrompt}`;
+                    `[Background work context — REFERENCE ONLY, not new user input.\n` +
+                        `Use this silently to understand follow-ups. Mention it only if the user asks about status, results, fixes, or what changed, or if it is a new urgent blocker. ` +
+                        `Do not lead greetings or casual small talk with stale heartbeat, cron, or background-task details.\n` +
+                        `Background:\n${contextLines.join('\n\n')}]\n\n${effectivePrompt}`;
             }
         }
         // Inject stall nudge if the previous query for this session showed stall signals
@@ -3070,6 +3080,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         const CHAT_TIMEOUT_MS = 30 * 60 * 1000;
         const guard = new StallGuard();
         let [responseText, sessionId] = await this.runQuery(effectivePrompt, key, onText, model, profile, securityAnnotation, effectiveMaxTurns, projectOverride, onToolActivity, verboseLevel, abortController, guard, CHAT_TIMEOUT_MS, intent, turnPolicy, toolset);
+        responseText = scrubInternalContextBlocks(responseText);
         // If we got a context-length / prompt-too-long error, retry with a fresh session
         const errLower = responseText.toLowerCase();
         const isContextOverflow = errLower.includes('prompt is too long') ||
@@ -6184,7 +6195,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
      * a query.  Used to give the DM session visibility of cron/heartbeat outputs
      * so follow-up conversation has context.
      */
-    injectContext(sessionKey, userText, assistantText) {
+    injectContext(sessionKey, userText, assistantText, opts = {}) {
         const trimmedUser = capContextBlock(userText, INJECTED_CONTEXT_MAX_CHARS);
         const trimmedAssistant = capContextBlock(assistantText, INJECTED_CONTEXT_MAX_CHARS);
         // Add to in-memory exchange history
@@ -6199,12 +6210,14 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // Queue as pending context so the next chat() prepends it even
         // when an active SDK session exists (session recovery alone won't
         // help because the SDK session has no knowledge of this exchange).
-        const pending = this.pendingContext.get(sessionKey) ?? [];
-        pending.push({ user: trimmedUser, assistant: trimmedAssistant });
-        // Keep at most 3 pending to avoid bloating the next prompt
-        if (pending.length > 3)
-            pending.shift();
-        this.pendingContext.set(sessionKey, pending);
+        if (opts.pending !== false) {
+            const pending = this.pendingContext.get(sessionKey) ?? [];
+            pending.push({ user: trimmedUser, assistant: trimmedAssistant });
+            // Keep at most 3 pending to avoid bloating the next prompt
+            if (pending.length > 3)
+                pending.shift();
+            this.pendingContext.set(sessionKey, pending);
+        }
         this.sessionTimestamps.set(sessionKey, new Date());
         this.saveSessions();
         // Persist to transcript store

package/dist/agent/tool-router.js

@@ -67,7 +67,7 @@ export const TOOL_BUNDLES = [
     },
     {
         id: 'github',
-        patterns: [/\b(github|pull request|pull requests|prs?|issues?)\b/i],
+        patterns: [/\b(github|pull request|pull requests|prs?)\b/i, /\b(repo|github)\s+issues?\b/i],
         externalMcpServers: ['github'],
         composioToolkits: ['github'],
     },

package/dist/cli/dashboard.js

@@ -7044,6 +7044,29 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    // Coverage + recall telemetry for both chunks and transcripts. Powers the
+    // Memory Coverage card showing whether dense recall is actually earning its
+    // keep on the current corpus.
+    app.get('/api/memory/coverage', async (_req, res) => {
+        try {
+            const gateway = await getGateway();
+            const store = gateway.assistant?.memoryStore;
+            if (!store) {
+                res.status(503).json({ error: 'Memory store not available' });
+                return;
+            }
+            const transcripts = typeof store.getTranscriptDenseCoverage === 'function'
+                ? store.getTranscriptDenseCoverage()
+                : { embedded: 0, total: 0, model: null };
+            const recall = typeof store.getRecallTelemetrySummary === 'function'
+                ? store.getRecallTelemetrySummary(7)
+                : { total: 0, semanticOnly: 0, lexicalOnly: 0, bothModes: 0, avgTopScore: 0 };
+            res.json({ ok: true, transcripts, recall });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
     // Quick-add: append a sentence to today's daily note from the dashboard.
     // Mirrors the agent's memory_write({action:'append_daily'}) path so the
     // note gets indexed identically.
@@ -24903,6 +24926,38 @@ async function refreshCoverageStrip() {
       html += '<span style="margin-left:auto;color:var(--text-muted)">All chunks indexed</span>';
     }
     html += '</div>';
+
+    // Second strip: transcripts dense coverage + 7-day recall hit-rate.
+    try {
+      var rc = await apiFetch('/api/memory/coverage');
+      var dc = await rc.json();
+      if (dc.ok) {
+        var tx = dc.transcripts || { embedded: 0, total: 0 };
+        var rec = dc.recall || { total: 0, semanticOnly: 0, lexicalOnly: 0, bothModes: 0, avgTopScore: 0 };
+        var txPct = tx.total > 0 ? Math.round((tx.embedded / tx.total) * 100) : 0;
+        var txColor = txPct >= 95 ? '#10b981' : txPct >= 50 ? '#f59e0b' : '#ef4444';
+        var recallTotal = rec.total || 0;
+        var hit = function(n){ return recallTotal > 0 ? Math.round((n / recallTotal) * 100) : 0; };
+        html += '<div style="display:flex;align-items:center;gap:14px;padding:10px 14px;margin-top:8px;background:var(--bg-secondary);border:1px solid var(--border);border-radius:8px;flex-wrap:wrap;font-size:12px">';
+        html += '<span style="color:var(--text-muted)">Conversation recall:</span>';
+        html += '<span><span style="color:' + txColor + '">●</span> Transcripts ' + txPct + '% '
+          + '<span style="color:var(--text-muted)">(' + tx.embedded.toLocaleString() + '/' + tx.total.toLocaleString() + ')</span></span>';
+        if (recallTotal > 0) {
+          html += '<span style="color:var(--text-muted)">|</span>';
+          html += '<span title="Last 7 days">Hit-rate: '
+            + 'semantic ' + hit(rec.semanticOnly) + '% · '
+            + 'lexical ' + hit(rec.lexicalOnly) + '% · '
+            + 'both ' + hit(rec.bothModes) + '% '
+            + '<span style="color:var(--text-muted)">(' + recallTotal.toLocaleString() + ' queries)</span></span>';
+        } else {
+          html += '<span style="color:var(--text-muted)">No recall queries logged in the last 7 days.</span>';
+        }
+        if (tx.total > 0 && tx.embedded < tx.total) {
+          html += '<span style="margin-left:auto;color:var(--text-muted)">' + (tx.total - tx.embedded).toLocaleString() + ' transcripts unembedded — run <code>clementine memory reembed --target transcripts</code></span>';
+        }
+        html += '</div>';
+      }
+    } catch (e) { /* coverage strip is best-effort */ }
     el.innerHTML = html;
   } catch (err) {
     el.innerHTML = '';

package/dist/cli/index.js

@@ -3276,9 +3276,10 @@ memoryModelCmd
 });
 memoryCmd
     .command('reembed')
-    .description('Backfill dense neural embeddings for all chunks (or all stale chunks if model changed). Default model: Snowflake/snowflake-arctic-embed-m-v1.5 — first run downloads ~440MB to ~/.clementine/models/.')
-    .option('--limit <n>', 'Max chunks to embed in this run (default: all)')
+    .description('Backfill dense neural embeddings for chunks and/or transcripts. Default model: Snowflake/snowflake-arctic-embed-m-v1.5 — first run downloads ~440MB to ~/.clementine/models/.')
+    .option('--limit <n>', 'Max items to embed in this run (default: all)')
     .option('--model <id>', 'Override embedding model id (e.g. Xenova/bge-base-en-v1.5)')
+    .option('--target <kind>', 'What to backfill: chunks | transcripts | all', 'all')
     .action(async (opts) => {
     const BOLD = '\x1b[1m';
     const DIM = '\x1b[0;90m';
@@ -3290,6 +3291,11 @@ memoryCmd
         if (opts.model) {
             process.env.EMBEDDING_DENSE_MODEL = opts.model;
         }
+        const target = (opts.target ?? 'all').toLowerCase();
+        if (!['chunks', 'transcripts', 'all'].includes(target)) {
+            console.error(`  ${RED}Invalid --target${RESET}: "${opts.target}". Use chunks | transcripts | all.`);
+            process.exit(1);
+        }
         const limit = opts.limit ? parseInt(opts.limit, 10) : undefined;
         const { MemoryStore } = await import('../memory/store.js');
         const embeddings = await import('../memory/embeddings.js');
@@ -3298,7 +3304,7 @@ memoryCmd
         const store = new MemoryStore(DB_PATH, VAULT_DIR);
         store.initialize();
         console.log();
-        console.log(`  ${BOLD}Dense embedding backfill${RESET}`);
+        console.log(`  ${BOLD}Dense embedding backfill${RESET} ${DIM}(target: ${target})${RESET}`);
         console.log(`  Model: ${embeddings.currentDenseModel()}`);
         console.log(`  ${DIM}Loading model (first run downloads ~440MB)…${RESET}`);
         const ready = await embeddings.probeDenseReady();
@@ -3309,28 +3315,59 @@ memoryCmd
         }
         console.log(`  ${GREEN}✓${RESET} Model ready (${embeddings.denseDimension()}-dim).`);
         console.log();
-        const startTime = Date.now();
-        let lastReport = 0;
-        const result = await store.backfillDenseEmbeddings({
-            limit,
-            onProgress: (done, total) => {
-                // Throttle to avoid spamming
+        const reportProgress = (label, startTime) => {
+            let lastReport = 0;
+            return (done, total) => {
                 const now = Date.now();
                 if (now - lastReport < 500 && done < total)
                     return;
                 lastReport = now;
                 const pct = total > 0 ? Math.round((done / total) * 100) : 0;
                 const elapsed = Math.round((now - startTime) / 1000);
-                process.stdout.write(`\r  Progress: ${BOLD}${done.toLocaleString()}${RESET}/${total.toLocaleString()} (${pct}%) ${DIM}${elapsed}s${RESET}    `);
-            },
-        });
-        process.stdout.write('\n\n');
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-        console.log(`  ${GREEN}✓${RESET} Embedded ${BOLD}${result.embedded.toLocaleString()}${RESET} chunks ${DIM}(${elapsed}s elapsed)${RESET}`);
-        if (result.failed > 0) {
-            console.log(`  ${YELLOW}!${RESET} Failed: ${result.failed.toLocaleString()} ${DIM}(model returned null — usually empty or invalid input)${RESET}`);
+                process.stdout.write(`\r  ${label}: ${BOLD}${done.toLocaleString()}${RESET}/${total.toLocaleString()} (${pct}%) ${DIM}${elapsed}s${RESET}    `);
+            };
+        };
+        let totalEmbedded = 0;
+        let totalFailed = 0;
+        let lastModel = '';
+        if (target === 'chunks' || target === 'all') {
+            const startTime = Date.now();
+            const result = await store.backfillDenseEmbeddings({
+                limit,
+                onProgress: reportProgress('Chunks', startTime),
+            });
+            process.stdout.write('\n');
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            console.log(`  ${GREEN}✓${RESET} Embedded ${BOLD}${result.embedded.toLocaleString()}${RESET} chunks ${DIM}(${elapsed}s elapsed)${RESET}`);
+            if (result.failed > 0) {
+                console.log(`  ${YELLOW}!${RESET} Chunk failures: ${result.failed.toLocaleString()}`);
+            }
+            totalEmbedded += result.embedded;
+            totalFailed += result.failed;
+            lastModel = result.model;
+        }
+        if (target === 'transcripts' || target === 'all') {
+            const startTime = Date.now();
+            const result = await store.backfillTranscriptDenseEmbeddings({
+                limit,
+                onProgress: reportProgress('Transcripts', startTime),
+            });
+            process.stdout.write('\n');
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            console.log(`  ${GREEN}✓${RESET} Embedded ${BOLD}${result.embedded.toLocaleString()}${RESET} transcripts ${DIM}(${elapsed}s elapsed)${RESET}`);
+            if (result.failed > 0) {
+                console.log(`  ${YELLOW}!${RESET} Transcript failures: ${result.failed.toLocaleString()}`);
+            }
+            totalEmbedded += result.embedded;
+            totalFailed += result.failed;
+            lastModel = result.model;
+        }
+        console.log();
+        console.log(`  Total embedded: ${BOLD}${totalEmbedded.toLocaleString()}${RESET}`);
+        if (totalFailed > 0) {
+            console.log(`  ${DIM}(model returned null on ${totalFailed.toLocaleString()} — usually empty or invalid input)${RESET}`);
         }
-        console.log(`  Model: ${result.model}`);
+        console.log(`  Model: ${lastModel}`);
         console.log();
         console.log(`  ${DIM}Run \`clementine memory status\` to see updated coverage.${RESET}`);
         console.log();

package/dist/gateway/active-context.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Active working set context.
+ *
+ * This is the short-lived "what matters right now" layer above semantic
+ * memory. It is deliberately bounded and deterministic so every channel can
+ * stay aware of active operational state without dragging full transcripts or
+ * run logs into the model.
+ */
+export interface ActiveContextItem {
+    source: 'notification' | 'background-task' | 'unleashed' | 'turn-ledger';
+    label: string;
+    detail: string;
+    priority: number;
+    timestamp?: string;
+    eventId?: string;
+    sourceId?: string;
+    alreadyLogged?: boolean;
+    alreadySurfaced?: boolean;
+    acknowledged?: boolean;
+    resolved?: boolean;
+    greetingEligible?: boolean;
+}
+export interface ActiveContextSnapshot {
+    sessionKey: string;
+    items: ActiveContextItem[];
+    promptBlock: string | null;
+    greetingLine: string | null;
+}
+export interface ActiveContextOptions {
+    baseDir: string;
+    now?: number;
+    maxItems?: number;
+    recordEvents?: boolean;
+    /**
+     * Dense embedding coverage for transcripts. When < 50%, the prompt block
+     * carries an inline note so the model knows recall is degraded.
+     */
+    transcriptCoverage?: {
+        embedded: number;
+        total: number;
+    };
+}
+export declare function buildActiveContextSnapshot(sessionKey: string, opts: ActiveContextOptions): ActiveContextSnapshot;
+//# sourceMappingURL=active-context.d.ts.map

package/dist/gateway/active-context.js

@@ -0,0 +1,330 @@
+/**
+ * Active working set context.
+ *
+ * This is the short-lived "what matters right now" layer above semantic
+ * memory. It is deliberately bounded and deterministic so every channel can
+ * stay aware of active operational state without dragging full transcripts or
+ * run logs into the model.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { listBackgroundTasks } from '../agent/background-tasks.js';
+import { listRecentNotificationEvents } from './notification-context.js';
+import { readRecentTurnLedger } from './turn-ledger.js';
+import { isLiveUnleashedStatus } from './unleashed-status.js';
+import { recordContextEvent } from './context-events.js';
+const RECENT_TASK_TTL_MS = 24 * 60 * 60 * 1000;
+const RECENT_UNLEASHED_ERROR_TTL_MS = 12 * 60 * 60 * 1000;
+const FRESH_ACTIVE_TASK_GREETING_TTL_MS = 20 * 60 * 1000;
+const MAX_DETAIL_CHARS = 220;
+function compactWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function cap(text, max = MAX_DETAIL_CHARS) {
+    const normalized = compactWhitespace(text);
+    return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+function timestampMs(value) {
+    const ms = value ? Date.parse(value) : NaN;
+    return Number.isFinite(ms) ? ms : 0;
+}
+function normalizeForSurface(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function buildSurfaceHistory(sessionKey, opts) {
+    let entries = [];
+    try {
+        entries = readRecentTurnLedger(sessionKey, 12, opts.baseDir);
+    }
+    catch {
+        entries = [];
+    }
+    const loggedText = entries
+        .map((entry) => [
+        entry.userMessagePreview,
+        entry.responsePreview ?? '',
+        entry.errorPreview ?? '',
+    ].join(' '))
+        .join(' ');
+    const surfacedText = entries
+        .map((entry) => [
+        entry.responsePreview ?? '',
+        entry.errorPreview ?? '',
+    ].join(' '))
+        .join(' ');
+    return {
+        entries,
+        loggedText: normalizeForSurface(loggedText),
+        surfacedText: normalizeForSurface(surfacedText),
+    };
+}
+function mentionsAny(haystack, needles) {
+    if (!haystack)
+        return false;
+    return needles.some((needle) => {
+        const normalized = normalizeForSurface(needle ?? '');
+        return normalized.length >= 4 && haystack.includes(normalized);
+    });
+}
+function taskAgeMs(task, now) {
+    const ms = timestampMs(task.completedAt ?? task.startedAt ?? task.createdAt);
+    return ms > 0 ? now - ms : Number.POSITIVE_INFINITY;
+}
+function taskMatchesSession(task, sessionKey) {
+    return task.sessionKey === sessionKey;
+}
+function maybeRecordContextEvent(opts, input) {
+    if (opts.recordEvents === false)
+        return null;
+    return recordContextEvent(input, { baseDir: opts.baseDir, now: opts.now });
+}
+function backgroundTaskItems(sessionKey, opts, surfaceHistory) {
+    const now = opts.now ?? Date.now();
+    const dir = path.join(opts.baseDir, 'background-tasks');
+    return listBackgroundTasks({}, { dir })
+        .filter((task) => taskMatchesSession(task, sessionKey))
+        .filter((task) => task.status === 'pending' || task.status === 'running' || taskAgeMs(task, now) <= RECENT_TASK_TTL_MS)
+        .slice(0, 5)
+        .map((task) => {
+        const active = task.status === 'pending' || task.status === 'running';
+        const failed = task.status === 'failed' || task.status === 'aborted';
+        const blocker = /usage limit|billing|credit balance|monthly usage|auth/i.test(task.error ?? '');
+        const ageMs = taskAgeMs(task, now);
+        const detail = failed
+            ? `Failed: ${cap(task.error ?? task.prompt)}`
+            : task.status === 'done'
+                ? `Done: ${cap(task.result ?? task.prompt)}`
+                : cap(task.prompt);
+        const terminalPriority = failed ? (blocker ? 65 : 60) : 30;
+        const severity = blocker ? 'urgent' : failed ? 'warning' : active ? 'normal' : 'low';
+        const eventAt = task.completedAt ?? task.startedAt ?? task.createdAt;
+        const event = maybeRecordContextEvent(opts, {
+            source: 'background-task',
+            sourceId: task.id,
+            sessionKey,
+            title: `${task.id} ${task.status}`,
+            summary: detail,
+            status: task.status,
+            severity,
+            eventAt,
+            loggedAt: eventAt,
+            ...(task.status === 'done' ? { resolvedAt: task.completedAt ?? eventAt } : {}),
+            fingerprintParts: [sessionKey, 'background-task', task.id],
+            metadata: { fromAgent: task.fromAgent },
+        });
+        const alreadyLogged = Boolean(event?.loggedAt) || mentionsAny(surfaceHistory.loggedText, [task.id]);
+        const alreadySurfaced = Boolean(event?.surfacedAt) || mentionsAny(surfaceHistory.surfacedText, [task.id]);
+        return {
+            source: 'background-task',
+            label: `${task.id} ${task.status}`,
+            detail,
+            priority: active ? (blocker ? 85 : 78) : terminalPriority,
+            timestamp: eventAt,
+            eventId: event?.id,
+            sourceId: task.id,
+            alreadyLogged,
+            alreadySurfaced,
+            acknowledged: Boolean(event?.acknowledgedAt),
+            resolved: Boolean(event?.resolvedAt),
+            greetingEligible: active
+                && !alreadySurfaced
+                && ageMs <= FRESH_ACTIVE_TASK_GREETING_TTL_MS,
+        };
+    });
+}
+function notificationItems(sessionKey, opts) {
+    return listRecentNotificationEvents(sessionKey, { baseDir: opts.baseDir, now: opts.now }, 5)
+        .map((event) => {
+        const jobs = event.jobNames?.length ? ` (${event.jobNames.join(', ')})` : '';
+        const body = `${event.summary} ${event.textPreview}`;
+        const noisyOrRecovered = /\b0\/0 recent runs failed\b/i.test(body)
+            || /\b(no active failures|has recovered|fully recovered|running healthy|no fix needed)\b/i.test(body);
+        const basePriority = event.type === 'cron_failure' ? 72 : event.type === 'cron_sla' ? 65 : 40;
+        const contextEvent = maybeRecordContextEvent(opts, {
+            source: 'notification',
+            sourceId: event.id,
+            sessionKey: event.sessionKey ?? sessionKey,
+            title: `${event.type}: ${event.title}${jobs}`,
+            summary: event.summary || event.textPreview,
+            status: event.type === 'cron_failure' ? 'failed' : 'active',
+            severity: noisyOrRecovered ? 'low' : event.type === 'cron_failure' ? 'warning' : 'normal',
+            eventAt: event.sentAt,
+            loggedAt: event.sentAt,
+            surfacedAt: event.sentAt,
+            fingerprintParts: [
+                event.sessionKey ?? sessionKey,
+                'notification',
+                event.type,
+                event.jobNames?.join(',') ?? event.title,
+                event.summary || event.textPreview,
+            ],
+            metadata: { notificationId: event.id, jobNames: event.jobNames ?? [] },
+        });
+        return {
+            source: 'notification',
+            label: `${event.type}: ${event.title}${jobs}`,
+            detail: cap(event.summary || event.textPreview),
+            priority: noisyOrRecovered ? Math.min(basePriority, 30) : basePriority,
+            timestamp: event.sentAt,
+            eventId: contextEvent?.id,
+            sourceId: event.id,
+            alreadyLogged: true,
+            alreadySurfaced: true,
+            acknowledged: Boolean(contextEvent?.acknowledgedAt),
+            resolved: Boolean(contextEvent?.resolvedAt),
+            greetingEligible: false,
+        };
+    });
+}
+function readJsonFile(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function unleashedItems(opts, surfaceHistory) {
+    const now = opts.now ?? Date.now();
+    const dir = path.join(opts.baseDir, 'unleashed');
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    let names = [];
+    try {
+        names = readdirSync(dir)
+            .filter((name) => {
+            try {
+                return statSync(path.join(dir, name)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+    for (const name of names) {
+        const status = readJsonFile(path.join(dir, name, 'status.json'));
+        if (!status)
+            continue;
+        const rawStatus = String(status.status ?? 'running');
+        const updatedAt = String(status.updatedAt ?? status.finishedAt ?? status.startedAt ?? '');
+        const updatedMs = timestampMs(updatedAt);
+        const live = isLiveUnleashedStatus(status, now);
+        const recentError = rawStatus === 'error' && updatedMs > 0 && now - updatedMs <= RECENT_UNLEASHED_ERROR_TTL_MS;
+        if (!live && !recentError)
+            continue;
+        const phase = status.phase == null ? '' : ` phase ${String(status.phase)}`;
+        const liveWork = live && rawStatus !== 'error';
+        const label = `${name} ${rawStatus}${phase}`;
+        const detail = live ? 'Active long-running work.' : 'Recent long-running job error.';
+        const contextEvent = maybeRecordContextEvent(opts, {
+            source: 'unleashed',
+            sourceId: name,
+            title: label,
+            summary: detail,
+            status: rawStatus === 'error' ? 'failed' : liveWork ? 'running' : 'unknown',
+            severity: rawStatus === 'error' ? 'warning' : 'normal',
+            eventAt: updatedAt || new Date(now).toISOString(),
+            loggedAt: updatedAt || new Date(now).toISOString(),
+            fingerprintParts: ['unleashed', name],
+            metadata: { phase: status.phase ?? null },
+        });
+        const alreadyLogged = Boolean(contextEvent?.loggedAt) || mentionsAny(surfaceHistory.loggedText, [name]);
+        const alreadySurfaced = Boolean(contextEvent?.surfacedAt) || mentionsAny(surfaceHistory.surfacedText, [name]);
+        out.push({
+            source: 'unleashed',
+            label,
+            detail,
+            priority: rawStatus === 'error' ? 62 : 70,
+            timestamp: updatedAt,
+            eventId: contextEvent?.id,
+            sourceId: name,
+            alreadyLogged,
+            alreadySurfaced,
+            acknowledged: Boolean(contextEvent?.acknowledgedAt),
+            resolved: Boolean(contextEvent?.resolvedAt),
+            greetingEligible: liveWork && !alreadySurfaced,
+        });
+    }
+    return out;
+}
+function turnLedgerItems(surfaceHistory) {
+    return surfaceHistory.entries
+        .filter((entry) => entry.deliveryStatus === 'failed' || entry.actionExpected || entry.toolCallsMade > 0)
+        .slice(0, 2)
+        .map((entry) => ({
+        source: 'turn-ledger',
+        label: `recent turn ${entry.deliveryStatus}`,
+        detail: cap(entry.responsePreview || entry.errorPreview || entry.userMessagePreview),
+        priority: entry.deliveryStatus === 'failed' ? 60 : entry.actionExpected ? 45 : 25,
+        timestamp: entry.createdAt,
+        alreadyLogged: true,
+        alreadySurfaced: true,
+        acknowledged: true,
+        greetingEligible: false,
+    }));
+}
+function formatPromptBlock(items, coverage) {
+    if (items.length === 0)
+        return null;
+    const lines = items.map((item) => {
+        const tags = [
+            item.greetingEligible ? 'fresh' : 'context only',
+            item.alreadySurfaced ? 'already surfaced' : null,
+            item.alreadyLogged ? 'logged' : null,
+            item.acknowledged ? 'acknowledged' : null,
+            item.resolved ? 'resolved' : null,
+        ].filter(Boolean).join(', ');
+        const id = item.eventId ? ` id=${item.eventId}` : '';
+        return `- ${item.source}${id}: ${item.label}${tags ? ` (${tags})` : ''} — ${item.detail}`;
+    });
+    const coverageNote = coverage && coverage.total > 0 && coverage.embedded / coverage.total < 0.5
+        ? `Recall note: memory partially indexed (${coverage.embedded.toLocaleString()} of ${coverage.total.toLocaleString()} turns embedded). Paraphrased recall may miss; lexical recall still works.`
+        : null;
+    return [
+        '[Context governance: active working set]',
+        'REFERENCE ONLY — recalled operational context, not new user input.',
+        'Use this before deciding whether a vague/casual turn is new work, a follow-up, or a status request.',
+        'Context-only, logged, acknowledged, resolved, or already-surfaced items are memory anchors for explicit follow-ups. Do not repeat heartbeat/alert details on greetings or casual small talk unless the user asks for status, a fix, or what changed.',
+        ...(coverageNote ? [coverageNote] : []),
+        ...lines,
+        '[/Context governance: active working set]',
+    ].join('\n');
+}
+function formatGreetingLine(items) {
+    const top = items.find((item) => item.greetingEligible && item.priority >= 75);
+    if (!top)
+        return null;
+    return `Hey. I am here. Still working on ${top.label}: ${top.detail}`;
+}
+export function buildActiveContextSnapshot(sessionKey, opts) {
+    const maxItems = Math.max(1, opts.maxItems ?? 6);
+    const surfaceHistory = buildSurfaceHistory(sessionKey, opts);
+    const items = [
+        ...backgroundTaskItems(sessionKey, opts, surfaceHistory),
+        ...notificationItems(sessionKey, opts),
+        ...unleashedItems(opts, surfaceHistory),
+        ...turnLedgerItems(surfaceHistory),
+    ]
+        .sort((a, b) => {
+        const priority = b.priority - a.priority;
+        if (priority !== 0)
+            return priority;
+        return timestampMs(b.timestamp) - timestampMs(a.timestamp);
+    })
+        .slice(0, maxItems);
+    return {
+        sessionKey,
+        items,
+        promptBlock: formatPromptBlock(items, opts.transcriptCoverage),
+        greetingLine: formatGreetingLine(items),
+    };
+}
+//# sourceMappingURL=active-context.js.map