clementine-agent 1.18.26 → 1.18.28

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,58 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    // Recent episodes — durable consolidated session summaries.
+    app.get('/api/memory/episodes', async (req, res) => {
+        try {
+            const gateway = await getGateway();
+            const store = gateway.assistant?.memoryStore;
+            if (!store || typeof store.listRecentEpisodes !== 'function') {
+                res.status(503).json({ error: 'Episodes store not available' });
+                return;
+            }
+            const limit = Math.min(parseInt(String(req.query.limit ?? '30'), 10) || 30, 200);
+            const sessionKey = req.query.session ? String(req.query.session) : undefined;
+            const sinceParam = req.query.since ? String(req.query.since) : '';
+            // since: '24h' | '7d' | '30d' | '' (all) | ISO string
+            let sinceIso;
+            if (sinceParam === '24h')
+                sinceIso = new Date(Date.now() - 24 * 3600_000).toISOString();
+            else if (sinceParam === '7d')
+                sinceIso = new Date(Date.now() - 7 * 24 * 3600_000).toISOString();
+            else if (sinceParam === '30d')
+                sinceIso = new Date(Date.now() - 30 * 24 * 3600_000).toISOString();
+            else if (sinceParam)
+                sinceIso = sinceParam;
+            const episodes = store.listRecentEpisodes({ limit, sessionKey, sinceIso });
+            res.json({ ok: true, episodes });
+        }
+        catch (err) {
+            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.
@@ -14975,6 +15027,23 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
                 <div class="skel-block" style="padding:14px"><div class="skel-row med"></div><div class="skel-row short"></div></div>
               </div>
             </div>
+            <div class="card" style="margin-bottom:14px">
+              <div class="card-header" style="display:flex;align-items:center;justify-content:space-between;gap:8px;flex-wrap:wrap">
+                <span>Recent episodes</span>
+                <div style="display:flex;align-items:center;gap:8px">
+                  <select id="episodes-filter-since" onchange="refreshRecentEpisodes()" style="font-size:12px;padding:4px 6px;border:1px solid var(--border);border-radius:4px;background:var(--bg-input);color:var(--text)">
+                    <option value="24h">Last 24h</option>
+                    <option value="7d" selected>Last 7d</option>
+                    <option value="30d">Last 30d</option>
+                    <option value="">All</option>
+                  </select>
+                  <span style="font-size:11px;color:var(--text-muted)">Consolidated session summaries</span>
+                </div>
+              </div>
+              <div class="card-body" id="panel-recent-episodes" style="padding:0">
+                <div class="skel-block" style="padding:14px"><div class="skel-row med"></div><div class="skel-row short"></div></div>
+              </div>
+            </div>
             <div class="card">
               <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
                 <span>Self-correction (supersedes)</span>
@@ -18485,6 +18554,7 @@ function switchTab(group, tab) {
       // Consolidated Memory tab: search results + stats + MEMORY.md + recent writes + supersedes + coverage strip.
       refreshMemory();
       if (typeof refreshRecentWrites === 'function') refreshRecentWrites();
+      if (typeof refreshRecentEpisodes === 'function') refreshRecentEpisodes();
       if (typeof refreshSupersedes === 'function') refreshSupersedes();
       if (typeof refreshCoverageStrip === 'function') refreshCoverageStrip();
     }
@@ -24842,6 +24912,7 @@ async function submitQuickAddMemory() {
     setTimeout(function() {
       closeQuickAddMemory();
       if (typeof refreshRecentWrites === 'function') refreshRecentWrites();
+      if (typeof refreshRecentEpisodes === 'function') refreshRecentEpisodes();
       if (typeof refreshMemory === 'function') refreshMemory();
     }, 600);
   } catch (err) {
@@ -24903,6 +24974,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 = '';
@@ -24963,6 +25066,55 @@ async function refreshRecentWrites() {
   }
 }
 
+async function refreshRecentEpisodes() {
+  var el = document.getElementById('panel-recent-episodes');
+  if (!el) return;
+  try {
+    var sel = document.getElementById('episodes-filter-since');
+    var since = sel ? sel.value : '7d';
+    var url = '/api/memory/episodes?limit=30' + (since ? '&since=' + encodeURIComponent(since) : '');
+    var r = await apiFetch(url);
+    var d = await r.json();
+    if (!d.ok || !Array.isArray(d.episodes)) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">' + esc(d.error || 'No data') + '</div>';
+      return;
+    }
+    if (d.episodes.length === 0) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">No episodes yet. They land automatically when a session has been idle for ~20 min with at least 3 exchanges.</div>';
+      return;
+    }
+    var html = '<table class="data-table" style="width:100%">';
+    html += '<thead><tr>'
+      + '<th style="width:120px">When</th>'
+      + '<th style="width:160px">Session</th>'
+      + '<th>Summary</th>'
+      + '<th style="width:140px">Topics</th>'
+      + '<th style="width:120px">Outcome</th>'
+      + '<th style="width:50px;text-align:right">Open</th>'
+      + '</tr></thead><tbody>';
+    for (var i = 0; i < d.episodes.length; i++) {
+      var ep = d.episodes[i];
+      var when = '';
+      try { when = new Date(ep.createdAt + 'Z').toLocaleString(); } catch { when = ep.createdAt; }
+      var topics = (ep.topics || []).slice(0, 3).map(esc).join(', ');
+      var openCount = (ep.openLoops || []).length;
+      var openColor = openCount > 0 ? '#f59e0b' : 'var(--text-muted)';
+      html += '<tr>'
+        + '<td style="font-size:11px;color:var(--text-muted)">' + esc(when) + '</td>'
+        + '<td style="font-size:11px">' + esc(ep.sessionKey) + '</td>'
+        + '<td style="font-size:12px">' + esc(ep.summary) + '</td>'
+        + '<td style="font-size:11px;color:var(--text-muted)">' + (topics || '—') + '</td>'
+        + '<td style="font-size:11px">' + esc(ep.outcome || '—') + '</td>'
+        + '<td style="text-align:right;font-weight:600;color:' + openColor + '">' + openCount + '</td>'
+        + '</tr>';
+    }
+    html += '</tbody></table>';
+    el.innerHTML = html;
+  } catch (err) {
+    el.innerHTML = '<div class="empty-state" style="padding:14px">Failed to load: ' + esc(String(err)) + '</div>';
+  }
+}
+
 async function memoryHealthAction(action, extra) {
   var labels = { 'janitor': 'cleanup', 'rebuild-fts': 'FTS rebuild', 'fix-orphans': 'orphan fix', 'install-dense-model': 'local embedding model install/verify', 'reembed-dense': 'dense embedding backfill' };
   if (!confirm('Run ' + (labels[action] || action) + ' now?')) return;

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