@lensmcp/protocol-types 1.17.0 → 1.17.2

package/index.d.ts

@@ -5,6 +5,7 @@ export * from './lib/event.js';
 export * from './lib/node.js';
 export * from './lib/edge.js';
 export * from './lib/attributes.js';
+export * from './lib/producer-health.js';
 export * from './lib/resources.js';
 export * from './lib/tokens.js';
 export * from './lib/capture-demand.js';

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}

package/index.js

@@ -5,6 +5,7 @@ export * from './lib/event.js';
 export * from './lib/node.js';
 export * from './lib/edge.js';
 export * from './lib/attributes.js';
+export * from './lib/producer-health.js';
 export * from './lib/resources.js';
 export * from './lib/tokens.js';
 export * from './lib/capture-demand.js';

package/lib/producer-health.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+/**
+ * Producer health — the "is anybody actually watching?" half of every check
+ * resource (`typecheck://current`, `lint://current`, `build://current`).
+ *
+ * WHY this exists, concretely: `typecheck://current` shipped as
+ * `{"status":"unknown","errorCount":0,"revision":0}` and `lint://current` as
+ * `{"status":"unknown","errorCount":0,"warningCount":0,"revision":0}` — and an
+ * agent reading either one cannot tell those apart from a healthy, silent,
+ * genuinely-clean system. They were not clean. `startTscCollector` and
+ * `runEslintOnce` existed, were exported from `@lensmcp/session`, and were
+ * called by NOTHING; the dev cluster's real type checking (the tsgo plugin)
+ * printed diagnostics to the console and to no bus at all. So those resources
+ * had never received a single event in their lives, and said so in a way that
+ * read exactly like "all good".
+ *
+ * `revision: 0` was the only tell, and it is far too subtle to be a contract:
+ * one empty read teaches a reader to stop asking, which is precisely what
+ * happened. So every check resource now states, in the body, whether a
+ * producer has EVER reported (`producer`), which producers are live
+ * (`producers`), how old the newest report is (`ageMs`/`stale`), and a
+ * sentence a human or an agent can act on (`detail`).
+ *
+ * `status` keeps its original value set (`unknown | clean | …`) so existing
+ * readers — the MCP resource wrappers and the human dashboard — are unaffected;
+ * everything here is additive.
+ */
+/**
+ * Has any producer ever reported into this resource?
+ *
+ * - `none`      — no producer has ever reported. `status` is NOT evidence of
+ *                 health; nothing is watching. This is the state the three
+ *                 check resources were silently stuck in.
+ * - `connected` — at least one producer has reported at least once, so
+ *                 `status` reflects a real run.
+ *
+ * Deliberately NOT a third `stale` member: staleness is orthogonal (a
+ * connected producer that has not re-run recently is still connected), and
+ * folding it in here would force readers to re-derive "did anyone ever
+ * report?" from a union. Read `stale`/`ageMs` for freshness.
+ */
+export declare const ProducerStateSchema: z.ZodEnum<{
+    none: "none";
+    connected: "connected";
+}>;
+export type ProducerState = z.infer<typeof ProducerStateSchema>;
+/** Outcome of a producer's most recent run. */
+export declare const ProducerRunStatusSchema: z.ZodEnum<{
+    error: "error";
+    running: "running";
+    clean: "clean";
+    failing: "failing";
+}>;
+export type ProducerRunStatus = z.infer<typeof ProducerRunStatusSchema>;
+/**
+ * One reporting producer. Keyed by `id` so a multi-service cluster (13 pods,
+ * each running its own tsgo check against its own tsconfig, all appending to
+ * ONE `.lensmcp/events.jsonl`) shows up as 13 rows rather than a single
+ * last-writer-wins verdict.
+ */
+export declare const ProducerReportSchema: z.ZodObject<{
+    id: z.ZodString;
+    tool: z.ZodString;
+    project: z.ZodOptional<z.ZodString>;
+    firstReportedAt: z.ZodNumber;
+    lastReportedAt: z.ZodNumber;
+    lastRunStatus: z.ZodEnum<{
+        error: "error";
+        running: "running";
+        clean: "clean";
+        failing: "failing";
+    }>;
+    lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProducerReport = z.infer<typeof ProducerReportSchema>;
+/**
+ * The additive block every check resource carries. Mixed into
+ * `typecheck://current`, `lint://current` and `build://current`.
+ */
+export declare const ProducerHealthSchema: z.ZodObject<{
+    producer: z.ZodEnum<{
+        none: "none";
+        connected: "connected";
+    }>;
+    producers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        firstReportedAt: z.ZodNumber;
+        lastReportedAt: z.ZodNumber;
+        lastRunStatus: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            clean: "clean";
+            failing: "failing";
+        }>;
+        lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastReportedAt: z.ZodOptional<z.ZodNumber>;
+    ageMs: z.ZodOptional<z.ZodNumber>;
+    stale: z.ZodBoolean;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export type ProducerHealth = z.infer<typeof ProducerHealthSchema>;
+/**
+ * A connected producer whose newest report is older than this is reported
+ * `stale`. Generous on purpose: these producers are edge-triggered (they run
+ * on rebuild / on demand), so silence is normal and is NOT evidence of a
+ * problem — it only means the verdict may predate the current source.
+ */
+export declare const PRODUCER_STALE_AFTER_MS: number;
+/**
+ * Fold a producer registry into the {@link ProducerHealth} block.
+ *
+ * Lives here rather than in each reducer so `typecheck`, `lint` and `build`
+ * cannot drift into three different definitions of "nobody is watching" — the
+ * exact class of divergence that let the original bug hide in two of the three.
+ *
+ * `now` is injected so the value is testable and so callers can pin one clock
+ * across a single resource render.
+ */
+export declare function summariseProducers(args: {
+    producers: readonly ProducerReport[];
+    /** Domain label used in `detail`, e.g. `typecheck`. */
+    domain: string;
+    /** Appended to `detail` when there is no producer — how to get one. */
+    noProducerHint: string;
+    now?: number;
+}): ProducerHealth;
+//# sourceMappingURL=producer-health.d.ts.map

package/lib/producer-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"producer-health.d.ts","sourceRoot":"","sources":["../../src/lib/producer-health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;EAAgC,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,+CAA+C;AAC/C,eAAO,MAAM,uBAAuB;;;;;EASlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;iBAe/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAAc,CAAC;AAEnD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IACrC,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,cAAc,CAuCjB"}

package/lib/producer-health.js

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+/**
+ * Producer health — the "is anybody actually watching?" half of every check
+ * resource (`typecheck://current`, `lint://current`, `build://current`).
+ *
+ * WHY this exists, concretely: `typecheck://current` shipped as
+ * `{"status":"unknown","errorCount":0,"revision":0}` and `lint://current` as
+ * `{"status":"unknown","errorCount":0,"warningCount":0,"revision":0}` — and an
+ * agent reading either one cannot tell those apart from a healthy, silent,
+ * genuinely-clean system. They were not clean. `startTscCollector` and
+ * `runEslintOnce` existed, were exported from `@lensmcp/session`, and were
+ * called by NOTHING; the dev cluster's real type checking (the tsgo plugin)
+ * printed diagnostics to the console and to no bus at all. So those resources
+ * had never received a single event in their lives, and said so in a way that
+ * read exactly like "all good".
+ *
+ * `revision: 0` was the only tell, and it is far too subtle to be a contract:
+ * one empty read teaches a reader to stop asking, which is precisely what
+ * happened. So every check resource now states, in the body, whether a
+ * producer has EVER reported (`producer`), which producers are live
+ * (`producers`), how old the newest report is (`ageMs`/`stale`), and a
+ * sentence a human or an agent can act on (`detail`).
+ *
+ * `status` keeps its original value set (`unknown | clean | …`) so existing
+ * readers — the MCP resource wrappers and the human dashboard — are unaffected;
+ * everything here is additive.
+ */
+/**
+ * Has any producer ever reported into this resource?
+ *
+ * - `none`      — no producer has ever reported. `status` is NOT evidence of
+ *                 health; nothing is watching. This is the state the three
+ *                 check resources were silently stuck in.
+ * - `connected` — at least one producer has reported at least once, so
+ *                 `status` reflects a real run.
+ *
+ * Deliberately NOT a third `stale` member: staleness is orthogonal (a
+ * connected producer that has not re-run recently is still connected), and
+ * folding it in here would force readers to re-derive "did anyone ever
+ * report?" from a union. Read `stale`/`ageMs` for freshness.
+ */
+export const ProducerStateSchema = z.enum(['none', 'connected']);
+/** Outcome of a producer's most recent run. */
+export const ProducerRunStatusSchema = z.enum([
+    /** A run is in flight; its diagnostics have not landed yet. */
+    'running',
+    /** The run completed with zero errors. */
+    'clean',
+    /** The run completed and reported at least one error. */
+    'failing',
+    /** The tool itself failed to run (crash / bad config) — the run produced NO verdict. */
+    'error',
+]);
+/**
+ * One reporting producer. Keyed by `id` so a multi-service cluster (13 pods,
+ * each running its own tsgo check against its own tsconfig, all appending to
+ * ONE `.lensmcp/events.jsonl`) shows up as 13 rows rather than a single
+ * last-writer-wins verdict.
+ */
+export const ProducerReportSchema = z.object({
+    /** Stable identity: `<tool>:<project ?? '*'>`. */
+    id: z.string(),
+    /** The tool behind it — `tsgo`, `tsc`, `eslint`, `vite`, … */
+    tool: z.string(),
+    /** Nx project the run covered; absent for a workspace-wide producer. */
+    project: z.string().optional(),
+    firstReportedAt: z.number().int().nonnegative(),
+    lastReportedAt: z.number().int().nonnegative(),
+    lastRunStatus: ProducerRunStatusSchema,
+    lastRunDurationMs: z.number().int().nonnegative().optional(),
+    errorCount: z.number().int().nonnegative(),
+    warningCount: z.number().int().nonnegative().optional(),
+    /** Set when `lastRunStatus === 'error'` — why the tool could not produce a verdict. */
+    error: z.string().optional(),
+});
+/**
+ * The additive block every check resource carries. Mixed into
+ * `typecheck://current`, `lint://current` and `build://current`.
+ */
+export const ProducerHealthSchema = z.object({
+    producer: ProducerStateSchema,
+    producers: z.array(ProducerReportSchema),
+    /** Epoch ms of the newest report across all producers. Absent iff `producer === 'none'`. */
+    lastReportedAt: z.number().int().nonnegative().optional(),
+    /** Age of `lastReportedAt` at read time. Absent iff `producer === 'none'`. */
+    ageMs: z.number().int().nonnegative().optional(),
+    /**
+     * `true` when connected but the newest report is older than
+     * {@link PRODUCER_STALE_AFTER_MS}. A stale CLEAN result means "clean as of
+     * `ageMs` ago, and nothing has re-checked since" — not "clean now".
+     * Always `false` when `producer === 'none'` (nothing to be stale).
+     */
+    stale: z.boolean(),
+    /** One sentence a reader can act on. Never empty. */
+    detail: z.string(),
+});
+/**
+ * A connected producer whose newest report is older than this is reported
+ * `stale`. Generous on purpose: these producers are edge-triggered (they run
+ * on rebuild / on demand), so silence is normal and is NOT evidence of a
+ * problem — it only means the verdict may predate the current source.
+ */
+export const PRODUCER_STALE_AFTER_MS = 10 * 60_000;
+/**
+ * Fold a producer registry into the {@link ProducerHealth} block.
+ *
+ * Lives here rather than in each reducer so `typecheck`, `lint` and `build`
+ * cannot drift into three different definitions of "nobody is watching" — the
+ * exact class of divergence that let the original bug hide in two of the three.
+ *
+ * `now` is injected so the value is testable and so callers can pin one clock
+ * across a single resource render.
+ */
+export function summariseProducers(args) {
+    const now = args.now ?? Date.now();
+    const producers = [...args.producers].sort((a, b) => b.lastReportedAt - a.lastReportedAt);
+    if (producers.length === 0) {
+        return {
+            producer: 'none',
+            producers: [],
+            stale: false,
+            detail: `No ${args.domain} producer has ever reported into this session — ` +
+                `this is NOT a clean result, nothing is watching. ${args.noProducerHint}`,
+        };
+    }
+    const lastReportedAt = producers[0].lastReportedAt;
+    const ageMs = Math.max(0, now - lastReportedAt);
+    const stale = ageMs > PRODUCER_STALE_AFTER_MS;
+    const failing = producers.filter((p) => p.lastRunStatus === 'failing');
+    const errored = producers.filter((p) => p.lastRunStatus === 'error');
+    const parts = [
+        `${producers.length} ${args.domain} producer${producers.length === 1 ? '' : 's'} reporting ` +
+            `(${producers.map((p) => p.id).join(', ')}); newest report ${describeAge(ageMs)}.`,
+    ];
+    if (errored.length > 0) {
+        parts.push(`${errored.length} produced NO verdict (the tool itself failed): ` +
+            `${errored.map((p) => `${p.id} — ${p.error ?? 'unknown error'}`).join('; ')}.`);
+    }
+    if (failing.length > 0)
+        parts.push(`${failing.length} reporting errors.`);
+    if (stale) {
+        parts.push(`Older than ${Math.round(PRODUCER_STALE_AFTER_MS / 60_000)}m — the verdict may predate the current source.`);
+    }
+    return { producer: 'connected', producers, lastReportedAt, ageMs, stale, detail: parts.join(' ') };
+}
+function describeAge(ageMs) {
+    if (ageMs < 1_000)
+        return 'just now';
+    if (ageMs < 60_000)
+        return `${Math.round(ageMs / 1_000)}s ago`;
+    if (ageMs < 3_600_000)
+        return `${Math.round(ageMs / 60_000)}m ago`;
+    return `${Math.round(ageMs / 3_600_000)}h ago`;
+}

package/lib/resources.d.ts

@@ -13,19 +13,19 @@ export declare const ResourceEnvelopeSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ResourceEnvelope = z.infer<typeof ResourceEnvelopeSchema>;
 export declare const AgentStatusKindSchema: z.ZodEnum<{
-    starting: "starting";
-    clean: "clean";
     warning: "warning";
+    clean: "clean";
     failing: "failing";
+    starting: "starting";
 }>;
 export type AgentStatusKind = z.infer<typeof AgentStatusKindSchema>;
 export declare const AgentBlockingItemSchema: z.ZodObject<{
     source: z.ZodString;
     severity: z.ZodEnum<{
         error: "error";
-        warning: "warning";
         debug: "debug";
         info: "info";
+        warning: "warning";
         fatal: "fatal";
     }>;
     title: z.ZodString;
@@ -45,37 +45,37 @@ export declare const AgentBlockingItemSchema: z.ZodObject<{
 export type AgentBlockingItem = z.infer<typeof AgentBlockingItemSchema>;
 export declare const AgentChecksSchema: z.ZodObject<{
     typecheck: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
     lint: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
     build: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
     visual: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
     memory: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
+        unknown: "unknown";
         passed: "passed";
         failed: "failed";
-        unknown: "unknown";
     }>>;
 }, z.core.$strip>;
 export declare const AgentCurrentStatusSchema: z.ZodObject<{
@@ -85,10 +85,10 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     updatedAt: z.ZodOptional<z.ZodString>;
     sessionId: z.ZodString;
     status: z.ZodEnum<{
-        starting: "starting";
-        clean: "clean";
         warning: "warning";
+        clean: "clean";
         failing: "failing";
+        starting: "starting";
     }>;
     activeTab: z.ZodOptional<z.ZodString>;
     tabsWithIssues: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -96,9 +96,9 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
             error: "error";
-            warning: "warning";
             debug: "debug";
             info: "info";
+            warning: "warning";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -119,9 +119,9 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
             error: "error";
-            warning: "warning";
             debug: "debug";
             info: "info";
+            warning: "warning";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -141,37 +141,37 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     suggestedReads: z.ZodArray<z.ZodString>;
     checks: z.ZodOptional<z.ZodObject<{
         typecheck: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
         lint: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
         build: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
         runtime: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
         visual: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
         memory: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
+            unknown: "unknown";
             passed: "passed";
             failed: "failed";
-            unknown: "unknown";
         }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -248,4 +248,205 @@ export declare const AgentSessionSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AgentSession = z.infer<typeof AgentSessionSchema>;
+/**
+ * The three "is my code OK?" resources: an envelope + a status + counts + the
+ * {@link ProducerHealthSchema} block.
+ *
+ * The producer block is what makes `status` legible. Without it,
+ * `{"status":"unknown","errorCount":0,"revision":0}` is ambiguous between
+ * "checked, nothing wrong" and "nothing has ever checked" — and for
+ * `typecheck://` and `lint://` it was always the second, because neither had a
+ * producer wired at all. Read `producer` BEFORE trusting `status`.
+ */
+declare const CheckEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    message: z.ZodString;
+    fingerprint: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    rule: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warning: "warning";
+        fatal: "fatal";
+    }>>;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CheckEntry = z.infer<typeof CheckEntrySchema>;
+export declare const TypecheckCurrentSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    producer: z.ZodEnum<{
+        none: "none";
+        connected: "connected";
+    }>;
+    producers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        firstReportedAt: z.ZodNumber;
+        lastReportedAt: z.ZodNumber;
+        lastRunStatus: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            clean: "clean";
+            failing: "failing";
+        }>;
+        lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastReportedAt: z.ZodOptional<z.ZodNumber>;
+    ageMs: z.ZodOptional<z.ZodNumber>;
+    stale: z.ZodBoolean;
+    detail: z.ZodString;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        clean: "clean";
+        failing: "failing";
+    }>;
+    errorCount: z.ZodNumber;
+    lastRunAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TypecheckCurrent = z.infer<typeof TypecheckCurrentSchema>;
+export declare const TypecheckErrorsSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    producer: z.ZodEnum<{
+        none: "none";
+        connected: "connected";
+    }>;
+    producers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        firstReportedAt: z.ZodNumber;
+        lastReportedAt: z.ZodNumber;
+        lastRunStatus: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            clean: "clean";
+            failing: "failing";
+        }>;
+        lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastReportedAt: z.ZodOptional<z.ZodNumber>;
+    ageMs: z.ZodOptional<z.ZodNumber>;
+    stale: z.ZodBoolean;
+    detail: z.ZodString;
+    errors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        message: z.ZodString;
+        fingerprint: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warning: "warning";
+            fatal: "fatal";
+        }>>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        project: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TypecheckErrors = z.infer<typeof TypecheckErrorsSchema>;
+export declare const LintCurrentSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    producer: z.ZodEnum<{
+        none: "none";
+        connected: "connected";
+    }>;
+    producers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        firstReportedAt: z.ZodNumber;
+        lastReportedAt: z.ZodNumber;
+        lastRunStatus: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            clean: "clean";
+            failing: "failing";
+        }>;
+        lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastReportedAt: z.ZodOptional<z.ZodNumber>;
+    ageMs: z.ZodOptional<z.ZodNumber>;
+    stale: z.ZodBoolean;
+    detail: z.ZodString;
+    status: z.ZodEnum<{
+        warning: "warning";
+        unknown: "unknown";
+        clean: "clean";
+        failing: "failing";
+    }>;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    lastRunAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LintCurrent = z.infer<typeof LintCurrentSchema>;
+export declare const BuildCurrentSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    producer: z.ZodEnum<{
+        none: "none";
+        connected: "connected";
+    }>;
+    producers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        firstReportedAt: z.ZodNumber;
+        lastReportedAt: z.ZodNumber;
+        lastRunStatus: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            clean: "clean";
+            failing: "failing";
+        }>;
+        lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastReportedAt: z.ZodOptional<z.ZodNumber>;
+    ageMs: z.ZodOptional<z.ZodNumber>;
+    stale: z.ZodBoolean;
+    detail: z.ZodString;
+    status: z.ZodEnum<{
+        warning: "warning";
+        unknown: "unknown";
+        clean: "clean";
+        failing: "failing";
+    }>;
+    hmrUpdates: z.ZodNumber;
+}, z.core.$strip>;
+export type BuildCurrent = z.infer<typeof BuildCurrentSchema>;
+export {};
 //# sourceMappingURL=resources.d.ts.map

