@aixle/insights 0.2.0 → 0.2.1-staging

package/dist/readers/claude.js

@@ -6,6 +6,83 @@ import { homedir } from "node:os";
 import { glob } from "glob";
 import { calculateCost } from "../pricing.js";
 import { scanText } from "../risk-scanner.js";
+const NAV_TOOLS = new Set(["Read", "Grep", "Glob", "LS"]);
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function bashCommand(block) {
+    const c = block.input?.command;
+    return typeof c === "string" ? c : "";
+}
+export function classifyToolUse(block) {
+    if (NAV_TOOLS.has(block.name))
+        return null;
+    if (EDIT_TOOLS.has(block.name))
+        return "edit";
+    if (block.name === "Bash") {
+        const cmd = bashCommand(block);
+        // Require a space or end-of-string after "commit" so "git commit-tree" is not a commit.
+        if (/\bgit\s+commit(\s|$)/.test(cmd))
+            return "commit";
+        if (/\b(rspec|jest|vitest|pytest|phpunit)\b/i.test(cmd))
+            return "test";
+    }
+    return "tool_use";
+}
+/**
+ * Redacts credential-bearing substrings from a Bash command string before egress.
+ *
+ * Claude events carry `scannable: true`, which causes the server's ClassificationActivity
+ * to take Path 2 (classification_activity.rb:30-44) — trusting the CLI verbatim and
+ * skipping server-side sanitization. This function is the single point of trust for
+ * command strings derived from tool_input.command. Any new pattern that reads from
+ * tool_input.command MUST pass through this function before being emitted. See DATA-CURRENT.md §12.
+ */
+/**
+ * True when an env-var name looks credential-bearing.
+ * Long tokens (SECRET/TOKEN/PASSWORD/…) may appear as substrings; short ones
+ * (KEY/PASS/PWD) must be underscore-delimited segments so "monkey" / "keyboard"
+ * are not redacted.
+ */
+function isSecretEnvName(name) {
+    const n = name.toUpperCase();
+    if (/(?:SECRET|TOKEN|PASSWORD|APIKEY|API_KEY)/.test(n))
+        return true;
+    return /(?:^|_)(?:KEY|PASS|PWD)(?:_|$)/.test(n);
+}
+export function scrubBashCommand(cmd) {
+    return (cmd
+        // Authorization / Bearer / Basic headers (curl -H, fetch headers, etc.)
+        .replace(/\b(Authorization\s*:\s*)(Bearer|Basic|Token)\s+\S+/gi, "$1$2 [REDACTED]")
+        // Inline env-var assignments carrying secrets (AWS_SECRET_ACCESS_KEY=…, db_password=…)
+        .replace(/\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\S+/g, (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
+        // --password=, --token=, --secret=, --api-key= flags
+        .replace(/(--(?:password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key)=)\S+/gi, "$1[REDACTED]")
+        // -p / --password <value> flag-value pairs
+        .replace(/((?:^|\s)-p\s+)\S+/g, "$1[REDACTED]")
+        // AWS CLI --profile (may embed customer identifiers)
+        .replace(/(--profile\s+)\S+/g, "$1[REDACTED]")
+        // Cloud CLI credential flags: --access-key-id, --secret-access-key, --service-account-key
+        .replace(/(--(?:access-key-id|secret-access-key|service-account-key|client-secret)\s+)\S+/gi, "$1[REDACTED]")
+        // curl | sh / curl | bash patterns (remote code execution)
+        .replace(/\|\s*(sh|bash|zsh|dash)\b/g, "| [SHELL REDACTED]"));
+}
+export function summarizeToolUse(block) {
+    const input = block.input ?? {};
+    let raw;
+    if (typeof input.file_path === "string" && input.file_path.trim()) {
+        raw = `${block.name}: ${input.file_path}`;
+    }
+    else if (typeof input.command === "string" && input.command.trim()) {
+        const scrubbed = scrubBashCommand(input.command.trim().replace(/\s+/g, " "));
+        raw = `${block.name}: ${scrubbed}`;
+    }
+    else if (typeof input.pattern === "string") {
+        raw = `${block.name}: ${scrubBashCommand(input.pattern)}`;
+    }
+    else {
+        raw = block.name;
+    }
+    return raw.length <= 256 ? raw : `${raw.slice(0, 253)}...`;
+}
 /** Prompt substrings emitted for local IDE commands — not real user prompts. */
 const LOCAL_COMMAND_NOISE_PROMPT_PATTERNS = [
     /<local-command-caveat\b/i,
@@ -125,6 +202,10 @@ function newTurn(sessionId, turnIndex, filePath, fileSize, occurredAt, promptId)
         riskLevel: "low",
         riskScore: 0,
         riskCategories: [],
+        toolUses: [],
+        navToolCalls: 0,
+        totalToolCalls: 0,
+        messageIds: [],
         persisted: false,
     };
 }
@@ -141,6 +222,41 @@ function enrichTurnRisk(turn) {
     turn.riskScore = result.risk_score;
     turn.riskCategories = result.risk_categories;
 }
+function collectToolUsesFromContent(content, turn) {
+    if (!Array.isArray(content))
+        return;
+    let nav = 0;
+    let total = 0;
+    for (const raw of content) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const block = raw;
+        if (block.type !== "tool_use" || typeof block.name !== "string")
+            continue;
+        total += 1;
+        const toolBlock = {
+            id: typeof block.id === "string" ? block.id : undefined,
+            name: block.name,
+            input: typeof block.input === "object" && block.input !== null
+                ? block.input
+                : undefined,
+        };
+        const eventType = classifyToolUse(toolBlock);
+        if (eventType === null) {
+            nav += 1;
+            continue;
+        }
+        const id = toolBlock.id ?? `idx-${turn.toolUses.length}`;
+        turn.toolUses.push({
+            id,
+            name: toolBlock.name,
+            eventType,
+            summary: summarizeToolUse(toolBlock),
+        });
+    }
+    turn.navToolCalls += nav;
+    turn.totalToolCalls += total;
+}
 /** Streams a JSONL file and splits Claude transcripts into individual turns. */
 export async function parseTranscriptFile(filePath, verbose = false) {
     const turns = [];
@@ -254,9 +370,13 @@ export async function parseTranscriptFile(filePath, verbose = false) {
                 }
                 if (entry.message.model)
                     currentTurn.model = entry.message.model;
+                if (entry.message.id && !currentTurn.messageIds.includes(entry.message.id)) {
+                    currentTurn.messageIds.push(entry.message.id);
+                }
                 currentTurn.occurredAt = timestamp > currentTurn.occurredAt ? timestamp : currentTurn.occurredAt;
                 const text = extractContentText(entry.message.content).join("\n\n").trim();
                 currentTurn.assistantText = appendText(currentTurn.assistantText, text);
+                collectToolUsesFromContent(entry.message.content, currentTurn);
             }
         }
     }
