clementine-agent 1.0.2 → 1.0.4

package/README.md

@@ -85,6 +85,8 @@ bash install.sh
 
 The install script handles everything: system dependencies (redis, libomp, build tools), npm packages, TypeScript build, global CLI install, and launches the setup wizard. Safe to re-run — skips anything already installed.
 
+The setup wizard auto-generates a Discord bot invite URL from your token and offers to open it in your browser — no need to visit the Developer Portal manually.
+
 After setup:
 
 ```bash
@@ -324,6 +326,11 @@ clementine tools               List available MCP tools, plugins, and channels
 clementine config setup        Interactive configuration wizard
 clementine config set KEY VAL  Set a single config value
 clementine config get KEY      Read a config value
+clementine config edit         Open .env in your editor ($EDITOR)
+clementine memory search <q>   Search memory from the terminal (FTS5)
+clementine projects list       Show all linked projects
+clementine projects add <path> Link a project directory (-d desc, -k keywords)
+clementine projects remove <p> Unlink a project directory
 clementine cron list           List all cron jobs and last run status
 clementine cron run <job>      Run a specific cron job
 clementine cron run-due        Run all due jobs (for OS scheduler)

package/dist/agent/daily-planner.js

@@ -8,54 +8,9 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import Anthropic from '@anthropic-ai/sdk';
 import { BASE_DIR, GOALS_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, } from '../config.js';
 const logger = pino({ name: 'clementine.daily-planner' });
 const PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
-// ── .env reader (self-contained — no config.ts secret imports) ───────
-function getEnvValue(key) {
-    // Check process env first (already loaded by the daemon)
-    if (process.env[key])
-        return process.env[key];
-    // Fall back to .env file
-    const envPath = path.join(BASE_DIR, '.env');
-    if (!existsSync(envPath))
-        return '';
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        if (trimmed.slice(0, eqIndex) !== key)
-            continue;
-        let value = trimmed.slice(eqIndex + 1);
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        return value;
-    }
-    return '';
-}
-/**
- * Build Anthropic client credentials.
- * Priority: ANTHROPIC_AUTH_TOKEN (OAuth) > ANTHROPIC_API_KEY (legacy raw key).
- * Returns null if neither is configured.
- */
-function getAnthropicCredentials() {
-    const oauthToken = getEnvValue('CLAUDE_CODE_OAUTH_TOKEN');
-    if (oauthToken)
-        return { authToken: oauthToken };
-    const authToken = getEnvValue('ANTHROPIC_AUTH_TOKEN');
-    if (authToken)
-        return { authToken };
-    const apiKey = getEnvValue('ANTHROPIC_API_KEY');
-    if (apiKey)
-        return { apiKey };
-    return null;
-}
 // ── Helpers ──────────────────────────────────────────────────────────
 function todayStr() {
     const d = new Date();
@@ -303,24 +258,27 @@ Rules:
 - Limit to at most 10 priorities, 5 cron changes, 5 new work items
 - Focus on actionable items, not status reports
 - If everything is on track, return minimal priorities`;