package/lib/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/lib/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;GAGG;AACH,eAAO,MAAM,WAAW,+OAyBd,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAIrD,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAmBlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/lib/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;GAGG;AACH,eAAO,MAAM,WAAW,+OAyBd,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAIrD,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAmBlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D;;;;;;;;;GASG;AACH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;iBAYpB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/lib/resources.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { SCHEMA_VERSION } from './schema-version.js';
 import { SourceLocationSchema } from './source-location.js';
 import { SeveritySchema } from './event.js';
+import { ProducerHealthSchema } from './producer-health.js';
 /**
  * Well-known URI schemes used by LensMCP. See `planning/03-mcp-surface.md`.
  * Each scheme maps 1:1 to a FrontMCP @App package.
@@ -108,6 +109,7 @@ export const AgentStorageStatsSchema = z.object({
     /** The per-event `raw` limit in force. */
     rawByteLimit: z.number().int().nonnegative().optional(),
 });
+// -------- agent://session --------
 export const AgentSessionSchema = ResourceEnvelopeSchema.extend({
     sessionId: z.string(),
     supportedResources: z.array(z.string()),
@@ -127,3 +129,45 @@ export const AgentSessionSchema = ResourceEnvelopeSchema.extend({
     /** Optional — absent when the backend reports no stats. */
     storage: AgentStorageStatsSchema.optional(),
 });
+// -------- the check resources: typecheck:// · lint:// · build:// --------
+/**
+ * The three "is my code OK?" resources: an envelope + a status + counts + the
+ * {@link ProducerHealthSchema} block.
+ *
+ * The producer block is what makes `status` legible. Without it,
+ * `{"status":"unknown","errorCount":0,"revision":0}` is ambiguous between
+ * "checked, nothing wrong" and "nothing has ever checked" — and for
+ * `typecheck://` and `lint://` it was always the second, because neither had a
+ * producer wired at all. Read `producer` BEFORE trusting `status`.
+ */
+const CheckEntrySchema = z.object({
+    id: z.string(),
+    timestamp: z.number().int().nonnegative(),
+    message: z.string(),
+    fingerprint: z.string(),
+    code: z.string().optional(),
+    rule: z.string().optional(),
+    severity: SeveritySchema.optional(),
+    file: z.string().optional(),
+    line: z.number().int().nonnegative().optional(),
+    column: z.number().int().nonnegative().optional(),
+    project: z.string().optional(),
+});
+export const TypecheckCurrentSchema = ResourceEnvelopeSchema.merge(ProducerHealthSchema).extend({
+    status: z.enum(['unknown', 'clean', 'failing']),
+    errorCount: z.number().int().nonnegative(),
+    lastRunAt: z.number().int().nonnegative().optional(),
+});
+export const TypecheckErrorsSchema = ResourceEnvelopeSchema.merge(ProducerHealthSchema).extend({
+    errors: z.array(CheckEntrySchema),
+});
+export const LintCurrentSchema = ResourceEnvelopeSchema.merge(ProducerHealthSchema).extend({
+    status: z.enum(['unknown', 'clean', 'warning', 'failing']),
+    errorCount: z.number().int().nonnegative(),
+    warningCount: z.number().int().nonnegative(),
+    lastRunAt: z.number().int().nonnegative().optional(),
+});
+export const BuildCurrentSchema = ResourceEnvelopeSchema.merge(ProducerHealthSchema).extend({
+    status: z.enum(['unknown', 'clean', 'warning', 'failing']),
+    hmrUpdates: z.number().int().nonnegative(),
+});

package/package.json

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