@@ -273,7 +393,7 @@ export async function parseTranscriptFile(filePath, verbose = false) {
     flushCurrentTurn();
     return finalizedTurns.map(({ persisted: _persisted, ...turn }) => turn);
 }
-/** Converts a Claude transcript turn to a db90 ingest payload. */
+/** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
 export function mapTranscriptTurn(turn, options) {
     const { projectId, pricing } = options ?? {};
     const baseInputTokens = Math.max(0, turn.tokensIn - turn.cacheWriteTokens - turn.cacheReadTokens);
@@ -300,6 +420,11 @@ export function mapTranscriptTurn(turn, options) {
             prompt_text: turn.promptText || undefined,
             assistant_text: turn.assistantText || undefined,
             scannable: true,
+            cost_model: "token_count",
+            // Zero is intentional: confirms no tool activity on this turn (not an omission).
+            nav_tool_calls: turn.navToolCalls,
+            total_tool_calls: turn.totalToolCalls,
+            message_ids: turn.messageIds.length > 0 ? turn.messageIds : undefined,
         },
     };
     if (turn.model)
@@ -313,5 +438,32 @@ export function mapTranscriptTurn(turn, options) {
     }
     if (projectId)
         payload.project_id = projectId;
-    return payload;
+    const derivatives = turn.toolUses.map((toolUse) => {
+        const derivative = {
+            tool_name: "claude_code",
+            event_type: toolUse.eventType,
+            cost_usd: 0,
+            occurred_at: turn.occurredAt,
+            metadata: {
+                session_id: `${turn.turnId}:tool:${toolUse.id}`,
+                claude_session_id: turn.sessionId,
+                transcript_source: "claude_jsonl",
+                cost_model: "derivative",
+                parent_session_id: turn.turnId,
+                tool_name_inner: toolUse.name,
+                tool_use_id: toolUse.id,
+                summary: toolUse.summary,
+                scannable: false,
+                risk_level: "none",
+                risk_categories: [],
+                risk_score: 0,
+            },
+        };
+        if (turn.model)
+            derivative.model = turn.model;
+        if (projectId)
+            derivative.project_id = projectId;
+        return derivative;
+    });
+    return [payload, ...derivatives];
 }

package/dist/readers/cursor.d.ts

@@ -46,6 +46,8 @@ interface CursorComposerHeader {
     composerId: string;
     name: string | null;
     workspacePath: string | null;
+    /** Session start (composer.createdAt). Used to spread turns when JSONL lacks per-message times. */
+    createdAt: string | null;
     lastUpdatedAt: string | null;
 }
 export interface CursorTranscriptTurn {
@@ -83,7 +85,7 @@ export interface PricingConfig {
     chat_output_per_mtok: number;
 }
 export declare const DEFAULT_CURSOR_PRICING: PricingConfig;
-export type Db90CursorPayloadMetadata = {
+export type CursorPayloadMetadata = {
     session_id?: string;
     cursor_session_id: string | null;
     workspace: string;
@@ -109,8 +111,9 @@ export type Db90CursorPayloadMetadata = {
     generation_id?: string;
     hook_tool_name?: string;
     duration_ms?: number;
+    model_resolution?: "settings_json" | "state_vscdb" | "unresolved";
 };
-export interface CursorDb90Payload extends IngestPayload {
+export interface CursorPayload extends IngestPayload {
     tool_name: "cursor";
     event_type: "completion" | "chat" | "commit";
     model: string;
@@ -119,16 +122,16 @@ export interface CursorDb90Payload extends IngestPayload {
     cost_usd: number;
     occurred_at: string;
     project_id?: string;
-    metadata: Db90CursorPayloadMetadata;
+    metadata: CursorPayloadMetadata;
 }
 export declare function toEpochMs(timestamp: number | string | null | undefined): number | null;
-export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload[];
+export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload[];
 /**
  * Maps Cursor’s latest-commit snapshot (`aiCodeTracking.recentCommit`) to a single commit-classified event.
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload | null;
-export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorDb90Payload | null;
-export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload;
+export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload | null;
+export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorPayload | null;
+export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload;
 export {};

package/dist/readers/cursor.js

@@ -447,6 +447,62 @@ function toIsoFromMs(value) {
     const date = new Date(value);
     return Number.isNaN(date.getTime()) ? null : date.toISOString();
 }
+/** Coerce epoch ms/seconds, numeric strings, or ISO-8601 into an ISO timestamp. */
+function coerceTranscriptTimestamp(value) {
+    if (value == null)
+        return null;
+    if (typeof value === "number")
+        return toIsoFromMs(value);
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const fromEpoch = toIsoString(trimmed);
+    if (fromEpoch)
+        return fromEpoch;
+    const ms = Date.parse(trimmed);
+    if (Number.isNaN(ms))
+        return null;
+    return new Date(ms).toISOString();
+}
+/** Prefer explicit per-line / per-message times when Cursor includes them. */
+function extractLineOccurredAt(entry) {
+    const candidates = [
+        entry.timestamp,
+        entry.createdAt,
+        entry.unixMs,
+        entry.message?.timestamp,
+        entry.message?.createdAt,
+    ];
+    for (const candidate of candidates) {
+        const iso = coerceTranscriptTimestamp(candidate);
+        if (iso)
+            return iso;
+    }
+    return null;
+}
+/**
+ * Spread turns across [start, end] when the JSONL has no per-message times.
+ * Prevents first-sync backfill from collapsing every turn onto lastUpdatedAt/mtime
+ * (DB90DV-605 weekly chart spike).
+ */
+function interpolateTurnOccurredAt(startIso, endIso, index, total, fallbackIso) {
+    if (total <= 0)
+        return fallbackIso;
+    // Single turn: prefer session end (lastUpdatedAt) — matches prior composer-header behavior.
+    if (total === 1)
+        return endIso ?? startIso ?? fallbackIso;
+    const startMs = startIso ? Date.parse(startIso) : NaN;
+    const endMs = endIso ? Date.parse(endIso) : NaN;
+    if (Number.isNaN(startMs) || Number.isNaN(endMs)) {
+        return startIso ?? endIso ?? fallbackIso;
+    }
+    if (endMs <= startMs)
+        return startIso ?? fallbackIso;
+    const ms = startMs + ((endMs - startMs) * index) / (total - 1);
+    return new Date(ms).toISOString();
+}
 function readComposerHeaders(baseDir) {
     const userDir = baseDir ?? cursorUserDir();
     const dbPath = join(userDir, "globalStorage", "state.vscdb");
@@ -491,6 +547,7 @@ function readComposerHeaders(baseDir) {
                 composerId,
                 name: typeof composer.name === "string" ? composer.name : null,
                 workspacePath: typeof uri?.fsPath === "string" ? uri.fsPath : null,
+                createdAt: toIsoFromMs(composer.createdAt),
                 lastUpdatedAt: toIsoFromMs(composer.lastUpdatedAt),
             });
         }
@@ -563,11 +620,15 @@ function workspaceFromTranscriptFile(filePath) {
 const MAX_TRANSCRIPT_BYTES = 50 * 1024 * 1024; // 50 MB
 export async function parseCursorTranscriptFile(filePath, composerHeaders, verbose = false) {
     let fileSize = 0;
-    let occurredAt = new Date().toISOString();
+    let fileMtimeIso = new Date().toISOString();
+    let fileBirthIso = null;
     try {
         const stat = statSync(filePath);
         fileSize = stat.size;
-        occurredAt = stat.mtime.toISOString();
+        fileMtimeIso = stat.mtime.toISOString();
+        if (stat.birthtime && !Number.isNaN(stat.birthtime.getTime()) && stat.birthtime.getTime() > 0) {
+            fileBirthIso = stat.birthtime.toISOString();
+        }
     }
     catch {
         return [];
@@ -580,15 +641,25 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
     }
     const sessionId = basename(filePath, ".jsonl");
     const header = composerHeaders.get(sessionId);
-    if (header?.lastUpdatedAt)
-        occurredAt = header.lastUpdatedAt;
-    const turns = [];
+    const sessionFallback = header?.lastUpdatedAt ?? fileMtimeIso;
+    const sessionStart = header?.createdAt ?? fileBirthIso ?? sessionFallback;
+    const sessionEnd = header?.lastUpdatedAt ?? fileMtimeIso;
+    const drafts = [];
     let currentPromptParts = [];
     let currentAssistantParts = [];
+    let currentTurnOccurredAt = null;
     let turnIndex = 0;
     const hasher = createHash("sha256");
     const stream = createReadStream(filePath, { encoding: "utf-8" });
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    const noteLineTime = (entry) => {
+        const lineAt = extractLineOccurredAt(entry);
+        if (!lineAt)
+            return;
+        // Prefer the first timestamp in the turn (usually the user message).
+        if (!currentTurnOccurredAt)
+            currentTurnOccurredAt = lineAt;
+    };
     const finalizeTurn = () => {
         const promptText = currentPromptParts.join("\n\n").trim();
         const assistantText = currentAssistantParts.join("\n\n").trim();
@@ -596,14 +667,14 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             return;
         const risk = scanText(promptText);
         turnIndex += 1;
-        turns.push({
+        drafts.push({
             turnId: `${sessionId}:${turnIndex}`,
             sessionId,
             filePath,
             fileSize,
             workspacePath: header?.workspacePath ?? workspaceFromTranscriptFile(filePath),
             composerName: header?.name ?? null,
-            occurredAt,
+            turnOccurredAt: currentTurnOccurredAt,
             promptText,
             assistantText,
             tokensIn: estimateTokens(promptText),
@@ -612,6 +683,7 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             riskScore: risk.risk_score,
             riskCategories: risk.risk_categories,
         });
+        currentTurnOccurredAt = null;
     };
     let lineNumber = 0;
     try {
@@ -640,9 +712,11 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
                     currentPromptParts = [];
                     currentAssistantParts = [];
                 }
+                noteLineTime(entry);
                 currentPromptParts.push(...texts.map(stripUserQueryWrapper).filter((text) => text.length > 0));
             }
             else if (entry.role === "assistant") {
+                noteLineTime(entry);
                 currentAssistantParts.push(...texts.map((text) => text.trim()).filter((text) => text.length > 0));
             }
         }
@@ -659,9 +733,16 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
     }
     finalizeTurn();
     const contentHash = hasher.digest("hex").slice(0, 32);
-    for (const t of turns)
-        t.contentHash = contentHash;
-    return turns;
+    const total = drafts.length;
+    return drafts.map((draft, index) => {
+        const { turnOccurredAt, ...rest } = draft;
+        return {
+            ...rest,
+            contentHash,
+            occurredAt: turnOccurredAt ??
+                interpolateTurnOccurredAt(sessionStart, sessionEnd, index, total, sessionFallback),
+        };
+    });
 }
 export async function readCursorTranscriptSessions(cursorUserBaseDir, transcriptProjectDirs, verbose = false) {
     const composerHeaders = readComposerHeaders(cursorUserBaseDir);
@@ -730,7 +811,7 @@ function dailyStatsSessionId(date, eventType, modelKey) {
     return `cursor:daily_stats:${date}:${suffix}`;
 }
 function buildPayload(opts) {
-    const { eventType, tokensIn, tokensOut, costUsd, occurredAt, dbPath, date, model = "unknown", modelKey, projectId, costModel = LINE_COST_MODEL, } = opts;
+    const { eventType, tokensIn, tokensOut, costUsd, occurredAt, dbPath, date, model = "unknown", modelResolution, modelKey, projectId, costModel = LINE_COST_MODEL, } = opts;
     const payload = {
         tool_name: "cursor",
         event_type: eventType,
@@ -746,13 +827,14 @@ function buildPayload(opts) {
             cost_model: costModel,
             scannable: false,
             risk_level: "none",
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)
         payload.project_id = projectId;
     return payload;
 }
-export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const { date, value, dbPath } = entry;
     const occurredAt = `${date}T00:00:00.000Z`;
     const results = [];
@@ -773,6 +855,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
             dbPath,
             date,
             model,
+            modelResolution,
             projectId,
         }));
     }
@@ -781,11 +864,12 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
             eventType: "chat",
             tokensIn: composerSuggested,
             tokensOut: composerAccepted,
-            costUsd: computeLineCost("chat", composerAccepted, pricing),
+            costUsd: computeLineCost("chat", composerSuggested, pricing),
             occurredAt,
             dbPath,
             date,
             model,
+            modelResolution,
             projectId,
         }));
     }
