clementine-agent 1.1.19 → 1.1.21

package/dist/agent/self-improve.js

@@ -23,6 +23,7 @@ const DEFAULT_CONFIG = {
     iterationBudgetMs: 300_000, // 5 min
     maxDurationMs: 3_600_000, // 1 hour
     acceptThreshold: 0.7,
+    surfaceThreshold: 0.85,
     plateauLimit: 3,
     // 'source' deprecated — self-improvement produces data, not engine TS edits.
     // 'advisor-rule' writes YAML to ~/.clementine/advisor-rules/user/.
@@ -300,12 +301,25 @@ export class SelfImproveLoop {
                     const score = evaluation?.score ?? 0;
                     const normalizedScore = score / 10; // Convert 0-10 to 0-1
                     const accepted = normalizedScore >= this.config.acceptThreshold;
+                    // Surface gate: even when accepted, only score >= surfaceThreshold
+                    // reaches the user's pending-changes inbox. Below that floor we
+                    // keep the experiment in the trend log but don't ping the user.
+                    const surfaceFloor = this.config.surfaceThreshold ?? this.config.acceptThreshold;
+                    const surfaced = normalizedScore >= surfaceFloor;
                     const priorScores = history
                         .filter(e => e.area === proposal.area && e.target === proposal.target && e.score > 0)
                         .map(e => e.score);
                     const baselineScore = priorScores.length > 0
                         ? priorScores.reduce((a, b) => a + b, 0) / priorScores.length
                         : 0.5;
+                    const initialStatus = accepted
+                        ? (surfaced ? 'pending' : 'unsurfaced')
+                        : 'denied';
+                    const reason = accepted
+                        ? (surfaced
+                            ? `Score ${score}/10 exceeds surface threshold — pending approval`
+                            : `Score ${score}/10 accepted but below surface floor (${surfaceFloor * 10}/10) — kept in trend log only`)
+                        : `Score ${score}/10 below accept threshold (${this.config.acceptThreshold * 10}/10)`;
                     const experiment = {
                         id,
                         iteration: i,
@@ -319,17 +333,19 @@ export class SelfImproveLoop {
                         baselineScore,
                         score: normalizedScore,
                         accepted,
-                        approvalStatus: accepted ? 'pending' : 'denied',
-                        reason: accepted
-                            ? `Score ${score}/10 exceeds threshold — pending approval`
-                            : `Score ${score}/10 below threshold (${this.config.acceptThreshold * 10}/10)`,
+                        approvalStatus: initialStatus,
+                        reason,
                     };
                     // Step 7: Log
                     this.appendExperimentLog(experiment);
                     history.push(experiment);
                     state.totalExperiments++;
-                    // Step 6: Gate — save pending change + notify (tiered by risk)
-                    if (accepted) {
+                    if (accepted && !surfaced) {
+                        logger.info({ id, area: proposal.area, target: proposal.target, score: score, surfaceFloor: surfaceFloor * 10 }, 'Proposal accepted but unsurfaced — below noise floor, not added to review queue');
+                    }
+                    // Step 6: Gate — save pending change + notify (tiered by risk).
+                    // Only proposals that ALSO clear the surface floor reach the inbox.
+                    if (accepted && surfaced) {
                         const risk = classifyRisk(proposal.area);
                         if (this.config.autoApply && risk === 'low') {
                             // Low-risk + auto-apply enabled: apply immediately without approval

package/dist/cli/index.js

@@ -2090,10 +2090,390 @@ configCmd
         console.error(`  Failed to open editor: ${editor}`);
     }
 });
+// ── Agent commands ──────────────────────────────────────────────────
+const agentCmd = program
+    .command('agent')
+    .description('Hire, list, and manage specialist agents');
+agentCmd
+    .command('list')
+    .description('List all agents with status and tier')
+    .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 {
+        const { AgentManager } = await import('../agent/agent-manager.js');
+        const AGENTS_DIR = path.join(BASE_DIR, 'agents');
+        const mgr = new AgentManager(AGENTS_DIR);
+        const agents = mgr.listAll();
+        if (opts.json) {
+            console.log(JSON.stringify(agents.map(a => ({
+                slug: a.slug, name: a.name, status: a.status, tier: a.tier,
+                description: a.description, hasChannel: !!a.team?.channelName,
+            })), null, 2));
+            return;
+        }
+        if (agents.length === 0) {
+            console.log(`\n  No agents found in ${AGENTS_DIR}.`);
+            console.log(`  Hire one: ${BOLD}clementine agent new <slug>${RESET}\n`);
+            return;
+        }
+        console.log();
+        console.log(`  ${BOLD}${'SLUG'.padEnd(28)}${'NAME'.padEnd(24)}${'STATUS'.padEnd(12)}${'TIER'.padEnd(6)}${RESET}`);
+        console.log(`  ${DIM}${'─'.repeat(70)}${RESET}`);
+        for (const a of agents) {
+            const statusColor = a.status === 'active' ? GREEN : a.status === 'paused' ? YELLOW : RED;
+            const statusStr = `${statusColor}${(a.status ?? 'active').padEnd(10)}${RESET}`;
+            console.log(`  ${a.slug.padEnd(28)}${(a.name ?? '').slice(0, 22).padEnd(24)}${statusStr}  ${String(a.tier).padEnd(6)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error listing agents: ${err}`);
+        process.exit(1);
+    }
+});
+agentCmd
+    .command('new <slug>')
+    .description('Scaffold a new agent at agents/<slug>/agent.md (does not overwrite)')
+    .option('-n, --name <name>', 'Display name (default: title-case of slug)')
+    .option('-d, --description <text>', 'One-line description of what the agent does')
+    .option('-r, --role <role>', 'Role template — auto-scaffolds CRON.md / PLAYBOOK.md (sdr, researcher)')
+    .option('-t, --tier <tier>', 'Security tier — 1 = vault-only, 2 = bash/git allowed', '1')
+    .option('-m, --model <model>', 'Default model (sonnet, haiku, opus). Inherits global default if omitted.')
+    .option('--channel <name>', 'Discord/Slack channel name the agent listens in (enables team mode)')
+    .action(async (slug, opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const GREEN = '\x1b[0;32m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    // Validate slug — lowercase, dashes, alphanumeric, no leading/trailing dash.
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(slug) || slug.length < 3) {
+        console.error(`  ${RED}Invalid slug${RESET}: must be 3+ chars, lowercase letters/digits/dashes, no leading/trailing dash. Got: "${slug}"`);
+        process.exit(1);
+    }
+    if (slug === 'clementine') {
+        console.error(`  ${RED}Reserved slug${RESET}: "clementine" is the master assistant. Pick a different name.`);
+        process.exit(1);
+    }
+    const tier = Math.max(1, Math.min(2, parseInt(opts.tier ?? '1', 10) || 1));
+    const name = opts.name ?? slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    const description = opts.description ?? `${name} — specialist agent.`;
+    try {
+        const { AgentManager } = await import('../agent/agent-manager.js');
+        const AGENTS_DIR = path.join(BASE_DIR, 'agents');
+        const mgr = new AgentManager(AGENTS_DIR);
+        // Refuse if already taken (createAgent throws but we want a friendly error)
+        if (mgr.get(slug)) {
+            console.error(`  ${RED}Agent "${slug}" already exists${RESET}. Edit ${path.join(AGENTS_DIR, slug, 'agent.md')} or pick a different slug.`);
+            process.exit(1);
+        }
+        const config = {
+            name,
+            description,
+            tier,
+        };
+        if (opts.model)
+            config.model = opts.model;
+        if (opts.channel)
+            config.channelName = opts.channel;
+        if (opts.role)
+            config.role = opts.role;
+        const profile = mgr.createAgent(config);
+        const agentMdPath = path.join(profile.agentDir ?? path.join(AGENTS_DIR, slug), 'agent.md');
+        console.log();
+        console.log(`  ${GREEN}✓${RESET} Created agent ${BOLD}${profile.name}${RESET} (${profile.slug})`);
+        console.log(`  ${DIM}File: ${agentMdPath}${RESET}`);
+        if (opts.role) {
+            console.log(`  ${DIM}Role scaffold "${opts.role}" wrote CRON.md / PLAYBOOK.md / SEQUENCES.md if applicable.${RESET}`);
+        }
+        console.log();
+        console.log(`  Next steps:`);
+        console.log(`    1. Edit ${BOLD}agent.md${RESET} to refine personality / standing instructions`);
+        if (!opts.channel) {
+            console.log(`    2. Add a ${BOLD}channelName${RESET} (and DISCORD/SLACK token via 'clementine config set') to give them their own bot`);
+        }
+        console.log(`    3. Edit ${BOLD}~/.clementine/agents/${slug}/CRON.md${RESET} to schedule autonomous work`);
+        console.log(`    4. Restart the daemon: ${BOLD}clementine restart${RESET}`);
+        console.log();
+    }
+    catch (err) {
+        console.error(`  ${RED}Failed to create agent${RESET}: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+});
+agentCmd
+    .command('show <slug>')
+    .description('Show an agent\'s file path and parsed profile summary')
+    .action(async (slug) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    try {
+        const { AgentManager } = await import('../agent/agent-manager.js');
+        const AGENTS_DIR = path.join(BASE_DIR, 'agents');
+        const mgr = new AgentManager(AGENTS_DIR);
+        const profile = mgr.get(slug);
+        if (!profile) {
+            console.error(`  ${RED}Agent "${slug}" not found${RESET}.`);
+            console.error(`  List agents: ${BOLD}clementine agent list${RESET}`);
+            process.exit(1);
+        }
+        const agentMdPath = path.join(profile.agentDir ?? path.join(AGENTS_DIR, slug), 'agent.md');
+        console.log();
+        console.log(`  ${BOLD}${profile.name}${RESET}  ${DIM}(${profile.slug})${RESET}`);
+        console.log(`  ${DIM}${agentMdPath}${RESET}`);
+        console.log();
+        console.log(`  Status:       ${profile.status ?? 'active'}`);
+        console.log(`  Tier:         ${profile.tier}`);
+        if (profile.model)
+            console.log(`  Model:        ${profile.model}`);
+        console.log(`  Description:  ${profile.description || DIM + '(none)' + RESET}`);
+        if (profile.team?.channelName) {
+            const ch = Array.isArray(profile.team.channelName) ? profile.team.channelName.join(', ') : profile.team.channelName;
+            console.log(`  Channel:      ${ch}`);
+        }
+        if (profile.activeHours) {
+            console.log(`  Active hours: ${profile.activeHours.start.toFixed(2)}–${profile.activeHours.end.toFixed(2)} (decimal hours)`);
+        }
+        if (profile.budgetMonthlyCents != null && profile.budgetMonthlyCents > 0) {
+            console.log(`  Budget/mo:    $${(profile.budgetMonthlyCents / 100).toFixed(2)}`);
+        }
+        console.log(`  Strict mem:   ${profile.strictMemoryIsolation === false ? 'no (soft boost)' : 'yes (default)'}`);
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error reading agent: ${err}`);
+        process.exit(1);
+    }
+});
 // ── Memory commands ─────────────────────────────────────────────────
 const memoryCmd = program
     .command('memory')
     .description('Search and manage memory');
+memoryCmd
+    .command('status')
+    .description('Show memory store stats — chunk count, embeddings coverage, agent/category breakdown, salience')
+    .option('--json', 'Emit machine-readable JSON')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const CYAN = '\x1b[0;36m';
+    const RESET = '\x1b[0m';
+    try {
+        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);
+        const stats = store.getMemoryStats();
+        if (opts.json) {
+            console.log(JSON.stringify(stats, null, 2));
+            return;
+        }
+        const pct = stats.totalChunks > 0
+            ? ((stats.chunksWithEmbeddings / stats.totalChunks) * 100).toFixed(1)
+            : '0.0';
+        console.log();
+        console.log(`  ${BOLD}Memory store${RESET}  ${DIM}${DB_PATH}${RESET}`);
+        console.log();
+        console.log(`  Total chunks:         ${BOLD}${stats.totalChunks.toLocaleString()}${RESET}`);
+        console.log(`  With embeddings:      ${stats.chunksWithEmbeddings.toLocaleString()} ${DIM}(${pct}%, TF-IDF 512-dim)${RESET}`);
+        console.log(`  Pinned (manual):      ${stats.pinnedChunks}`);
+        console.log(`  Avg salience:         ${stats.avgSalience.toFixed(3)} ${DIM}(0 = no access boost; >1 = strong reinforcement)${RESET}`);
+        if (stats.oldestUpdated) {
+            console.log(`  Date range:           ${stats.oldestUpdated.slice(0, 10)} → ${stats.newestUpdated?.slice(0, 10)}`);
+        }
+        console.log();
+        console.log(`  ${BOLD}Per agent${RESET}`);
+        for (const a of stats.perAgent.slice(0, 10)) {
+            console.log(`    ${CYAN}${a.agentSlug.padEnd(28)}${RESET}${a.count.toLocaleString().padStart(8)}`);
+        }
+        if (stats.perAgent.length > 10)
+            console.log(`    ${DIM}…and ${stats.perAgent.length - 10} more${RESET}`);
+        console.log();
+        console.log(`  ${BOLD}Per category${RESET}`);
+        for (const c of stats.perCategory.slice(0, 10)) {
+            console.log(`    ${CYAN}${c.category.padEnd(28)}${RESET}${c.count.toLocaleString().padStart(8)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error reading memory stats: ${err}`);
+        process.exit(1);
+    }
+});
+memoryCmd
+    .command('pin <chunkId>')
+    .description('Pin a chunk — gives its score a 2x boost in recall (use chunk IDs from `memory search`)')
+    .action(async (chunkIdStr) => {
+    const GREEN = '\x1b[0;32m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    const chunkId = parseInt(chunkIdStr, 10);
+    if (!Number.isFinite(chunkId) || chunkId <= 0) {
+        console.error(`  ${RED}Invalid chunk id${RESET}: "${chunkIdStr}". Use IDs from \`clementine memory search\`.`);
+        process.exit(1);
+    }
+    try {
+        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);
+        const ok = store.setPinned(chunkId, true);
+        if (!ok) {
+            console.error(`  ${RED}Chunk ${chunkId} not found.${RESET}`);
+            process.exit(1);
+        }
+        console.log(`  ${GREEN}✓${RESET} Pinned chunk ${chunkId}. It now gets a 2× boost in memory_recall.`);
+    }
+    catch (err) {
+        console.error(`  Error pinning chunk: ${err}`);
+        process.exit(1);
+    }
+});
+memoryCmd
+    .command('unpin <chunkId>')
+    .description('Unpin a chunk — removes the manual 2x boost, leaves automatic salience untouched')
+    .action(async (chunkIdStr) => {
+    const GREEN = '\x1b[0;32m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    const chunkId = parseInt(chunkIdStr, 10);
+    if (!Number.isFinite(chunkId) || chunkId <= 0) {
+        console.error(`  ${RED}Invalid chunk id${RESET}: "${chunkIdStr}".`);
+        process.exit(1);
+    }
+    try {
+        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);
+        const ok = store.setPinned(chunkId, false);
+        if (!ok) {
+            console.error(`  ${RED}Chunk ${chunkId} not found.${RESET}`);
+            process.exit(1);
+        }
+        console.log(`  ${GREEN}✓${RESET} Unpinned chunk ${chunkId}.`);
+    }
+    catch (err) {
+        console.error(`  Error unpinning chunk: ${err}`);
+        process.exit(1);
+    }
+});
+memoryCmd
+    .command('dedup')
+    .description('Find near-duplicate chunks via embedding cosine similarity. Dry-run by default.')
+    .option('--threshold <n>', 'Cosine similarity threshold (0-1)', '0.95')
+    .option('--apply', 'Actually delete duplicates (default: dry-run preview only)')
+    .option('--limit <n>', 'Max clusters to report', '50')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const GREEN = '\x1b[0;32m';
+    const YELLOW = '\x1b[0;33m';
+    const RESET = '\x1b[0m';
+    const threshold = parseFloat(opts.threshold);
+    const limit = parseInt(opts.limit, 10);
+    try {
+        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);
+        const clusters = store.findNearDuplicates({ threshold, limit });
+        if (clusters.length === 0) {
+            console.log(`  ${GREEN}No near-duplicates found above threshold ${threshold}.${RESET}`);
+            return;
+        }
+        const totalDupes = clusters.reduce((sum, c) => sum + c.duplicates.length, 0);
+        console.log();
+        console.log(`  ${BOLD}Found ${clusters.length} cluster${clusters.length === 1 ? '' : 's'} (${totalDupes} duplicate chunk${totalDupes === 1 ? '' : 's'})${RESET}`);
+        console.log(`  ${DIM}Keeping the most-recent chunk per cluster; older copies will be removed if --apply is passed.${RESET}`);
+        console.log();
+        for (const cluster of clusters.slice(0, 20)) {
+            const keepLabel = `${cluster.keep.sourceFile} > ${cluster.keep.section}`;
+            const agent = cluster.keep.agentSlug ?? 'global';
+            console.log(`  ${BOLD}KEEP${RESET} #${cluster.keep.chunkId}  ${DIM}[${agent}]${RESET}  ${keepLabel}`);
+            for (const dup of cluster.duplicates) {
+                const dupLabel = `${dup.sourceFile} > ${dup.section}`;
+                console.log(`    ${YELLOW}drop${RESET} #${dup.chunkId}  sim=${dup.similarity.toFixed(3)}  ${DIM}${dupLabel}${RESET}`);
+            }
+        }
+        if (clusters.length > 20) {
+            console.log(`  ${DIM}…and ${clusters.length - 20} more clusters (raise --limit to see them).${RESET}`);
+        }
+        console.log();
+        if (opts.apply) {
+            const allDupeIds = clusters.flatMap(c => c.duplicates.map(d => d.chunkId));
+            const removed = store.deleteChunks(allDupeIds);
+            console.log(`  ${GREEN}✓${RESET} Deleted ${removed} duplicate chunk${removed === 1 ? '' : 's'}.`);
+        }
+        else {
+            console.log(`  ${DIM}This was a preview. Re-run with ${BOLD}--apply${RESET}${DIM} to delete the duplicates.${RESET}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error during dedup: ${err}`);
+        process.exit(1);
+    }
+});
+memoryCmd
+    .command('cross-agent')
+    .description('Surface chunks that recur across 3+ agents — candidates for promotion to global memory')
+    .option('--threshold <n>', 'Cosine similarity threshold for "same idea" (0-1)', '0.88')
+    .option('--min-agents <n>', 'Minimum distinct agents touched by a cluster', '3')
+    .option('--limit <n>', 'Max clusters to report', '30')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const CYAN = '\x1b[0;36m';
+    const GREEN = '\x1b[0;32m';
+    const RESET = '\x1b[0m';
+    try {
+        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);
+        const clusters = store.findCrossAgentRecurrence({
+            threshold: parseFloat(opts.threshold),
+            minAgents: parseInt(opts.minAgents, 10),
+            limit: parseInt(opts.limit, 10),
+        });
+        if (clusters.length === 0) {
+            console.log(`  ${GREEN}No cross-agent recurrence found above threshold ${opts.threshold} touching ${opts.minAgents}+ agents.${RESET}`);
+            return;
+        }
+        console.log();
+        console.log(`  ${BOLD}Found ${clusters.length} cluster${clusters.length === 1 ? '' : 's'} recurring across ${opts.minAgents}+ agents${RESET}`);
+        console.log(`  ${DIM}These are candidates for promotion to global memory — facts the team has independently arrived at.${RESET}`);
+        console.log();
+        for (const c of clusters) {
+            const preview = c.representative.content.replace(/\n/g, ' ').slice(0, 140);
+            console.log(`  ${BOLD}Cluster (${c.agents.length} agents)${RESET}  ${CYAN}${c.agents.join(', ')}${RESET}`);
+            console.log(`    representative #${c.representative.chunkId}  ${DIM}${c.representative.sourceFile} > ${c.representative.section}${RESET}`);
+            console.log(`    ${DIM}${preview}${preview.length >= 140 ? '…' : ''}${RESET}`);
+            for (const m of c.members.slice(1, 4)) {
+                console.log(`    ${DIM}└─ #${m.chunkId} [${m.agentSlug}] sim=${m.similarity.toFixed(3)}${RESET}`);
+            }
+            if (c.members.length > 4) {
+                console.log(`    ${DIM}└─ +${c.members.length - 4} more${RESET}`);
+            }
+            console.log();
+        }
+        console.log(`  ${DIM}To promote a chunk to global, use the agent-side ${BOLD}memory_promote${RESET}${DIM} tool with the chunk id, or pin it with ${BOLD}clementine memory pin <id>${RESET}${DIM} for now.${RESET}`);
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error finding cross-agent recurrence: ${err}`);
+        process.exit(1);
+    }
+});
 memoryCmd
     .command('search <query>')
     .description('Search memory (full-text)')
@@ -2118,10 +2498,13 @@ memoryCmd
             const source = r.sourceFile ? path.basename(r.sourceFile) : 'unknown';
             const section = r.section || '';
             const snippet = r.content.replace(/\n/g, ' ').slice(0, 120);
-            console.log(`  ${BOLD}${source}${RESET}${section ? ` › ${CYAN}${section}${RESET}` : ''}`);
+            const pinned = r.pinned ? ' 📌' : '';
+            console.log(`  ${DIM}#${r.chunkId}${RESET}  ${BOLD}${source}${RESET}${section ? ` › ${CYAN}${section}${RESET}` : ''}${pinned}`);
             console.log(`  ${DIM}${snippet}${snippet.length >= 120 ? '…' : ''}${RESET}`);
             console.log();
         }
