clementine-agent 1.18.19 → 1.18.21

package/dist/cli/dashboard.js

@@ -39,6 +39,7 @@ const HEARTBEAT_WORK_QUEUE_FILE = path.join(BASE_DIR, 'heartbeat', 'work-queue.j
 const MEMORY_DB_PATH = path.join(VAULT_DIR, '.memory.db');
 const PROJECTS_META_FILE = path.join(BASE_DIR, 'projects.json');
 const DASHBOARD_PID_FILE = path.join(BASE_DIR, '.dashboard.pid');
+const INTERACTIVE_FAILURE_LOG = path.join(BASE_DIR, 'self-improve', 'interactive-failures.jsonl');
 /**
  * Kill all existing dashboard processes before starting a new one.
  * Uses both the PID file and a process sweep to catch orphans.
@@ -5679,6 +5680,43 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         process.env[key] = normalized;
         return { ok: true, value: normalized };
     }
+    function readRecentDashboardChatFailures(limit = 5) {
+        try {
+            if (!existsSync(INTERACTIVE_FAILURE_LOG))
+                return [];
+            const lines = readFileSync(INTERACTIVE_FAILURE_LOG, 'utf-8')
+                .trim()
+                .split('\n')
+                .filter(Boolean)
+                .slice(-80)
+                .reverse();
+            const out = [];
+            for (const line of lines) {
+                try {
+                    const item = JSON.parse(line);
+                    const error = String(item.error ?? '');
+                    const stage = String(item.stage ?? '');
+                    const haystack = `${stage} ${error}`;
+                    if (!/1m|context|budget|credit|api error|rate.?limit/i.test(haystack))
+                        continue;
+                    out.push({
+                        createdAt: String(item.createdAt ?? ''),
+                        stage,
+                        sessionKey: String(item.sessionKey ?? ''),
+                        textPreview: String(item.textPreview ?? '').slice(0, 220),
+                        error: error.slice(0, 500),
+                    });
+                    if (out.length >= limit)
+                        break;
+                }
+                catch { /* skip malformed lines */ }
+            }
+            return out;
+        }
+        catch {
+            return [];
+        }
+    }
     const ASSISTANT_PREF_OPTIONS = {
         proactivity: ['quiet', 'balanced', 'proactive', 'operator'],
         responseStyle: ['concise', 'balanced', 'detailed'],
@@ -5797,6 +5835,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                     legacyMode,
                 },
                 findings,
+                recentFailures: readRecentDashboardChatFailures(),
                 counts: doctor.counts,
             });
         }
@@ -6533,6 +6572,22 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 res.json({ ok: true, action, report });
                 return;
             }
