@aixle/insights 0.1.0

package/dist/cursor-settings.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { cursorUserDir } from "./readers/cursor.js";
+// Keys are tried in specificity order — Cursor-namespaced keys first, then
+// generic fallbacks. "model" is last to avoid capturing unrelated workspace
+// settings that happen to have a "model" key.
+const SETTINGS_MODEL_KEYS = [
+    "cursor.aiModel",
+    "aiModel",
+    "cursor.general.preferredModel",
+    "model",
+];
+/**
+ * Best-effort: read active model name from Cursor's settings.json.
+ * Returns null on any error (file absent, unreadable, no matching key).
+ * Never throws.
+ */
+export function readCursorActiveModel(baseDir) {
+    const settingsPath = join(baseDir ?? cursorUserDir(), "settings.json");
+    try {
+        if (!existsSync(settingsPath))
+            return null;
+        const raw = readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const obj = parsed;
+        for (const key of SETTINGS_MODEL_KEYS) {
+            const val = obj[key];
+            if (typeof val === "string" && val.trim().length > 0)
+                return val.trim();
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cursor-store-audit.d.ts

@@ -0,0 +1,48 @@
+import { DailyStatsVersionDiscovery } from "./daily-stats-versions.js";
+export type { DailyStatsVersionDiscovery } from "./daily-stats-versions.js";
+export type PathCLegacyVerdict = "no_legacy_dbs" | "legacy_present_empty" | "legacy_has_rows";
+export interface LegacyDbAuditEntry {
+    db_path_redacted: string;
+    file_bytes: number;
+    has_feedback_table: boolean;
+    feedback_row_count: number;
+}
+export interface StateVscdbAuditEntry {
+    db_path_redacted: string;
+    exists: boolean;
+    daily_stats_key_count: number;
+    has_recent_commit: boolean;
+}
+export interface CursorStoreAuditReport {
+    captured_at: string;
+    platform: NodeJS.Platform;
+    sqlite_probe_ok: boolean;
+    state_vscdb: {
+        total_paths: number;
+        global: StateVscdbAuditEntry;
+        workspace_scoped_count: number;
+        workspace_with_daily_stats: number;
+        workspace_with_recent_commit: number;
+    };
+    legacy_cursor_db: {
+        count: number;
+        with_feedback_table: number;
+        total_feedback_rows: number;
+        entries: LegacyDbAuditEntry[];
+    };
+    path_c_verdict: PathCLegacyVerdict;
+    /** Human-readable summary for CUR-V07 / DATA-CURRENT.md. */
+    ingest_note: string;
+    /** CUR-V11 — version prefixes under `aiCodeTracking.dailyStats.*` (install-wide). */
+    daily_stats_versions: DailyStatsVersionDiscovery;
+    /** Short note when v1.6+ or unparsed keys need cursor-6 work. */
+    daily_stats_version_note: string;
+}
+export declare function redactCursorPath(p: string): string;
+export declare function auditStateVscdbFile(dbPath: string): StateVscdbAuditEntry;
+export declare function auditLegacyCursorDbFile(dbPath: string): LegacyDbAuditEntry;
+/**
+ * CUR-V07 — inventory local Cursor stores (state.vscdb vs legacy cursor.db).
+ * Does not read disk outside Cursor's User directory unless `baseDir` is passed (tests).
+ */
+export declare function auditCursorLocalStores(baseDir?: string): CursorStoreAuditReport;

package/dist/cursor-store-audit.js

@@ -0,0 +1,155 @@
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { discoverDailyStatsVersionsInDb, mergeDailyStatsVersionDiscoveries, } from "./daily-stats-versions.js";
+import { cursorUserDir, findCursorDbs, findStateVscDbs, isGlobalStateDbPath, probeCursorGlobalStateDb, } from "./readers/cursor.js";
+const LEGACY_TABLE = "CursorRequestFeedback";
+const STATE_TABLE = "ItemTable";
+const RECENT_COMMIT_KEY = "aiCodeTracking.recentCommit";
+export function redactCursorPath(p) {
+    return p.replaceAll(homedir(), "~");
+}
+function tableExists(db, tableName) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+        .get(tableName);
+    return row !== undefined;
+}
+export function auditStateVscdbFile(dbPath) {
+    const entry = {
+        db_path_redacted: redactCursorPath(dbPath),
+        exists: existsSync(dbPath),
+        daily_stats_key_count: 0,
+        has_recent_commit: false,
+    };
+    if (!entry.exists)
+        return entry;
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        const ds = db
+            .prepare(`SELECT count(*) AS c FROM ${STATE_TABLE} WHERE key LIKE 'aiCodeTracking.dailyStats%'`)
+            .get();
+        const rc = db
+            .prepare(`SELECT 1 FROM ${STATE_TABLE} WHERE key = ? LIMIT 1`)
+            .get(RECENT_COMMIT_KEY);
+        entry.daily_stats_key_count = ds.c;
+        entry.has_recent_commit = rc !== undefined;
+    }
+    catch {
+        // Leave counts at zero — caller checks sqlite_probe_ok.
+    }
+    finally {
+        db?.close();
+    }
+    return entry;
+}
+export function auditLegacyCursorDbFile(dbPath) {
+    const entry = {
+        db_path_redacted: redactCursorPath(dbPath),
+        file_bytes: existsSync(dbPath) ? statSync(dbPath).size : 0,
+        has_feedback_table: false,
+        feedback_row_count: 0,
+    };
+    if (!existsSync(dbPath))
+        return entry;
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        if (!tableExists(db, LEGACY_TABLE))
+            return entry;
+        entry.has_feedback_table = true;
+        const row = db.prepare(`SELECT count(*) AS c FROM ${LEGACY_TABLE}`).get();
+        entry.feedback_row_count = row.c;
+    }
+    catch {
+        return entry;
+    }
+    finally {
+        db?.close();
+    }
+    return entry;
+}
+function dailyStatsVersionNote(discovery) {
+    if (discovery.buckets.length === 0) {
+        return "No aiCodeTracking.dailyStats keys found in any state.vscdb.";
+    }
+    const versions = discovery.buckets.map((b) => `${b.version} (${b.key_count})`).join(", ");
+    if (discovery.has_version_newer_than_v1_5) {
+        const extra = discovery.unmatched_keys.length > 0
+            ? ` Unparsed keys: ${discovery.unmatched_keys.slice(0, 3).join(", ")}${discovery.unmatched_keys.length > 3 ? "…" : ""}.`
+            : "";
+        return (`Found dailyStats version(s): ${versions}. Highest: ${discovery.highest_version}.` +
+            " v1.6+ or non-standard keys present — track as cursor-6 (schema discovery / mapper)." +
+            extra);
+    }
+    return (`Found dailyStats version(s): ${versions}. Highest: ${discovery.highest_version}.` +
+        " Reader accepts any v* dated key; no cursor-6 follow-up on this install.");
+}
+function pathCIngestNote(verdict, legacyCount, totalRows) {
+    switch (verdict) {
+        case "no_legacy_dbs":
+            return (`No workspaceStorage/**/cursor.db files found (${legacyCount} paths). ` +
+                "Path C (legacy per-request) contributes zero events on this install; rely on state.vscdb Paths A/B.");
+        case "legacy_present_empty":
+            return (`Found ${legacyCount} cursor.db file(s) but CursorRequestFeedback is empty or missing. ` +
+                "Path C wired in sync but produces no payloads until/unless Cursor writes legacy rows.");
+        case "legacy_has_rows":
+            return (`Found ${legacyCount} cursor.db file(s) with ${totalRows} CursorRequestFeedback row(s). ` +
+                "Path C can emit real token counts and model names when synced.");
+    }
+}
+/**
+ * CUR-V07 — inventory local Cursor stores (state.vscdb vs legacy cursor.db).
+ * Does not read disk outside Cursor's User directory unless `baseDir` is passed (tests).
+ */
+export function auditCursorLocalStores(baseDir) {
+    const sqlite_probe_ok = probeCursorGlobalStateDb(false);
+    const statePaths = findStateVscDbs(baseDir);
+    const globalPath = statePaths.find((p) => isGlobalStateDbPath(p)) ??
+        join(baseDir ?? cursorUserDir(), "globalStorage", "state.vscdb");
+    const global = auditStateVscdbFile(globalPath);
+    const workspacePaths = statePaths.filter((p) => !isGlobalStateDbPath(p));
+    const workspaceAudits = workspacePaths.map(auditStateVscdbFile);
+    const versionDiscoveries = statePaths
+        .filter((p) => existsSync(p))
+        .map(discoverDailyStatsVersionsInDb);
+    const daily_stats_versions = mergeDailyStatsVersionDiscoveries(versionDiscoveries);
+    const legacyPaths = findCursorDbs(baseDir);
+    const legacyEntries = legacyPaths.map(auditLegacyCursorDbFile);
+    const withFeedbackTable = legacyEntries.filter((e) => e.has_feedback_table).length;
+    const totalFeedbackRows = legacyEntries.reduce((sum, e) => sum + e.feedback_row_count, 0);
+    let path_c_verdict;
+    if (legacyPaths.length === 0) {
+        path_c_verdict = "no_legacy_dbs";
+    }
+    else if (totalFeedbackRows === 0) {
+        path_c_verdict = "legacy_present_empty";
+    }
+    else {
+        path_c_verdict = "legacy_has_rows";
+    }
+    return {
+        captured_at: new Date().toISOString(),
+        platform: process.platform,
+        sqlite_probe_ok,
+        state_vscdb: {
+            total_paths: statePaths.length,
+            global,
+            workspace_scoped_count: workspacePaths.length,
+            workspace_with_daily_stats: workspaceAudits.filter((e) => e.daily_stats_key_count > 0).length,
+            workspace_with_recent_commit: workspaceAudits.filter((e) => e.has_recent_commit).length,
+        },
+        legacy_cursor_db: {
+            count: legacyPaths.length,
+            with_feedback_table: withFeedbackTable,
+            total_feedback_rows: totalFeedbackRows,
+            entries: legacyEntries,
+        },
+        path_c_verdict,
+        ingest_note: pathCIngestNote(path_c_verdict, legacyPaths.length, totalFeedbackRows),
+        daily_stats_versions,
+        daily_stats_version_note: dailyStatsVersionNote(daily_stats_versions),
+    };
+}