+        console.log(`  ${DIM}Tip: pin a chunk to boost its score in recall — ${BOLD}clementine memory pin <id>${RESET}`);
+        console.log();
     }
     catch (err) {
         console.error(`  Error searching memory: ${err}`);

package/dist/memory/store.d.ts

@@ -50,6 +50,94 @@ export declare class MemoryStore {
     private get conn();
     /** Return the total number of indexed chunks. */
     getChunkCount(): number;
+    /** Toggle the manual pin flag on a chunk. Pinned chunks get a 2x score boost in recall. */
+    setPinned(chunkId: number, pinned: boolean): boolean;
+    /**
+     * Aggregate stats for the memory store — used by `clementine memory status`.
+     * Single-pass scans so it stays fast even on large chunk tables.
+     */
+    getMemoryStats(): {
+        totalChunks: number;
+        chunksWithEmbeddings: number;
+        pinnedChunks: number;
+        perAgent: Array<{
+            agentSlug: string;
+            count: number;
+        }>;
+        perCategory: Array<{
+            category: string;
+            count: number;
+        }>;
+        avgSalience: number;
+        oldestUpdated: string | null;
+        newestUpdated: string | null;
+    };
+    /**
+     * Find clusters of near-duplicate chunks using embedding cosine similarity.
+     * Returns clusters where at least 2 chunks score above the threshold.
+     *
+     * Caller decides what to do — typical use is `clementine memory dedup` to
+     * preview / merge / mark-superseded. Per-pair O(n²) within agent scope to
+     * keep the search space tractable; cross-agent dupes are surfaced separately
+     * by the auto-promote flow.
+     */
+    findNearDuplicates(opts?: {
+        threshold?: number;
+        minLen?: number;
+        limit?: number;
+    }): Array<{
+        keep: {
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            content: string;
+            agentSlug: string | null;
+            updatedAt: string | null;
+        };
+        duplicates: Array<{
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            content: string;
+            agentSlug: string | null;
+            updatedAt: string | null;
+            similarity: number;
+        }>;
+    }>;
+    /** Delete chunks by id. Used by dedup --apply. */
+    deleteChunks(chunkIds: number[]): number;
+    /**
+     * Find chunks whose semantic content recurs across 3+ different agents —
+     * candidates for promotion to global memory. Detection-only; surfacing.
+     * The user (or a future cron) decides whether to actually promote.
+     *
+     * Approach: scan agent-scoped chunks with embeddings, cluster cross-agent
+     * pairs above the similarity threshold, return clusters touching >= minAgents
+     * distinct agents. Limits keep the O(n²) scan tractable on large stores.
+     */
+    findCrossAgentRecurrence(opts?: {
+        threshold?: number;
+        minAgents?: number;
+        minLen?: number;
+        limit?: number;
+    }): Array<{
+        representative: {
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            content: string;
+            agentSlug: string;
+        };
+        members: Array<{
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            agentSlug: string;
+            similarity: number;
+            updatedAt: string | null;
+        }>;
+        agents: string[];
+    }>;
     /**
      * Scan the entire vault, hash-compare, and re-index changed files.
      */

package/dist/memory/store.js

@@ -173,6 +173,15 @@ export class MemoryStore {
         catch {
             // Column already exists
         }
+        // Add pinned flag — manual salience reinforcement. When true, recall
+        // applies an extra score boost on top of the access-pattern salience.
+        // Toggled by `clementine memory pin/unpin <chunkId>` (or the dashboard).
+        try {
+            this.conn.exec('ALTER TABLE chunks ADD COLUMN pinned INTEGER DEFAULT 0');
+        }
+        catch {
+            // Column already exists
+        }
         // Indexes for category/topic filtering
         try {
             this.conn.exec('CREATE INDEX idx_chunks_category ON chunks(category)');
@@ -737,6 +746,213 @@ export class MemoryStore {
             return 0;
         }
     }
+    /** Toggle the manual pin flag on a chunk. Pinned chunks get a 2x score boost in recall. */
+    setPinned(chunkId, pinned) {
+        try {
+            const result = this.conn.prepare('UPDATE chunks SET pinned = ? WHERE id = ?')
+                .run(pinned ? 1 : 0, chunkId);
+            return result.changes > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Aggregate stats for the memory store — used by `clementine memory status`.
+     * Single-pass scans so it stays fast even on large chunk tables.
+     */
+    getMemoryStats() {
+        const totalChunks = this.getChunkCount();
+        const chunksWithEmbeddings = this.conn
+            .prepare('SELECT COUNT(*) as cnt FROM chunks WHERE embedding IS NOT NULL')
+            .get()?.cnt ?? 0;
+        const pinnedChunks = this.conn
+            .prepare('SELECT COUNT(*) as cnt FROM chunks WHERE pinned = 1')
+            .get()?.cnt ?? 0;
+        const perAgent = this.conn
+            .prepare(`SELECT COALESCE(agent_slug, 'global') as agentSlug, COUNT(*) as count
+                FROM chunks GROUP BY agent_slug ORDER BY count DESC`)
+            .all();
+        const perCategory = this.conn
+            .prepare(`SELECT COALESCE(category, '(none)') as category, COUNT(*) as count
+                FROM chunks GROUP BY category ORDER BY count DESC`)
+            .all();
+        const avgRow = this.conn
+            .prepare('SELECT AVG(salience) as avg FROM chunks WHERE salience > 0')
+            .get();
+        const dateRow = this.conn
+            .prepare('SELECT MIN(updated_at) as oldest, MAX(updated_at) as newest FROM chunks WHERE updated_at IS NOT NULL')
+            .get();
+        return {
+            totalChunks,
+            chunksWithEmbeddings,
+            pinnedChunks,
+            perAgent,
+            perCategory,
+            avgSalience: avgRow?.avg ?? 0,
+            oldestUpdated: dateRow?.oldest ?? null,
+            newestUpdated: dateRow?.newest ?? null,
+        };
+    }
+    /**
+     * Find clusters of near-duplicate chunks using embedding cosine similarity.
+     * Returns clusters where at least 2 chunks score above the threshold.
+     *
+     * Caller decides what to do — typical use is `clementine memory dedup` to
+     * preview / merge / mark-superseded. Per-pair O(n²) within agent scope to
+     * keep the search space tractable; cross-agent dupes are surfaced separately
+     * by the auto-promote flow.
+     */
+    findNearDuplicates(opts = {}) {
+        const threshold = opts.threshold ?? 0.95;
+        const minLen = opts.minLen ?? 80; // skip very short chunks — too easily collide
+        const limitClusters = opts.limit ?? 50; // cap results so the CLI stays readable
+        if (!embeddingsModule.isReady())
+            return [];
+        const rows = this.conn.prepare(`SELECT id, source_file, section, content, embedding, agent_slug, updated_at
+       FROM chunks
+       WHERE embedding IS NOT NULL AND length(content) >= ?
+       ORDER BY agent_slug, updated_at DESC`).all(minLen);
+        // Group by agent first — only compare within the same scope to bound the
+        // O(n²) blow-up. Cross-agent dedup is the auto-promote flow's job.
+        const buckets = new Map();
+        for (const r of rows) {
+            const key = r.agent_slug ?? '__global__';
+            if (!buckets.has(key))
+                buckets.set(key, []);
+            buckets.get(key).push(r);
+        }
+        const clusters = [];
+        const consumed = new Set();
+        for (const bucket of buckets.values()) {
+            // Decode embeddings once per row.
+            const decoded = bucket.map(r => ({
+                ...r,
+                vec: embeddingsModule.deserializeEmbedding(r.embedding),
+            }));
+            for (let i = 0; i < decoded.length; i++) {
+                if (consumed.has(decoded[i].id))
+                    continue;
+                const head = decoded[i];
+                const dupes = [];
+                for (let j = i + 1; j < decoded.length; j++) {
+                    if (consumed.has(decoded[j].id))
+                        continue;
+                    const sim = embeddingsModule.cosineSimilarity(head.vec, decoded[j].vec);
+                    if (sim >= threshold) {
+                        dupes.push({
+                            chunkId: decoded[j].id,
+                            sourceFile: decoded[j].source_file,
+                            section: decoded[j].section,
+                            content: decoded[j].content,
+                            agentSlug: decoded[j].agent_slug,
+                            updatedAt: decoded[j].updated_at,
+                            similarity: sim,
+                        });
+                        consumed.add(decoded[j].id);
+                    }
+                }
+                if (dupes.length > 0) {
+                    consumed.add(head.id);
+                    clusters.push({
+                        keep: {
+                            chunkId: head.id,
+                            sourceFile: head.source_file,
+                            section: head.section,
+                            content: head.content,
+                            agentSlug: head.agent_slug,
+                            updatedAt: head.updated_at,
+                        },
+                        duplicates: dupes,
+                    });
+                    if (clusters.length >= limitClusters)
+                        return clusters;
+                }
+            }
+        }
+        return clusters;
+    }
+    /** Delete chunks by id. Used by dedup --apply. */
+    deleteChunks(chunkIds) {
+        if (!chunkIds.length)
+            return 0;
+        const placeholders = chunkIds.map(() => '?').join(',');
+        const result = this.conn.prepare(`DELETE FROM chunks WHERE id IN (${placeholders})`).run(...chunkIds);
+        return result.changes;
+    }
+    /**
+     * Find chunks whose semantic content recurs across 3+ different agents —
+     * candidates for promotion to global memory. Detection-only; surfacing.
+     * The user (or a future cron) decides whether to actually promote.
+     *
+     * Approach: scan agent-scoped chunks with embeddings, cluster cross-agent
+     * pairs above the similarity threshold, return clusters touching >= minAgents
+     * distinct agents. Limits keep the O(n²) scan tractable on large stores.
+     */
+    findCrossAgentRecurrence(opts = {}) {
+        const threshold = opts.threshold ?? 0.88; // looser than dedup — paraphrases count
+        const minAgents = opts.minAgents ?? 3;
+        const minLen = opts.minLen ?? 100;
+        const limitClusters = opts.limit ?? 30;
+        if (!embeddingsModule.isReady())
+            return [];
+        // Only consider chunks that ARE agent-scoped (NULL = already global).
+        const rows = this.conn.prepare(`SELECT id, source_file, section, content, embedding, agent_slug, updated_at
+       FROM chunks
+       WHERE embedding IS NOT NULL
+         AND agent_slug IS NOT NULL
+         AND length(content) >= ?
+       ORDER BY updated_at DESC`).all(minLen);
+        if (rows.length < minAgents)
+            return [];
+        const decoded = rows.map(r => ({ ...r, vec: embeddingsModule.deserializeEmbedding(r.embedding) }));
+        const clusters = [];
+        const consumed = new Set();
+        for (let i = 0; i < decoded.length; i++) {
+            if (consumed.has(decoded[i].id))
+                continue;
+            const head = decoded[i];
+            const members = [
+                { chunkId: head.id, sourceFile: head.source_file, section: head.section, agentSlug: head.agent_slug, similarity: 1.0, updatedAt: head.updated_at },
+            ];
+            const agentsTouched = new Set([head.agent_slug]);
+            for (let j = i + 1; j < decoded.length; j++) {
+                if (consumed.has(decoded[j].id))
+                    continue;
+                const sim = embeddingsModule.cosineSimilarity(head.vec, decoded[j].vec);
+                if (sim >= threshold) {
+                    members.push({
+                        chunkId: decoded[j].id,
+                        sourceFile: decoded[j].source_file,
+                        section: decoded[j].section,
+                        agentSlug: decoded[j].agent_slug,
+                        similarity: sim,
+                        updatedAt: decoded[j].updated_at,
+                    });
+                    agentsTouched.add(decoded[j].agent_slug);
+                }
+            }
+            if (agentsTouched.size >= minAgents) {
+                // Mark all in this cluster consumed so we don't re-cluster around them.
+                for (const m of members)
+                    consumed.add(m.chunkId);
+                clusters.push({
+                    representative: {
+                        chunkId: head.id,
+                        sourceFile: head.source_file,
+                        section: head.section,
+                        content: head.content,
+                        agentSlug: head.agent_slug,
+                    },
+                    members,
+                    agents: Array.from(agentsTouched).sort(),
+                });
+                if (clusters.length >= limitClusters)
+                    break;
+            }
+        }
+        return clusters;
+    }
     // ── Full Sync ──────────────────────────────────────────────────────
     /**
      * Scan the entire vault, hash-compare, and re-index changed files.
@@ -878,7 +1094,7 @@ export class MemoryStore {
         try {
             let sql = `SELECT c.id, c.source_file, c.section, c.content, c.chunk_type,
                   c.updated_at, c.salience, c.last_outcome_score, c.agent_slug, c.category, c.topic,
-                  bm25(chunks_fts) as score
+                  c.pinned, bm25(chunks_fts) as score
            FROM chunks_fts f
            JOIN chunks c ON c.id = f.rowid
            WHERE chunks_fts MATCH ?`;
@@ -912,6 +1128,7 @@ export class MemoryStore {
                 agentSlug: row.agent_slug ?? null,
                 category: row.category,
                 topic: row.topic,
+                pinned: row.pinned === 1,
             }));
         }
         catch {
@@ -1030,6 +1247,12 @@ export class MemoryStore {
             if (r.salience > 0) {
                 r.score *= 1.0 + r.salience;
             }
+            // Manual pin: stronger boost than access-pattern salience. Toggled via
+            // `clementine memory pin <chunkId>`. Doubles the relevance score so
+            // pinned chunks consistently rank near the top within their relevance band.
+            if (r.pinned) {
+                r.score *= 2.0;
+            }
             // Outcome-driven adjustment: chunks that recently got cited in
             // responses get a small boost; chunks that were pulled in and
             // ignored get a small penalty. Bounded to ±30% so outcome noise

package/dist/tools/memory-tools.js

@@ -108,6 +108,51 @@ export function registerMemoryTools(server) {
             }
         }
     });
+    // ── 0b. team_scratchpad ────────────────────────────────────────────────
+    //
+    // Cross-agent shared scratchpad. Unlike working_memory (per-agent), this
+    // is a single shared markdown file every agent can read and append to.
+    // Use cases: live coordination ("Sasha is drafting the brief, Ross hold
+    // outbound for 30m"), cross-agent context drops, async hand-offs that
+    // don't warrant a full goal_create or task_add. Append tags every entry
+    // with the author's agent slug + ISO timestamp so the trail stays clear.
+    const TEAM_SCRATCHPAD_FILE = path.join(BASE_DIR, 'team-scratchpad.md');
+    server.tool('team_scratchpad', getToolDescription('team_scratchpad') ?? 'Cross-agent shared scratchpad for live team coordination. All agents read/write the same file. Use for hand-offs, "I am working on X", short-term context drops. For durable facts, use memory_write/MEMORY.md instead.', {
+        action: z.enum(['read', 'append', 'replace', 'clear']).describe('What to do with the team scratchpad'),
+        content: z.string().optional().describe('Text to append or replace with (required for append/replace)'),
+    }, async ({ action, content }) => {
+        const author = ACTIVE_AGENT_SLUG ?? 'clementine';
+        switch (action) {
+            case 'read': {
+                if (!existsSync(TEAM_SCRATCHPAD_FILE)) {
+                    return textResult('Team scratchpad is empty.');
+                }
+                return textResult(readFileSync(TEAM_SCRATCHPAD_FILE, 'utf-8'));
+            }
+            case 'append': {
+                if (!content)
+                    return textResult('Error: content is required for append.');
+                const stamp = new Date().toISOString();
+                const entry = `\n- **[${author}@${stamp}]** ${content}\n`;
+                const existing = existsSync(TEAM_SCRATCHPAD_FILE) ? readFileSync(TEAM_SCRATCHPAD_FILE, 'utf-8') : '# Team Scratchpad\n\nShared across all agents. Append tags entries with author + timestamp.\n';
+                writeFileSync(TEAM_SCRATCHPAD_FILE, existing + entry);
+                return textResult(`Appended to team scratchpad as ${author}.`);
+            }
+            case 'replace': {
+                if (!content)
+                    return textResult('Error: content is required for replace.');
+                const stamp = new Date().toISOString();
+                const header = `# Team Scratchpad\n\n_Replaced by ${author} at ${stamp}._\n\n`;
+                writeFileSync(TEAM_SCRATCHPAD_FILE, header + content + '\n');
+                return textResult(`Team scratchpad replaced by ${author}.`);
+            }
+            case 'clear': {
+                if (existsSync(TEAM_SCRATCHPAD_FILE))
+                    unlinkSync(TEAM_SCRATCHPAD_FILE);
+                return textResult('Team scratchpad cleared.');
+            }
+        }
+    });
     // ── 1. memory_read ─────────────────────────────────────────────────────
     server.tool('memory_read', getToolDescription('memory_read') ?? "Read a note from the Obsidian vault. Shortcuts: 'today', 'yesterday', 'memory', 'tasks', 'heartbeat', 'cron', 'soul'. Or pass a relative path or note name.", {
         name: z.string().describe('Note name, path, or shortcut'),
@@ -305,7 +350,7 @@ export function registerMemoryTools(server) {
         return textResult(results.join('\n'));
     });
     // ── 4. memory_recall ───────────────────────────────────────────────────
-    server.tool('memory_recall', getToolDescription('memory_recall') ?? 'Context retrieval combining FTS5 relevance + recency search. Better than memory_search for finding related content by meaning. Optional category/topic filters narrow results.', {
+    server.tool('memory_recall', getToolDescription('memory_recall') ?? 'Context retrieval combining FTS5 relevance + recency search, scoped to your memory + global. For cross-agent synthesis use brain_recall.', {
         query: z.string().describe('Natural language search query'),
         category: z.enum(['facts', 'events', 'discoveries', 'preferences', 'advice']).optional().describe('Filter by category'),
         topic: z.string().optional().describe('Filter by topic'),
@@ -321,11 +366,56 @@ export function registerMemoryTools(server) {
             store.recordAccess(chunkIds);
         const lines = results.map(r => {
             const label = `[${r.matchType}]`;
+            const agentTag = r.agentSlug ? ` [agent: ${r.agentSlug}]` : '';
             const preview = r.content.slice(0, 300).replace(/\n/g, ' ');
-            return `**${r.sourceFile} > ${r.section}** ${label} (score: ${r.score.toFixed(3)})\n${preview}\n`;
+            return `**${r.sourceFile} > ${r.section}** ${label}${agentTag} (score: ${r.score.toFixed(3)})\n${preview}\n`;
         });
         return textResult(lines.join('\n'));
     });
+    // ── 4b. brain_recall ──────────────────────────────────────────────────
+    //
+    // Cross-agent unified recall. Differs from memory_recall in two ways:
+    //   1. No agentSlug scope — pulls from every agent's memory + global.
+    //   2. Always tags each result with [agent: <slug>] so the caller can
+    //      see provenance (which agent's memory the chunk came from).
+    //
+    // Intended caller: Clementine herself. Specialist agents normally stay in
+    // memory_recall (which respects strict isolation). brain_recall is the
+    // "single brain" view that lets the master assistant synthesize across
+    // the whole team.
+    server.tool('brain_recall', getToolDescription('brain_recall') ?? 'Cross-agent unified recall — searches across all agents with source-agent attribution. Use for synthesis questions or when you need the full picture, not just your own scope.', {
+        query: z.string().describe('Natural language query — what to find across all agents'),
+        category: z.enum(['facts', 'events', 'discoveries', 'preferences', 'advice']).optional().describe('Filter by category'),
+        topic: z.string().optional().describe('Filter by topic'),
+        limit: z.number().optional().describe('Max results across all agents (default 12)'),
+    }, async ({ query, category, topic, limit }) => {
+        const store = await getStore();
+        // Intentionally omit agentSlug — we want the unscoped, cross-agent view.
+        const results = store.searchContext(query, { category, topic, limit: limit ?? 12 });
+        if (!results.length) {
+            return textResult(`No results for: ${query}`);
+        }
+        const chunkIds = results.map(r => r.chunkId).filter(Boolean);
+        if (chunkIds.length)
+            store.recordAccess(chunkIds);
+        // Group attribution counts so the agent gets a quick summary of the spread.
+        const perAgent = new Map();
+        for (const r of results) {
+            const key = r.agentSlug ?? 'global';
+            perAgent.set(key, (perAgent.get(key) ?? 0) + 1);
+        }
+        const spread = Array.from(perAgent.entries())
+            .sort((a, b) => b[1] - a[1])
+            .map(([slug, n]) => `${slug}:${n}`)
+            .join(', ');
+        const lines = results.map(r => {
+            const agent = r.agentSlug ?? 'global';
+            const label = `[${r.matchType}]`;
+            const preview = r.content.slice(0, 300).replace(/\n/g, ' ');
+            return `**${r.sourceFile} > ${r.section}** ${label} [agent: ${agent}] (score: ${r.score.toFixed(3)})\n${preview}\n`;
+        });
+        return textResult(`Cross-agent spread: ${spread}\n\n${lines.join('\n')}`);
+    });
     // ── 10. memory_connections ─────────────────────────────────────────────
     server.tool('memory_connections', 'Query the wikilink graph — find all notes connected to/from a given note.', {
         note_name: z.string().describe('Note name (without .md) to find connections for'),

package/dist/tools/tool-meta.js

@@ -11,10 +11,15 @@
 const TOOL_META = {
     // ── Memory & Vault ────────────────────────────────────────────────
     working_memory: {
-        description: 'Persistent scratchpad that survives across conversations. Use to jot down current project context, TODOs, reminders, or anything you need to remember for next time. Actions: read, append, replace, clear. ALWAYS read before replacing to avoid overwriting useful notes.',
+        description: 'Per-agent persistent scratchpad — only YOU see it. Survives across conversations. Use for current project context, TODOs, reminders, or anything you need to remember for next time. Actions: read, append, replace, clear. ALWAYS read before replacing. For cross-agent coordination, use team_scratchpad instead.',
         exampleUsage: 'Before starting complex work, read working_memory to check for context from prior sessions.',
         returnHint: 'Full working memory contents (markdown text).',
     },
+    team_scratchpad: {
+        description: 'Cross-agent shared scratchpad — every agent on the team reads and writes the same file. Use for live coordination, hand-offs, "I am working on X — back off until Y", short-lived context drops. For durable facts that should outlive coordination noise, use memory_write to MEMORY.md instead. Append tags entries with author slug + timestamp.',
+        exampleUsage: 'Before starting outbound work, read team_scratchpad to see if another agent has already claimed a prospect or paused outreach.',
+        returnHint: 'Full scratchpad contents with per-entry author + ISO timestamp.',
+    },
     memory_search: {
         description: 'Full-text search across all vault notes. Best for finding specific keywords or phrases. For broader semantic matching, use memory_recall instead. Results include file path, section heading, and relevance score.',
         exampleUsage: 'Use when the user asks "what did we discuss about X" or you need to find a specific note.',
@@ -22,10 +27,15 @@ const TOOL_META = {
         paginationNote: 'Default limit is 20 results. For broad queries, start with limit=5 and increase only if needed.',
     },
     memory_recall: {
-        description: 'Context retrieval combining text relevance + recency. Better than memory_search for finding related content — it considers how recently notes were updated. Use this as your default "what do I know about X" tool.',
-        exampleUsage: 'Use before responding to questions about people, projects, or topics the user has discussed before.',
+        description: 'Context retrieval combining text relevance + recency, scoped to YOUR memory + global memory. Best as your default "what do I know about X" tool when the question lives in your domain. For cross-agent synthesis (what your team as a whole knows), use brain_recall instead.',
+        exampleUsage: 'Use before responding to questions about people, projects, or topics the user has discussed with you before.',
         returnHint: 'Ranked chunks with source file, category, and content preview.',
     },
+    brain_recall: {
+        description: 'CROSS-AGENT unified recall — searches the entire memory store across YOU and every team agent, with source-agent attribution per result. Use for synthesis questions ("what does my team know about X?", "have any of my agents discussed Y?"), or whenever you need the full picture instead of just your own scope. Specialist agents normally stay in memory_recall (which respects their isolation); brain_recall is the single-brain view, primarily for Clementine.',
+        exampleUsage: 'When the user asks "what have we collectively learned about Acme this quarter", brain_recall returns chunks from every agent that touched the topic.',
+        returnHint: 'Ranked chunks tagged [agent: <slug>] or [agent: global], plus source file and content preview.',
+    },
     memory_read: {
         description: "Read a note from the Obsidian vault. Shortcuts: 'today' (daily note), 'yesterday', 'memory' (MEMORY.md), 'tasks' (TASKS.md), 'heartbeat', 'cron', 'soul'. Or pass a relative path like '03-Projects/my-project.md'.",
         exampleUsage: "memory_read('today') to check what happened today before making plans.",

package/dist/types.d.ts

@@ -15,6 +15,7 @@ export interface SearchResult {
     agentSlug?: string | null;
     category?: string | null;
     topic?: string | null;
+    pinned?: boolean;
 }
 export type ChunkCategory = 'facts' | 'events' | 'discoveries' | 'preferences' | 'advice';
 export interface Chunk {
@@ -508,7 +509,7 @@ export interface SelfImproveExperiment {
     baselineScore: number;
     score: number;
     accepted: boolean;
-    approvalStatus: 'pending' | 'approved' | 'denied' | 'expired';
+    approvalStatus: 'pending' | 'approved' | 'denied' | 'expired' | 'unsurfaced';
     reason: string;
     error?: string;
 }
@@ -548,6 +549,13 @@ export interface SelfImproveConfig {
     iterationBudgetMs: number;
     maxDurationMs: number;
     acceptThreshold: number;
+    /**
+     * Default: 0.85. Stricter floor for what reaches the user's pending-changes
+     * inbox. Proposals scoring >= acceptThreshold but < surfaceThreshold are
+     * marked 'unsurfaced' — kept in the experiment log for trend analysis but
+     * NOT written to PENDING_DIR. Cuts noise without losing signal data.
+     */
+    surfaceThreshold?: number;
     plateauLimit: number;
     areas: ('soul' | 'cron' | 'workflow' | 'memory' | 'agent' | 'source' | 'communication' | 'goal' | 'advisor-rule' | 'prompt-override')[];
     /** Enable tiered auto-apply: low-risk changes apply without approval. Default: false. */

package/package.json

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