clementine-agent 1.18.20 → 1.18.21

package/dist/channels/discord.js

@@ -13,6 +13,8 @@ import path from 'node:path';
 import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, rehydrateStatusEmbed, setSavedStatusEmbed, } from './discord-utils.js';
 import { DISCORD_TOKEN, DISCORD_OWNER_ID, DISCORD_WATCHED_CHANNELS, MODELS, ASSISTANT_NAME, OWNER_NAME, PKG_DIR, VAULT_DIR, BASE_DIR, DEFAULT_MODEL_TIER, } from '../config.js';
 import { findProjectByName, getLinkedProjects } from '../agent/assistant.js';
+import { detectApprovalReply } from '../agent/local-turn.js';
+import { normalizeToolsetName } from '../agent/toolsets.js';
 import * as cronParser from 'cron-parser';
 const logger = pino({ name: 'clementine.discord' });
 const BOT_MESSAGE_TRACKING_LIMIT = 100;
@@ -35,6 +37,12 @@ const slashCommands = [
         .addStringOption(o => o.setName('job').setDescription('Job name (for run/enable/disable)').setAutocomplete(true)),
     new SlashCommandBuilder().setName('heartbeat').setDescription('Run heartbeat check manually'),
     new SlashCommandBuilder().setName('tools').setDescription('List available MCP tools'),
+    new SlashCommandBuilder().setName('toolset').setDescription('Set this chat tool mode')
+        .addStringOption(o => o.setName('mode').setDescription('Tool mode').setRequired(true)
+        .addChoices({ name: 'Auto', value: 'auto' }, { name: 'Safe', value: 'safe' }, { name: 'Diagnostic', value: 'diagnostic' }, { name: 'Communications', value: 'communications' }, { name: 'Memory', value: 'memory' }, { name: 'Full', value: 'full' })),
+    new SlashCommandBuilder().setName('compress').setDescription('Compact this conversation context into memory'),
+    new SlashCommandBuilder().setName('usage').setDescription('Show recent turn/tool usage for this chat'),
+    new SlashCommandBuilder().setName('debug').setDescription('Show session diagnostics for this chat'),
     new SlashCommandBuilder().setName('project').setDescription('Set active project context')
         .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
         .addChoices({ name: 'List projects', value: 'list' }, { name: 'Set active project', value: 'set' }, { name: 'Clear active project', value: 'clear' }, { name: 'Show current', value: 'status' }))
@@ -269,6 +277,8 @@ function handleHelp() {
         '`!self-improve run|status|history|pending|apply|deny` \u2014 Self-improvement',
         '`!team setup|list|status|messages|topology` \u2014 Manage agent team',
         '`!status [job]` \u2014 Check unleashed task progress',
+        '`/toolset` \u2014 Set tool mode \u00b7 `/compress` \u2014 Compact context \u00b7 `/usage` \u2014 Usage snapshot',
+        '`/debug` \u2014 Session diagnostics',
         '`!dashboard` \u2014 Send a fresh system status embed',
         '`!heartbeat` \u2014 Run heartbeat \u00b7 `!tools` \u2014 List tools \u00b7 `!clear` \u2014 Reset',
         '`!stop` \u2014 Interrupt current response',
@@ -1074,15 +1084,12 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
             }
             // ── Approval responses (DM only) ────────────────────────────────
             if (isDm) {
-                const lower = text.toLowerCase();
-                if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+                const approvalReply = detectApprovalReply(text);
+                if (approvalReply !== null) {
                     const approvals = gateway.getPendingApprovals();
                     if (approvals.length > 0) {
-                        // Pass 'always' as a string so the check-in gate can persist the channel
-                        const result = lower === 'always' ? 'always' :
-                            (lower === 'yes' || lower === 'approve' || lower === 'go');
-                        gateway.resolveApproval(approvals[approvals.length - 1], result);
-                        await message.react(lower === 'no' || lower === 'deny' || lower === 'skip' ? '\u274c' : '\u2705');
+                        gateway.resolveApproval(approvals[approvals.length - 1], approvalReply);
+                        await message.react(approvalReply === false ? '\u274c' : '\u2705');
                         return;
                     }
                 }
@@ -1227,6 +1234,30 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                     await cmd.reply(formatToolsList());
                     return;
                 }
+                if (name === 'toolset') {
+                    const mode = normalizeToolsetName(cmd.options.getString('mode', true));
+                    if (!mode) {
+                        await cmd.reply({ content: 'Unknown toolset.', ephemeral: true });
+                        return;
+                    }
+                    gateway.setSessionToolset(sessionKey, mode);
+                    await cmd.reply({ content: `Toolset set to **${mode}**.`, ephemeral: true });
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'compress') {
+                    await cmd.reply({ content: gateway.compactSessionForUser(sessionKey), ephemeral: true });
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'usage') {
+                    await cmd.reply({ content: gateway.describeSessionUsage(sessionKey), ephemeral: true });
+                    return;
+                }
+                if (name === 'debug') {
+                    await cmd.reply({ content: gateway.describeSessionDebug(sessionKey).slice(0, 1900), ephemeral: true });
+                    return;
+                }
                 if (name === 'status') {
                     const jobArg = cmd.options.getString('job') ?? undefined;
                     await cmd.reply(handleUnleashedStatus(jobArg));

package/dist/channels/telegram.js

@@ -7,6 +7,7 @@
 import { Bot } from 'grammy';
 import pino from 'pino';
 import { TELEGRAM_BOT_TOKEN, TELEGRAM_OWNER_ID, } from '../config.js';
+import { detectApprovalReply } from '../agent/local-turn.js';
 const logger = pino({ name: 'clementine.telegram' });
 const STREAM_UPDATE_INTERVAL = 1500; // ms
 const TELEGRAM_MSG_LIMIT = 4096;
@@ -139,14 +140,12 @@ export async function startTelegram(gateway, dispatcher) {
         const chatId = ctx.chat.id;
         const sessionKey = `telegram:user:${userId}`;
         // ── Approval responses ──────────────────────────────────────────
-        const lower = text.toLowerCase().trim();
-        if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+        const approvalReply = detectApprovalReply(text);
+        if (approvalReply !== null) {
             const approvals = gateway.getPendingApprovals();
             if (approvals.length > 0) {
-                const result = lower === 'always' ? 'always' :
-                    (lower === 'yes' || lower === 'approve' || lower === 'go');
-                gateway.resolveApproval(approvals[approvals.length - 1], result);
-                const approved = result !== false;
+                gateway.resolveApproval(approvals[approvals.length - 1], approvalReply);
+                const approved = approvalReply !== false;
                 await ctx.reply(approved ? '✅ Approved.' : '❌ Denied.');
                 return;
             }

package/dist/cli/dashboard.js

@@ -6572,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
@@ -22854,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;
@@ -22866,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>'
@@ -22938,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.
@@ -23185,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)'
@@ -23196,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';
+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): {