package/dist/daily-stats-versions.d.ts

@@ -0,0 +1,31 @@
+/** Full key shape for a dated dailyStats row. */
+export declare const DAILY_STATS_KEY_RE: RegExp;
+export interface DailyStatsVersionBucket {
+    version: string;
+    key_count: number;
+    date_min: string | null;
+    date_max: string | null;
+    /** Up to three sample keys (for verification docs). */
+    sample_keys: string[];
+}
+export interface DailyStatsVersionDiscovery {
+    buckets: DailyStatsVersionBucket[];
+    /** Keys matching dailyStats% but not matching {@link DAILY_STATS_KEY_RE}. */
+    unmatched_keys: string[];
+    highest_version: string | null;
+    /** True when a version newer than v1.5 is present (cursor-6 follow-up). */
+    has_version_newer_than_v1_5: boolean;
+}
+export declare function parseDailyStatsKey(key: string): {
+    version: string;
+    date: string;
+} | null;
+export declare function parseVersionTag(tag: string): number[];
+export declare function compareVersionTags(a: string, b: string): number;
+export declare function isVersionNewerThanV1_5(version: string): boolean;
+/**
+ * Read all `aiCodeTracking.dailyStats%` keys from one `state.vscdb` file.
+ */
+export declare function discoverDailyStatsVersionsInDb(dbPath: string): DailyStatsVersionDiscovery;
+/** Merge discoveries from global + workspace `state.vscdb` files (dedupe sample keys only). */
+export declare function mergeDailyStatsVersionDiscoveries(discoveries: DailyStatsVersionDiscovery[]): DailyStatsVersionDiscovery;

