clementine-agent 1.6.2 → 1.7.0

package/dist/dashboard/builder/serializer.js

@@ -18,33 +18,79 @@ import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from
 import path from 'node:path';
 import matter from 'gray-matter';
 import yaml from 'js-yaml';
-import { CRON_FILE, WORKFLOWS_DIR } from '../../config.js';
+import { CRON_FILE, WORKFLOWS_DIR, AGENTS_DIR } from '../../config.js';
 import { snapshotWorkflow } from './snapshots.js';
 // ── ID scheme ───────────────────────────────────────────────────────
+//
+// Global:        `cron:<key>` / `workflow:<key>`
+// Agent-scoped:  `cron@<slug>:<key>` / `workflow@<slug>:<key>`
+// `@` is reserved (slugs and workflow keys are kebab-case `[a-z0-9-]+`),
+// so it cleanly distinguishes scoped ids from global ones without
+// breaking any existing global id parser.
 const CRON_ID_PREFIX = 'cron:';
 const WORKFLOW_ID_PREFIX = 'workflow:';
-export function cronId(name) {
+const CRON_AGENT_PREFIX = 'cron@';
+const WORKFLOW_AGENT_PREFIX = 'workflow@';
+export function cronId(name, agentSlug) {
+    if (agentSlug)
+        return CRON_AGENT_PREFIX + agentSlug + ':' + name;
     return CRON_ID_PREFIX + name;
 }
-export function workflowId(filename) {
+export function workflowId(filename, agentSlug) {
     const base = filename.endsWith('.md') ? filename.slice(0, -3) : filename;
+    if (agentSlug)
+        return WORKFLOW_AGENT_PREFIX + agentSlug + ':' + base;
     return WORKFLOW_ID_PREFIX + base;
 }
 export function parseBuilderId(id) {
+    if (id.startsWith(CRON_AGENT_PREFIX)) {
+        const rest = id.slice(CRON_AGENT_PREFIX.length);
+        const colon = rest.indexOf(':');
+        if (colon < 1 || colon === rest.length - 1)
+            return null;
+        return { origin: 'cron', scope: 'agent', agentSlug: rest.slice(0, colon), key: rest.slice(colon + 1) };
+    }
+    if (id.startsWith(WORKFLOW_AGENT_PREFIX)) {
+        const rest = id.slice(WORKFLOW_AGENT_PREFIX.length);
+        const colon = rest.indexOf(':');
+        if (colon < 1 || colon === rest.length - 1)
+            return null;
+        return { origin: 'workflow', scope: 'agent', agentSlug: rest.slice(0, colon), key: rest.slice(colon + 1) };
+    }
     if (id.startsWith(CRON_ID_PREFIX))
-        return { origin: 'cron', key: id.slice(CRON_ID_PREFIX.length) };
+        return { origin: 'cron', scope: 'global', key: id.slice(CRON_ID_PREFIX.length) };
     if (id.startsWith(WORKFLOW_ID_PREFIX))
-        return { origin: 'workflow', key: id.slice(WORKFLOW_ID_PREFIX.length) };
+        return { origin: 'workflow', scope: 'global', key: id.slice(WORKFLOW_ID_PREFIX.length) };
     return null;
 }
+// ── Agent path helpers ──────────────────────────────────────────────
+function agentCronFile(slug) {
+    return path.join(AGENTS_DIR, slug, 'CRON.md');
+}
+function agentWorkflowsDir(slug) {
+    return path.join(AGENTS_DIR, slug, 'workflows');
+}
+function listAgentSlugs() {
+    if (!existsSync(AGENTS_DIR))
+        return [];
+    try {
+        return readdirSync(AGENTS_DIR, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+    }
+    catch {
+        return [];
+    }
+}
 // ── List ────────────────────────────────────────────────────────────
 export function listAllForBuilder() {
     const out = [];
-    // Crons from CRON.md
-    for (const job of readCronJobs()) {
+    // Global crons from CRON.md
+    for (const job of readCronJobsFromFile(CRON_FILE)) {
         out.push({
             id: cronId(job.name),
             origin: 'cron',
+            scope: 'global',
             name: job.name,
             description: '',
             enabled: job.enabled,
@@ -54,7 +100,7 @@ export function listAllForBuilder() {
             agentSlug: job.agentSlug,
         });
     }
-    // Workflows from workflows dir
+    // Global workflows from workflows dir
     if (existsSync(WORKFLOWS_DIR)) {
         for (const file of readdirSync(WORKFLOWS_DIR).filter(f => f.endsWith('.md'))) {
             try {
@@ -62,6 +108,7 @@ export function listAllForBuilder() {
                 out.push({
                     id: workflowId(file),
                     origin: 'workflow',
+                    scope: 'global',
                     name: wf.name,
                     description: wf.description,
                     enabled: wf.enabled,
@@ -76,6 +123,47 @@ export function listAllForBuilder() {
             }
         }
     }
+    // Agent-scoped crons + workflows from <AGENTS_DIR>/<slug>/...
+    for (const slug of listAgentSlugs()) {
+        const cronFile = agentCronFile(slug);
+        for (const job of readCronJobsFromFile(cronFile)) {
+            out.push({
+                id: cronId(job.name, slug),
+                origin: 'cron',
+                scope: 'agent',
+                name: job.name,
+                description: '',
+                enabled: job.enabled,
+                schedule: job.schedule,
+                stepCount: 1,
+                sourceFile: cronFile,
+                agentSlug: slug,
+            });
+        }
+        const wfDir = agentWorkflowsDir(slug);
+        if (existsSync(wfDir)) {
+            for (const file of readdirSync(wfDir).filter(f => f.endsWith('.md'))) {
+                try {
+                    const wf = parseWorkflowFile(path.join(wfDir, file));
+                    out.push({
+                        id: workflowId(file, slug),
+                        origin: 'workflow',
+                        scope: 'agent',
+                        name: wf.name,
+                        description: wf.description,
+                        enabled: wf.enabled,
+                        schedule: wf.trigger.schedule,
+                        stepCount: wf.steps.length,
+                        sourceFile: wf.sourceFile,
+                        agentSlug: slug,
+                    });
+                }
+                catch {
+                    // Skip unparseable workflow files
+                }
+            }
+        }
+    }
     return out.sort((a, b) => a.name.localeCompare(b.name));
 }
 // ── Read ────────────────────────────────────────────────────────────
@@ -84,25 +172,31 @@ export function readWorkflow(id) {
     if (!parsed)
         return null;
     if (parsed.origin === 'cron') {
-        const job = readCronJobs().find(j => j.name === parsed.key);
+        const cronFile = parsed.scope === 'agent' ? agentCronFile(parsed.agentSlug) : CRON_FILE;
+        const slug = parsed.scope === 'agent' ? parsed.agentSlug : undefined;
+        const job = readCronJobsFromFile(cronFile).find(j => j.name === parsed.key);
         if (!job)
             return null;
-        return cronJobToWorkflow(job);
+        return cronJobToWorkflow(slug ? { ...job, agentSlug: slug } : job, { sourceFile: cronFile });
     }
-    const file = path.join(WORKFLOWS_DIR, parsed.key + '.md');
+    const wfDir = parsed.scope === 'agent' ? agentWorkflowsDir(parsed.agentSlug) : WORKFLOWS_DIR;
+    const file = path.join(wfDir, parsed.key + '.md');
     if (!existsSync(file))
         return null;
     try {
-        return parseWorkflowFile(file);
+        const wf = parseWorkflowFile(file);
+        if (parsed.scope === 'agent' && !wf.agentSlug)
+            wf.agentSlug = parsed.agentSlug;
+        return wf;
     }
     catch {
         return null;
     }
 }
-function readCronJobs() {
-    if (!existsSync(CRON_FILE))
+function readCronJobsFromFile(cronFile) {
+    if (!existsSync(cronFile))
         return [];
-    const raw = readFileSync(CRON_FILE, 'utf-8');
+    const raw = readFileSync(cronFile, 'utf-8');
     let parsed;
     try {
         parsed = matter(raw);
@@ -219,7 +313,7 @@ function parseWorkflowFile(filePath) {
     };
 }
 // ── Cron ⇄ Workflow ─────────────────────────────────────────────────
-export function cronJobToWorkflow(job) {
+export function cronJobToWorkflow(job, opts = {}) {
     const step = {
         id: 'main',
         prompt: job.prompt,
@@ -237,7 +331,7 @@ export function cronJobToWorkflow(job) {
         trigger: { schedule: job.schedule, manual: false },
         inputs: {},
         steps: [step],
-        sourceFile: CRON_FILE,
+        sourceFile: opts.sourceFile ?? CRON_FILE,
         agentSlug: job.agentSlug,
     };
 }
@@ -265,23 +359,41 @@ export function saveWorkflow(id, wf) {
         if (!isCronShape(wf)) {
             return { ok: false, error: 'Cron entry must remain a single prompt step with a cron schedule' };
         }
-        return saveCronEntry(parsed.key, wf);
+        const cronFile = parsed.scope === 'agent' ? agentCronFile(parsed.agentSlug) : CRON_FILE;
+        const slug = parsed.scope === 'agent' ? parsed.agentSlug : undefined;
+        return saveCronEntry(parsed.key, wf, { cronFile, agentSlug: slug });
     }
-    return saveWorkflowFile(parsed.key, wf);
+    const wfDir = parsed.scope === 'agent' ? agentWorkflowsDir(parsed.agentSlug) : WORKFLOWS_DIR;
+    const slug = parsed.scope === 'agent' ? parsed.agentSlug : undefined;
+    return saveWorkflowFile(parsed.key, wf, { dir: wfDir, agentSlug: slug });
 }
-/** Resolve the on-disk file path for a builder id (cron entries all share CRON_FILE). */
+/** Resolve the on-disk file path for a builder id. */
 export function sourceFileForId(id, parsedHint) {
     const parsed = parsedHint ?? parseBuilderId(id);
     if (!parsed)
         return null;
-    if (parsed.origin === 'cron')
-        return CRON_FILE;
-    return path.join(WORKFLOWS_DIR, parsed.key + '.md');
+    if (parsed.origin === 'cron') {
+        return parsed.scope === 'agent' ? agentCronFile(parsed.agentSlug) : CRON_FILE;
+    }
+    const dir = parsed.scope === 'agent' ? agentWorkflowsDir(parsed.agentSlug) : WORKFLOWS_DIR;
+    return path.join(dir, parsed.key + '.md');
 }
-function saveCronEntry(originalName, wf) {
-    if (!existsSync(CRON_FILE))
-        return { ok: false, error: 'CRON.md does not exist' };
-    const raw = readFileSync(CRON_FILE, 'utf-8');
+/**
+ * Strip an `<agentSlug>:` prefix the UI may have stored in `wf.name` when
+ * editing an agent-scoped entity. The on-disk name is always the bare key —
+ * the slug lives in the file path, not the name.
+ */
+function stripAgentPrefix(name, agentSlug) {
+    if (!agentSlug)
+        return name;
+    const prefix = agentSlug + ':';
+    return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+function saveCronEntry(originalName, wf, opts) {
+    const { cronFile, agentSlug } = opts;
+    if (!existsSync(cronFile))
+        return { ok: false, error: 'CRON.md does not exist: ' + cronFile };
+    const raw = readFileSync(cronFile, 'utf-8');
     let parsed;
     try {
         parsed = matter(raw);
@@ -297,7 +409,7 @@ function saveCronEntry(originalName, wf) {
     const prev = jobs[idx];
     const updated = {
         ...prev,
-        name: wf.name,
+        name: stripAgentPrefix(wf.name, agentSlug),
         schedule: wf.trigger.schedule,
         prompt: step.prompt,
         enabled: wf.enabled,
@@ -309,18 +421,21 @@ function saveCronEntry(originalName, wf) {
         updated.model = step.model;
     if (step.workDir != null)
         updated.work_dir = step.workDir;
-    if (wf.agentSlug)
+    // Agent slug for global crons that are bound to a specific agent (legacy
+    // shape). For agent-dir crons the slug lives in the path, not the entry.
+    if (!agentSlug && wf.agentSlug)
         updated.agentSlug = wf.agentSlug;
     jobs[idx] = updated;
     parsed.data.jobs = jobs;
     const out = matter.stringify(parsed.content ?? '', parsed.data);
-    writeFileSync(CRON_FILE, out, 'utf-8');
+    writeFileSync(cronFile, out, 'utf-8');
     return { ok: true };
 }
-function saveWorkflowFile(key, wf) {
-    if (!existsSync(WORKFLOWS_DIR))
-        mkdirSync(WORKFLOWS_DIR, { recursive: true });
-    const file = path.join(WORKFLOWS_DIR, key + '.md');
+function saveWorkflowFile(key, wf, opts) {
+    const { dir, agentSlug } = opts;
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, key + '.md');
     // Preserve body content if the file exists; otherwise empty body.
     let body = '';
     if (existsSync(file)) {
@@ -334,12 +449,14 @@ function saveWorkflowFile(key, wf) {
     }
     const data = {
         type: 'workflow',
-        name: wf.name,
+        name: stripAgentPrefix(wf.name, agentSlug),
         description: wf.description,
         enabled: wf.enabled,
         trigger: wf.trigger,
     };
-    if (wf.agentSlug)
+    // Agent slug for legacy global workflows that target a specific agent.
+    // For agent-dir workflows the slug lives in the path, not the frontmatter.
+    if (!agentSlug && wf.agentSlug)
         data.agentSlug = wf.agentSlug;
     if (Object.keys(wf.inputs).length > 0)
         data.inputs = wf.inputs;

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

@@ -20,6 +20,9 @@ export declare class HeartbeatScheduler {
     private lastAgentSiRuns;
     private cronScheduler;
     private runLog;
+    private lastDenseBackfillAt;
+    private denseBackfillInFlight;
+    private lastSalienceDecayDate;
     /** Wire up the cron scheduler so daily plan suggestions can be applied. */
     setCronScheduler(cs: CronScheduler): void;
     private getLastAgentSiRun;
@@ -33,6 +36,23 @@ export declare class HeartbeatScheduler {
      * Proactive insight check — gather signals, evaluate urgency, send if warranted.
      * Runs as a lightweight Haiku call, separate from the main heartbeat LLM invocation.
      */
+    /**
+     * Self-healing dense embedding backfill. Runs a small batch each tick when:
+     *  - chat lane has 0 active sessions (don't compete with response latency)
+     *  - dense model is available
+     *  - >= 10 minutes since last backfill (cooldown)
+     *  - not already running
+     *
+     * Per-pass cap (50 chunks) keeps each tick under ~30s on Apple Silicon CPU.
+     * Coverage climbs over hours/days without user action.
+     */
+    private maybeIdleDenseBackfill;
+    /**
+     * Daily salience decay. Multiplies salience by 0.95 on chunks unaccessed
+     * for >30 days. Date-gated (one pass per calendar day), persisted in
+     * HeartbeatState. Pinned chunks exempt; soft-deleted and superseded skipped.
+     */
+    private maybeRunSalienceDecay;
     private runInsightCheck;
     /** Called when user replies to a proactive message — resets cooldown. */
     recordInsightAcknowledged(): void;

package/dist/gateway/heartbeat-scheduler.js

@@ -30,6 +30,9 @@ export class HeartbeatScheduler {
     lastAgentSiRuns = new Map();
     cronScheduler = null;
     runLog = new CronRunLog();
+    lastDenseBackfillAt = 0;
+    denseBackfillInFlight = false;
+    lastSalienceDecayDate = '';
     /** Wire up the cron scheduler so daily plan suggestions can be applied. */
     setCronScheduler(cs) { this.cronScheduler = cs; }
     getLastAgentSiRun(slug) {
@@ -48,6 +51,8 @@ export class HeartbeatScheduler {
             this.lastSelfImproveDate = this.lastState.lastSelfImproveDate;
         if (this.lastState.lastConsolidationDate)
             this.lastConsolidationDate = this.lastState.lastConsolidationDate;
+        if (this.lastState.lastSalienceDecayDate)
+            this.lastSalienceDecayDate = this.lastState.lastSalienceDecayDate;
         if (this.lastState.lastAgentSiRuns) {
             this.lastAgentSiRuns = new Map(Object.entries(this.lastState.lastAgentSiRuns));
         }
@@ -115,6 +120,18 @@ export class HeartbeatScheduler {
                 logger.warn({ err }, 'Failure sweep failed');
             });
         }).catch(err => logger.warn({ err }, 'Failure sweep import failed'));
+        // Idle dense-embedding backfill. Retrieval quality silently degrades when
+        // chunks are stuck on TF-IDF only — this self-healing loop keeps coverage
+        // climbing during quiet periods. Skipped when chat lane is busy (CPU
+        // would compete with response latency) or already on cooldown.
+        this.maybeIdleDenseBackfill().catch(err => {
+            logger.debug({ err }, 'Idle dense backfill failed (non-fatal)');
+        });
+        // Daily salience decay — fades stale, unaccessed chunks so retrieval
+        // doesn't keep boosting facts that aren't earning their context budget.
+        // Pinned + soft-deleted + superseded chunks are exempt. One UPDATE per
+        // day, gated by a date stamp on HeartbeatState.
+        this.maybeRunSalienceDecay();
         // Claim verification sweep — auto-verify pending claims whose due
         // times have passed (e.g. "I scheduled X for 8am" → check at 9am).
         import('./claim-tracker.js').then(async ({ verifyDueClaims, drainLLMFallback }) => {
@@ -713,6 +730,81 @@ export class HeartbeatScheduler {
      * Proactive insight check — gather signals, evaluate urgency, send if warranted.
      * Runs as a lightweight Haiku call, separate from the main heartbeat LLM invocation.
      */
+    /**
+     * Self-healing dense embedding backfill. Runs a small batch each tick when:
+     *  - chat lane has 0 active sessions (don't compete with response latency)
+     *  - dense model is available
+     *  - >= 10 minutes since last backfill (cooldown)
+     *  - not already running
+     *
+     * Per-pass cap (50 chunks) keeps each tick under ~30s on Apple Silicon CPU.
+     * Coverage climbs over hours/days without user action.
+     */
+    async maybeIdleDenseBackfill() {
+        if (this.denseBackfillInFlight)
+            return;
+        const sinceLastMs = Date.now() - this.lastDenseBackfillAt;
+        if (sinceLastMs < 10 * 60 * 1000)
+            return;
+        const { lanes } = await import('./lanes.js');
+        if (lanes.status().chat.active > 0)
+            return;
+        const store = this.gateway.getMemoryStore();
+        if (!store)
+            return;
+        const stats = store.getMemoryStats();
+        if (stats.totalChunks === 0)
+            return;
+        if (stats.chunksWithDenseEmbeddings >= stats.totalChunks)
+            return;
+        const embeddings = await import('../memory/embeddings.js');
+        if (!embeddings.isDenseReady()) {
+            // First time: try to load the model in the background. Don't block the
+            // tick — if download is needed (~440MB), it can take a while.
+            embeddings.probeDenseReady().catch(() => { });
+            return;
+        }
+        this.denseBackfillInFlight = true;
+        this.lastDenseBackfillAt = Date.now();
+        try {
+            const result = await store.backfillDenseEmbeddings({ limit: 50 });
+            if (result.embedded > 0) {
+                const after = store.getMemoryStats();
+                const pct = after.totalChunks > 0
+                    ? Math.round((after.chunksWithDenseEmbeddings / after.totalChunks) * 100)
+                    : 0;
+                logger.info({ embedded: result.embedded, failed: result.failed, coveragePct: pct, model: result.model }, 'Idle dense backfill batch complete');
+            }
+        }
+        finally {
+            this.denseBackfillInFlight = false;
+        }
+    }
+    /**
+     * Daily salience decay. Multiplies salience by 0.95 on chunks unaccessed
+     * for >30 days. Date-gated (one pass per calendar day), persisted in
+     * HeartbeatState. Pinned chunks exempt; soft-deleted and superseded skipped.
+     */
+    maybeRunSalienceDecay() {
+        const today = todayISO();
+        if (this.lastSalienceDecayDate === today)
+            return;
+        const store = this.gateway.getMemoryStore();
+        if (!store || typeof store.decayStaleSalience !== 'function')
+            return;
+        try {
+            const decayed = store
+                .decayStaleSalience({ staleDays: 30, decayFactor: 0.95, floor: 0 });
+            this.lastSalienceDecayDate = today;
+            this.lastState.lastSalienceDecayDate = today;
+            this.saveState();
+            if (decayed > 0)
+                logger.info({ decayed }, 'Daily salience decay sweep complete');
+        }
+        catch (err) {
+            logger.debug({ err }, 'Salience decay sweep failed (non-fatal)');
+        }
+    }
     async runInsightCheck() {
         // Initialize insight state if needed
         if (!this.lastState.insightState) {

package/dist/memory/store.d.ts

@@ -275,6 +275,7 @@ export declare class MemoryStore {
         chunkIds: number[];
         scores: number[];
         agentSlug?: string | null;
+        matchTypes?: string[];
     }): void;
     /** Internal sync recall_trace insert. Called by the WriteQueue. */
     _logRecallTraceSync(opts: {
@@ -284,6 +285,7 @@ export declare class MemoryStore {
         chunkIds: number[];
         scores: number[];
         agentSlug?: string | null;
+        matchTypes?: string[];
     }): void;
     /**
      * Fetch recent recall traces for a session, newest first.
@@ -891,6 +893,104 @@ export declare class MemoryStore {
      * so frequently-mentioned facts surface higher in search results.
      */
     bumpChunkSalience(chunkId: number, boost?: number): void;
+    /**
+     * Mark a chunk as superseded by a newer one. The old chunk becomes
+     * invisible to retrieval but stays in the DB for provenance. Idempotent:
+     * supersede(A, B) followed by supersede(A, C) records C as the new
+     * pointer. Won't link a chunk to itself or to a missing chunk.
+     */
+    markChunkSuperseded(oldChunkId: number, newChunkId: number, opts?: {
+        reason?: string;
+        agent?: string;
+    }): boolean;
+    /**
+     * Daily salience-decay sweep. Multiplies salience by `decayFactor` (default
+     * 0.95) on chunks that haven't been accessed or written-to in `staleDays`.
+     * Pinned chunks are exempt — pinning is the user's explicit "keep this hot."
+     * Soft-deleted and superseded chunks are also skipped (they're already out
+     * of circulation). Returns count of rows updated.
+     */
+    decayStaleSalience(opts?: {
+        staleDays?: number;
+        decayFactor?: number;
+        floor?: number;
+    }): number;
+    /**
+     * Composition / graph stats — wikilink density + per-match-type recall
+     * contribution over a recent window. Surfaces whether entity linking is
+     * paying off in retrieval.
+     */
+    getGraphStats(opts?: {
+        topN?: number;
+        lookbackHours?: number;
+    }): {
+        wikilinkCount: number;
+        topLinkedTargets: Array<{
+            target: string;
+            count: number;
+        }>;
+        recallContributionByType: Record<string, number>;
+        tracesAnalyzed: number;
+    };
+    /**
+     * Cross-channel session bridge — the most recent N session summaries per
+     * channel (Discord / dashboard / cron / etc). Channel inferred from the
+     * sessionKey prefix (everything before first ':'). Powers the dashboard
+     * "Cross-channel handoff" panel so we can see whether continuity is
+     * actually flowing between sources.
+     */
+    getRecentSummariesByChannel(limitPerChannel?: number): Record<string, SessionSummary[]>;
+    /**
+     * Stats for the supersede graph — count of superseded chunks (excluded
+     * from retrieval) for the dashboard.
+     */
+    getSupersedeStats(): {
+        superseded: number;
+        recent: Array<{
+            oldId: number;
+            newId: number;
+            reason: string | null;
+            supersededAt: string;
+        }>;
+    };
+    /**
+     * Apply an agent-supplied salience hint to chunks freshly written by
+     * memory_write. Called after incrementalSync so the new chunks exist.
+     * Sets salience to MAX(existing, hint) — a higher hint wins, but we
+     * never trample reinforcement that already accumulated. Allowed range
+     * 0.5–2.0; values >1.0 are reserved for explicit "this is critical"
+     * signals from the agent (e.g. user identity, hard preferences,
+     * irreversible decisions).
+     */
+    applyWriteSalience(sourceFile: string, section: string | null, hint: number): number;
+    /**
+     * Apply an agent-supplied confidence value to chunks freshly written by
+     * memory_write. Confidence (0.0–1.0) is orthogonal to salience: salience
+     * = "how important if true," confidence = "how certain it's still true."
+     * Defaults to 1.0 on insert; agents lower it for tentative facts. Used as
+     * a multiplier in retrieval scoring so uncertain chunks lose ranking.
+     */
+    applyWriteConfidence(sourceFile: string, section: string | null, confidence: number): number;
+    /**
+     * Recent writes panel — surfaces what the agent has been capturing and why.
+     * Joins memory_extractions to chunks (best-effort match by source_file +
+     * section if the tool_input carries those). Limit defaults to 50 since this
+     * powers a dashboard panel, not analytics.
+     */
+    getRecentWrites(limit?: number): Array<{
+        id: number;
+        extractedAt: string;
+        sessionKey: string;
+        agentSlug: string | null;
+        toolName: string;
+        action: string | null;
+        section: string | null;
+        filePath: string | null;
+        reason: string | null;
+        salienceHint: number | null;
+        status: string;
+        userMessage: string;
+    }>;
     /**
      * Log a memory extraction event for transparency tracking.
      */
@@ -1160,6 +1260,16 @@ export declare class MemoryStore {
         } | null;
         dbSizeBytes: number;
         lastVacuumAt: string | null;
+        denseEmbeddings: {
+            withDense: number;
+            total: number;
+            models: Array<{
+                model: string;
+                count: number;
+            }>;
+            currentModel: string;
+            ready: boolean;
+        };
     };
     /**
      * Get consolidation stats for monitoring.