@kernel.chat/kbot 3.63.0 → 3.64.0

package/dist/memory-scanner.js

@@ -0,0 +1,461 @@
+// kbot Memory Scanner — Passive In-Session Memory Detection
+//
+// The dream engine consolidates AFTER sessions end. This fills the gap:
+// a passive scanner that watches conversation turns DURING a session and
+// detects "memory-worthy" moments in real time.
+//
+// How it works:
+//   1. Hook into addTurn() from memory.ts — observe every turn
+//   2. After every N turns (default 5), scan the recent window
+//   3. Use keyword + context windows (NOT regex sentiment — we're better than that)
+//   4. When a memory-worthy moment is found, auto-save via the memory_save tool
+//   5. Debounce and dedup to avoid noise
+//
+// Detection categories:
+//   - Corrections:   "no, I meant...", "actually...", "don't do that"
+//   - Preferences:   "I prefer...", "always use...", "never..."
+//   - Project facts:  "the deadline is...", "we're using...", "the API key is in..."
+//   - Emotional:      "this is frustrating", "perfect!", "exactly what I wanted"
+//
+// Storage: Scanner state persists to ~/.kbot/memory/scanner-state.json
+// Memories saved via the memory_save tool (same as agent-initiated saves)
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { getHistory } from './memory.js';
+// ── Constants ──
+const SCANNER_STATE_FILE = join(homedir(), '.kbot', 'memory', 'scanner-state.json');
+const SCAN_INTERVAL = 5; // Scan every N turns
+const CONTEXT_WINDOW = 6; // Look at the last N turns when scanning
+const DEDUP_WINDOW_MS = 300_000; // 5 min — don't save duplicate memories within this window
+const MAX_MEMORIES_PER_SESSION = 20; // Safety cap — don't flood memory store
+// Correction signals — user is fixing a misunderstanding
+const CORRECTION_PATTERNS = {
+    triggers: [
+        'no, i meant', 'no i meant', 'actually,', 'actually ', "that's not what i",
+        "don't do that", 'dont do that', 'not what i asked', 'i said',
+        'what i meant was', 'let me clarify', 'to clarify', 'i was referring to',
+        'you misunderstood', 'that\'s not right', "that's wrong", 'incorrect',
+        'no, use', 'no, it should', 'wrong approach', 'not like that',
+        'i meant', 'what i want is', 'stop doing',
+    ],
+    validators: [
+        // Validator: correction follows an assistant message (there's something to correct)
+        (_turn, context) => {
+            const prevAssistant = [...context].reverse().find(t => t.role === 'assistant');
+            if (!prevAssistant)
+                return null;
+            return 'correction after assistant response';
+        },
+    ],
+    kind: 'correction',
+    category: 'pattern',
+};
+// Preference signals — user states how they like things done
+const PREFERENCE_PATTERNS = {
+    triggers: [
+        'i prefer', 'i always', 'i never', 'always use', 'never use',
+        'i like to', "i don't like", 'i dont like', 'my preference is',
+        'i usually', 'i tend to', 'please always', 'please never',
+        'from now on', 'going forward', "let's stick with", 'lets stick with',
+        'i want you to always', 'i want you to never', 'keep using',
+        'stop using', 'switch to', 'use this instead', 'my style is',
+        'the way i like it', 'my convention is',
+    ],
+    validators: [
+        // Validator: message is long enough to contain a real preference (not just "I prefer")
+        (turn) => {
+            const words = turn.content.trim().split(/\s+/);
+            if (words.length >= 5)
+                return 'substantive preference statement';
+            return null;
+        },
+    ],
+    kind: 'preference',
+    category: 'preference',
+};
+// Project fact signals — user shares project context
+const PROJECT_FACT_PATTERNS = {
+    triggers: [
+        'the deadline is', 'deadline is', 'due date is', 'due by',
+        "we're using", 'we are using', "we're running", 'we use',
+        'the api key is in', 'api key is stored', 'credentials are in',
+        'the database is', 'our database', 'the repo is', 'our repo',
+        'the stack is', 'our stack', 'tech stack is',
+        'we deploy to', 'deployed on', 'hosted on', 'runs on',
+        'the config is', 'config file is', 'settings are in',
+        'the port is', 'it runs on port', 'the endpoint is',
+        'the team uses', 'our team', 'my team',
+        'the project is', 'this project', 'the codebase',
+        'the convention is', 'our convention', 'the rule is',
+        'we follow', 'the standard is', 'our standard',
+        'the branch is', 'main branch is', 'we branch from',
+    ],
+    validators: [
+        // Validator: contains specific details (numbers, paths, names)
+        (turn) => {
+            const content = turn.content;
+            // Check for specifics: paths, URLs, versions, port numbers, dates
+            const hasSpecifics = /(?:\/[\w.-]+\/|https?:\/\/|v?\d+\.\d+|port\s+\d+|\d{4}-\d{2})/i.test(content);
+            if (hasSpecifics)
+                return 'contains specific project details';
+            // Check for substantial content (at least a sentence)
+            if (content.trim().split(/\s+/).length >= 8)
+                return 'substantive project statement';
+            return null;
+        },
+    ],
+    kind: 'project_fact',
+    category: 'fact',
+};
+// Emotional signals — user's satisfaction/frustration
+const EMOTIONAL_PATTERNS = {
+    triggers: [
+        'this is frustrating', 'so frustrating', 'ugh', 'annoying',
+        'perfect!', 'exactly what i wanted', 'exactly right', 'exactly!',
+        'love it', 'great job', 'well done', 'nice work', 'nailed it',
+        'this is amazing', 'this is terrible', 'this sucks', 'hate this',
+        'finally!', 'thank god', 'thank you!', 'thanks!',
+        'this is exactly', "that's exactly", "that's perfect",
+        'much better', 'way better', 'huge improvement',
+        'this keeps happening', 'same issue again', 'broken again',
+    ],
+    validators: [
+        // Validator: emotional signals are only worth saving if they contain
+        // actionable context (what was good/bad)
+        (turn, context) => {
+            // Positive signal after assistant response = something worked well
+            const prevAssistant = [...context].reverse().find(t => t.role === 'assistant');
+            if (prevAssistant)
+                return 'emotional reaction to assistant output';
+            return null;
+        },
+    ],
+    kind: 'emotional',
+    category: 'pattern',
+};
+const ALL_PATTERNS = [
+    CORRECTION_PATTERNS,
+    PREFERENCE_PATTERNS,
+    PROJECT_FACT_PATTERNS,
+    EMOTIONAL_PATTERNS,
+];
+// ── Scanner State ──
+let enabled = true;
+let turnsObserved = 0;
+let scansPerformed = 0;
+let momentsDetected = 0;
+let memoriesSaved = 0;
+let sessionStart = new Date().toISOString();
+const byKind = {
+    correction: 0,
+    preference: 0,
+    project_fact: 0,
+    emotional: 0,
+};
+const recentDetections = [];
+const recentSavedKeys = new Map(); // key → timestamp, for dedup
+let turnCountSinceLastScan = 0;
+let hooked = false;
+// ── Persistent State ──
+function ensureDir() {
+    const dir = join(homedir(), '.kbot', 'memory');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function loadScannerState() {
+    ensureDir();
+    const defaults = {
+        totalScans: 0,
+        totalDetections: 0,
+        totalSaved: 0,
+        lastScan: null,
+        cumulativeByKind: { correction: 0, preference: 0, project_fact: 0, emotional: 0 },
+    };
+    if (!existsSync(SCANNER_STATE_FILE))
+        return defaults;
+    try {
+        return { ...defaults, ...JSON.parse(readFileSync(SCANNER_STATE_FILE, 'utf-8')) };
+    }
+    catch {
+        return defaults;
+    }
+}
+function saveScannerState() {
+    ensureDir();
+    const state = loadScannerState();
+    state.totalScans += scansPerformed;
+    state.totalDetections += momentsDetected;
+    state.totalSaved += memoriesSaved;
+    state.lastScan = new Date().toISOString();
+    for (const kind of Object.keys(byKind)) {
+        state.cumulativeByKind[kind] = (state.cumulativeByKind[kind] || 0) + byKind[kind];
+    }
+    try {
+        writeFileSync(SCANNER_STATE_FILE, JSON.stringify(state, null, 2));
+    }
+    catch {
+        // Non-critical — state can be rebuilt
+    }
+}
+// ── Detection Engine ──
+/** Extract a clean, saveable memory from a detected signal */
+function extractMemoryContent(turn, context, kind) {
+    const userMsg = turn.content.trim();
+    // For corrections, include what was corrected
+    if (kind === 'correction') {
+        const prevAssistant = [...context].reverse().find(t => t.role === 'assistant');
+        const prevSnippet = prevAssistant ? prevAssistant.content.slice(0, 80) : '';
+        const content = prevSnippet
+            ? `User corrected: "${prevSnippet}..." → "${userMsg.slice(0, 200)}"`
+            : `User correction: ${userMsg.slice(0, 250)}`;
+        const key = `correction-${slugify(userMsg.slice(0, 40))}`;
+        return { content, key };
+    }
+    // For preferences, capture the full preference statement
+    if (kind === 'preference') {
+        const content = `User preference: ${userMsg.slice(0, 300)}`;
+        const key = `pref-${slugify(userMsg.slice(0, 40))}`;
+        return { content, key };
+    }
+    // For project facts, capture the factual statement
+    if (kind === 'project_fact') {
+        const content = `Project fact: ${userMsg.slice(0, 300)}`;
+        const key = `fact-${slugify(userMsg.slice(0, 40))}`;
+        return { content, key };
+    }
+    // For emotional signals, note what provoked the reaction
+    const prevAssistant = [...context].reverse().find(t => t.role === 'assistant');
+    const prevSnippet = prevAssistant ? prevAssistant.content.slice(0, 100) : '';
+    const sentiment = detectSentimentDirection(userMsg);
+    const content = prevSnippet
+        ? `User ${sentiment} reaction to: "${prevSnippet}..." — "${userMsg.slice(0, 150)}"`
+        : `User ${sentiment} reaction: ${userMsg.slice(0, 200)}`;
+    const key = `emotion-${sentiment}-${slugify(userMsg.slice(0, 30))}`;
+    return { content, key };
+}
+/** Determine if the emotional signal is positive or negative */
+function detectSentimentDirection(text) {
+    const lower = text.toLowerCase();
+    const positiveWords = ['perfect', 'exactly', 'love', 'great', 'nice', 'nailed', 'amazing', 'better', 'improvement', 'finally', 'thank'];
+    const negativeWords = ['frustrating', 'annoying', 'terrible', 'sucks', 'hate', 'broken', 'ugh', 'same issue'];
+    let posScore = 0;
+    let negScore = 0;
+    for (const w of positiveWords) {
+        if (lower.includes(w))
+            posScore++;
+    }
+    for (const w of negativeWords) {
+        if (lower.includes(w))
+            negScore++;
+    }
+    return posScore >= negScore ? 'positive' : 'negative';
+}
+/** Create a filesystem-safe slug from text */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 60);
+}
+/** Check if a key was recently saved (dedup within the window) */
+function isRecentlySaved(key) {
+    const savedAt = recentSavedKeys.get(key);
+    if (!savedAt)
+        return false;
+    return (Date.now() - savedAt) < DEDUP_WINDOW_MS;
+}
+/** Scan a window of conversation turns for memory-worthy signals */
+function scanTurns(sessionId) {
+    const history = getHistory(sessionId);
+    if (history.length < 2)
+        return []; // Need at least one exchange
+    // Look at the recent context window
+    const windowStart = Math.max(0, history.length - CONTEXT_WINDOW);
+    const window = history.slice(windowStart);
+    const detected = [];
+    // Only scan user turns (assistant turns don't contain user memories)
+    for (let i = 0; i < window.length; i++) {
+        const turn = window[i];
+        if (turn.role !== 'user')
+            continue;
+        const lowerContent = turn.content.toLowerCase();
+        for (const pattern of ALL_PATTERNS) {
+            // Phase 1: Keyword trigger check — does the message contain any trigger phrase?
+            const triggered = pattern.triggers.some(trigger => lowerContent.includes(trigger));
+            if (!triggered)
+                continue;
+            // Phase 2: Context validation — does the surrounding context confirm the signal?
+            const contextBefore = window.slice(0, i);
+            let validated = false;
+            for (const validator of pattern.validators) {
+                const result = validator(turn, contextBefore);
+                if (result !== null) {
+                    validated = true;
+                    break;
+                }
+            }
+            if (!validated)
+                continue;
+            // Phase 3: Extract memory content
+            const { content, key } = extractMemoryContent(turn, contextBefore, pattern.kind);
+            // Phase 4: Dedup — skip if we already saved this key recently
+            if (isRecentlySaved(key))
+                continue;
+            // Phase 5: Confidence scoring
+            // More triggers matched = higher confidence
+            const triggerCount = pattern.triggers.filter(t => lowerContent.includes(t)).length;
+            const confidence = Math.min(0.5 + triggerCount * 0.15, 0.95);
+            detected.push({
+                kind: pattern.kind,
+                content,
+                key,
+                category: pattern.category,
+                confidence,
+                turnIndex: windowStart + i,
+                detectedAt: new Date().toISOString(),
+            });
+        }
+    }
+    return detected;
+}
+// ── Memory Saving ──
+/** Save a detected memory via the memory tool filesystem (bypasses tool execution) */
+function saveDetectedMemory(memory) {
+    try {
+        const memDir = join(homedir(), '.kbot', 'memory', memory.category);
+        if (!existsSync(memDir))
+            mkdirSync(memDir, { recursive: true });
+        const sanitizedKey = memory.key
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 128);
+        const filePath = join(memDir, `${sanitizedKey}.json`);
+        const now = new Date().toISOString();
+        // Check if memory already exists — update instead of overwrite
+        let existing = null;
+        if (existsSync(filePath)) {
+            try {
+                existing = JSON.parse(readFileSync(filePath, 'utf-8'));
+            }
+            catch {
+                existing = null;
+            }
+        }
+        const entry = {
+            key: sanitizedKey,
+            content: memory.content,
+            category: memory.category,
+            created_at: existing?.created_at || now,
+            modified_at: now,
+            access_count: (existing?.access_count || 0) + 1,
+            source: 'memory-scanner',
+            signal_kind: memory.kind,
+            confidence: memory.confidence,
+        };
+        writeFileSync(filePath, JSON.stringify(entry, null, 2));
+        recentSavedKeys.set(memory.key, Date.now());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Turn Observer ──
+/** Called after every addTurn — this is the scanner's heartbeat */
+function onTurnAdded(turn, sessionId) {
+    if (!enabled)
+        return;
+    turnsObserved++;
+    turnCountSinceLastScan++;
+    // Only scan on the interval
+    if (turnCountSinceLastScan < SCAN_INTERVAL)
+        return;
+    turnCountSinceLastScan = 0;
+    // Safety cap
+    if (memoriesSaved >= MAX_MEMORIES_PER_SESSION)
+        return;
+    // Run detection (synchronous — fast keyword matching, no I/O)
+    const detected = scanTurns(sessionId);
+    scansPerformed++;
+    for (const memory of detected) {
+        momentsDetected++;
+        byKind[memory.kind]++;
+        // Save the memory
+        const saved = saveDetectedMemory(memory);
+        if (saved) {
+            memoriesSaved++;
+            // Keep recent detections list bounded
+            recentDetections.push(memory);
+            if (recentDetections.length > 10)
+                recentDetections.shift();
+        }
+    }
+}
+// ── Monkey-Patch Hook ──
+//
+// We wrap the original addTurn() to observe turns without modifying memory.ts.
+// This is the same pattern used by learning.ts's async extraction.
+/** Install the scanner hook on addTurn. Idempotent. */
+function installHook() {
+    if (hooked)
+        return;
+    // We can't actually monkey-patch an imported function binding in ESM.
+    // Instead, we expose a notifyTurn() function that the agent loop calls.
+    // See: agent.ts calls addTurn() then notifyTurn() for scanner awareness.
+    hooked = true;
+}
+// ── Public API ──
+/** Notify the scanner that a turn was added. Call after addTurn(). */
+export function notifyTurn(turn, sessionId = 'default') {
+    onTurnAdded(turn, sessionId);
+}
+/** Start the memory scanner for the current session */
+export function startMemoryScanner() {
+    enabled = true;
+    turnsObserved = 0;
+    scansPerformed = 0;
+    momentsDetected = 0;
+    memoriesSaved = 0;
+    turnCountSinceLastScan = 0;
+    sessionStart = new Date().toISOString();
+    byKind.correction = 0;
+    byKind.preference = 0;
+    byKind.project_fact = 0;
+    byKind.emotional = 0;
+    recentDetections.length = 0;
+    recentSavedKeys.clear();
+    installHook();
+}
+/** Stop the memory scanner and persist stats */
+export function stopMemoryScanner() {
+    if (memoriesSaved > 0 || scansPerformed > 0) {
+        saveScannerState();
+    }
+    enabled = false;
+}
+/** Get current scanner stats */
+export function getMemoryScannerStats() {
+    return {
+        enabled,
+        turnsObserved,
+        scansPerformed,
+        momentsDetected,
+        memoriesSaved,
+        byKind: { ...byKind },
+        recentDetections: [...recentDetections],
+        sessionStart,
+    };
+}
+/** Check if the scanner is currently enabled */
+export function isScannerEnabled() {
+    return enabled;
+}
+/** Get cumulative stats from disk (across all sessions) */
+export function getCumulativeScannerStats() {
+    return loadScannerState();
+}
+//# sourceMappingURL=memory-scanner.js.map

package/dist/tools/buddy-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerBuddyTools(): void;
+//# sourceMappingURL=buddy-tools.d.ts.map

package/dist/tools/buddy-tools.js

@@ -0,0 +1,63 @@
+// kbot Buddy Tools — Interact with your terminal companion
+//
+// Two tools:
+//   buddy_status — Show buddy name, species, mood, and sprite
+//   buddy_rename — Give your buddy a custom name (persisted to ~/.kbot/buddy.json)
+import { registerTool } from './index.js';
+import { getBuddy, getBuddySprite, getBuddyGreeting, formatBuddyStatus, renameBuddy, } from '../buddy.js';
+const VALID_MOODS = ['idle', 'thinking', 'success', 'error', 'learning'];
+export function registerBuddyTools() {
+    registerTool({
+        name: 'buddy_status',
+        description: 'Show your terminal buddy — its name, species, current mood, and ASCII sprite. Optionally preview a specific mood.',
+        parameters: {
+            mood: {
+                type: 'string',
+                description: 'Preview a specific mood: idle, thinking, success, error, learning. Defaults to current mood.',
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const buddy = getBuddy();
+            const mood = args.mood ? String(args.mood) : undefined;
+            if (mood && !VALID_MOODS.includes(mood)) {
+                return `Unknown mood "${mood}". Valid moods: ${VALID_MOODS.join(', ')}`;
+            }
+            const sprite = getBuddySprite(mood).join('\n');
+            const greeting = getBuddyGreeting();
+            return [
+                `Name: ${buddy.name}`,
+                `Species: ${buddy.species}`,
+                `Mood: ${mood || buddy.mood}`,
+                '',
+                sprite,
+                '',
+                `"${greeting}"`,
+            ].join('\n');
+        },
+    });
+    registerTool({
+        name: 'buddy_rename',
+        description: 'Give your terminal buddy a custom name. The name is persisted to ~/.kbot/buddy.json.',
+        parameters: {
+            name: {
+                type: 'string',
+                description: 'The new name for your buddy',
+                required: true,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const newName = String(args.name).trim();
+            if (!newName)
+                return 'Error: name cannot be empty.';
+            if (newName.length > 32)
+                return 'Error: name must be 32 characters or fewer.';
+            const oldBuddy = getBuddy();
+            const oldName = oldBuddy.name;
+            renameBuddy(newName);
+            return formatBuddyStatus(`${oldName} is now ${newName}!`);
+        },
+    });
+}
+//# sourceMappingURL=buddy-tools.js.map

package/dist/tools/index.js

@@ -299,6 +299,9 @@ const LAZY_MODULE_IMPORTS = [
     { path: './dj-set-builder.js', registerFn: 'registerDjSetBuilderTools' },
     { path: './serum2-preset.js', registerFn: 'registerSerum2PresetTools' },
     { path: './dream-tools.js', registerFn: 'registerDreamTools' },
+    { path: './memory-scanner-tools.js', registerFn: 'registerMemoryScannerTools' },
+    { path: './buddy-tools.js', registerFn: 'registerBuddyTools' },
+    { path: './voice-input-tools.js', registerFn: 'registerVoiceInputTools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

package/dist/tools/memory-scanner-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerMemoryScannerTools(): void;
+//# sourceMappingURL=memory-scanner-tools.d.ts.map

package/dist/tools/memory-scanner-tools.js

@@ -0,0 +1,87 @@
+// kbot Memory Scanner Tools — Agent-accessible controls for the passive scanner
+//
+// Two tools:
+//   - memory_scan_status: Show scanner stats (moments detected, memories saved, etc.)
+//   - memory_scan_toggle: Enable/disable the passive scanner
+import { registerTool } from './index.js';
+import { getMemoryScannerStats, getCumulativeScannerStats, startMemoryScanner, stopMemoryScanner, isScannerEnabled, } from '../memory-scanner.js';
+export function registerMemoryScannerTools() {
+    // ── memory_scan_status ──
+    registerTool({
+        name: 'memory_scan_status',
+        description: 'Show memory scanner status — how many turns observed, scans performed, memory-worthy moments detected, memories saved, and breakdown by signal kind (corrections, preferences, project facts, emotional). Includes cumulative stats across all sessions.',
+        parameters: {},
+        tier: 'free',
+        timeout: 5_000,
+        async execute() {
+            const stats = getMemoryScannerStats();
+            const cumulative = getCumulativeScannerStats();
+            const lines = [
+                'Memory Scanner Status',
+                '═════════════════════',
+                `State: ${stats.enabled ? 'ACTIVE' : 'PAUSED'}`,
+                `Session start: ${stats.sessionStart.split('T')[0]} ${stats.sessionStart.split('T')[1]?.slice(0, 8) || ''}`,
+                '',
+                '── This Session ──',
+                `Turns observed: ${stats.turnsObserved}`,
+                `Scans performed: ${stats.scansPerformed}`,
+                `Moments detected: ${stats.momentsDetected}`,
+                `Memories saved: ${stats.memoriesSaved}`,
+                '',
+                'Signal breakdown:',
+                `  Corrections:   ${stats.byKind.correction}`,
+                `  Preferences:   ${stats.byKind.preference}`,
+                `  Project facts: ${stats.byKind.project_fact}`,
+                `  Emotional:     ${stats.byKind.emotional}`,
+            ];
+            if (stats.recentDetections.length > 0) {
+                lines.push('', 'Recent detections:');
+                for (const d of stats.recentDetections.slice(-5)) {
+                    const time = d.detectedAt.split('T')[1]?.slice(0, 8) || '';
+                    lines.push(`  [${time}] [${d.kind}] (${Math.round(d.confidence * 100)}%) ${d.content.slice(0, 100)}${d.content.length > 100 ? '...' : ''}`);
+                }
+            }
+            lines.push('', '── Cumulative (all sessions) ──', `Total scans: ${cumulative.totalScans + stats.scansPerformed}`, `Total detections: ${cumulative.totalDetections + stats.momentsDetected}`, `Total saved: ${cumulative.totalSaved + stats.memoriesSaved}`, `Last scan: ${cumulative.lastScan || 'this session'}`, '', 'Cumulative by kind:', `  Corrections:   ${(cumulative.cumulativeByKind.correction || 0) + stats.byKind.correction}`, `  Preferences:   ${(cumulative.cumulativeByKind.preference || 0) + stats.byKind.preference}`, `  Project facts: ${(cumulative.cumulativeByKind.project_fact || 0) + stats.byKind.project_fact}`, `  Emotional:     ${(cumulative.cumulativeByKind.emotional || 0) + stats.byKind.emotional}`);
+            return lines.join('\n');
+        },
+    });
+    // ── memory_scan_toggle ──
+    registerTool({
+        name: 'memory_scan_toggle',
+        description: 'Enable or disable the passive memory scanner. When enabled, the scanner watches conversation turns and auto-saves memory-worthy moments (corrections, preferences, project facts, emotional reactions). Disabling it stops detection but preserves already-saved memories.',
+        parameters: {
+            action: {
+                type: 'string',
+                description: '"enable" to start scanning, "disable" to stop, or "status" to check current state',
+                required: true,
+            },
+        },
+        tier: 'free',
+        timeout: 5_000,
+        async execute(args) {
+            const action = String(args.action || '').toLowerCase().trim();
+            if (action === 'enable' || action === 'on' || action === 'start') {
+                if (isScannerEnabled()) {
+                    return 'Memory scanner is already active.';
+                }
+                startMemoryScanner();
+                return 'Memory scanner enabled. Now passively watching for memory-worthy moments in conversation.';
+            }
+            if (action === 'disable' || action === 'off' || action === 'stop') {
+                if (!isScannerEnabled()) {
+                    return 'Memory scanner is already paused.';
+                }
+                const stats = getMemoryScannerStats();
+                stopMemoryScanner();
+                return `Memory scanner paused. Session summary: ${stats.momentsDetected} moments detected, ${stats.memoriesSaved} memories saved.`;
+            }
+            if (action === 'status') {
+                const active = isScannerEnabled();
+                const stats = getMemoryScannerStats();
+                return `Scanner is ${active ? 'ACTIVE' : 'PAUSED'}. This session: ${stats.turnsObserved} turns observed, ${stats.memoriesSaved} memories saved.`;
+            }
+            return 'Invalid action. Use "enable", "disable", or "status".';
+        },
+    });
+} // end registerMemoryScannerTools
+//# sourceMappingURL=memory-scanner-tools.js.map

package/dist/tools/voice-input-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerVoiceInputTools(): void;
+//# sourceMappingURL=voice-input-tools.d.ts.map