package/dist/daily-stats-versions.js

@@ -0,0 +1,170 @@
+/**
+ * CUR-V11 — discover `aiCodeTracking.dailyStats` version prefixes on disk.
+ * Keys look like: aiCodeTracking.dailyStats.v1.5.2026-05-20
+ */
+import Database from "better-sqlite3";
+const STATE_TABLE = "ItemTable";
+const DAILY_STATS_LIKE = "aiCodeTracking.dailyStats%";
+/** Full key shape for a dated dailyStats row. */
+export const DAILY_STATS_KEY_RE = /^aiCodeTracking\.dailyStats\.(v[\d.]+)\.(\d{4}-\d{2}-\d{2})$/;
+export function parseDailyStatsKey(key) {
+    const m = key.match(DAILY_STATS_KEY_RE);
+    if (!m)
+        return null;
+    return { version: m[1], date: m[2] };
+}
+export function parseVersionTag(tag) {
+    if (!tag.startsWith("v"))
+        return [];
+    return tag
+        .slice(1)
+        .split(".")
+        .map((part) => parseInt(part, 10))
+        .filter((n) => !Number.isNaN(n));
+}
+export function compareVersionTags(a, b) {
+    const pa = parseVersionTag(a);
+    const pb = parseVersionTag(b);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+const V1_5 = "v1.5";
+export function isVersionNewerThanV1_5(version) {
+    return compareVersionTags(version, V1_5) > 0;
+}
+function minDate(a, b) {
+    return a === null || b < a ? b : a;
+}
+function maxDate(a, b) {
+    return a === null || b > a ? b : a;
+}
+function mergeBuckets(target, discovery) {
+    for (const bucket of discovery.buckets) {
+        const existing = target.get(bucket.version);
+        if (!existing) {
+            target.set(bucket.version, { ...bucket, sample_keys: [...bucket.sample_keys] });
+            continue;
+        }
+        existing.key_count += bucket.key_count;
+        existing.date_min =
+            bucket.date_min === null
+                ? existing.date_min
+                : minDate(existing.date_min, bucket.date_min);
+        existing.date_max =
+            bucket.date_max === null
+                ? existing.date_max
+                : maxDate(existing.date_max, bucket.date_max);
+        for (const key of bucket.sample_keys) {
+            if (existing.sample_keys.length >= 3)
+                break;
+            if (!existing.sample_keys.includes(key))
+                existing.sample_keys.push(key);
+        }
+    }
+}
+/**
+ * Read all `aiCodeTracking.dailyStats%` keys from one `state.vscdb` file.
+ */
+export function discoverDailyStatsVersionsInDb(dbPath) {
+    const byVersion = new Map();
+    const unmatched = [];
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        const table = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+            .get(STATE_TABLE);
+        if (!table) {
+            return emptyDiscovery();
+        }
+        const rows = db
+            .prepare(`SELECT key FROM ${STATE_TABLE} WHERE key LIKE ?`)
+            .all(DAILY_STATS_LIKE);
+        for (const { key } of rows) {
+            const parsed = parseDailyStatsKey(key);
+            if (!parsed) {
+                unmatched.push(key);
+                continue;
+            }
+            const bucket = byVersion.get(parsed.version) ?? {
+                count: 0,
+                dateMin: null,
+                dateMax: null,
+                samples: [],
+            };
+            bucket.count += 1;
+            bucket.dateMin = minDate(bucket.dateMin, parsed.date);
+            bucket.dateMax = maxDate(bucket.dateMax, parsed.date);
+            if (bucket.samples.length < 3)
+                bucket.samples.push(key);
+            byVersion.set(parsed.version, bucket);
+        }
+    }
+    catch {
+        return emptyDiscovery();
+    }
+    finally {
+        db?.close();
+    }
+    return buildDiscovery(byVersion, unmatched);
+}
+function emptyDiscovery() {
+    return {
+        buckets: [],
+        unmatched_keys: [],
+        highest_version: null,
+        has_version_newer_than_v1_5: false,
+    };
+}
+function buildDiscovery(byVersion, unmatched) {
+    const buckets = [...byVersion.entries()]
+        .map(([version, b]) => ({
+        version,
+        key_count: b.count,
+        date_min: b.dateMin,
+        date_max: b.dateMax,
+        sample_keys: b.samples,
+    }))
+        .sort((a, b) => compareVersionTags(a.version, b.version));
+    let highest = null;
+    for (const b of buckets) {
+        if (highest === null || compareVersionTags(b.version, highest) > 0) {
+            highest = b.version;
+        }
+    }
+    const hasNewer = buckets.some((b) => isVersionNewerThanV1_5(b.version));
+    return {
+        buckets,
+        unmatched_keys: unmatched.sort(),
+        highest_version: highest,
+        has_version_newer_than_v1_5: hasNewer || unmatched.length > 0,
+    };
+}
+/** Merge discoveries from global + workspace `state.vscdb` files (dedupe sample keys only). */
+export function mergeDailyStatsVersionDiscoveries(discoveries) {
+    const merged = new Map();
+    const unmatched = new Set();
+    for (const d of discoveries) {
+        mergeBuckets(merged, d);
+        for (const key of d.unmatched_keys)
+            unmatched.add(key);
+    }
+    const buckets = [...merged.values()].sort((a, b) => compareVersionTags(a.version, b.version));
+    let highest = null;
+    for (const b of buckets) {
+        if (highest === null || compareVersionTags(b.version, highest) > 0) {
+            highest = b.version;
+        }
+    }
+    return {
+        buckets,
+        unmatched_keys: [...unmatched].sort(),
+        highest_version: highest,
+        has_version_newer_than_v1_5: buckets.some((b) => isVersionNewerThanV1_5(b.version)) || unmatched.size > 0,
+    };
+}

