clementine-agent 1.17.0 → 1.18.1

package/dist/agent/assistant.d.ts

@@ -267,6 +267,7 @@ export declare class PersonalAssistant {
             schema: Record<string, unknown>;
         };
         delegateProfile?: AgentProfile;
+        abortSignal?: AbortSignal;
     }): Promise<string>;
     runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, opts?: {
         disableAllTools?: boolean;

package/dist/agent/assistant.js

@@ -4069,10 +4069,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
     }
     // ── Plan Step Execution ───────────────────────────────────────────
     async runPlanStep(stepId, prompt, opts = {}) {
-        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile } = opts;
+        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile, abortSignal } = opts;
         // Don't mutate the global — pass source through the closure instead
         // Per-step stall guard so concurrent steps don't cross-contaminate
         const stepGuard = new StallGuard();
+        // Per-step AbortController, mirroring the parent signal so the orchestrator
+        // (or gateway, via the session AC) can stop in-flight SDK streams.
+        const stepAc = new AbortController();
+        if (abortSignal) {
+            if (abortSignal.aborted)
+                stepAc.abort(abortSignal.reason);
+            else
+                abortSignal.addEventListener('abort', () => stepAc.abort(abortSignal.reason), { once: true });
+        }
         const sdkOptions = await this.buildOptions({
             isHeartbeat: false,
             cronTier: tier,
@@ -4085,6 +4094,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             outputFormat,
             stallGuard: stepGuard,
             profile: delegateProfile ?? null,
+            abortController: stepAc,
         });
         const trace = [];
         const stream = query({ prompt, options: sdkOptions });

package/dist/agent/orchestrator.d.ts

@@ -39,15 +39,22 @@ export declare class PlanOrchestrator {
     private startTime;
     private stateId;
     private agentProfiles;
+    private abortSignal?;
     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). */
     static loadState(stateId: string): PlanState | null;
     /**
      * Main entry: plan → approve → execute → synthesize → return final response.
+     *
+     * `abortSignal` (typically the gateway session controller) lets the user stop
+     * a running plan: the orchestrator checks it between waves and forwards it to
+     * every `runPlanStep` call so in-flight SDK streams abort immediately.
      */
-    run(taskDescription: string, onProgress?: (updates: PlanProgressUpdate[]) => Promise<void>, onApproval?: (planSummary: string, steps: PlanStep[]) => Promise<boolean | string>, availableAgents?: AgentProfile[]): Promise<string>;
+    run(taskDescription: string, onProgress?: (updates: PlanProgressUpdate[]) => Promise<void>, onApproval?: (planSummary: string, steps: PlanStep[]) => Promise<boolean | string>, availableAgents?: AgentProfile[], abortSignal?: AbortSignal): Promise<string>;
     /**
      * Goal-backward verification pass using Haiku after plan synthesis.
      * Verifies outcomes rather than just rating quality:

package/dist/agent/orchestrator.js

@@ -123,10 +123,22 @@ export class PlanOrchestrator {
     startTime = 0;
     stateId;
     agentProfiles = new Map();
+    abortSignal;
     constructor(assistant) {
         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 {
@@ -161,13 +173,18 @@ export class PlanOrchestrator {
     }
     /**
      * Main entry: plan → approve → execute → synthesize → return final response.
+     *
+     * `abortSignal` (typically the gateway session controller) lets the user stop
+     * a running plan: the orchestrator checks it between waves and forwards it to
+     * every `runPlanStep` call so in-flight SDK streams abort immediately.
      */