+            if (action === 'install-dense-model') {
+                const embeddings = await import('../memory/embeddings.js');
+                const ready = await embeddings.probeDenseReady();
+                if (!ready) {
+                    res.status(503).json({ error: 'Dense embedding model failed to load' });
+                    return;
+                }
+                res.json({
+                    ok: true,
+                    action,
+                    model: embeddings.currentDenseModel(),
+                    dimension: embeddings.denseDimension(),
+                    cacheDir: embeddings.denseModelCacheDir(),
+                });
+                return;
+            }
             if (action === 'reembed-dense') {
                 // Run backfill in the background — first call also pays the model
                 // load cost (~440MB download on first ever run). We respond immediately
@@ -20083,6 +20138,7 @@ async function refreshBudgetHealth() {
     var modeClass = mode === 'off' ? 'badge-green' : mode === 'on' ? 'badge-yellow' : 'badge-blue';
     var rows = d.budgets || [];
     var findings = d.findings || [];
+    var recentFailures = d.recentFailures || [];
     var html = '<div class="card">'
       + '<div class="card-header" style="display:flex;align-items:center;justify-content:space-between;gap:12px">'
       + '<div style="display:flex;align-items:center;gap:8px"><span>Spend Guards &amp; Context Health</span><span class="badge ' + modeClass + '" style="font-size:10px">1M ' + esc(mode) + '</span></div>'
@@ -20131,6 +20187,22 @@ async function refreshBudgetHealth() {
       + '<div style="font-size:12px;color:var(--text-secondary);margin-top:4px">Safe Recovery lowers autonomous spend and disables 1M context for accounts seeing credit or entitlement errors.</div>'
       + '<div style="font-size:11px;color:var(--text-muted);margin-top:6px">Restart the daemon after changing budgets or context mode.</div>'
       + '</div></div>';
+    if (recentFailures.length) {
+      html += '<div style="border-top:1px solid var(--border);padding-top:10px;margin-bottom:10px">'
+        + '<div style="font-weight:600;font-size:13px;margin-bottom:6px">Recent chat failures</div>';
+      for (var rf = 0; rf < recentFailures.length; rf++) {
+        var fail = recentFailures[rf] || {};
+        html += '<div style="padding:8px 0;border-bottom:1px solid rgba(127,127,127,0.12)">'
+          + '<div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">'
+          + '<span class="badge badge-yellow" style="font-size:10px">' + esc(fail.stage || 'failure') + '</span>'
+          + '<span style="font-size:11px;color:var(--text-muted)">' + esc(fail.createdAt || '') + '</span>'
+          + '</div>'
+          + '<div style="font-size:12px;color:var(--text-secondary);margin-top:4px">' + esc(fail.error || '') + '</div>'
+          + (fail.textPreview ? '<div style="font-size:11px;color:var(--text-muted);margin-top:3px">Prompt: ' + esc(fail.textPreview) + '</div>' : '')
+          + '</div>';
+      }
+      html += '</div>';
+    }
     if (findings.length) {
       html += '<div style="border-top:1px solid var(--border);padding-top:10px">'
         + '<div style="font-weight:600;font-size:13px;margin-bottom:6px">Potential causes</div>';
@@ -22798,7 +22870,7 @@ async function refreshCoverageStrip() {
     if (!d.ok || !d.health) { el.innerHTML = ''; return; }
     var h = d.health;
     var total = (h.chunks && h.chunks.total) || 0;
-    var de = h.denseEmbeddings || { withDense: 0, total: total, currentModel: '', ready: false };
+    var de = h.denseEmbeddings || { withDense: 0, total: total, currentModel: '', ready: false, installed: false, cacheSize: '0 B' };
     var sparseCovered = (h.chunks && h.chunks.withSparseEmbedding != null) ? h.chunks.withSparseEmbedding : null;
     var densePct = de.total > 0 ? Math.round((de.withDense / de.total) * 100) : 0;
     var sparsePct = (sparseCovered != null && total > 0) ? Math.round((sparseCovered / total) * 100) : null;
@@ -22810,7 +22882,26 @@ async function refreshCoverageStrip() {
     if (sparsePct != null) html += '<span><span style="color:#10b981">●</span> Sparse ' + sparsePct + '%</span>';
     html += '<span><span style="color:' + denseColor + '">●</span> Dense ' + densePct + '%'
       + (modelLabel ? ' <span style="color:var(--text-muted)">(' + esc(modelLabel) + ')</span>' : '') + '</span>';
-    if (de.total > 0 && de.withDense < de.total) {
+    if (!de.installed) {
+      html += '<span style="margin-left:auto;display:flex;align-items:center;gap:8px">'
+        + '<span style="color:#f59e0b">Model not installed</span>'
+        + '<button class="btn-sm" onclick="memoryHealthAction(\\'install-dense-model\\')">Install model</button>'
+        + '</span>';
+    } else if (!de.ready) {
+      html += '<span style="margin-left:auto;display:flex;align-items:center;gap:8px">'
+        + '<span style="color:#f59e0b">Model not verified</span>'
+        + '<button class="btn-sm" onclick="memoryHealthAction(\\'install-dense-model\\')">Verify model</button>'
+        + '</span>';
+    } else if (!de.ready) {
+      html += '<div class="card" style="margin-bottom:16px;border-left:3px solid #f59e0b">';
+      html += '<div class="card-body" style="padding:14px;display:flex;align-items:center;gap:14px;flex-wrap:wrap">';
+      html += '<div style="flex:1;min-width:240px">';
+      html += '<div style="font-weight:600;margin-bottom:4px">Embedding model is cached but has not been verified in this daemon</div>';
+      html += '<div style="font-size:12px;color:var(--text-muted)">Run a quick load check to confirm the local model is usable before relying on dense recall.</div>';
+      html += '</div>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'install-dense-model\\')" title="Load and verify the cached model">Verify model</button>';
+      html += '</div></div>';
+    } else if (de.total > 0 && de.withDense < de.total) {
       var missing = de.total - de.withDense;
       html += '<span style="margin-left:auto;display:flex;gap:6px">'
         + '<span style="color:var(--text-muted)">' + missing.toLocaleString() + ' missing</span>'
@@ -22882,12 +22973,17 @@ async function refreshRecentWrites() {
 }
 
 async function memoryHealthAction(action, extra) {
-  var labels = { 'janitor': 'cleanup', 'rebuild-fts': 'FTS rebuild', 'fix-orphans': 'orphan fix', 'reembed-dense': 'dense embedding backfill' };
+  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;
   try {
     var body = Object.assign({ action: action }, extra || {});
     var r = await apiJson('POST', '/api/memory/health/action', body);
     if (r.error) { toast('Action failed: ' + r.error, 'error'); return; }
+    if (action === 'install-dense-model') {
+      toast('Embedding model verified: ' + (r.model || 'local model'), 'success');
+      refreshMemoryHealth();
+      return;
+    }
     if (action === 'reembed-dense' && r.started) {
       toast('Backfill started in background (' + (r.limit || '?') + ' chunks). Refreshing every 10s…', 'info');
       // Poll coverage updates so the user sees progress without manually refreshing.
@@ -23129,7 +23225,7 @@ async function refreshMemoryHealth() {
 
     // Dense embedding coverage — the leading indicator for retrieval quality.
     // <50% means the agent is mostly searching on TF-IDF and missing semantic matches.
-    var de = h.denseEmbeddings || { withDense: 0, total: 0, models: [], currentModel: '', ready: false };
+    var de = h.denseEmbeddings || { withDense: 0, total: 0, models: [], currentModel: '', ready: false, installed: false, cacheSize: '0 B' };
     var densePct = de.total > 0 ? ((de.withDense / de.total) * 100).toFixed(1) : '0.0';
     var denseColor = de.total === 0 ? 'var(--text-muted)'
       : (de.withDense / Math.max(1, de.total)) >= 0.95 ? 'var(--success, #10b981)'
@@ -23140,12 +23236,22 @@ async function refreshMemoryHealth() {
       + '<div class="metric-hero-value" style="color:' + denseColor + '">' + densePct + '%</div>'
       + '<div class="metric-hero-label">Semantic Coverage</div>'
       + '<div class="metric-hero-sub">' + (de.withDense || 0) + ' of ' + (de.total || 0)
-      + ' chunks &middot; ' + esc(modelLabel) + '</div></div>';
+      + ' chunks &middot; ' + esc(modelLabel) + ' &middot; model ' + (de.installed ? esc(de.cacheSize || 'cached') : 'not installed') + '</div></div>';
 
     html += '</div>';
 
     // Coverage call-to-action — only render when there's work to do.
-    if (de.total > 0 && de.withDense < de.total) {
+    if (!de.installed) {
+      html += '<div class="card" style="margin-bottom:16px;border-left:3px solid #f59e0b">';
+      html += '<div class="card-body" style="padding:14px;display:flex;align-items:center;gap:14px;flex-wrap:wrap">';
+      html += '<div style="flex:1;min-width:240px">';
+      html += '<div style="font-weight:600;margin-bottom:4px">Local embedding model is not installed yet</div>';
+      html += '<div style="font-size:12px;color:var(--text-muted)">Install once to enable dense semantic recall without waiting for the first chat or backfill to download it.</div>';
+      if (de.cacheDir) html += '<div style="font-size:11px;color:var(--text-muted);margin-top:4px;font-family:\\x27JetBrains Mono\\x27,monospace">' + esc(de.cacheDir) + '</div>';
+      html += '</div>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'install-dense-model\\')" title="Download and verify the local dense embedding model">Install model</button>';
+      html += '</div></div>';
+    } else if (de.total > 0 && de.withDense < de.total) {
       var missing = de.total - de.withDense;
       html += '<div class="card" style="margin-bottom:16px;border-left:3px solid ' + denseColor + '">';
       html += '<div class="card-body" style="padding:14px;display:flex;align-items:center;gap:14px;flex-wrap:wrap">';

package/dist/cli/index.js

@@ -64,6 +64,45 @@ function getLaunchdPlistPath() {
 function getSystemdServiceName() {
     return `${getAssistantName().toLowerCase()}.service`;
 }
+function formatBytes(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return '0 B';
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function dirSizeBytes(dir) {
+    if (!existsSync(dir))
+        return 0;
+    let total = 0;
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                total += dirSizeBytes(full);
+            else if (entry.isFile())
+                total += statSync(full).size;
+        }
+    }
+    catch {
+        return total;
+    }
+    return total;
+}
+async function suppressStdout(fn) {
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = () => true;
+    try {
+        return await fn();
+    }
+    finally {
+        process.stdout.write = originalWrite;
+    }
+}
 function getSystemdServicePath() {
     const home = process.env.HOME ?? '';
     return path.join(home, '.config', 'systemd', 'user', getSystemdServiceName());
@@ -797,6 +836,24 @@ function cmdDoctor(opts = {}) {
     else {
         console.log(`  ${DIM}  ○  memory database (created on first launch)${RESET}`);
     }
+    // Local dense embedding model cache. Doctor does a cheap filesystem check;
+    // `--fix` runs the real model probe/installer so users can verify the model
+    // without needing to know the hidden Transformers.js cache mechanics.
+    const modelCacheDir = path.join(BASE_DIR, 'models');
+    const modelCacheBytes = dirSizeBytes(modelCacheDir);
+    if (modelCacheBytes >= 1024 * 1024) {
+        console.log(`  ${GREEN}OK${RESET}  local embedding model cache (${formatBytes(modelCacheBytes)})`);
+        console.log(`       ${DIM}Verify load: clementine memory model status --probe${RESET}`);
+    }
+    else {
+        console.log(`  ${YELLOW}WARN${RESET}  local embedding model not installed/verified`);
+        const installCmd = `"${process.execPath}" "${path.join(PACKAGE_ROOT, 'dist', 'cli', 'index.js')}" memory model install`;
+        if (!tryFix('local embedding model', installCmd, { cwd: PACKAGE_ROOT, timeout: 10 * 60_000 })) {
+            console.log(`       Install: ${CYAN}clementine memory model install${RESET}`);
+            console.log(`       Auto-prefetch on updates: ${CYAN}clementine config set CLEMENTINE_PREFETCH_EMBEDDINGS 1${RESET}`);
+            issues++;
+        }
+    }
     // Channel tokens (informational)
     if (existsSync(ENV_PATH)) {
         const env = readFileSync(ENV_PATH, 'utf-8');
@@ -3100,6 +3157,123 @@ memoryCmd
         process.exit(1);
     }
 });
+const memoryModelCmd = memoryCmd
+    .command('model')
+    .description('Inspect or install the local dense embedding model used for semantic recall');
+memoryModelCmd
+    .command('status')
+    .description('Show whether the local dense embedding model is cached and optionally verify it loads')
+    .option('--probe', 'Load the model to verify the cache is usable; first run may download weights')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const GREEN = '\x1b[0;32m';
+    const YELLOW = '\x1b[0;33m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    try {
+        if (opts.json)
+            process.env.CLEMENTINE_EMBEDDINGS_LOG_LEVEL = process.env.CLEMENTINE_EMBEDDINGS_LOG_LEVEL || 'silent';
+        const embeddings = await import('../memory/embeddings.js');
+        const cacheDir = embeddings.denseModelCacheDir();
+        const cacheBytes = dirSizeBytes(cacheDir);
+        const probeRan = !!opts.probe;
+        let ready = embeddings.isDenseReady();
+        if (opts.probe) {
+            ready = opts.json
+                ? await suppressStdout(() => embeddings.probeDenseReady())
+                : await embeddings.probeDenseReady();
+        }
+        const status = {
+            model: embeddings.currentDenseModel(),
+            dimension: embeddings.denseDimension(),
+            cacheDir,
+            cacheExists: existsSync(cacheDir),
+            cacheBytes,
+            cacheSize: formatBytes(cacheBytes),
+            readyInThisProcess: embeddings.isDenseReady(),
+            verified: probeRan ? ready : false,
+            probeRan,
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        console.log();
+        console.log(`  ${BOLD}Local embedding model${RESET}`);
+        console.log(`  Model:       ${status.model}`);
+        console.log(`  Dimension:   ${status.dimension}`);
+        console.log(`  Cache:       ${status.cacheExists ? `${GREEN}${status.cacheSize}${RESET}` : `${YELLOW}missing${RESET}`} ${DIM}${cacheDir}${RESET}`);
+        if (probeRan) {
+            console.log(`  Load check:  ${ready ? `${GREEN}verified${RESET}` : `${RED}failed${RESET}`}`);
+        }
+        else {
+            console.log(`  Load check:  ${DIM}not run (use --probe to verify)${RESET}`);
+        }
+        if (!status.cacheExists || status.cacheBytes < 1024 * 1024) {
+            console.log();
+            console.log(`  ${DIM}Install with: clementine memory model install${RESET}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  ${RED}Error reading model status${RESET}: ${err}`);
+        process.exit(1);
+    }
+});
+memoryModelCmd
+    .command('install')
+    .description('Download/cache and verify the local dense embedding model; optionally backfill memory chunks')
+    .option('--model <id>', 'Override embedding model id (default: Snowflake/snowflake-arctic-embed-m-v1.5)')
+    .option('--backfill', 'After installing, backfill dense embeddings for existing chunks')
+    .option('--limit <n>', 'Backfill at most N chunks when --backfill is used')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const GREEN = '\x1b[0;32m';
+    const YELLOW = '\x1b[0;33m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    try {
+        if (opts.model)
+            process.env.EMBEDDING_DENSE_MODEL = opts.model;
+        const embeddings = await import('../memory/embeddings.js');
+        console.log();
+        console.log(`  ${BOLD}Installing local embedding model${RESET}`);
+        console.log(`  Model: ${embeddings.currentDenseModel()}`);
+        console.log(`  Cache: ${embeddings.denseModelCacheDir()}`);
+        console.log(`  ${DIM}First run may download model weights; later runs use the local cache.${RESET}`);
+        const ready = await embeddings.probeDenseReady();
+        if (!ready) {
+            console.error(`  ${RED}Failed to load dense embedding model.${RESET}`);
+            console.error(`  ${DIM}Check network access for the first download, then re-run this command.${RESET}`);
+            process.exit(1);
+        }
+        const cacheBytes = dirSizeBytes(embeddings.denseModelCacheDir());
+        console.log(`  ${GREEN}✓${RESET} Model ready (${embeddings.denseDimension()}-dim, ${formatBytes(cacheBytes)} cached).`);
+        if (opts.backfill) {
+            const limit = opts.limit ? parseInt(opts.limit, 10) : undefined;
+            const { MemoryStore } = await import('../memory/store.js');
+            const VAULT_DIR = path.join(BASE_DIR, 'vault');
+            const DB_PATH = path.join(VAULT_DIR, '.memory.db');
+            const store = new MemoryStore(DB_PATH, VAULT_DIR);
+            store.initialize();
+            console.log();
+            console.log(`  ${BOLD}Backfilling memory chunks${RESET}${limit ? ` ${DIM}(limit ${limit})${RESET}` : ''}`);
+            const result = await store.backfillDenseEmbeddings({ limit });
+            console.log(`  ${GREEN}✓${RESET} Embedded ${result.embedded.toLocaleString()} chunk${result.embedded === 1 ? '' : 's'}.`);
+            if (result.failed > 0) {
+                console.log(`  ${YELLOW}!${RESET} Failed ${result.failed.toLocaleString()} chunk${result.failed === 1 ? '' : 's'}.`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  ${RED}Error installing model${RESET}: ${err}`);
+        process.exit(1);
+    }
+});
 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/.')

package/dist/cli/ingest.js

@@ -62,7 +62,11 @@ export async function cmdIngestSeed(inputPath, opts) {
     console.log(`  Records in:      ${result.recordsIn}`);
     console.log(`  Records written: ${result.recordsWritten}`);
     console.log(`  Records skipped: ${result.recordsSkipped}`);
+    console.log(`  Records unchanged: ${result.recordsUnchanged}`);
     console.log(`  Records failed:  ${result.recordsFailed}`);
+    if (result.recallCheckStatus) {
+        console.log(`  Recall check:    ${result.recallCheckStatus}${result.recallCheck ? ` (${result.recallCheck.hits}/${result.recallCheck.checked})` : ''}`);
+    }
     if (result.overviewNotePath) {
         console.log(`  Overview note:   ${result.overviewNotePath}`);
     }
@@ -94,7 +98,9 @@ export async function cmdIngestRun(slug) {
         },
     });
     process.stdout.write('\n');
-    console.log(`  written=${result.recordsWritten} skipped=${result.recordsSkipped} failed=${result.recordsFailed}`);
+    console.log(`  written=${result.recordsWritten} unchanged=${result.recordsUnchanged} skipped=${result.recordsSkipped} failed=${result.recordsFailed}`);
+    if (result.recallCheckStatus)
+        console.log(`  recall=${result.recallCheckStatus}`);
     if (result.overviewNotePath) {
         console.log(`  overview: ${result.overviewNotePath}`);
     }
@@ -130,7 +136,7 @@ export async function cmdIngestStatus(slug) {
     }
     console.log(`\nRecent runs (${runs.length}):\n`);
     for (const r of runs) {
-        console.log(`  #${r.id}  ${r.startedAt}  ${r.status.padEnd(8)}  in=${r.recordsIn} written=${r.recordsWritten} skipped=${r.recordsSkipped} failed=${r.recordsFailed}`);
+        console.log(`  #${r.id}  ${r.startedAt}  ${r.status.padEnd(8)}  in=${r.recordsIn} written=${r.recordsWritten} unchanged=${r.recordsUnchanged} skipped=${r.recordsSkipped} failed=${r.recordsFailed} recall=${r.recallCheckStatus ?? '—'}`);
         if (r.overviewNotePath)
             console.log(`         overview: ${r.overviewNotePath}`);
     }

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

@@ -0,0 +1,17 @@
+export interface GatewayContextSnapshot {
+    sessionKey: string;
+    textChars: number;
+    exchangeCount: number;
+    pendingContextChars?: number;
+    recentTranscriptChars?: number;
+}
+export interface GatewayContextHygieneDecision {
+    shouldCompact: boolean;
+    reason: string;
+    estimatedTokens: number;
+}
+export declare const GATEWAY_CONTEXT_COMPACT_EXCHANGES = 30;
+export declare const GATEWAY_CONTEXT_COMPACT_TOKENS = 90000;
+export declare function assessGatewayContextHygiene(snapshot: GatewayContextSnapshot): GatewayContextHygieneDecision;
+export declare function formatGatewayHygieneAnnotation(decision: GatewayContextHygieneDecision): string;
+//# sourceMappingURL=context-hygiene.d.ts.map

package/dist/gateway/context-hygiene.js

@@ -0,0 +1,31 @@
+import { estimateTokensApprox } from './turn-ledger.js';
+export const GATEWAY_CONTEXT_COMPACT_EXCHANGES = 30;
+export const GATEWAY_CONTEXT_COMPACT_TOKENS = 90_000;
+export function assessGatewayContextHygiene(snapshot) {
+    const totalChars = snapshot.textChars + (snapshot.pendingContextChars ?? 0) + (snapshot.recentTranscriptChars ?? 0);
+    const estimatedTokens = estimateTokensApprox('x'.repeat(Math.min(totalChars, 400_000)))
+        + Math.max(0, Math.ceil((totalChars - 400_000) / 4));
+    if (snapshot.exchangeCount >= GATEWAY_CONTEXT_COMPACT_EXCHANGES) {
+        return {
+            shouldCompact: true,
+            reason: `exchange_count_${snapshot.exchangeCount}`,
+            estimatedTokens,
+        };
+    }
+    if (estimatedTokens >= GATEWAY_CONTEXT_COMPACT_TOKENS) {
+        return {
+            shouldCompact: true,
+            reason: `estimated_tokens_${estimatedTokens}`,
+            estimatedTokens,
+        };
+    }
+    return {
+        shouldCompact: false,
+        reason: 'within_budget',
+        estimatedTokens,
+    };
+}
+export function formatGatewayHygieneAnnotation(decision) {
+    return `[Context hygiene: compacted older session context before this turn (${decision.reason}, approx ${decision.estimatedTokens} tokens in visible gateway inputs). Continuity was saved to session summaries and lineage; use transcript_search/memory for exact details.]`;
+}
+//# sourceMappingURL=context-hygiene.js.map

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

@@ -8,6 +8,26 @@ import type { HeartbeatWorkItem } from '../types.js';
 import type { CronScheduler } from './cron-scheduler.js';
 import type { NotificationDispatcher } from './notifications.js';
 import type { Gateway } from './router.js';
+export declare function buildInsightCheckCronCall(prompt: string): {
+    jobName: 'insight-check';
+    jobPrompt: string;
+    tier: 1;
+    maxTurns: 1;
+    model: 'haiku';
+    opts: {
+        disableAllTools: true;
+    };
+};
+export declare function buildConsolidationCronCall(prompt: string): {
+    jobName: 'consolidation-llm';
+    jobPrompt: string;
+    tier: 1;
+    maxTurns: 1;
+    model: 'haiku';
+    opts: {
+        disableAllTools: true;
+    };
+};
 export declare class HeartbeatScheduler {
     private readonly stateFile;
     private gateway;

package/dist/gateway/heartbeat-scheduler.js

@@ -17,6 +17,26 @@ import { recentDecisions, recordDecision, recordDecisionOutcome, wasRecentlyDeci
 import { CronRunLog, logToDailyNote, todayISO } from './cron-scheduler.js';
 const logger = pino({ name: 'clementine.heartbeat' });
 const PROACTIVE_DECISION_DEDUPE_MS = 24 * 60 * 60 * 1000;
+export function buildInsightCheckCronCall(prompt) {
+    return {
+        jobName: 'insight-check',
+        jobPrompt: prompt,
+        tier: 1,
+        maxTurns: 1,
+        model: 'haiku',
+        opts: { disableAllTools: true },
+    };
+}
+export function buildConsolidationCronCall(prompt) {
+    return {
+        jobName: 'consolidation-llm',
+        jobPrompt: prompt,
+        tier: 1,
+        maxTurns: 1,
+        model: 'haiku',
+        opts: { disableAllTools: true },
+    };
+}
 // ── HeartbeatScheduler ────────────────────────────────────────────────
 export class HeartbeatScheduler {
     stateFile;
@@ -265,7 +285,8 @@ export class HeartbeatScheduler {
                 }
                 // LLM callback for summarization/principle extraction
                 const llmCall = async (prompt) => {
-                    const result = await this.gateway.handleCronJob('consolidation-llm', prompt, 1, 1, 'haiku');
+                    const cronCall = buildConsolidationCronCall(prompt);
+                    const result = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, 'standard', undefined, undefined, undefined, undefined, cronCall.opts);
                     return result || '';
                 };
                 const result = await runConsolidation(store, llmCall);
@@ -905,18 +926,14 @@ export class HeartbeatScheduler {
         const prompt = buildInsightPrompt(signals);
         if (!prompt)
             return;
-        // Run lightweight LLM call via gateway. Log success AND failure to the
-        // cron run log so the failure monitor can see hourly breakage.
-        // maxTurns bumped 1 → 3 because the agent needs to fan out ~4 parallel
-        // tool calls (activity_history, outlook_inbox, goal_list, task_list)
-        // before composing its rating — at 1 turn it always crashes with
-        // "Reached maximum number of turns".
+        // Run a no-tool classifier call via gateway. gatherInsightSignals()
+        // already assembled the local signal list; attaching MCP schemas here can
+        // make the prompt too large before the model ever evaluates urgency.
         const icStartedAt = new Date();
         let response = null;
         try {
-            response = await this.gateway.handleCronJob('insight-check', prompt, 1, // tier 1
-            3, // max 3 turns (parallel tool fan-out + synthesis)
-            'haiku');
+            const cronCall = buildInsightCheckCronCall(prompt);
+            response = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, 'standard', undefined, undefined, undefined, undefined, cronCall.opts);
             this.runLog.append({
                 jobName: 'insight-check',
                 startedAt: icStartedAt.toISOString(),

package/dist/gateway/router.d.ts

@@ -11,10 +11,12 @@ import { TeamRouter } from '../agent/team-router.js';
 import { TeamBus } from '../agent/team-bus.js';
 import type { NotificationDispatcher } from './notifications.js';
 import { type ProactiveNotificationInput } from './notification-context.js';
-export type ChatErrorKind = 'rate_limit' | 'context_overflow' | 'auth' | 'billing' | 'transient' | 'unknown';
+import { type ToolsetName } from '../agent/toolsets.js';
+export type ChatErrorKind = 'rate_limit' | 'one_million_context' | 'context_overflow' | 'auth' | 'billing' | 'transient' | 'unknown';
 export declare function classifyChatError(err: unknown): ChatErrorKind;
 /** Detect auth-like errors in response text that the SDK returned as "successful" results. */
 export declare function looksLikeAuthError(text: string): boolean;
+export declare function isLiveUnleashedStatus(status: Record<string, unknown>, nowMs?: number): boolean;
 export declare class Gateway {
     readonly assistant: PersonalAssistant;
     /** Resolvers for pending approvals. `true` = approved, `false` = denied, `string` = revision feedback. */
@@ -143,6 +145,8 @@ export declare class Gateway {
     }): Promise<string>;
     setSessionVerboseLevel(sessionKey: string, level: VerboseLevel): void;
     getSessionVerboseLevel(sessionKey: string): VerboseLevel | undefined;
+    setSessionToolset(sessionKey: string, toolset: ToolsetName): void;
+    getSessionToolset(sessionKey: string): ToolsetName;
     setSessionModel(sessionKey: string, modelId: string): void;
     getSessionModel(sessionKey: string): string | undefined;
     setSessionProject(sessionKey: string, project: ProjectMeta): void;
@@ -238,6 +242,9 @@ export declare class Gateway {
         maxExchanges: number;
         memoryCount: number;
     };
+    compactSessionForUser(sessionKey: string): string;
+    describeSessionUsage(sessionKey: string): string;
+    describeSessionDebug(sessionKey: string): string;
     clearSession(sessionKey: string): void;
     /** Get the last auto-matched project for a session. */
     getLastMatchedProject(sessionKey: string): {