@@ -820,7 +904,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const { value: obj, dbPath } = entry;
     const occurredAt = toIsoString(obj.timestamp);
     if (!occurredAt)
@@ -866,6 +950,7 @@ export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICI
                     : undefined,
             scannable: false,
             risk_level: "none",
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)
@@ -902,7 +987,7 @@ export function mapEvent(row, workspacePath, projectId, pricing = DEFAULT_CURSOR
         payload.project_id = projectId;
     return payload;
 }
-export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const payload = {
         tool_name: "cursor",
         event_type: "chat",
@@ -924,6 +1009,7 @@ export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRIC
             composer_name: turn.composerName ?? undefined,
             prompt_text: turn.promptText || undefined,
             assistant_text: turn.assistantText || undefined,
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)

package/dist/server.d.ts

@@ -7,8 +7,25 @@ export declare const SYNC_NOW_INPUT_SCHEMA: z.ZodObject<{
         cursor: "cursor";
     }>>>;
 }, z.core.$strict>;
-/** Structured status for `db90_status` — tolerates missing/malformed credentials and state. */
-export declare function buildDb90StatusPayload(): Promise<Record<string, unknown>>;
+/**
+ * Whether a `credential_validation_failed` warning should mirror to stderr.
+ * Mirrors for one-shot/startup sources so an installed-but-uninitialized MCP is
+ * visible, but NOT for the recurring background `"interval"` tick — that fires
+ * every SYNC_INTERVAL_MS for the whole process lifetime and would spam the logs.
+ * The event is always written to mcp.log regardless of this return value.
+ */
+export declare function shouldMirrorMissingCredentials(source: string): boolean;
+/** Structured status for `aixle_insights_status` — tolerates missing/malformed credentials and state. */
+export declare function buildAixleInsightsStatusPayload(): Promise<Record<string, unknown>>;
 /** In-process MCP server instance (stdio not attached). */
-export declare function createDb90McpServer(): McpServer;
+export declare function createAixleInsightsMcpServer(): McpServer;
+/**
+ * Subscribes `shutdown` to the given stream's "end" and "close" events.
+ * Closing stdin is how the OS signals a stdio-transport MCP server that its
+ * parent process is gone — this fires even when the parent can't deliver a
+ * signal (e.g. it was itself SIGKILL'd, or the OS reparented this process
+ * without ever sending one). Exported standalone so it's testable with a
+ * plain EventEmitter instead of the real process.stdin.
+ */
+export declare function wireParentExitShutdown(stdin: Pick<NodeJS.ReadStream, "on">, shutdown: () => void): void;
 export declare function startServer(): Promise<void>;