package/dist/health.d.ts

@@ -0,0 +1,31 @@
+import type { TelemetryToolId } from "./auth/credentials.js";
+import { type McpOperatorState } from "./state.js";
+import { type SyncResult } from "./sync.js";
+export interface HealthSnapshot {
+    authenticated: boolean;
+    configured: boolean;
+    host: string | null;
+    ingest_tools: TelemetryToolId[];
+    app_dir: string;
+    log_path: string;
+    state_file_paths: string[];
+    state_tracked_sessions: number;
+    /** Whether the Cursor hooks forwarder is installed in ~/.cursor/hooks.json. */
+    hooks_installed: boolean;
+    /** Number of unprocessed events waiting in the hooks queue file. */
+    hooks_queue_depth: number;
+    /** Best-effort merge of credential-scoped `mcp_operator` (latest `last_sync_at`). */
+    persisted: McpOperatorState | null;
+    /** In-process telemetry (same fields as `getSyncTelemetry`). */
+    process: {
+        last_sync_at: string | null;
+        last_result: SyncResult | null;
+        recent_errors: string[];
+    };
+}
+/** Pick the freshest persisted operator block by `last_sync_at` lexicographic (ISO-safe). */
+export declare function mergePersistedOperators(snapshots: McpOperatorState[]): McpOperatorState | null;
+export declare function buildHealthSnapshot(): Promise<HealthSnapshot>;
+/** MCP `db90_status` JSON — single source shared with CLI health. */
+export declare function healthSnapshotToStatusPayload(snapshot: HealthSnapshot): Record<string, unknown>;
+export declare function formatHealthForCli(snapshot: HealthSnapshot): string;