-        const creds = getAnthropicCredentials();
-        if (!creds) {
-            logger.warn('No Anthropic credentials found — generating fallback plan. Run `clementine login` to authenticate.');
-            return this.fallbackPlan(today);
-        }
         try {
-            const client = new Anthropic(creds.authToken ? { authToken: creds.authToken } : { apiKey: creds.apiKey });
-            const response = await client.messages.create({
-                model: MODELS.haiku,
-                max_tokens: 2000,
-                messages: [{ role: 'user', content: prompt }],
-                system: 'You are a planning assistant. Analyze the context and produce a prioritized daily plan as JSON. Return only valid JSON, no markdown fencing.',
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            let text = '';
+            const stream = query({
+                prompt,
+                options: {
+                    model: MODELS.haiku,
+                    maxTurns: 1,
+                    systemPrompt: 'You are a planning assistant. Analyze the context and produce a prioritized daily plan as JSON. Return only valid JSON, no markdown fencing.',
+                },
             });
-            const text = response.content
-                .filter(block => block.type === 'text')
-                .map(block => block.text)
-                .join('');
-            const plan = JSON.parse(text);
+            for await (const msg of stream) {
+                if (msg.type === 'result')
+                    text = msg.result ?? '';
+            }
+            if (!text) {
+                logger.warn('LLM returned empty plan — using fallback');
+                return this.fallbackPlan(today);
+            }
+            const cleaned = text.replace(/^```(?:json)?\s*/i, '').replace(/\s*```\s*$/, '').trim();
+            const plan = JSON.parse(cleaned);
             plan.date = today;
             plan.createdAt = new Date().toISOString();
             plan.priorities = plan.priorities ?? [];

package/dist/agent/strategic-planner.js

@@ -12,54 +12,27 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import Anthropic from '@anthropic-ai/sdk';
 import { BASE_DIR, GOALS_DIR, MODELS } from '../config.js';
 const logger = pino({ name: 'clementine.strategic-planner' });
 const DAILY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
 const WEEKLY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'weekly');
 const MONTHLY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'monthly');
-// ── .env reader ──────────────────────────────────────────────────────
-function getEnvValue(key) {
-    if (process.env[key])
-        return process.env[key];
-    const envPath = path.join(BASE_DIR, '.env');
-    if (!existsSync(envPath))
-        return '';
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        if (trimmed.slice(0, eqIndex) !== key)
-            continue;
-        let value = trimmed.slice(eqIndex + 1);
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        return value;
+async function llmJsonCall(prompt, systemPrompt) {
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+    let text = '';
+    const stream = query({
+        prompt,
+        options: {
+            model: MODELS.haiku,
+            maxTurns: 1,
+            systemPrompt,
+        },
+    });
+    for await (const msg of stream) {
+        if (msg.type === 'result')
+            text = msg.result ?? '';
     }
-    return '';
-}
-function getAnthropicCredentials() {
-    const oauthToken = getEnvValue('CLAUDE_CODE_OAUTH_TOKEN');
-    if (oauthToken)
-        return { authToken: oauthToken };
-    const authToken = getEnvValue('ANTHROPIC_AUTH_TOKEN');
-    if (authToken)
-        return { authToken };
-    const apiKey = getEnvValue('ANTHROPIC_API_KEY');
-    if (apiKey)
-        return { apiKey };
-    return null;
-}
-function makeAnthropicClient() {
-    const creds = getAnthropicCredentials();
-    if (!creds)
-        return null;
-    return new Anthropic(creds.authToken ? { authToken: creds.authToken } : { apiKey: creds.apiKey });
+    return text;
 }
 // ── Strategic Planner ────────────────────────────────────────────────
 export class StrategicPlanner {
@@ -153,16 +126,8 @@ export class StrategicPlanner {
             })),
             summary: 'No data available for weekly review.',
         };