-    async run(taskDescription, onProgress, onApproval, availableAgents) {
+    async run(taskDescription, onProgress, onApproval, availableAgents, abortSignal) {
         // Reset instance state for reuse safety
         this.stepStatuses.clear();
         this.stepStartTimes.clear();
         this.agentProfiles.clear();
         this.startTime = Date.now();
+        this.abortSignal = abortSignal;
         // Index available agents for delegation lookups
         if (availableAgents) {
             for (const agent of availableAgents) {
@@ -206,6 +223,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) {
@@ -269,6 +287,15 @@ export class PlanOrchestrator {
         };
         this.saveState(state);
         for (const wave of waves) {
+            // User-initiated cancellation: bail before starting the next wave so we
+            // don't kick off SDK streams the user already asked to stop.
+            if (this.abortSignal?.aborted) {
+                logger.info({ goal: taskDescription, wavesCompleted: state.wavesCompleted }, 'Plan cancelled by user');
+                state.status = 'failed';
+                this.saveState(state);
+                this.logAutonomy('plan_aborted', { reason: 'user_cancelled', wavesCompleted: state.wavesCompleted });
+                return 'Plan cancelled.';
+            }
             // Mark running
             for (const step of wave) {
                 this.stepStatuses.set(step.id, {
@@ -291,6 +318,7 @@ export class PlanOrchestrator {
                     maxTurns: step.maxTurns ?? 15,
                     model: step.model,
                     delegateProfile,
+                    abortSignal: this.abortSignal,
                 });
                 return { stepId: step.id, result };
             }), MAX_CONCURRENT_STEPS);
@@ -312,6 +340,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,9 +353,20 @@ 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());
+            // If the user aborted mid-wave, the SDK calls above already threw and
+            // `outcome.reason` will reflect the abort. Surface that as a clean
+            // cancellation instead of falling through to spot-check / repair / synthesis.
+            if (this.abortSignal?.aborted) {
+                logger.info({ goal: taskDescription, wavesCompleted: state.wavesCompleted }, 'Plan cancelled by user mid-wave');
+                state.status = 'failed';
+                this.saveState(state);
+                this.logAutonomy('plan_aborted', { reason: 'user_cancelled', wavesCompleted: state.wavesCompleted });
+                return 'Plan cancelled.';
+            }
             // Inter-wave spot-check with severity levels: critical issues trigger repair
             const spotCheckIssues = this.spotCheckWaveResults(wave, results);
             if (spotCheckIssues.length > 0) {
@@ -348,6 +388,7 @@ export class PlanOrchestrator {
                                         tier: step.tier ?? 2,
                                         maxTurns: step.maxTurns ?? 15,
                                         model: step.model,
+                                        abortSignal: this.abortSignal,
                                     });
                                     results.set(step.id, retryResult || '[No output on retry]');
                                     this.stepStatuses.set(step.id, {
@@ -367,6 +408,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
@@ -434,10 +476,12 @@ export class PlanOrchestrator {
                 tier: 2,
                 maxTurns: 5,
                 disableTools: true,
+                abortSignal: this.abortSignal,
             });
         }
         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 +497,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);
@@ -602,6 +647,7 @@ export class PlanOrchestrator {
                 maxTurns: 1,
                 model: 'haiku',
                 disableTools: true,
+                abortSignal: this.abortSignal,
             });
             const cleaned = decision.trim().toLowerCase();
             if (cleaned.includes('retry'))
@@ -628,7 +674,7 @@ export class PlanOrchestrator {
                 `If a step matches an agent's specialty, add "delegateTo": "agent-slug" to that step. ` +
                 `The delegated agent will run the step with their own personality, tools, and expertise.\n`;
         }
-        const plannerResult = await this.assistant.runPlanStep('planner', PLANNER_PROMPT + agentContext + task + PLANNER_PROMPT_SUFFIX, { tier: 2, maxTurns: 1, model: 'sonnet', disableTools: true });
+        const plannerResult = await this.assistant.runPlanStep('planner', PLANNER_PROMPT + agentContext + task + PLANNER_PROMPT_SUFFIX, { tier: 2, maxTurns: 1, model: 'sonnet', disableTools: true, abortSignal: this.abortSignal });
         // Parse JSON from the planner response
         const parsed = this.parseJsonFromResponse(plannerResult);
         if (!parsed?.steps || !Array.isArray(parsed.steps) || parsed.steps.length === 0) {
@@ -781,6 +827,7 @@ Work through this task narrating your reasoning:
         return this.assistant.runPlanStep('fallback', task, {
             tier: 2,
             maxTurns: 25,
+            abortSignal: this.abortSignal,
         });
     }
     getAllUpdates() {

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/gateway/router.js

@@ -1424,9 +1424,15 @@ export class Gateway {
                 }
                 // Register provenance for the orchestrator session
                 this.ensureProvenance(sessionKey);
+                // Register a session AbortController so a follow-up message ("stop", or
+                // any new prompt) can interrupt the plan via acquireSessionLock — which
+                // calls abortController.abort('interrupted-by-new-message') when it
+                // sees an in-flight query on this session.
+                const planAc = new AbortController();
+                this.getSession(sessionKey).abortController = planAc;
                 const { PlanOrchestrator } = await import('../agent/orchestrator.js');
                 const orchestrator = new PlanOrchestrator(this.assistant);
-                const result = await orchestrator.run(taskDescription, onProgress, onApproval);
+                const result = await orchestrator.run(taskDescription, onProgress, onApproval, undefined, planAc.signal);
                 scanner.refreshIntegrity();
                 this.assistant.injectContext(sessionKey, `[Plan: ${taskDescription}]`, result);
                 return result;

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.17.0",
+  "version": "1.18.1",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",