package/dist/health.js

@@ -0,0 +1,195 @@
+import { loadCredentials, credentialsHaveAnyToken } from "./credentials.js";
+import { readState, getAppDir, credentialStateFilePath, } from "./state.js";
+import { getSyncTelemetry } from "./sync.js";
+import { getMcpLogPath } from "./log.js";
+import { verifyHooksConfig } from "./hooks/hooks-config.js";
+function snapshotToResult(s) {
+    if (!s)
+        return null;
+    return {
+        sent: s.sent,
+        failed: s.failed,
+        skipped: s.skipped,
+        locked: s.locked,
+        errors: s.errors,
+        rateLimitedUntil: s.rate_limited_until ?? undefined,
+    };
+}
+function mergeErrors(a, b) {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...a, ...b]) {
+        if (seen.has(x))
+            continue;
+        seen.add(x);
+        out.push(x);
+        if (out.length >= 20)
+            break;
+    }
+    return out;
+}
+/** Pick the freshest persisted operator block by `last_sync_at` lexicographic (ISO-safe). */
+export function mergePersistedOperators(snapshots) {
+    if (snapshots.length === 0)
+        return null;
+    let best = snapshots[0];
+    for (const s of snapshots.slice(1)) {
+        const a = best.last_sync_at ?? "";
+        const b = s.last_sync_at ?? "";
+        if (b > a)
+            best = s;
+    }
+    return best;
+}
+function collectPersistedAndPaths(appDir, host, creds) {
+    const seenTok = new Set();
+    const blocks = [];
+    const paths = [];
+    let tracked = 0;
+    for (const tok of Object.values(creds.accounts)) {
+        if (typeof tok !== "string" || tok.length === 0 || seenTok.has(tok))
+            continue;
+        seenTok.add(tok);
+        paths.push(credentialStateFilePath(appDir, host, tok));
+        const st = readState(appDir, host, tok);
+        tracked += Object.keys(st.sessions).length;
+        if (st.mcp_operator)
+            blocks.push(st.mcp_operator);
+    }
+    return { paths, merged: mergePersistedOperators(blocks), tracked };
+}
+export async function buildHealthSnapshot() {
+    const appDir = getAppDir();
+    const logPath = getMcpLogPath(appDir);
+    const telemetry = getSyncTelemetry();
+    const hooksReport = verifyHooksConfig(appDir);
+    try {
+        const creds = await loadCredentials();
+        if (!creds || !credentialsHaveAnyToken(creds)) {
+            return {
+                authenticated: false,
+                configured: false,
+                host: null,
+                ingest_tools: [],
+                app_dir: appDir,
+                log_path: logPath,
+                state_file_paths: [],
+                state_tracked_sessions: 0,
+                hooks_installed: hooksReport.hooks_json_installed,
+                hooks_queue_depth: hooksReport.queue_depth,
+                persisted: null,
+                process: {
+                    last_sync_at: telemetry.lastSyncAt,
+                    last_result: telemetry.lastResult,
+                    recent_errors: telemetry.recentErrors,
+                },
+            };
+        }
+        const ingest_tools = Object.entries(creds.accounts)
+            .filter(([, tok]) => typeof tok === "string" && tok.length > 0)
+            .map(([k]) => k)
+            .sort();
+        const { paths, merged, tracked } = collectPersistedAndPaths(appDir, creds.host, creds);
+        return {
+            authenticated: true,
+            configured: true,
+            host: creds.host,
+            ingest_tools,
+            app_dir: appDir,
+            log_path: logPath,
+            state_file_paths: paths.sort(),
+            state_tracked_sessions: tracked,
+            hooks_installed: hooksReport.hooks_json_installed,
+            hooks_queue_depth: hooksReport.queue_depth,
+            persisted: merged,
+            process: {
+                last_sync_at: telemetry.lastSyncAt,
+                last_result: telemetry.lastResult,
+                recent_errors: telemetry.recentErrors,
+            },
+        };
+    }
+    catch (err) {
+        return {
+            authenticated: false,
+            configured: false,
+            host: null,
+            ingest_tools: [],
+            app_dir: appDir,
+            log_path: logPath,
+            state_file_paths: [],
+            state_tracked_sessions: 0,
+            hooks_installed: hooksReport.hooks_json_installed,
+            hooks_queue_depth: hooksReport.queue_depth,
+            persisted: null,
+            process: {
+                last_sync_at: telemetry.lastSyncAt,
+                last_result: telemetry.lastResult,
+                recent_errors: [
+                    ...telemetry.recentErrors,
+                    err instanceof Error ? err.message : String(err),
+                ].slice(-20),
+            },
+        };
+    }
+}
+/** MCP `db90_status` JSON — single source shared with CLI health. */
+export function healthSnapshotToStatusPayload(snapshot) {
+    const proc = snapshot.process;
+    const pers = snapshot.persisted;
+    const lastSyncAt = proc.last_sync_at ?? pers?.last_sync_at ?? null;
+    const lastResult = proc.last_result ?? snapshotToResult(pers?.last_result ?? null);
+    const errors = mergeErrors(proc.recent_errors, pers?.recent_errors ?? []);
+    return {
+        authenticated: snapshot.authenticated,
+        configured: snapshot.configured,
+        host: snapshot.host,
+        ingest_tools: snapshot.ingest_tools,
+        last_sync_at: lastSyncAt,
+        last_result: lastResult,
+        sessions_synced: lastResult?.sent ?? 0,
+        skipped: lastResult?.skipped ?? 0,
+        state_tracked_sessions: snapshot.state_tracked_sessions,
+        errors,
+        app_dir: snapshot.app_dir,
+        log_path: snapshot.log_path,
+        state_file_paths: snapshot.state_file_paths,
+        persisted_operator: pers,
+    };
+}
+export function formatHealthForCli(snapshot) {
+    const lines = ["aixle-insights health diagnostic", ""];
+    lines.push(`app_dir: ${snapshot.app_dir}`);
+    lines.push(`log_path: ${snapshot.log_path}`);
+    lines.push(`authenticated: ${snapshot.authenticated}`);
+    lines.push(`configured: ${snapshot.configured}`);
+    lines.push(`host: ${snapshot.host ?? "(none)"}`);
+    lines.push(`ingest_tools: ${snapshot.ingest_tools.length ? snapshot.ingest_tools.join(", ") : "(none)"}`);
+    lines.push(`state_file_paths:`);
+    if (snapshot.state_file_paths.length === 0) {
+        lines.push("  (none — no credential-scoped state files yet)");
+    }
+    else {
+        for (const p of snapshot.state_file_paths) {
+            lines.push(`  - ${p}`);
+        }
+    }
+    const sta = healthSnapshotToStatusPayload(snapshot);
+    lines.push("");
+    lines.push(`last_sync_at: ${String(sta["last_sync_at"] ?? "null")}`);
+    lines.push(`last_result: ${JSON.stringify(sta["last_result"] ?? null)}`);
+    lines.push(`state_tracked_sessions: ${String(snapshot.state_tracked_sessions)}`);
+    lines.push(`persisted_operator: ${JSON.stringify(snapshot.persisted)}`);
+    const err = sta["errors"];
+    lines.push("");
+    lines.push(`recent_errors (${Array.isArray(err) ? err.length : 0}):`);
+    if (Array.isArray(err) && err.length > 0) {
+        for (const e of err) {
+            lines.push(`  - ${e}`);
+        }
+    }
+    else {
+        lines.push("  (none)");
+    }
+    return lines.join("\n");
+}