-        const client = makeAnthropicClient();
-        if (!client)
-            return defaultReview;
         try {
-            const response = await client.messages.create({
-                model: MODELS.haiku,
-                max_tokens: 1000,
-                messages: [{ role: 'user', content: prompt }],
-            });
-            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            const text = await llmJsonCall(prompt, 'You synthesize weekly reviews. Return only valid JSON, no markdown fencing.');
             const jsonMatch = text.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 const parsed = JSON.parse(jsonMatch[0]);
@@ -235,9 +200,6 @@ export class StrategicPlanner {
             proposedGoals: [],
             summary: 'No data available for monthly assessment.',
         };
-        const client2 = makeAnthropicClient();
-        if (!client2)
-            return defaultAssessment;
         const prompt = `You are generating a monthly strategic assessment for ${monthId}.\n\n` +
             `${context}\n\n` +
             `Output ONLY a JSON object:\n` +
@@ -248,12 +210,7 @@ export class StrategicPlanner {
             `  "summary": "2-3 sentence strategic assessment"\n` +
             `}`;
         try {
-            const response = await client2.messages.create({
-                model: MODELS.haiku,
-                max_tokens: 1000,
-                messages: [{ role: 'user', content: prompt }],
-            });
-            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            const text = await llmJsonCall(prompt, 'You produce monthly strategic assessments. Return only valid JSON, no markdown fencing.');
             const jsonMatch = text.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 const parsed = JSON.parse(jsonMatch[0]);

package/dist/cli/chat.js

@@ -198,17 +198,35 @@ export async function cmdChat(opts) {
         }
         // ── Send message ──────────────────────────────────────────
         process.stdout.write(`\n${DIM}thinking...${RESET}\r`);
+        let firstToken = true;
+        let streamedLen = 0;
         try {
-            const response = await gateway.handleMessage(sessionKey, effectiveText, undefined, oneOffModel);
-            // Clear "thinking..." line
-            process.stdout.write('\x1b[2K\r');
-            // Show active project if auto-matched
-            const matched = gateway.getLastMatchedProject(sessionKey);
-            if (matched) {
-                console.log(`\x1b[0;90m[project: ${path.basename(matched.path)}]\x1b[0m`);
+            const response = await gateway.handleMessage(sessionKey, effectiveText, async (token) => {
+                if (firstToken) {
+                    // Clear "thinking..." and show project context on first real token
+                    process.stdout.write('\x1b[2K\r');
+                    const matched = gateway.getLastMatchedProject(sessionKey);
+                    if (matched) {
+                        process.stdout.write(`${DIM}[project: ${path.basename(matched.path)}]${RESET}\n`);
+                    }
+                    firstToken = false;
+                }
+                process.stdout.write(token);
+                streamedLen += token.length;
+            }, oneOffModel);
+            // If we streamed, just add a newline. Otherwise fall back to full render.
+            if (streamedLen > 0) {
+                process.stdout.write('\n\n');
+            }
+            else {
+                process.stdout.write('\x1b[2K\r');
+                const matched = gateway.getLastMatchedProject(sessionKey);
+                if (matched) {
+                    console.log(`${DIM}[project: ${path.basename(matched.path)}]${RESET}`);
+                }
+                console.log(renderMarkdown(response));
+                console.log();
             }
-            console.log(renderMarkdown(response));
-            console.log();
         }
         catch (err) {
             process.stdout.write('\x1b[2K\r');

package/dist/cli/index.js

@@ -57,6 +57,13 @@ function getLaunchdPlistPath() {
     const home = process.env.HOME ?? '';
     return path.join(home, 'Library', 'LaunchAgents', `${getLaunchdLabel()}.plist`);
 }
+function getSystemdServiceName() {
+    return `${getAssistantName().toLowerCase()}.service`;
+}
+function getSystemdServicePath() {
+    const home = process.env.HOME ?? '';
+    return path.join(home, '.config', 'systemd', 'user', getSystemdServiceName());
+}
 function readPid() {
     const pidFile = getPidFilePath();
     if (!existsSync(pidFile))
@@ -104,10 +111,10 @@ function killPid(pid) {
         // already dead
     }
 }
-/** Stop the daemon safely: unload LaunchAgent first (prevents respawn), then kill the process. */
+/** Stop the daemon safely: disable the service manager first (prevents respawn), then kill the process. */
 function stopDaemon(pid) {
-    // Unload LaunchAgent BEFORE killing — otherwise launchd respawns it immediately
     if (process.platform === 'darwin') {
+        // Unload LaunchAgent BEFORE killing — otherwise launchd respawns it immediately
         const plist = getLaunchdPlistPath();
         if (existsSync(plist)) {
             try {
@@ -118,6 +125,18 @@ function stopDaemon(pid) {
             }
         }
     }
+    else if (process.platform === 'linux') {
+        // Stop systemd service BEFORE killing — otherwise systemd respawns it
+        const servicePath = getSystemdServicePath();
+        if (existsSync(servicePath)) {
+            try {
+                execSync(`systemctl --user stop ${getSystemdServiceName()}`, { stdio: 'pipe' });
+            }
+            catch {
+                // not active — that's fine
+            }
+        }
+    }
     killPid(pid);
 }
 /** Bootstrap ~/.clementine/ on first run — create data dir and copy vault templates. */
@@ -136,43 +155,68 @@ function ensureDataHome() {
 // ── Commands ─────────────────────────────────────────────────────────
 function cmdLaunch(options) {
     if (options.uninstall) {
-        const plistPath = getLaunchdPlistPath();
-        if (existsSync(plistPath)) {
-            try {
-                execSync(`launchctl unload "${plistPath}"`, { stdio: 'ignore' });
+        if (process.platform === 'darwin') {
+            const plistPath = getLaunchdPlistPath();
+            if (existsSync(plistPath)) {
+                try {
+                    execSync(`launchctl unload "${plistPath}"`, { stdio: 'ignore' });
+                }
+                catch {
+                    // not loaded
+                }
+                unlinkSync(plistPath);
+                console.log(`  Uninstalled LaunchAgent: ${getLaunchdLabel()}`);
             }
-            catch {
-                // not loaded
+            else {
+                console.log('  LaunchAgent not installed.');
             }
-            unlinkSync(plistPath);
-            console.log(`  Uninstalled LaunchAgent: ${getLaunchdLabel()}`);
         }
-        else {
-            console.log('  LaunchAgent not installed.');
+        else if (process.platform === 'linux') {
+            const servicePath = getSystemdServicePath();
+            const serviceName = getSystemdServiceName();
+            if (existsSync(servicePath)) {
+                try {
+                    execSync(`systemctl --user stop ${serviceName}`, { stdio: 'ignore' });
+                    execSync(`systemctl --user disable ${serviceName}`, { stdio: 'ignore' });
+                }
+                catch {
+                    // not active
+                }
+                unlinkSync(servicePath);
+                try {
+                    execSync('systemctl --user daemon-reload', { stdio: 'ignore' });
+                }
+                catch { /* ignore */ }
+                console.log(`  Uninstalled systemd service: ${serviceName}`);
+            }
+            else {
+                console.log('  Systemd service not installed.');
+            }
         }
         return;
     }
     if (options.install) {
-        const plistPath = getLaunchdPlistPath();
-        const plistDir = path.dirname(plistPath);
-        if (!existsSync(plistDir)) {
-            mkdirSync(plistDir, { recursive: true });
-        }
-        // Unload existing plist if already installed (idempotent reinstall)
-        if (existsSync(plistPath)) {
-            try {
-                execSync(`launchctl unload "${plistPath}"`, { stdio: 'ignore' });
+        if (process.platform === 'darwin') {
+            const plistPath = getLaunchdPlistPath();
+            const plistDir = path.dirname(plistPath);
+            if (!existsSync(plistDir)) {
+                mkdirSync(plistDir, { recursive: true });
             }
-            catch {
-                // not loaded — fine
+            // Unload existing plist if already installed (idempotent reinstall)
+            if (existsSync(plistPath)) {
+                try {
+                    execSync(`launchctl unload "${plistPath}"`, { stdio: 'ignore' });
+                }
+                catch {
+                    // not loaded — fine
+                }
             }
-        }
-        const nodePath = process.execPath;
-        const logDir = path.join(BASE_DIR, 'logs');
-        if (!existsSync(logDir)) {
-            mkdirSync(logDir, { recursive: true });
-        }
-        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+            const nodePath = process.execPath;
+            const logDir = path.join(BASE_DIR, 'logs');
+            if (!existsSync(logDir)) {
+                mkdirSync(logDir, { recursive: true });
+            }
+            const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -204,15 +248,80 @@ function cmdLaunch(options) {
   </dict>
 </dict>
 </plist>`;
-        writeFileSync(plistPath, plist);
-        try {
-            execSync(`launchctl load "${plistPath}"`);
-            console.log(`  Installed and loaded LaunchAgent: ${getLaunchdLabel()}`);
-            console.log(`  Plist: ${plistPath}`);
-            console.log(`  Logs:  ${logDir}/`);
+            writeFileSync(plistPath, plist);
+            try {
+                execSync(`launchctl load "${plistPath}"`);
+                console.log(`  Installed and loaded LaunchAgent: ${getLaunchdLabel()}`);
+                console.log(`  Plist: ${plistPath}`);
+                console.log(`  Logs:  ${logDir}/`);
+            }
+            catch (err) {
+                console.error(`  Failed to load LaunchAgent: ${err}`);
+            }
         }
-        catch (err) {
-            console.error(`  Failed to load LaunchAgent: ${err}`);
+        else if (process.platform === 'linux') {
+            const servicePath = getSystemdServicePath();
+            const serviceName = getSystemdServiceName();
+            const serviceDir = path.dirname(servicePath);
+            if (!existsSync(serviceDir)) {
+                mkdirSync(serviceDir, { recursive: true });
+            }
+            // Stop existing service if already installed (idempotent reinstall)
+            if (existsSync(servicePath)) {
+                try {
+                    execSync(`systemctl --user stop ${serviceName}`, { stdio: 'ignore' });
+                }
+                catch {
+                    // not active — fine
+                }
+            }
+            const nodePath = process.execPath;
+            const logDir = path.join(BASE_DIR, 'logs');
+            if (!existsSync(logDir)) {
+                mkdirSync(logDir, { recursive: true });
+            }
+            const envPath = path.join(BASE_DIR, '.env');
+            const servicePATH = [path.dirname(nodePath), '/usr/local/bin', '/usr/bin', '/bin']
+                .join(':');
+            const unit = `[Unit]
+Description=${getAssistantName()} AI Assistant
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${DIST_ENTRY}
+WorkingDirectory=${BASE_DIR}
+Environment=PATH=${servicePATH}
+Environment=CLEMENTINE_HOME=${BASE_DIR}
+EnvironmentFile=-${envPath}
+Restart=always
+RestartSec=5
+StandardOutput=append:${path.join(logDir, 'clementine.log')}
+StandardError=append:${path.join(logDir, 'clementine-error.log')}
+
+[Install]
+WantedBy=default.target
+`;
+            writeFileSync(servicePath, unit);
+            try {
+                execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+                execSync(`systemctl --user enable --now ${serviceName}`, { stdio: 'pipe' });
+                // Enable lingering so the service runs even when the user is not logged in (VPS)
+                try {
+                    execSync(`loginctl enable-linger $(whoami)`, { stdio: 'pipe' });
+                }
+                catch {
+                    console.log('  Note: Could not enable linger. Run as root: loginctl enable-linger $(whoami)');
+                }
+                console.log(`  Installed and started systemd service: ${serviceName}`);
+                console.log(`  Service: ${servicePath}`);
+                console.log(`  Logs:    ${logDir}/`);
+                console.log(`  Status:  systemctl --user status ${serviceName}`);
+            }
+            catch (err) {
+                console.error(`  Failed to enable systemd service: ${err}`);
+            }
         }
         // Also install the cron scheduler alongside the daemon
         console.log();
@@ -681,7 +790,7 @@ function cmdDoctor(opts = {}) {
     else {
         console.log(`  ${DIM}  ○  Daemon not running${RESET}`);
     }
-    // LaunchAgent health check (macOS only)
+    // Service health check (platform-specific)
     if (process.platform === 'darwin') {
         const plistPath = getLaunchdPlistPath();
         if (existsSync(plistPath)) {
@@ -700,6 +809,25 @@ function cmdDoctor(opts = {}) {
             issues++;
         }
     }
+    else if (process.platform === 'linux') {
+        const servicePath = getSystemdServicePath();
+        const serviceName = getSystemdServiceName();
+        if (existsSync(servicePath)) {
+            try {
+                execSync(`systemctl --user is-active ${serviceName}`, { stdio: 'pipe' });
+                console.log(`  ${GREEN}OK${RESET}  Systemd service installed and active`);
+            }
+            catch {
+                console.log(`  ${YELLOW}WARN${RESET}  Systemd service installed but not active`);
+                console.log(`       Start it: systemctl --user start ${serviceName}`);
+                issues++;
+            }
+        }
+        else {
+            console.log(`  ${YELLOW}WARN${RESET}  Systemd service not installed (run: clementine launch --install)`);
+            issues++;
+        }
+    }
     console.log();
     if (issues === 0 && fixed === 0) {
         console.log(`  ${GREEN}All checks passed.${RESET}`);
@@ -925,6 +1053,16 @@ program
     .description('Restart the assistant (daemon by default)')
     .option('-f, --foreground', 'Run in foreground after restart')
     .action(cmdRestart);
+program
+    .command('setup')
+    .description('Run interactive setup wizard')
+    .action(() => {
+    ensureDataHome();
+    runSetup().catch((err) => {
+        console.error('Setup failed:', err);
+        process.exit(1);
+    });
+});
 program
     .command('rebuild')
     .description('Rebuild from source and restart all processes (daemon + dashboard)')

package/dist/cli/setup.js

@@ -629,19 +629,20 @@ export async function runSetup() {
     console.log(`  All users:  ${allowAll ? 'yes' : 'no (owner only)'}`);
     console.log();
     // ── Step 8: Auto-start on login ───────────────────────────────────
-    if (process.platform === 'darwin') {
+    if (process.platform === 'darwin' || process.platform === 'linux') {
         sectionHeader('Step 8: Auto-Start');
-        console.log(`  ${DIM}Install a login service so ${entries['ASSISTANT_NAME'] || 'Clementine'} starts${RESET}`);
-        console.log(`  ${DIM}automatically when you turn on your computer.${RESET}`);
+        const serviceName = process.platform === 'darwin' ? 'LaunchAgent' : 'systemd service';
+        console.log(`  ${DIM}Install a ${serviceName} so ${entries['ASSISTANT_NAME'] || 'Clementine'} starts${RESET}`);
+        console.log(`  ${DIM}automatically when the system boots.${RESET}`);
         console.log();
         const installService = await confirm({
-            message: 'Start automatically on login? (recommended)',
+            message: 'Start automatically on boot? (recommended)',
             default: true,
         });
         if (installService) {
-            // Signal to the caller that LaunchAgent should be installed
-            writeFileSync(path.join(BASE_DIR, '.install-launchagent'), '');
-            console.log(`  ${GREEN}✔ Will install login service after first launch${RESET}`);
+            // Signal to the caller that the service should be installed
+            writeFileSync(path.join(BASE_DIR, '.install-service'), '');
+            console.log(`  ${GREEN}✔ Will install ${serviceName} after first launch${RESET}`);
         }
     }
     console.log();

package/dist/config.d.ts

@@ -117,8 +117,8 @@ export declare const LINK_EXTRACT_MAX_URLS = 3;
 export declare const LINK_EXTRACT_MAX_CHARS = 4000;
 export declare const MEMORY_DB_PATH: string;
 export declare const GRAPH_DB_DIR: string;
-export declare const SEARCH_CONTEXT_LIMIT = 3;
-export declare const SEARCH_RECENCY_LIMIT = 3;
+export declare const SEARCH_CONTEXT_LIMIT = 6;
+export declare const SEARCH_RECENCY_LIMIT = 4;
 export declare const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 export declare const SESSION_EXCHANGE_HISTORY_SIZE = 10;
 export declare const SESSION_EXCHANGE_MAX_CHARS = 2000;

package/dist/config.js

@@ -239,8 +239,8 @@ export const LINK_EXTRACT_MAX_CHARS = 4000;
 // ── Memory / Search ──────────────────────────────────────────────────
 export const MEMORY_DB_PATH = path.join(VAULT_DIR, '.memory.db');
 export const GRAPH_DB_DIR = path.join(BASE_DIR, '.graph.db');
-export const SEARCH_CONTEXT_LIMIT = 3;
-export const SEARCH_RECENCY_LIMIT = 3;
+export const SEARCH_CONTEXT_LIMIT = 6;
+export const SEARCH_RECENCY_LIMIT = 4;
 export const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 // ── Session Persistence ──────────────────────────────────────────────
 export const SESSION_EXCHANGE_HISTORY_SIZE = 10;

package/dist/gateway/cron-scheduler.js

@@ -990,6 +990,19 @@ export class CronScheduler {
                 }
                 catch { /* non-fatal */ }
             }
+            // Auto-disable after too many consecutive failures — prevents zombie jobs
+            // from burning resources indefinitely. Re-enable from the dashboard.
+            if (consErrors >= 10 && !this.disabledJobs.has(job.name)) {
+                this.disabledJobs.add(job.name);
+                const scheduledTask = this.scheduledTasks.get(job.name);
+                if (scheduledTask) {
+                    scheduledTask.stop();
+                    this.scheduledTasks.delete(job.name);
+                }
+                logger.error({ job: job.name, consErrors }, `Auto-disabled cron after ${consErrors} consecutive failures`);
+                this.logAdvisorEvent('auto-disabled', job.name, `Auto-disabled after ${consErrors} consecutive failures`);
+                this.dispatcher.send(`🛑 **Cron auto-disabled** — \`${job.name}\` failed ${consErrors} times in a row. Fix the job and re-enable it from the dashboard.`, { agentSlug: job.agentSlug }).catch(err => logger.debug({ err }, 'Failed to send auto-disable notification'));
+            }
         }
     }
     /**

package/dist/gateway/heartbeat-scheduler.js

@@ -204,7 +204,7 @@ export class HeartbeatScheduler {
                 '(preferences, decisions, people info, project updates) to long-term memory using ' +
                 'memory_write. Skip anything already in MEMORY.md. Be selective — only save facts ' +
                 'that will be useful in future conversations. Do not create duplicate entries.', 1, // tier 1 (vault-only)
-            3, // max 3 turns
+            10, // max 10 turns — workflow needs read + candidates + read + write + mark_consolidated
             'haiku').catch(err => {
                 logger.error({ err }, 'Evening memory consolidation failed');
             });

package/dist/index.js

@@ -545,6 +545,33 @@ async function asyncMain() {
     // Agent layer
     const { PersonalAssistant } = await import('./agent/assistant.js');
     const assistant = new PersonalAssistant();
+    // Memory maintenance — startup + periodic (non-blocking)
+    let maintenanceInterval;
+    {
+        const memStore = assistant.getMemoryStore();
+        if (memStore) {
+            const { runStartupMaintenance, startPeriodicMaintenance } = await import('./memory/maintenance.js');
+            // Fire-and-forget startup maintenance
+            runStartupMaintenance(memStore).catch(() => { });
+            // Periodic maintenance every 6 hours (consolidation needs an LLM caller)
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            const llmCall = async (prompt) => {
+                try {
+                    let result = '';
+                    const stream = query({ prompt, options: { model: 'claude-haiku-4-5-20251001', maxTurns: 1, systemPrompt: 'You are a memory consolidation assistant. Be concise.' } });
+                    for await (const msg of stream) {
+                        if (msg.type === 'result')
+                            result = msg.result ?? '';
+                    }
+                    return result;
+                }
+                catch {
+                    return '';
+                }
+            };
+            maintenanceInterval = startPeriodicMaintenance(memStore, llmCall);
+        }
+    }
     // Gateway layer
     const { Gateway } = await import('./gateway/router.js');
     const gateway = new Gateway(assistant);
@@ -833,6 +860,8 @@ async function asyncMain() {
     clearInterval(timerInterval);
     clearInterval(teamDeliveryInterval);
     clearInterval(sourceEditInterval);
+    if (maintenanceInterval)
+        clearInterval(maintenanceInterval);
     // Close graph store FIRST — FalkorDBLite's cleanup.js registers an
     // uncaughtException handler that re-throws errors.  If a Redis socket
     // drops during the drain wait, that handler crashes the process.

package/dist/memory/maintenance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export declare function runStartupMaintenance(store: any): Promise<void>;
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export declare function startPeriodicMaintenance(store: any, llmCall?: (prompt: string) => Promise<string>): ReturnType<typeof setInterval>;
+//# sourceMappingURL=maintenance.d.ts.map

package/dist/memory/maintenance.js

@@ -0,0 +1,121 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+import pino from 'pino';
+const logger = pino({ name: 'clementine.maintenance' });
+const PERIODIC_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export async function runStartupMaintenance(store) {
+    const start = Date.now();
+    logger.info('Starting memory maintenance (startup)');
+    try {
+        const decayed = store.decaySalience?.();
+        if (decayed)
+            logger.info({ decayed }, 'Salience decay applied');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Salience decay failed');
+    }
+    try {
+        const pruned = store.pruneStaleData?.();
+        if (pruned)
+            logger.info(pruned, 'Stale data pruned');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Stale data pruning failed');
+    }
+    try {
+        const embedded = store.buildEmbeddings?.();
+        if (embedded)
+            logger.info(embedded, 'Embeddings built/backfilled');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Embedding backfill failed');
+    }
+    // Prune old extraction logs (keep active extractions regardless of age)
+    try {
+        const conn = store.conn;
+        if (conn) {
+            const result = conn.prepare(`DELETE FROM memory_extractions
+         WHERE extracted_at < datetime('now', '-90 days')
+         AND status != 'active'`).run();
+            if (result.changes > 0) {
+                logger.info({ pruned: result.changes }, 'Old extraction logs pruned');
+            }
+        }
+    }
+    catch {
+        // Table may not exist yet — non-fatal
+    }
+    logger.info({ durationMs: Date.now() - start }, 'Startup maintenance complete');
+}
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export function startPeriodicMaintenance(store, llmCall) {
+    const runCycle = async () => {
+        const start = Date.now();
+        logger.info('Starting periodic memory maintenance');
+        // 1. Decay + prune
+        try {
+            store.decaySalience?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic decay failed');
+        }
+        try {
+            store.pruneStaleData?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic prune failed');
+        }
+        // 2. Rebuild vocab + backfill embeddings
+        try {
+            store.buildEmbeddings?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic embedding build failed');
+        }
+        // 3. Consolidation (dedup, summarize, extract principles)
+        if (llmCall) {
+            try {
+                const { runConsolidation } = await import('./consolidation.js');
+                const result = await runConsolidation(store, llmCall);
+                logger.info(result, 'Consolidation cycle complete');
+            }
+            catch (err) {
+                logger.warn({ err }, 'Consolidation failed');
+            }
+            // 4. Re-backfill embeddings for any new summary chunks from consolidation
+            try {
+                store.buildEmbeddings?.();
+            }
+            catch (err) {
+                logger.warn({ err }, 'Post-consolidation embedding build failed');
+            }
+        }
+        // 5. Extraction log pruning
+        try {
+            const conn = store.conn;
+            if (conn) {
+                conn.prepare(`DELETE FROM memory_extractions
+           WHERE extracted_at < datetime('now', '-90 days')
+           AND status != 'active'`).run();
+            }
+        }
+        catch { /* non-fatal */ }
+        logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
+    };
+    return setInterval(runCycle, PERIODIC_INTERVAL_MS);
+}
+//# sourceMappingURL=maintenance.js.map

package/dist/memory/store.js

@@ -748,9 +748,7 @@ export class MemoryStore {
         const rows = this.conn
             .prepare(`SELECT id, source_file, section, content, chunk_type, embedding, salience, agent_slug, updated_at, category, topic
          FROM chunks
-         WHERE embedding IS NOT NULL AND consolidated = 0
-         ORDER BY updated_at DESC
-         LIMIT 500`)
+         WHERE embedding IS NOT NULL`)
             .all();
         const scored = [];
         for (const row of rows) {
@@ -1616,10 +1614,18 @@ export class MemoryStore {
      */
     insertSummaryChunk(sourceFile, section, content) {
         const hash = createHash('sha256').update(content).digest('hex').slice(0, 16);
-        this.conn
+        const result = this.conn
             .prepare(`INSERT INTO chunks (source_file, section, content, chunk_type, content_hash, salience, consolidated)
          VALUES (?, ?, ?, 'summary', ?, 0.8, 0)`)
             .run(sourceFile, section, content, hash);
+        // Immediately compute embedding so the summary is vector-searchable right away
+        if (embeddingsModule.isReady()) {
+            const vec = embeddingsModule.embed(content);
+            if (vec) {
+                this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?')
+                    .run(embeddingsModule.serializeEmbedding(vec), result.lastInsertRowid);
+            }
+        }
     }
     // ── SDR Operational Data ─────────────────────────────────────────
     // -- Leads --
@@ -1912,17 +1918,17 @@ export class MemoryStore {
     buildEmbeddings() {
         // Gather all chunk contents for vocabulary building
         const rows = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE consolidated = 0')
+            .prepare('SELECT id, content FROM chunks')
             .all();
         if (rows.length === 0)
             return { vocabSize: 0, backfilled: 0 };
-        // Build vocabulary from corpus
+        // Build vocabulary from entire corpus (including consolidated summaries)
         embeddingsModule.buildVocab(rows.map((r) => r.content));
         if (!embeddingsModule.isReady())
             return { vocabSize: 0, backfilled: 0 };
-        // Backfill embeddings for chunks that don't have one
+        // Backfill embeddings for all chunks that don't have one
         const missing = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL AND consolidated = 0')
+            .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL')
             .all();
         const updateStmt = this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?');
         let backfilled = 0;

package/package.json

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