clementine-agent 1.2.2 → 1.3.0

package/dist/dashboard/builder/snapshots.js

@@ -0,0 +1,138 @@
+/**
+ * Builder snapshot history — file-based undo for workflow saves.
+ *
+ * Every successful save writes a copy of the source file to:
+ *   ~/.clementine/snapshots/builder/<origin>/<key>/<timestamp>.md
+ *
+ * Bounded: keep at most MAX_PER_WORKFLOW snapshots per workflow id.
+ * Older snapshots are pruned on each save.
+ *
+ * No git dependency, no user-facing CLI — agent invokes via MCP tools
+ * (workflow_history / workflow_restore).
+ */
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parseBuilderId } from './serializer.js';
+function snapRoot() {
+    return path.join(process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine'), 'snapshots', 'builder');
+}
+const MAX_PER_WORKFLOW = 20;
+let _snapshotCounter = 0;
+function nextSnapshotFilename() {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const seq = (++_snapshotCounter).toString(36).padStart(3, '0');
+    return `${ts}-${seq}.md`;
+}
+function snapshotDirFor(id) {
+    const parsed = parseBuilderId(id);
+    if (!parsed)
+        return null;
+    return path.join(snapRoot(), parsed.origin, sanitizeKey(parsed.key));
+}
+function sanitizeKey(key) {
+    return key.replace(/[^a-z0-9._-]/gi, '_').slice(0, 120);
+}
+/**
+ * Write a snapshot of the current state of a workflow's source file.
+ * Best-effort — failures are logged but never block the underlying save.
+ */
+export function snapshotWorkflow(id, sourceFile) {
+    if (!sourceFile || !existsSync(sourceFile))
+        return null;
+    const dir = snapshotDirFor(id);
+    if (!dir)
+        return null;
+    try {
+        mkdirSync(dir, { recursive: true });
+        const filename = nextSnapshotFilename();
+        const dst = path.join(dir, filename);
+        copyFileSync(sourceFile, dst);
+        pruneOldSnapshots(dir);
+        return entryFromFile(id, dir, filename);
+    }
+    catch {
+        return null;
+    }
+}
+/** List snapshots for a builder id, newest first. */
+export function listSnapshots(id) {
+    const dir = snapshotDirFor(id);
+    if (!dir || !existsSync(dir))
+        return [];
+    try {
+        const files = readdirSync(dir).filter(f => f.endsWith('.md'));
+        return files
+            .map(f => entryFromFile(id, dir, f))
+            .filter((e) => e != null)
+            .sort((a, b) => b.ts.localeCompare(a.ts));
+    }
+    catch {
+        return [];
+    }
+}
+/** Restore a snapshot by filename. Writes the snapshot's contents back into sourceFile. */
+export function restoreSnapshot(id, snapshotFilename, sourceFile) {
+    const dir = snapshotDirFor(id);
+    if (!dir)
+        return { ok: false, error: 'unknown id' };
+    const safe = path.basename(snapshotFilename);
+    const src = path.join(dir, safe);
+    if (!existsSync(src))
+        return { ok: false, error: 'snapshot not found' };
+    if (!sourceFile)
+        return { ok: false, error: 'missing sourceFile' };
+    try {
+        // Snapshot the *current* contents first so the restore itself is reversible.
+        snapshotWorkflow(id, sourceFile);
+        const content = readFileSync(src, 'utf-8');
+        writeFileSync(sourceFile, content, 'utf-8');
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}
+function pruneOldSnapshots(dir) {
+    let files;
+    try {
+        files = readdirSync(dir).filter(f => f.endsWith('.md'));
+    }
+    catch {
+        return;
+    }
+    if (files.length <= MAX_PER_WORKFLOW)
+        return;
+    const sorted = files.sort(); // ISO timestamps sort naturally
+    const overflow = sorted.length - MAX_PER_WORKFLOW;
+    for (let i = 0; i < overflow; i++) {
+        try {
+            unlinkSync(path.join(dir, sorted[i]));
+        }
+        catch { /* */ }
+    }
+}
+function entryFromFile(id, dir, filename) {
+    try {
+        const full = path.join(dir, filename);
+        const stat = statSync(full);
+        const ts = filename.replace(/\.md$/, '').replace(/-/g, ':').replace(/^(\d{4}):(\d{2}):(\d{2})T/, '$1-$2-$3T').replace(/T(\d{2}):(\d{2}):(\d{2}):(\d{3})Z?$/, 'T$1:$2:$3.$4Z');
+        let preview = '';
+        try {
+            const head = readFileSync(full, 'utf-8').slice(0, 240);
+            preview = head.replace(/\n/g, ' ').slice(0, 120);
+        }
+        catch { /* */ }
+        return {
+            id,
+            filename,
+            ts,
+            size: stat.size,
+            preview,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=snapshots.js.map

package/dist/dashboard/builder/validation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Builder workflow validation.
+ *
+ * Static, side-effect-free checks. Used both by `workflow_validate` (agent
+ * runs it explicitly) and by save handlers (refuse to persist invalid
+ * graphs). Errors block save; warnings are surfaced for the agent and UI
+ * but don't prevent persistence (e.g., disabled cron with no schedule —
+ * legal but probably wrong).
+ */
+import type { WorkflowDefinition } from '../../types.js';
+export type ValidationSeverity = 'error' | 'warning';
+export interface ValidationIssue {
+    severity: ValidationSeverity;
+    code: string;
+    stepId?: string;
+    field?: string;
+    message: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    issues: ValidationIssue[];
+}
+export declare function validateWorkflow(wf: WorkflowDefinition): ValidationResult;
+/** Lightweight cron expression validation. Accepts standard 5-field cron and common ranges/lists/steps. */
+export declare function isCronExpression(expr: string): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/dashboard/builder/validation.js

@@ -0,0 +1,183 @@
+/**
+ * Builder workflow validation.
+ *
+ * Static, side-effect-free checks. Used both by `workflow_validate` (agent
+ * runs it explicitly) and by save handlers (refuse to persist invalid
+ * graphs). Errors block save; warnings are surfaced for the agent and UI
+ * but don't prevent persistence (e.g., disabled cron with no schedule —
+ * legal but probably wrong).
+ */
+export function validateWorkflow(wf) {
+    const issues = [];
+    // ── Workflow-level ──
+    if (!wf.name || !wf.name.trim()) {
+        issues.push({ severity: 'error', code: 'name-empty', message: 'Workflow has no name' });
+    }
+    if (wf.steps.length === 0) {
+        issues.push({ severity: 'error', code: 'no-steps', message: 'Workflow has no steps' });
+    }
+    if (wf.trigger.schedule && !isCronExpression(wf.trigger.schedule)) {
+        issues.push({
+            severity: 'error', code: 'bad-schedule',
+            field: 'trigger.schedule',
+            message: `Invalid cron expression: "${wf.trigger.schedule}"`,
+        });
+    }
+    if (wf.enabled && !wf.trigger.schedule && !wf.trigger.manual) {
+        issues.push({
+            severity: 'warning', code: 'enabled-no-trigger',
+            message: 'Workflow is enabled but has neither a cron schedule nor a manual trigger',
+        });
+    }
+    // ── Step-level ──
+    const seenIds = new Set();
+    for (const step of wf.steps) {
+        if (seenIds.has(step.id)) {
+            issues.push({
+                severity: 'error', code: 'duplicate-step-id',
+                stepId: step.id,
+                message: `Duplicate step id: "${step.id}"`,
+            });
+        }
+        seenIds.add(step.id);
+        issues.push(...validateStepConfig(step));
+        for (const dep of step.dependsOn) {
+            if (dep === step.id) {
+                issues.push({
+                    severity: 'error', code: 'self-dep',
+                    stepId: step.id,
+                    message: `Step "${step.id}" depends on itself`,
+                });
+            }
+        }
+    }
+    // Missing dep references
+    for (const step of wf.steps) {
+        for (const dep of step.dependsOn) {
+            if (dep !== step.id && !seenIds.has(dep)) {
+                issues.push({
+                    severity: 'error', code: 'missing-dep',
+                    stepId: step.id,
+                    message: `Step "${step.id}" depends on unknown step "${dep}"`,
+                });
+            }
+        }
+    }
+    // Cycle detection (only worthwhile if there are no missing-dep errors)
+    if (!issues.some(i => i.code === 'missing-dep' || i.code === 'self-dep')) {
+        const cycle = findCycle(wf.steps);
+        if (cycle) {
+            issues.push({
+                severity: 'error', code: 'cycle',
+                message: `Cycle detected through steps: ${cycle.join(' → ')}`,
+            });
+        }
+    }
+    return { ok: !issues.some(i => i.severity === 'error'), issues };
+}
+function validateStepConfig(step) {
+    const issues = [];
+    const kind = step.kind ?? 'prompt';
+    switch (kind) {
+        case 'prompt':
+            if (!step.prompt || !step.prompt.trim()) {
+                issues.push({ severity: 'error', code: 'prompt-empty', stepId: step.id, message: `Prompt step "${step.id}" has empty prompt` });
+            }
+            break;
+        case 'mcp':
+            if (!step.mcp) {
+                issues.push({ severity: 'error', code: 'mcp-missing', stepId: step.id, message: `MCP step "${step.id}" has no config` });
+            }
+            else {
+                if (!step.mcp.server)
+                    issues.push({ severity: 'error', code: 'mcp-no-server', stepId: step.id, message: `MCP step "${step.id}" missing server` });
+                if (!step.mcp.tool)
+                    issues.push({ severity: 'error', code: 'mcp-no-tool', stepId: step.id, message: `MCP step "${step.id}" missing tool` });
+            }
+            break;
+        case 'channel':
+            if (!step.channel) {
+                issues.push({ severity: 'error', code: 'channel-missing', stepId: step.id, message: `Channel step "${step.id}" has no config` });
+            }
+            else {
+                if (!step.channel.channel)
+                    issues.push({ severity: 'error', code: 'channel-no-channel', stepId: step.id, message: `Channel step "${step.id}" missing channel` });
+                if (!step.channel.target)
+                    issues.push({ severity: 'error', code: 'channel-no-target', stepId: step.id, message: `Channel step "${step.id}" missing target` });
+                if (!step.channel.content)
+                    issues.push({ severity: 'warning', code: 'channel-no-content', stepId: step.id, message: `Channel step "${step.id}" has empty content` });
+            }
+            break;
+        case 'transform':
+            if (!step.transform || !step.transform.expression) {
+                issues.push({ severity: 'error', code: 'transform-no-expr', stepId: step.id, message: `Transform step "${step.id}" missing expression` });
+            }
+            break;
+        case 'conditional':
+            if (!step.conditional || !step.conditional.condition) {
+                issues.push({ severity: 'error', code: 'conditional-no-cond', stepId: step.id, message: `Conditional step "${step.id}" missing condition` });
+            }
+            break;
+        case 'loop':
+            if (!step.loop || !step.loop.items) {
+                issues.push({ severity: 'error', code: 'loop-no-items', stepId: step.id, message: `Loop step "${step.id}" missing items expression` });
+            }
+            break;
+    }
+    if (typeof step.tier !== 'number' || step.tier < 1 || step.tier > 5) {
+        issues.push({ severity: 'warning', code: 'tier-range', stepId: step.id, field: 'tier', message: `Step "${step.id}" tier out of usual range (1-5): ${step.tier}` });
+    }
+    if (typeof step.maxTurns !== 'number' || step.maxTurns < 1) {
+        issues.push({ severity: 'warning', code: 'max-turns-range', stepId: step.id, field: 'maxTurns', message: `Step "${step.id}" maxTurns invalid: ${step.maxTurns}` });
+    }
+    return issues;
+}
+/** Return the cycle as a list of step ids (first→last→first), or null if acyclic. */
+function findCycle(steps) {
+    const adj = new Map();
+    for (const s of steps)
+        adj.set(s.id, s.dependsOn.slice());
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = new Map();
+    for (const id of adj.keys())
+        color.set(id, WHITE);
+    const stack = [];
+    function dfs(node) {
+        color.set(node, GRAY);
+        stack.push(node);
+        for (const dep of adj.get(node) ?? []) {
+            const c = color.get(dep);
+            if (c === GRAY) {
+                const cycleStart = stack.indexOf(dep);
+                return [...stack.slice(cycleStart), dep];
+            }
+            if (c === WHITE) {
+                const found = dfs(dep);
+                if (found)
+                    return found;
+            }
+        }
+        stack.pop();
+        color.set(node, BLACK);
+        return null;
+    }
+    for (const id of adj.keys()) {
+        if (color.get(id) === WHITE) {
+            const found = dfs(id);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+const CRON_FIELD = /^(\*|(\d+|\*\/\d+)([,-/](\d+))*)$/;
+/** Lightweight cron expression validation. Accepts standard 5-field cron and common ranges/lists/steps. */
+export function isCronExpression(expr) {
+    if (!expr || typeof expr !== 'string')
+        return false;
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return false;
+    return fields.every(f => CRON_FIELD.test(f) || /^[A-Z*]+$/i.test(f));
+}
+//# sourceMappingURL=validation.js.map

package/dist/gateway/router.js

@@ -1445,9 +1445,38 @@ export class Gateway {
         try {
             logger.info({ workflow: workflow.name, inputs }, 'Running workflow');
             try {
-                const { WorkflowRunner } = await import('../agent/workflow-runner.js');
+                const [{ WorkflowRunner }, { emitBuilderEvent }, { workflowId }] = await Promise.all([
+                    import('../agent/workflow-runner.js'),
+                    import('../dashboard/builder/events.js'),
+                    import('../dashboard/builder/serializer.js'),
+                ]);
                 const runner = new WorkflowRunner(this.assistant);
-                const result = await runner.run(workflow, inputs);
+                // Derive builder id so the dashboard canvas can light up live if it's open.
+                const baseName = workflow.sourceFile
+                    ? workflow.sourceFile.split('/').pop()?.replace(/\.md$/, '') ?? workflow.name
+                    : workflow.name;
+                const builderId = workflowId(baseName);
+                const runId = `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                emitBuilderEvent({ type: 'run:started', workflowId: builderId, runId, payload: { mode: 'real', stepCount: workflow.steps.length } });
+                const result = await runner.run(workflow, inputs, (updates) => {
+                    for (const u of updates) {
+                        if (u.status === 'waiting')
+                            continue;
+                        const status = u.status === 'done' ? 'done' : u.status === 'failed' ? 'failed' : u.status === 'skipped' ? 'skipped' : 'running';
+                        emitBuilderEvent({
+                            type: 'run:step-status',
+                            workflowId: builderId,
+                            runId,
+                            payload: { stepId: u.stepId, status, durationMs: u.durationMs, mocked: false },
+                        });
+                    }
+                });
+                emitBuilderEvent({
+                    type: 'run:completed',
+                    workflowId: builderId,
+                    runId,
+                    payload: { status: result.status === 'ok' ? 'ok' : 'error', durationMs: result.entry.durationMs },
+                });
                 // Re-baseline integrity checksums after workflow (may write to vault)
                 scanner.refreshIntegrity();
                 return result.output || '*(workflow completed — no output)*';

package/dist/index.js

@@ -608,6 +608,15 @@ async function asyncMain() {
     {
         const memStore = assistant.getMemoryStore();
         if (memStore) {
+            // Async write queue: route transcript saves, recall traces, outcomes,
+            // and access-log inserts off the request thread. ~250ms flush window;
+            // drained on shutdown below. Idempotent — safe if called twice.
+            try {
+                memStore.enableWriteQueue();
+            }
+            catch (err) {
+                logger.warn({ err }, 'Failed to enable memory write queue — falling back to sync writes');
+            }
             const { runStartupMaintenance, startPeriodicMaintenance } = await import('./memory/maintenance.js');
             // Fire-and-forget startup maintenance
             runStartupMaintenance(memStore).catch(() => { });
@@ -685,6 +694,16 @@ async function asyncMain() {
     const heartbeat = new HeartbeatScheduler(gateway, dispatcher);
     const cronScheduler = new CronScheduler(gateway, dispatcher);
     heartbeat.setCronScheduler(cronScheduler);
+    // Builder runner — wire MCP invoke handler so canvas test runs can hit
+    // real read-only MCP tools (gmail.list_unread, github.list_prs, etc.).
+    // Stdio clients are pooled per server with idle teardown.
+    try {
+        const { installBuilderMcpHandler } = await import('./dashboard/builder/mcp-invoke.js');
+        installBuilderMcpHandler();
+    }
+    catch (err) {
+        logger.warn({ err }, 'Builder MCP invoke handler install failed (non-fatal)');
+    }
     // Per-agent heartbeats — one cheap-path observer per registered specialist.
     // LLM tick fires on signal change with the agent's profile and routes
     // output to their Discord channel.
@@ -999,6 +1018,25 @@ async function asyncMain() {
     catch (err) {
         logger.warn({ err }, 'Session flush on shutdown failed');
     }
+    // Drain the memory write queue so transcripts/recall traces/outcomes/access
+    // logs that were enqueued in the last <250ms make it to SQLite.
+    try {
+        const memStore = assistant.getMemoryStore();
+        if (memStore && typeof memStore.flushWrites === 'function') {
+            await memStore.flushWrites();
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Memory write queue drain failed');
+    }
+    // Tear down builder MCP client pool (best-effort).
+    try {
+        const { shutdownBuilderMcpHandler } = await import('./dashboard/builder/mcp-invoke.js');
+        await shutdownBuilderMcpHandler();
+    }
+    catch (err) {
+        logger.warn({ err }, 'Builder MCP handler shutdown failed (non-fatal)');
+    }
     // Now safe to tear down remaining infrastructure
     heartbeat.stop();
     cronScheduler.stop();

package/dist/memory/chunker.js

@@ -22,6 +22,13 @@ const DIR_CATEGORY_MAP = {
     '05-Tasks': 'advice',
     '07-Inbox': 'events',
 };
+/**
+ * Procedural memory: learned workflows live in 00-System/procedures/.
+ * Frontmatter `triggers: [verb-phrases]` is parsed separately by the store
+ * and used at retrieval time to boost the chunk when a query mentions one
+ * of the trigger verbs. Pattern adopted from Mem0's v1.0.0 procedural tier.
+ */
+const PROCEDURE_DIR = '00-System/procedures';
 /** Content keyword patterns for category detection (used as fallback). */
 const CATEGORY_KEYWORDS = [
     [/\b(prefer|always use|never use|i like|i don'?t like|i hate)\b/i, 'preferences'],
@@ -37,11 +44,15 @@ function detectCategoryAndTopic(relPath, frontmatter, content) {
     // 1. Explicit frontmatter category
     if (frontmatter.category) {
         const fm = String(frontmatter.category).toLowerCase();
-        if (['facts', 'events', 'discoveries', 'preferences', 'advice'].includes(fm)) {
+        if (['facts', 'events', 'discoveries', 'preferences', 'advice', 'procedure'].includes(fm)) {
             category = fm;
         }
     }
-    // 2. Directory-based
+    // 2. Procedure directory (overrides directory map below).
+    if (!category && relPath.startsWith(PROCEDURE_DIR)) {
+        category = 'procedure';
+    }
+    // 3. Directory-based
     if (!category) {
         const topDir = relPath.split('/')[0];
         category = DIR_CATEGORY_MAP[topDir] ?? null;

package/dist/memory/hot-cache.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tiny in-process LRU for hot chunk-row reads.
+ *
+ * Use case: searchContext + recall-trace expansion + dashboard chunk view all
+ * funnel through getChunksByIds, which often touches the same hot rows
+ * many times within a session. SQLite reads are already fast (microseconds),
+ * but the LRU eliminates the per-query overhead and lets us amortize the
+ * row-shape unpacking that getChunksByIds does.
+ *
+ * Bounded: capacity ~1000 by default (~1MB at 1KB/chunk). Map preserves
+ * insertion order, so we delete-then-set on access to keep most-recent at
+ * the tail and evict from the head.
+ *
+ * Concurrency: single-process daemon, single thread — no locking needed.
+ */
+export declare class HotCache<K, V> {
+    private map;
+    private capacity;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(capacity?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    /** Drop all entries — call when bulk-rebuilding the underlying store. */
+    clear(): void;
+    size(): number;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+        size: number;
+        capacity: number;
+        hitRate: number;
+    };
+}
+//# sourceMappingURL=hot-cache.d.ts.map

package/dist/memory/hot-cache.js

@@ -0,0 +1,73 @@
+/**
+ * Tiny in-process LRU for hot chunk-row reads.
+ *
+ * Use case: searchContext + recall-trace expansion + dashboard chunk view all
+ * funnel through getChunksByIds, which often touches the same hot rows
+ * many times within a session. SQLite reads are already fast (microseconds),
+ * but the LRU eliminates the per-query overhead and lets us amortize the
+ * row-shape unpacking that getChunksByIds does.
+ *
+ * Bounded: capacity ~1000 by default (~1MB at 1KB/chunk). Map preserves
+ * insertion order, so we delete-then-set on access to keep most-recent at
+ * the tail and evict from the head.
+ *
+ * Concurrency: single-process daemon, single thread — no locking needed.
+ */
+export class HotCache {
+    map = new Map();
+    capacity;
+    hits = 0;
+    misses = 0;
+    evictions = 0;
+    constructor(capacity = 1000) {
+        this.capacity = capacity;
+    }
+    get(key) {
+        const v = this.map.get(key);
+        if (v === undefined) {
+            this.misses++;
+            return undefined;
+        }
+        // Bump to most-recent.
+        this.map.delete(key);
+        this.map.set(key, v);
+        this.hits++;
+        return v;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= this.capacity) {
+            // Evict oldest (first inserted).
+            const oldestKey = this.map.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.map.delete(oldestKey);
+                this.evictions++;
+            }
+        }
+        this.map.set(key, value);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    /** Drop all entries — call when bulk-rebuilding the underlying store. */
+    clear() {
+        this.map.clear();
+    }
+    size() {
+        return this.map.size;
+    }
+    stats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            evictions: this.evictions,
+            size: this.map.size,
+            capacity: this.capacity,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+}
+//# sourceMappingURL=hot-cache.js.map

package/dist/memory/integrity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Memory store integrity probes — self-healing checks that run on the
+ * janitor's periodic cycle. Each probe is independent and conservative:
+ *  - reports what it found,
+ *  - repairs only when the fix is non-destructive,
+ *  - never throws (logs and continues).
+ *
+ * Three checks today (the cheap, high-value ones):
+ *   1. FTS5 contentless-table integrity → auto-rebuild on failure
+ *   2. derived_from references to deleted chunks → nullify the dangling refs
+ *   3. chunks with content but no embedding → return count for backfill
+ *
+ * Graph reachability is intentionally NOT probed here — it lives in
+ * graph-store.ts's own health probe, which auto-restarts FalkorDB.
+ */
+export interface IntegrityReport {
+    ftsOk: boolean;
+    ftsRebuilt: boolean;
+    orphanRefsNulled: number;
+    missingEmbeddings: number;
+}
+/**
+ * Run all probes and apply safe repairs. Returns a report; never throws.
+ * The store argument is typed loose so this module can be called from
+ * maintenance.ts without an import cycle.
+ */
+export declare function runIntegrityProbes(store: any): IntegrityReport;
+//# sourceMappingURL=integrity.d.ts.map