@lensmcp/protocol-types 1.25.2 → 1.25.5

package/lib/dashboard.d.ts

@@ -106,7 +106,8 @@ export interface DashService {
         min?: number;
         max?: number;
     };
-    workers: string[];
+    /** Its `serve` workers — each declared one, with what its devserver has said of it. */
+    workers: DashWorker[];
     lastColdStartMs?: number;
     restarts: number;
     buildFailed: boolean;
@@ -141,6 +142,40 @@ export interface DashService {
     /** What its running pods weigh, from their own post-GC reports (`pod-memory` events). Absent until one reports. */
     memory?: DashServiceMemory;
 }
+/**
+ * A service's `serve` worker (issues/closed/foodguard-80): a queue consumer or a background loop its devserver runs
+ * beside the pods, started again when it crashes. One that is not `running` is work nobody is doing.
+ */
+export interface DashWorker {
+    name: string;
+    /**
+     * `running` · `restarting` — it crashed and starts again at `nextAt` · `crash-looping` — it keeps crashing, each wait
+     * longer · `exited` — it ended on its own, or its bundle is missing: not started again until the next build ·
+     * `stopped` — its service stopped · `unknown` — declared, and its devserver has said nothing of it (one from before
+     * 1.25.3 says nothing).
+     */
+    state: 'running' | 'restarting' | 'crash-looping' | 'exited' | 'stopped' | 'unknown';
+    pid?: number;
+    /** When it entered this state. */
+    since?: number;
+    /** Crashes this session. */
+    crashes: number;
+    /** Crashes in a row (restarting / crash-looping). */
+    inARow?: number;
+    /** When it is started again. */
+    nextAt?: number;
+    /** Why it is not running (exited / stopped). */
+    reason?: string;
+    /** The last time it ended unasked: how, and what it printed last. */
+    lastCrash?: {
+        at: number;
+        exitCode: number | null;
+        signal: string | null;
+        reading?: string;
+        external?: boolean;
+        lines: string[];
+    };
+}
 /** A service's pods, summed: what the Cluster tab's memory column shows. Bytes throughout. */
 export interface DashServiceMemory {
     /** Heap after each pod's latest full GC. */
@@ -486,6 +521,17 @@ export interface DashFlowDetail {
     segmentStats?: DashSegmentStats;
     /** Present when the read asked for one segment (`?segment=`): `events` then holds only that segment. */
     focus?: DashFlowSegment;
+    /**
+     * Present when the flow was no longer in the live window and was read back — from the workspace's event history
+     * (30 days) or the bus files. `complete: false`: older events of it may be missing.
+     */
+    recovered?: {
+        from: 'bus' | 'history';
+        events: number;
+        complete: boolean;
+        /** Its list summary (title, route, duration, outcome) — the live flow list does not hold it. */
+        summary?: DashFlowSummary;
+    };
 }
 export interface DashLogLine {
     seq: number;
@@ -1120,6 +1166,35 @@ export interface DashSqlFinding {
     tool: string;
     at: number;
 }
+/**
+ * A place in the services' own code where something ran — what a coding agent opens. From the stack the tap took at
+ * the call: the service's nearest frame, and the callers above it.
+ */
+export interface DashCodeSite {
+    /** `server/apps/engine/src/users/users.service.ts:42 (UsersService.findAll)` — what to open. */
+    at: string;
+    /** Relative to the workspace root when inside it. */
+    file: string;
+    /** The source line: TypeScript's when the lens could map it (`exact`), else the line the stack said. */
+    line: number;
+    column?: number;
+    /** The function the line is in, or — when that one has no name (an arrow) — the nearest named caller. */
+    symbol?: string;
+    /** False: the line is the transpiled module's (close to the source's, not equal) — open `symbol` instead. */
+    exact: boolean;
+    /** The file was edited after this last ran: the line may have moved — find `symbol`. */
+    changed?: boolean;
+    /** The callers above it, nearest first. */
+    via?: Array<{
+        file: string;
+        line: number;
+        symbol?: string;
+    }>;
+    /** Runs that carried this site (the taps sample — a share of all runs), the services, and when it was last seen. */
+    seen: number;
+    services: string[];
+    lastSeenAt: number;
+}
 export interface DashSqlTemplateSummary {
     /** 12 hex characters — the statement's shape (`@lensmcp/core/sql-shape`). */
     id: string;
@@ -1131,6 +1206,10 @@ export interface DashSqlTemplateSummary {
     suggestedName?: string;
     /** Its newest finished SQL review, when it has one. */
     review?: DashReviewMark;
+    /** Where in the services' code it runs — each code path the taps saw, the busiest first (planning/code-locations). */
+    sites?: DashCodeSite[];
+    /** An unnamed statement its named version replaced (edited as it was named): that statement's id — not one to name. */
+    replacedBy?: string;
     /** SELECT · INSERT · UPDATE · DELETE · …; a WITH reads as the statement it leads to. */
     verb: string;
     tables: string[];
@@ -1175,6 +1254,8 @@ export interface DashSqlTemplateDetail extends DashSqlTemplateSummary {
 }
 export interface DashSqlTable {
     name: string;
+    /** The databases the statements that touch it ran on (the pg tap names each); absent from an older tap. */
+    databases?: string[];
     /** Runs of reading statements that touched it, and of writing ones. */
     reads: number;
     writes: number;
@@ -1452,6 +1533,9 @@ export interface DashDbLintIssue {
     fix: string;
     /** For an unnamed statement: a name in the convention, to start from. */
     suggestedName?: string;
+    /** Where in the code it runs — its busiest code path — and the others (planning/code-locations). */
+    where?: string;
+    sites?: DashCodeSite[];
     review?: {
         runId: string;
         at: number;
@@ -1970,8 +2054,8 @@ export interface DashAiRun {
     workspace: string;
     /** `queued`: waiting for a free slot (`queue` says how many are ahead); one job per target, at most N at once. */
     status: 'queued' | 'running' | 'done' | 'failed';
-    /** Started by itself (Settings › Features — a route that changed, a statement once named); absent: someone asked. */
-    trigger?: 'auto';
+    /** Who started it, and so which daily allowance it spends from (`DashAiTrigger`); absent: someone asked, before that was recorded. */
+    trigger?: DashAiTrigger;
     queue?: {
         ahead: number;
         max: number;
@@ -2382,12 +2466,24 @@ export interface DashAiTokens {
     };
     providers: DashAiProviderInfo[];
     tokens: DashAiToken[];
-    /** What this workspace's model calls cost today (UTC, estimated), and its daily cap. */
+    /** What this workspace's model calls cost today (UTC, estimated) — and by who asked, against each one's daily allowance. */
     today: {
         usd: number;
-        capUsd?: number;
+        by?: Record<DashAiTrigger, {
+            usd: number;
+            capUsd?: number;
+        }>;
     };
 }
+/**
+ * Who asked for a model call — each has its own daily allowance (Settings › Features), so reviews that start by
+ * themselves can never use up what a person or an agent asks for:
+ *   auto   started by itself (Settings › Features — a statement once named, a route that changed)
+ *   click  a person in the dashboard (Review with Claude, Ask AI, a key's test)
+ *   agent  a coding agent over MCP (`review.* { run: true }`)
+ */
+export type DashAiTrigger = 'auto' | 'click' | 'agent';
+export declare const DASH_AI_TRIGGERS: readonly DashAiTrigger[];
 /** One path a service read or wrote, by operation — from the fs tap's per-second aggregates. */
 export interface DashFilePath {
     /** `<service> <op> <path>`. */
@@ -2408,6 +2504,45 @@ export interface DashFilePath {
     flowId?: string;
     /** Route catalog ids whose requests touched it, most recent first. */
     routes: string[];
+    /** Its latest uses, newest first (at most 20): when, how often in that second, the bytes, and the flow and request. */
+    uses?: DashFileUse[];
+}
+/** One use of a path: a second of the fs tap's aggregate, for one flow. */
+export interface DashFileUse {
+    at: number;
+    n: number;
+    bytes: number;
+    flowId?: string;
+    requestId?: string;
+}
+/**
+ * `/api/files/read?path=` — a path the services touched, as it is on disk now (read-only). `content=1` adds its first
+ * 64 KB of text, redacted — never a file named like a secret (`.env`, keys, certificates), never a binary, and only on a
+ * loopback-bound dashboard.
+ */
+export interface DashFileRead {
+    path: string;
+    /** Where it was looked for: the workspace root joined with `path`. */
+    resolved: string;
+    exists: boolean;
+    kind?: 'file' | 'directory' | 'other';
+    bytes?: number;
+    modifiedAt?: number;
+    createdAt?: number;
+    /** Why it was not read, when it was not (outside the workspace, a secret's name, binary, not loopback). */
+    refused?: string;
+    /** Present when asked for and readable. */
+    content?: {
+        text: string;
+        truncated: boolean;
+        redacted: boolean;
+        lines: number;
+    };
+    /** A directory's first entries. */
+    entries?: Array<{
+        name: string;
+        kind: 'file' | 'directory' | 'other';
+    }>;
 }
 /** `/api/catalog/files` — every path the services read or wrote, newest first, kept 30 days. */
 export interface DashFiles {
@@ -2722,8 +2857,9 @@ export interface DashDbPrep {
 /** One thing an agent did through the lens: a tool call, a resource read, what it said it is doing. */
 export interface DashAgentEvent {
     at: number;
-    kind: 'tool' | 'read' | 'say';
-    /** The tool or the resource URI; `agent.task` for `say`. */
+    /** `ask`: a prompt the person gave it (the Claude Code plugin's hook) — `result` holds its first line. */
+    kind: 'tool' | 'read' | 'say' | 'ask';
+    /** The tool or the resource URI; `agent.task` for `say`; `prompt` for `ask`. */
     name: string;
     /** Its arguments, redacted, as JSON (at most 2 KB). */
     args?: string;
@@ -2753,6 +2889,12 @@ export interface DashAgentSession {
     task?: string;
     step?: string;
     saidAt?: number;
+    /**
+     * What the person last asked it — the prompt's first line, recorded by the LensMCP Claude Code plugin's
+     * `UserPromptSubmit` hook, so a session shows its task even when the agent never calls `agent.task`.
+     */
+    asked?: string;
+    askedAt?: number;
     conn: {
         transport: string;
         /** The lens server's pid, and the shim's (the `lensmcp mcp` process the client started), when it said. */

package/lib/dashboard.js

@@ -1 +1 @@
-"use strict";export const DASHBOARD_PROTOCOL=1,DASH_PERF_KINDS=["n-plus-one","db-in-loop","render-storm","slow-path","slow-route","slow-query","missing-index","leak","egress-slow","duplicate-requests","perf-rule","db-connection","other"];
+"use strict";export const DASHBOARD_PROTOCOL=1,DASH_PERF_KINDS=["n-plus-one","db-in-loop","render-storm","slow-path","slow-route","slow-query","missing-index","leak","egress-slow","duplicate-requests","perf-rule","db-connection","other"],DASH_AI_TRIGGERS=["auto","click","agent"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/protocol-types",
-  "version": "1.25.2",
+  "version": "1.25.5",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",