clementine-agent 1.16.0 → 1.18.0

package/dist/agent/assistant.js

@@ -4769,13 +4769,28 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             // Periodic progress beacon — sends a status update every 5 minutes
             // so the user knows the task is still alive during long phases.
             // Capped at 3 messages per phase to prevent notification spam.
+            // Also refreshes status.json so dashboard polls see liveness even
+            // when the SDK stream hasn't emitted a result yet.
             const BEACON_INTERVAL_MS = 5 * 60 * 1000;
             const MAX_BEACONS_PER_PHASE = 3;
             let beaconCount = 0;
             const beaconTimer = setInterval(() => {
+                const mins = Math.round((Date.now() - phaseStart) / 60_000);
+                try {
+                    writeStatus({
+                        jobName,
+                        status: 'running',
+                        phase,
+                        startedAt,
+                        maxHours: effectiveMaxHours,
+                        phaseStartedAt: new Date(phaseStart).toISOString(),
+                        phaseElapsedMin: mins,
+                        toolCallsThisPhase: phaseToolCount,
+                    });
+                }
+                catch { /* non-fatal */ }
                 if (this.onPhaseProgress && beaconCount < MAX_BEACONS_PER_PHASE) {
                     beaconCount++;
-                    const mins = Math.round((Date.now() - phaseStart) / 60_000);
                     try {
                         // Conversational beacon — no technical jargon
                         const msg = mins < 3
@@ -4826,6 +4841,22 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         // Capture terminal reason for execution advisor
                         this._lastTerminalReason = result.terminal_reason ?? undefined;
                         this.logQueryResult(result, 'unleashed', `unleashed:${jobName}`, jobName);
+                        // Refresh status.json the moment the SDK reports result —
+                        // even if the underlying stream stalls afterward, the dashboard
+                        // sees liveness instead of a frozen "phase 0 / running" row.
+                        try {
+                            writeStatus({
+                                jobName,
+                                status: 'running',
+                                phase,
+                                startedAt,
+                                maxHours: effectiveMaxHours,
+                                lastResultAt: new Date().toISOString(),
+                                lastResultIsError: !!result.is_error,
+                                toolCallsThisPhase: phaseToolCount,
+                            });
+                        }
+                        catch { /* non-fatal */ }
                         // Detect dollar-budget exceeded (strict marker — see cron
                         // handler above for the reasoning).
                         if (result.is_error && 'result' in result) {

package/dist/agent/complexity-classifier.js

@@ -50,6 +50,21 @@ const CHAIN_MARKERS = [
     /\bonce\s+(that|you)\b.*,/i,
     /\bnext\b.*,/i,
 ];
+/**
+ * Patterns that look like a pasted error message or stack trace.
+ * Error pastes are long and entity-heavy (file paths, quoted strings,
+ * "Error:" prefixes), which previously tripped the deepWorthy gate
+ * even when the user was just asking "what's wrong with this?". We
+ * still allow the plan-first directive to fire; we just don't auto-spawn
+ * an expensive multi-phase background task on a debug request.
+ */
+const ERROR_PASTE_MARKERS = [
+    /\b(Error|Exception|Traceback|Stack ?trace):\s/i,
+    /^\s*at\s+[\w.$<>]+\s*\(/m, // JS/TS stack frame: "at foo.bar (file:line)"
+    /\bfailed:\s*Error\b/i,
+    /Reached maximum number of turns/i,
+    /\bENOENT\b|\bECONNREFUSED\b|\bETIMEDOUT\b/,
+];
 /**
  * Phrasings that explicitly ask for plan-first behavior. Triggers
  * regardless of other heuristics.
@@ -148,7 +163,14 @@ export function classifyComplexity(text) {
         isLong,
         entities >= 3,
     ].filter(Boolean).length;
-    const deepWorthy = strongCount >= 2;
+    // Suppress deepWorthy on pasted error messages. They're long and
+    // entity-heavy (file paths, quoted strings) but the user is asking
+    // "what's wrong here?", not requesting sustained autonomous work.
+    // The plan-first path still fires when complex=true.
+    const looksLikeErrorPaste = ERROR_PASTE_MARKERS.some((re) => re.test(trimmed));
+    if (looksLikeErrorPaste)
+        signals.push('error-paste');
+    const deepWorthy = strongCount >= 2 && !looksLikeErrorPaste;
     if (complex) {
         return {
             complex: true,

package/dist/agent/orchestrator.d.ts

@@ -40,6 +40,8 @@ export declare class PlanOrchestrator {
     private stateId;
     private agentProfiles;
     constructor(assistant: PersonalAssistant);
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    private logAutonomy;
     private saveState;
     private cleanupState;
     /** Load a previously interrupted plan state (for future resumability). */

package/dist/agent/orchestrator.js

@@ -127,6 +127,17 @@ export class PlanOrchestrator {
         this.assistant = assistant;
         this.stateId = `plan-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     }
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    async logAutonomy(event, details) {
+        try {
+            const { getStore } = await import('../tools/shared.js');
+            const store = await getStore();
+            store.logAutonomyEvent({ component: 'orchestrator', event, details });
+        }
+        catch {
+            // Best-effort — telemetry must never break plan execution.
+        }
+    }
     // ── State persistence ────────────────────────────────────────────────
     saveState(state) {
         try {
@@ -206,6 +217,7 @@ export class PlanOrchestrator {
                 return this.runSingleStep(taskDescription);
             }
             logger.info({ goal: effectiveTask, stepCount: plan.steps.length, steps: plan.steps.map(s => s.id), revision: revisionCount }, 'Plan generated');
+            this.logAutonomy('plan_created', { stepCount: plan.steps.length, revision: revisionCount });
             // 2. Initialize statuses
             this.stepStatuses.clear();
             for (const step of plan.steps) {
@@ -312,6 +324,7 @@ export class PlanOrchestrator {
                         durationMs: elapsed,
                         resultPreview: resultText.slice(0, 100),
                     });
+                    this.logAutonomy('step_completed', { stepId: step.id, description: step.description, durationMs: elapsed, model: step.model });
                 }
                 else {
                     const errMsg = `[FAILED: ${outcome.reason}]`;
@@ -324,6 +337,7 @@ export class PlanOrchestrator {
                         resultPreview: errMsg.slice(0, 100),
                     });
                     logger.error({ stepId: step.id, err: outcome.reason }, 'Plan step failed');
+                    this.logAutonomy('step_failed', { stepId: step.id, description: step.description, error: String(outcome.reason).slice(0, 500) });
                 }
             }
             await safeProgress(this.getAllUpdates());
@@ -367,6 +381,7 @@ export class PlanOrchestrator {
                                 logger.warn({ stepId: issue.stepId }, 'Repair decision: abort plan');
                                 state.status = 'failed';
                                 this.saveState(state);
+                                this.logAutonomy('plan_aborted', { stepId: issue.stepId, reason: issue.issue });
                                 return `Plan aborted — step "${this.stepStatuses.get(issue.stepId)?.description ?? issue.stepId}" failed critically and could not be repaired.`;
                             }
                             // 'skip' falls through — annotate and continue
@@ -438,6 +453,7 @@ export class PlanOrchestrator {
         }
         catch (err) {
             logger.error({ err }, 'Synthesis step failed');
+            this.logAutonomy('synthesis_failed', { error: String(err).slice(0, 500) });
             // Fallback: concatenate results
             finalResult = Array.from(results.entries())
                 .map(([id, r]) => `**${this.stepStatuses.get(id)?.description ?? id}:**\n${r}`)
@@ -453,6 +469,7 @@ export class PlanOrchestrator {
         await safeProgress(this.getAllUpdates());
         const totalMs = Date.now() - this.startTime;
         logger.info({ totalMs, steps: plan.steps.length }, 'Plan execution complete');
+        this.logAutonomy('plan_completed', { totalMs, steps: plan.steps.length, errors: state.errors.length });
         // Mark state as complete and clean up
         state.status = 'complete';
         this.saveState(state);

package/dist/agent/self-improve-loop.d.ts

@@ -112,6 +112,8 @@ export declare class SelfImproveLoop {
     /** Coalesce a burst of fs.watch events (multiple triggers landing in
      * quick succession) into a single tick. */
     private scheduleDebouncedTick;
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    private logAutonomy;
     /**
      * Process all pending triggers. Public so tests + manual invocations
      * (e.g., a `clementine self-improve tick` CLI command) can call it.

package/dist/agent/self-improve-loop.js

@@ -313,6 +313,17 @@ export class SelfImproveLoop {
             this.tick().catch((err) => logger.error({ err }, 'Self-improve event-driven tick failed'));
         }, WATCH_DEBOUNCE_MS);
     }
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    async logAutonomy(event, trigger, details) {
+        try {
+            const { getStore } = await import('../tools/shared.js');
+            const store = await getStore();
+            store.logAutonomyEvent({ component: 'self_improve', event, agentSlug: trigger.agentSlug ?? null, details });
+        }
+        catch {
+            // Best-effort — telemetry must never break the self-improve loop.
+        }
+    }
     /**
      * Process all pending triggers. Public so tests + manual invocations
      * (e.g., a `clementine self-improve tick` CLI command) can call it.
@@ -346,11 +357,13 @@ export class SelfImproveLoop {
                     catch { /* ignore */ }
                     continue;
                 }
+                this.logAutonomy('trigger_detected', trigger, { consecutiveErrors: trigger.consecutiveErrors });
                 try {
                     await this.processOne(trigger, counts);
                 }
                 catch (err) {
                     logger.warn({ err, jobName: trigger.jobName }, 'Failed to process trigger — leaving in place for next tick');
+                    this.logAutonomy('process_failed', trigger, { error: String(err).slice(0, 500) });
                     continue;
                 }
                 // Successfully handled — remove the trigger
@@ -419,6 +432,7 @@ export class SelfImproveLoop {
         if (recipe.category === 'noop') {
             counts.noop++;
             logger.info({ jobName: trigger.jobName, reason: recipe.description }, 'Self-improve: no-op');
+            this.logAutonomy('fix_noop', trigger, { reason: recipe.description });
             return;
         }
         // risky | unknown → write proposal + DM agent
@@ -435,6 +449,7 @@ export class SelfImproveLoop {
         };
         const file = writePendingChange(record, this.pendingDir);
         counts.pending++;
+        this.logAutonomy('proposal_written', trigger, { category: recipe.category, proposalId: id });
         await this.notifyAgent(agentSlug, [
             `⚠️ **${trigger.jobName}** has failed ${trigger.consecutiveErrors} times in a row.`,
             '',

package/dist/cli/dashboard.js

@@ -1297,7 +1297,84 @@ export async function cmdDashboard(opts) {
         index: false,
     }));
     // Health check — always responds, no auth, no middleware dependency
-    app.get('/health', (_req, res) => { res.json({ ok: true, ts: Date.now() }); });
+    app.get('/health', async (_req, res) => {
+        const checks = {};
+        let overall = 'healthy';
+        // 1. Daemon process liveness
+        const pid = readPid();
+        const daemonAlive = pid ? isProcessAlive(pid) : false;
+        checks.daemon = daemonAlive ? 'ok' : 'unavailable';
+        if (!daemonAlive)
+            overall = 'unhealthy';
+        // 2. SQLite + memory health
+        try {
+            const { getStore } = await import('../tools/shared.js');
+            const store = await getStore();
+            const health = store.getMemoryHealth();
+            checks.sqlite = 'ok';
+            checks.fts5 = health.lastIntegrityReport?.ftsOk ? 'ok' : 'degraded';
+            checks.writeQueue = (health.writeQueue?.size ?? 0) > 100 ? 'degraded' : 'ok';
+            if (checks.fts5 === 'degraded' || checks.writeQueue === 'degraded') {
+                overall = overall === 'unhealthy' ? 'unhealthy' : 'degraded';
+            }
+        }
+        catch {
+            checks.sqlite = 'unavailable';
+            overall = 'unhealthy';
+        }
+        // 3. Graph store availability
+        try {
+            const { getSharedGraphStore } = await import('../memory/graph-store.js');
+            const graphDbDir = path.join(BASE_DIR, '.graph.db');
+            const gs = await getSharedGraphStore(graphDbDir);
+            checks.graphStore = gs?.isAvailable() ? 'ok' : 'unavailable';
+            if (checks.graphStore === 'unavailable' && overall !== 'unhealthy') {
+                overall = 'degraded';
+            }
+        }
+        catch {
+            checks.graphStore = 'unavailable';
+            if (overall !== 'unhealthy')
+                overall = 'degraded';
+        }
+        // 4. Recent cron failures (last 24h)
+        try {
+            const runsDir = path.join(BASE_DIR, 'cron', 'runs');
+            let recentFailures = 0;
+            let recentRuns = 0;
+            const dayAgo = Date.now() - 24 * 60 * 60 * 1000;
+            if (existsSync(runsDir)) {
+                for (const file of readdirSync(runsDir).filter(f => f.endsWith('.jsonl'))) {
+                    const lines = readFileSync(path.join(runsDir, file), 'utf-8').trim().split('\n').filter(Boolean);
+                    for (const line of lines.slice(-50)) {
+                        try {
+                            const entry = JSON.parse(line);
+                            const ts = entry.startedAt ? new Date(entry.startedAt).getTime() : 0;
+                            if (ts > dayAgo) {
+                                recentRuns++;
+                                if (entry.status === 'failed' || entry.status === 'error')
+                                    recentFailures++;
+                            }
+                        }
+                        catch { /* ignore parse errors */ }
+                    }
+                }
+            }
+            checks.cron = recentFailures > 3 ? 'degraded' : recentFailures > 0 ? 'degraded' : 'ok';
+            if (checks.cron === 'degraded' && overall !== 'unhealthy')
+                overall = 'degraded';
+        }
+        catch {
+            checks.cron = 'unavailable';
+        }
+        const statusCode = overall === 'healthy' ? 200 : overall === 'degraded' ? 503 : 503;
+        res.status(statusCode).json({
+            status: overall,
+            checks,
+            daemon: { pid: pid ?? null, alive: daemonAlive },
+            timestamp: new Date().toISOString(),
+        });
+    });
     // ── Webhook ingestion (raw-body, HMAC-authed) ─────────────────────
     // MUST be registered BEFORE the generic json parser below — otherwise
     // that parser consumes the body and HMAC verification fails since we
@@ -2203,6 +2280,23 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ error: String(err).slice(0, 200) });
         }
     });
+    app.get('/api/autonomy', async (req, res) => {
+        try {
+            const { getStore } = await import('../tools/shared.js');
+            const store = await getStore();
+            const logs = store.queryAutonomyLog({
+                component: typeof req.query.component === 'string' ? req.query.component : undefined,
+                event: typeof req.query.event === 'string' ? req.query.event : undefined,
+                agentSlug: typeof req.query.agentSlug === 'string' ? req.query.agentSlug : undefined,
+                limit: typeof req.query.limit === 'string' ? parseInt(req.query.limit, 10) : 100,
+                since: typeof req.query.since === 'string' ? req.query.since : undefined,
+            });
+            res.json({ logs });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err).slice(0, 200) });
+        }
+    });
     app.get('/api/heartbeat/agent/:slug', (req, res) => {
         const slug = req.params.slug;
         const state = getHeartbeat();

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

@@ -93,6 +93,8 @@ export declare class CronScheduler {
     private statusChangeListeners;
     private static readonly RUNNING_JOBS_FILE;
     constructor(gateway: Gateway, dispatcher: NotificationDispatcher);
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    private logAutonomy;
     /**
      * Atomically persist the current runningJobs set to disk. Uses write-then-
      * rename so a crash mid-write cannot corrupt the file.

package/dist/gateway/cron-scheduler.js

@@ -401,6 +401,17 @@ export class CronScheduler {
         // query jobs on connect which happens before start().
         this.loadJobDefinitions();
     }
+    /** Fire-and-forget autonomy telemetry — must never throw. */
+    async logAutonomy(event, job, details) {
+        try {
+            const { getStore } = await import('../tools/shared.js');
+            const store = await getStore();
+            store.logAutonomyEvent({ component: 'cron', event, agentSlug: job.agentSlug ?? null, details });
+        }
+        catch {
+            // Best-effort — telemetry must never break cron execution.
+        }
+    }
     /**
      * Atomically persist the current runningJobs set to disk. Uses write-then-
      * rename so a crash mid-write cannot corrupt the file.
@@ -974,6 +985,7 @@ export class CronScheduler {
         });
         this.persistRunningJobs(this.runMetadata);
         this.emitStatusChange();
+        this.logAutonomy('started', job, { model: job.model, mode: job.mode, tier: job.tier });
         try {
             logger.info(`Running cron job: ${job.name}${job.agentSlug ? ` (agent: ${job.agentSlug})` : ''}`);
             // Set agent profile for scoped cron jobs
@@ -1084,6 +1096,7 @@ export class CronScheduler {
                         }
                     }
                     this._logRun(entry);
+                    this.logAutonomy('completed', job, { durationMs: entry.durationMs, deliveryFailed: entry.deliveryFailed, advisorApplied: !!advisorApplied });
                     // Fire-and-forget: extract procedural skill from successful long-running cron jobs
                     if (entry.status === 'ok' && entry.durationMs > 30_000 && response && response.length > 500) {
                         this.gateway.extractCronSkill(job.name, job.prompt, response, entry.durationMs, job.agentSlug)
@@ -1135,6 +1148,7 @@ export class CronScheduler {
                     }
                     else {
                         logger.error({ err, job: job.name }, `Cron job '${job.name}' failed after ${attempt} attempt(s)`);
+                        this.logAutonomy('failed', job, { errorType, attempts: attempt, error: String(err).slice(0, 500) });
                         await this.dispatcher.send(CronScheduler.formatCronError(job.name, err), { agentSlug: job.agentSlug });
                     }
                 }
@@ -1170,6 +1184,7 @@ export class CronScheduler {
             const consErrors = this.runLog.consecutiveErrors(job.name);
             if (consErrors === 5) {
                 // Circuit breaker just engaged — notify
+                this.logAutonomy('circuit_breaker', job, { consecutiveErrors: consErrors });
                 this.logAdvisorEvent('circuit-breaker', job.name, `Circuit breaker engaged after ${consErrors} consecutive errors`);
                 this.dispatcher.send(`⚡ **Circuit breaker engaged** for \`${job.name}\` — ${consErrors} consecutive errors. Will retry in 1 hour.`, { agentSlug: job.agentSlug }).catch(err => logger.debug({ err }, 'Failed to send circuit breaker notification'));
             }
@@ -1189,6 +1204,7 @@ export class CronScheduler {
             // defined in per-agent CRON.md files (vault/00-System/agents/{slug}/CRON.md)
             // rather than only the central one.
             if (consErrors >= 3) {
+                this.logAutonomy('self_improve_triggered', job, { consecutiveErrors: consErrors });
                 try {
                     const triggerDir = path.join(BASE_DIR, 'self-improve', 'triggers');
                     mkdirSync(triggerDir, { recursive: true });
@@ -1218,6 +1234,7 @@ export class CronScheduler {
                     this.scheduledTasks.delete(job.name);
                 }
                 logger.error({ job: job.name, consErrors }, `Auto-disabled cron after ${consErrors} consecutive failures`);
+                this.logAutonomy('auto_disabled', job, { consecutiveErrors: consErrors });
                 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/memory/store.d.ts

@@ -1233,6 +1233,28 @@ export declare class MemoryStore {
      * Reduces salience so they appear lower in search results (but aren't deleted).
      */
     markConsolidated(chunkIds: number[]): void;
+    private _stmtLogAutonomy;
+    private _stmtQueryAutonomy;
+    logAutonomyEvent(row: {
+        component: string;
+        event: string;
+        agentSlug?: string | null;
+        details?: Record<string, unknown>;
+    }): void;
+    queryAutonomyLog(opts?: {
+        component?: string;
+        event?: string;
+        agentSlug?: string;
+        limit?: number;
+        since?: string;
+    }): Array<{
+        id: number;
+        component: string;
+        event: string;
+        agentSlug: string | null;
+        details: Record<string, unknown>;
+        createdAt: string;
+    }>;
     /**
      * Aggregate memory-health snapshot for the dashboard.
      *

package/dist/memory/store.js

@@ -834,6 +834,23 @@ export class MemoryStore {
         value TEXT NOT NULL,
         updated_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
+    `);
+        // Autonomy log — structured event stream for the self-improving,
+        // proactive, and planning layers. Makes the autonomous subsystem
+        // observable without grepping logs.
+        this.conn.exec(`
+      CREATE TABLE IF NOT EXISTS autonomy_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        component TEXT NOT NULL,
+        event TEXT NOT NULL,
+        agent_slug TEXT,
+        details_json TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_autonomy_component ON autonomy_log(component, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_autonomy_event ON autonomy_log(event, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_autonomy_agent ON autonomy_log(agent_slug, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_autonomy_created ON autonomy_log(created_at DESC);
     `);
     }
     // ── Skill usage telemetry ─────────────────────────────────────────
@@ -4331,6 +4348,70 @@ export class MemoryStore {
          WHERE id IN (${placeholders})`)
             .run(...chunkIds);
     }
+    // ── Autonomy log ───────────────────────────────────────────────────
+    _stmtLogAutonomy = null;
+    _stmtQueryAutonomy = null;
+    logAutonomyEvent(row) {
+        try {
+            if (!this._stmtLogAutonomy) {
+                this._stmtLogAutonomy = this.conn.prepare('INSERT INTO autonomy_log (component, event, agent_slug, details_json) VALUES (?, ?, ?, ?)');
+            }
+            this._stmtLogAutonomy.run(row.component, row.event, row.agentSlug ?? null, JSON.stringify(row.details ?? {}));
+        }
+        catch {
+            // Best-effort — autonomy telemetry must never break the system.
+        }
+    }
+    queryAutonomyLog(opts = {}) {
+        const conditions = [];
+        const params = [];
+        if (opts.component) {
+            conditions.push('component = ?');
+            params.push(opts.component);
+        }
+        if (opts.event) {
+            conditions.push('event = ?');
+            params.push(opts.event);
+        }
+        if (opts.agentSlug) {
+            conditions.push('agent_slug = ?');
+            params.push(opts.agentSlug);
+        }
+        if (opts.since) {
+            conditions.push('created_at >= ?');
+            params.push(opts.since);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = opts.limit ?? 100;
+        if (!this._stmtQueryAutonomy || conditions.length) {
+            // Ad-hoc query — conditions vary, use generic runner
+            return this.conn
+                .prepare(`SELECT * FROM autonomy_log ${where} ORDER BY created_at DESC LIMIT ?`)
+                .all(...params, limit)
+                .map((row) => {
+                const r = row;
+                return {
+                    id: r.id,
+                    component: r.component,
+                    event: r.event,
+                    agentSlug: r.agent_slug,
+                    details: JSON.parse(r.details_json || '{}'),
+                    createdAt: r.created_at,
+                };
+            });
+        }
+        return this._stmtQueryAutonomy.all(limit).map((row) => {
+            const r = row;
+            return {
+                id: r.id,
+                component: r.component,
+                event: r.event,
+                agentSlug: r.agent_slug,
+                details: JSON.parse(r.details_json || '{}'),
+                createdAt: r.created_at,
+            };
+        });
+    }
     /**
      * Aggregate memory-health snapshot for the dashboard.
      *

package/dist/tools/shared.d.ts

@@ -459,6 +459,94 @@ export type MemoryStoreType = {
         newestUpdated: string | null;
     };
     db: unknown;
+    getMemoryHealth(opts?: {
+        graphStore?: {
+            isAvailable(): boolean;
+            nodeCount?(): Promise<number>;
+            edgeCount?(): Promise<number>;
+        };
+        topCitedLimit?: number;
+    }): {
+        chunks: {
+            total: number;
+            consolidated: number;
+            pinned: number;
+            softDeleted: number;
+            zombieCount: number;
+        };
+        chunksByCategory: Array<{
+            category: string | null;
+            count: number;
+        }>;
+        tableRowCounts: Record<string, number>;
+        topCitedLast30d: Array<{
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            refCount: number;
+        }>;
+        staleUserModelSlots: Array<{
+            slot: string;
+            ageDays: number;
+            agentSlug: string | null;
+        }>;
+        staleHighSalienceChunks: Array<{
+            chunkId: number;
+            sourceFile: string;
+            section: string;
+            salience: number;
+            lastOutcomeScore: number;
+        }>;
+        chunkCacheStats: {
+            hits: number;
+            misses: number;
+            evictions: number;
+            size: number;
+        };
+        writeQueue: {
+            size: number;
+            dropped: number;
+        } | null;
+        lastIntegrityReport: {
+            ftsOk: boolean;
+            ftsRebuilt: boolean;
+            orphanRefsNulled: number;
+            missingEmbeddings: number;
+            ranAt: string;
+        } | null;
+        dbSizeBytes: number;
+        lastVacuumAt: string | null;
+        denseEmbeddings: {
+            withDense: number;
+            total: number;
+            models: Array<{
+                model: string;
+                count: number;
+            }>;
+            currentModel: string;
+            ready: boolean;
+        };
+    };
+    logAutonomyEvent(row: {
+        component: string;
+        event: string;
+        agentSlug?: string | null;
+        details?: Record<string, unknown>;
+    }): void;
+    queryAutonomyLog(opts?: {
+        component?: string;
+        event?: string;
+        agentSlug?: string;
+        limit?: number;
+        since?: string;
+    }): Array<{
+        id: number;
+        component: string;
+        event: string;
+        agentSlug: string | null;
+        details: Record<string, unknown>;
+        createdAt: string;
+    }>;
 };
 export declare function getStore(): Promise<MemoryStoreType>;
 export declare function getStoreSync(): MemoryStoreType | null;

package/package.json

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