@rsconcept/rstool 1.3.0 → 1.4.1

package/src/mappers/schema-adapter.ts

@@ -6,33 +6,33 @@ import {
   type AnalysisResult,
   type ConstituentaDraft,
   type ConstituentaState,
-  type DiagnosticRecord,
+  type Diagnostic,
   type SessionState
 } from '../models';
-import { toPublicAnalysis, toPublicError } from './types';
+import { toPublicAnalysis } from './types';
 
 export class SchemaAdapter {
   public analyzeAgainstSession(
     session: SessionState,
     draft: ConstituentaDraft
-  ): { result: AnalysisResult; diagnostics: DiagnosticRecord[] } {
+  ): { result: AnalysisResult; diagnostics: Diagnostic[] } {
     const analyzer = this.buildAnalyzer(session);
     const schema = this.toPseudoRSFormState(session, analyzer);
     const analysis = getAnalysisFor(draft.definitionFormal, draft.cstType, schema as unknown as RSForm, draft.alias);
-    const result = toPublicAnalysis({
-      success: analysis.success,
-      type: analysis.type as Record<string, unknown> | null,
-      valueClass: analysis.valueClass,
-      errors: analysis.errors
-    });
+    const target = { constituentId: draft.id, alias: draft.alias };
+    const result = toPublicAnalysis(
+      {
+        success: analysis.success,
+        type: analysis.type as Record<string, unknown> | null,
+        valueClass: analysis.valueClass,
+        errors: analysis.errors
+      },
+      draft.definitionFormal,
+      target
+    );
     return {
       result,
-      diagnostics: analysis.errors.map(error => ({
-        sessionId: session.sessionId,
-        constituentId: draft.id,
-        expression: draft.definitionFormal,
-        error: toPublicError(error)
-      }))
+      diagnostics: result.diagnostics
     };
   }
 

package/src/mappers/types.ts

@@ -1,8 +1,9 @@
-import { type ValueClass } from '@rsconcept/domain/rslang';
+import { DiagnosticKind, type DiagnosticTarget, expressionDiagnostic } from './diagnostic-assembly';
+import { type RSErrorDescription, type ValueClass } from '@rsconcept/domain/rslang';
 
-import { type AnalysisResult, type RSToolErrorDescription } from '../models';
+import { type AnalysisResult, type Diagnostic } from '../models';
 
-/** Minimal domain error shape before mapping to {@link RSToolErrorDescription}. */
+/** Minimal domain error shape before mapping to {@link Diagnostic}. */
 export interface DomainErrorLike {
   code: number;
   from: number;
@@ -19,21 +20,20 @@ export interface DomainAnalysisLike {
 }
 
 /** Map a domain parser/semantic error to the public diagnostic shape. */
-export function toPublicError(error: DomainErrorLike): RSToolErrorDescription {
-  return {
-    code: error.code,
-    from: error.from,
-    to: error.to,
-    params: error.params
-  };
+export function toDiagnostic(error: DomainErrorLike, expression: string, target?: DiagnosticTarget): Diagnostic {
+  return expressionDiagnostic(error as RSErrorDescription, expression, target);
 }
 
 /** Map a domain analysis result to the public {@link AnalysisResult} shape. */
-export function toPublicAnalysis(analysis: DomainAnalysisLike): AnalysisResult {
+export function toPublicAnalysis(
+  analysis: DomainAnalysisLike,
+  expression: string,
+  target?: DiagnosticTarget
+): AnalysisResult {
   return {
     success: analysis.success,
     type: analysis.type,
     valueClass: analysis.valueClass,
-    diagnostics: analysis.errors.map(toPublicError)
+    diagnostics: analysis.errors.map(error => expressionDiagnostic(error as RSErrorDescription, expression, target))
   };
 }

package/src/models/agent-workflow.ts

@@ -1,6 +1,6 @@
 import { type CstType } from './common';
 import { type ApplyConstituentsMode, type ApplyConstituentsResult, type ConstituentaDraft } from './constituenta';
-import { type DiagnosticRecord } from './diagnostic';
+import { type Diagnostic } from './diagnostic';
 import { type SessionHandle, type SessionRevision, type SessionState } from './session';
 
 /** Level of detail returned by {@link RSToolAgent.getSessionState}. */
@@ -54,7 +54,7 @@ export interface SessionSummary {
   modelItemCount: number;
   diagnosticsCount: number;
   items: SessionSummaryItem[];
-  diagnostics: DiagnosticRecord[];
+  diagnostics: Diagnostic[];
   lastRevision?: SessionRevision;
 }
 

package/src/models/analysis.ts

@@ -1,4 +1,5 @@
-import { type CstType, type RSToolErrorDescription, type ValueClass } from './common';
+import { type Diagnostic } from './diagnostic';
+import { type CstType, type ValueClass } from './common';
 
 /** Input for {@link RSToolAgent.analyzeExpression}. */
 export interface AnalyzeExpressionInput {
@@ -16,5 +17,5 @@ export interface AnalysisResult {
   /** Inferred RS type AST as a plain object, or `null` on failure. */
   type: Record<string, unknown> | null;
   valueClass: ValueClass | null;
-  diagnostics: RSToolErrorDescription[];
+  diagnostics: Diagnostic[];
 }

package/src/models/common.ts

@@ -10,15 +10,3 @@ export type { BasicBinding };
 
 /** Runtime evaluation value: number, nested array (set/tuple), or boolean 0/1. */
 export type RSToolValue = number | RSToolValue[];
-
-/** Language or validation error with source span and optional format parameters. */
-export interface RSToolErrorDescription {
-  /** Numeric error code (see {@link RSErrorCode}). */
-  code: number;
-  /** Start offset in the analyzed expression. */
-  from: number;
-  /** End offset in the analyzed expression. */
-  to: number;
-  /** Interpolation values for localized error messages. */
-  params?: readonly string[];
-}

package/src/models/constituenta.ts

@@ -1,6 +1,6 @@
 import { type AnalysisResult } from './analysis';
 import { type CstType } from './common';
-import { type DiagnosticRecord } from './diagnostic';
+import { type Diagnostic } from './diagnostic';
 
 /** Constituent payload before analysis and merge into session state. */
 export interface ConstituentaDraft {
@@ -33,7 +33,7 @@ export interface AddOrUpdateConstituentaInput {
 
 export interface AddOrUpdateConstituentaResult {
   state: ConstituentaState;
-  diagnostics: DiagnosticRecord[];
+  diagnostics: Diagnostic[];
 }
 
 /** How a multi-draft apply handles partial failures. */
@@ -48,6 +48,6 @@ export interface ApplyConstituentsInput {
 export interface ApplyConstituentsResult {
   success: boolean;
   applied: ConstituentaState[];
-  failed: Array<{ draft: ConstituentaDraft; diagnostics: DiagnosticRecord[] }>;
-  diagnostics: DiagnosticRecord[];
+  failed: Array<{ draft: ConstituentaDraft; diagnostics: Diagnostic[] }>;
+  diagnostics: Diagnostic[];
 }

package/src/models/diagnostic.ts

@@ -1,16 +1,21 @@
-import { type RSToolErrorDescription } from './common';
+import { type CstDiagnostic, DiagnosticKind, RSDiagnosticCode } from '@rsconcept/domain/library';
 
-/** Persisted diagnostic for a failed or warned expression in a session. */
-export interface DiagnosticRecord {
-  sessionId: string;
-  /** Constituent id when the diagnostic is tied to a stored item; omitted for scratch analysis. */
-  constituentId?: number;
-  /** Expression text that was analyzed. */
-  expression: string;
-  error: RSToolErrorDescription;
-}
+export {
+  type Diagnostic,
+  type DiagnosticSeverity,
+  type DiagnosticTarget,
+  expandCstDiagnostic,
+  expressionDiagnostic,
+  getDiagnosticName,
+  getDiagnosticSeverity,
+  modelStatusDiagnostic
+} from '../mappers/diagnostic-assembly';
+
+export { type CstDiagnostic, DiagnosticKind, RSDiagnosticCode };
 
 /** Filters for {@link RSToolAgent.listDiagnostics}. */
 export interface ListDiagnosticsFilters {
   constituentId?: number;
+  kind?: DiagnosticKind;
+  severity?: import('../mappers/diagnostic-assembly').DiagnosticSeverity;
 }

package/src/models/evaluation.ts

@@ -1,10 +1,5 @@
-import {
-  type BasicBinding,
-  type CstType,
-  type EvalStatus,
-  type RSToolErrorDescription,
-  type RSToolValue
-} from './common';
+import { type BasicBinding, type CstType, type EvalStatus, type RSToolValue } from './common';
+import { type Diagnostic } from './diagnostic';
 
 export interface EvaluateExpressionInput {
   expression: string;
@@ -32,5 +27,5 @@ export interface EvaluationResult {
   status: EvalStatus;
   iterations: number;
   cacheHits: number;
-  diagnostics: RSToolErrorDescription[];
+  diagnostics: Diagnostic[];
 }

package/src/models/index.ts

@@ -14,11 +14,17 @@ export {
   RSErrorCode,
   ValueClass,
   type BasicBinding,
-  type RSToolErrorDescription,
   type RSToolValue
 } from './common';
 export { type ApplyConstituentsMode, type ConstituentaDraft, type ConstituentaState } from './constituenta';
-export { type DiagnosticRecord, type ListDiagnosticsFilters } from './diagnostic';
+export {
+  type CstDiagnostic,
+  type Diagnostic,
+  DiagnosticKind,
+  type DiagnosticSeverity,
+  type ListDiagnosticsFilters,
+  RSDiagnosticCode
+} from './diagnostic';
 export { type EvaluateInput, type EvaluationResult } from './evaluation';
 export {
   type ExportFormat,

package/src/models/rstool-agent.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, it } from 'vitest';
 
 import { TUPLE_ID } from '@rsconcept/domain';
 
-import { CstType, EvalStatus, RSErrorCode, RSToolAgent } from './index';
+import { CstType, EvalStatus, RSErrorCode, RSDiagnosticCode, RSToolAgent } from './index';
 
 function buildSampleForm(tool: RSToolAgent, sessionId: string) {
   tool.applySchemaPatch(
@@ -44,6 +44,7 @@ describe('RSToolAgent', () => {
     const analysis = tool.analyzeExpression({ expression: '(', cstType: CstType.TERM }, session.sessionId);
     expect(analysis.success).toBe(false);
     expect(analysis.diagnostics.length).toBeGreaterThan(0);
+    expect(analysis.diagnostics.every(record => record.constituentId === undefined)).toBe(true);
   });
 
   it('rejects formal definition for constants', () => {
@@ -56,7 +57,7 @@ describe('RSToolAgent', () => {
       session.sessionId
     );
     expect(result.success).toBe(false);
-    expect(result.failed[0]?.diagnostics[0]?.error.code).toBe(RSErrorCode.definitionNotAllowed);
+    expect(result.failed[0]?.diagnostics[0]?.code).toBe(RSErrorCode.definitionNotAllowed);
   });
 
   it('rejects formal definition for basic sets', () => {
@@ -69,7 +70,7 @@ describe('RSToolAgent', () => {
       session.sessionId
     );
     expect(result.success).toBe(false);
-    expect(result.failed[0]?.diagnostics[0]?.error.code).toBe(RSErrorCode.definitionNotAllowed);
+    expect(result.failed[0]?.diagnostics[0]?.code).toBe(RSErrorCode.definitionNotAllowed);
   });
 
   it('returns known analysis for empty base definition', () => {
@@ -412,6 +413,27 @@ describe('RSToolAgent modeling and evaluation', () => {
     expect(model.items).toHaveLength(1);
     expect(model.items[0]?.value).toEqual({ 0: 'zero' });
   });
+
+  it('preserves exported diagnostics on session import', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1', term: 'person' },
+          { alias: 'X2', term: 'Person' }
+        ]
+      },
+      session.sessionId
+    );
+    const beforeImport = tool.listDiagnostics(undefined, session.sessionId);
+    expect(beforeImport.some(record => record.code === RSDiagnosticCode.schemaHomonym)).toBe(true);
+
+    const exported = tool.exportSession(session.sessionId);
+    const imported = tool.importData(exported, 'session');
+    const afterImport = tool.listDiagnostics(undefined, imported.sessionId);
+    expect(afterImport).toEqual(beforeImport);
+  });
 });
 
 describe('RSToolAgent agent ergonomics', () => {
@@ -474,10 +496,72 @@ describe('RSToolAgent agent ergonomics', () => {
       { mode: 'best_effort', items: [{ alias: 'X1', cstType: CstType.BASE, definitionFormal: 'Z' }] },
       session.sessionId
     );
-    expect(tool.listDiagnostics(undefined, session.sessionId)).toHaveLength(1);
+    const expressionDiags = tool.listDiagnostics({ kind: 'expression' }, session.sessionId);
+    expect(expressionDiags).toHaveLength(1);
+    expect(expressionDiags[0]?.code).toBe(RSErrorCode.definitionNotAllowed);
 
     tool.applySchemaPatch({ items: [{ alias: 'X1', cstType: CstType.BASE, definitionFormal: '' }] }, session.sessionId);
-    expect(tool.listDiagnostics(undefined, session.sessionId)).toHaveLength(0);
+    expect(tool.listDiagnostics({ kind: 'expression' }, session.sessionId)).toHaveLength(0);
+    expect(tool.listDiagnostics({ kind: 'schema' }, session.sessionId).length).toBeGreaterThan(0);
+    expect(tool.listDiagnostics({ kind: 'model' }, session.sessionId)).toHaveLength(0);
+  });
+
+  it('reports schema homonyms and missing convention', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1', term: 'person', convention: 'people' },
+          { alias: 'X2', term: 'Person', convention: 'other people' }
+        ]
+      },
+      session.sessionId
+    );
+
+    const homonyms = tool.listDiagnostics({ kind: 'schema' }, session.sessionId);
+    expect(homonyms.some(record => record.code === RSDiagnosticCode.schemaHomonym)).toBe(true);
+    expect(homonyms.filter(record => record.code === RSDiagnosticCode.schemaHomonym)).toHaveLength(2);
+  });
+
+  it('reports formal duplicate definitions', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1', convention: 'base' },
+          { alias: 'S1', definitionFormal: 'ℬ(X1×X1)', convention: 'pairs' },
+          { alias: 'D1', definitionFormal: 'Pr1(S1)' },
+          { alias: 'D2', definitionFormal: 'Pr1(S1)' }
+        ]
+      },
+      session.sessionId
+    );
+
+    const duplicates = tool
+      .listDiagnostics({ kind: 'schema' }, session.sessionId)
+      .filter(record => record.code === RSDiagnosticCode.schemaFormalDuplicate);
+    expect(duplicates).toHaveLength(2);
+    expect(duplicates[0]?.params?.[0]).toContain('D2');
+  });
+
+  it('reports model diagnostics for empty basic sets after model refresh', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    tool.applySchemaPatch(
+      {
+        items: [{ alias: 'X1', convention: 'base', term: 'element' }]
+      },
+      session.sessionId
+    );
+
+    expect(tool.listDiagnostics({ kind: 'model' }, session.sessionId)).toHaveLength(0);
+
+    tool.recalculateModel(session.sessionId);
+
+    const modelIssues = tool.listDiagnostics({ kind: 'model' }, session.sessionId);
+    expect(modelIssues.some(record => record.code === RSDiagnosticCode.modelEmpty)).toBe(true);
   });
 
   it('does not record analyzeExpression diagnostics by default', () => {
@@ -919,6 +1003,9 @@ describe('RSToolAgent modeling semantics', () => {
     const a1 = recalculated.items.find(item => item.alias === 'A1');
     expect(a1?.status).toBe(EvalStatus.AXIOM_FALSE);
     expect(a1?.value).toBe(0);
+
+    const modelIssues = tool.listDiagnostics({ kind: 'model' }, session.sessionId);
+    expect(modelIssues.some(record => record.code === RSDiagnosticCode.modelAxiomFalse)).toBe(true);
   });
 
   it('throws when evaluate input is incomplete', () => {

package/src/models/rstool-agent.ts

@@ -4,6 +4,7 @@ import {
   portalSchemaToDrafts,
   portalSchemaToSessionSeed
 } from '../mappers/portal-adapter';
+import { collectModelDiagnostics, collectSchemaDiagnostics } from '../mappers/diagnostics-collector';
 import { ModelAdapter } from '../mappers/model-adapter';
 import { SchemaAdapter } from '../mappers/schema-adapter';
 import { orderDrafts, reorderSessionItemsByDrafts } from '../session/batch-apply';
@@ -26,7 +27,7 @@ import {
   type ConstituentaDraft,
   type ConstituentaState
 } from './constituenta';
-import { type DiagnosticRecord, type ListDiagnosticsFilters } from './diagnostic';
+import { type Diagnostic, type ListDiagnosticsFilters } from './diagnostic';
 import { type EvaluateInput, type EvaluationResult } from './evaluation';
 import { detectImportKind, parseImportPayload } from './import-detect';
 import { type ExportPortalInput, type ExportPortalResult, type ImportDataKind } from './import-export';
@@ -190,14 +191,11 @@ export class RSToolAgent implements RSToolAgentContract {
       cstType: input.cstType,
       definitionFormal: input.expression
     });
+    const sanitizedDiagnostics = diagnostics.map(item => ({ ...item, constituentId: undefined }));
     if (input.recordDiagnostics) {
-      this.sessions.replaceDiagnosticsForConstituent(
-        id,
-        undefined,
-        diagnostics.map(item => ({ ...item, constituentId: undefined }))
-      );
+      this.sessions.setDiagnostics(id, [...collectSchemaDiagnostics(envelope.state), ...sanitizedDiagnostics]);
     }
-    return result;
+    return { ...result, diagnostics: sanitizedDiagnostics };
   }
 
   /** @inheritdoc */
@@ -263,9 +261,11 @@ export class RSToolAgent implements RSToolAgentContract {
         const model = await this.evaluation.setConstituentaValues(state, { items: input.set });
         state = { ...state, model };
         this.sessions.replaceState(id, state);
+        this.refreshModelDiagnostics(id);
         return model;
       }
 
+      this.refreshModelDiagnostics(id);
       return structuredClone(this.sessions.get(id).state.model);
     } catch (error) {
       this.sessions.restore(id, snapshot);
@@ -296,8 +296,11 @@ export class RSToolAgent implements RSToolAgentContract {
 
   /** @inheritdoc */
   public recalculateModel(sessionId?: string): RecalculateModelResult {
-    const envelope = this.sessions.get(this.resolveSessionId(sessionId));
-    return this.evaluation.recalculateModel(envelope.state);
+    const id = this.resolveSessionId(sessionId);
+    const envelope = this.sessions.get(id);
+    const result = this.evaluation.recalculateModel(envelope.state);
+    this.refreshModelDiagnostics(id);
+    return result;
   }
 
   private addOrUpdateConstituenta(
@@ -308,7 +311,6 @@ export class RSToolAgent implements RSToolAgentContract {
     const envelope = this.sessions.get(id);
     const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, input.draft);
     const state = this.adapter.mergeStateWithDraft(envelope.state, input.draft, result);
-    this.sessions.replaceDiagnosticsForConstituent(id, input.draft.id, diagnostics);
     return { state, diagnostics };
   }
 
@@ -342,6 +344,7 @@ export class RSToolAgent implements RSToolAgentContract {
     const envelope = this.sessions.get(id);
     reorderSessionItemsByDrafts(envelope.state.items, input.drafts, preBatchItemIds);
     this.sessions.replaceState(id, envelope.state);
+    this.refreshDiagnostics(id);
 
     return {
       success: failed.length === 0,
@@ -418,11 +421,13 @@ export class RSToolAgent implements RSToolAgentContract {
     }
     const data = parsed as {
       state: SessionState;
-      diagnostics?: DiagnosticRecord[];
+      diagnostics?: Diagnostic[];
     };
     const handle = this.sessions.create(normalizeImportedState(data.state), this.contractVersion);
     if (data.diagnostics?.length) {
       this.sessions.setDiagnostics(handle.sessionId, data.diagnostics);
+    } else {
+      this.refreshDiagnostics(handle.sessionId);
     }
     return this.trackSession(handle);
   }
@@ -509,4 +514,17 @@ export class RSToolAgent implements RSToolAgentContract {
     this.sessions.saveCurrentSessionId(handle.sessionId);
     return handle;
   }
+
+  private refreshDiagnostics(sessionId: string): void {
+    const envelope = this.sessions.get(sessionId);
+    this.sessions.setDiagnostics(sessionId, collectSchemaDiagnostics(envelope.state));
+  }
+
+  private refreshModelDiagnostics(sessionId: string): void {
+    const envelope = this.sessions.get(sessionId);
+    this.sessions.setDiagnostics(sessionId, [
+      ...collectSchemaDiagnostics(envelope.state),
+      ...collectModelDiagnostics(envelope.state)
+    ]);
+  }
 }

package/src/models/tool-contract.ts

@@ -5,14 +5,14 @@ import {
   type SessionStateResult
 } from './agent-workflow';
 import { type AnalysisResult, type AnalyzeExpressionInput } from './analysis';
-import { type DiagnosticRecord, type ListDiagnosticsFilters } from './diagnostic';
+import { type Diagnostic, type ListDiagnosticsFilters } from './diagnostic';
 import { type EvaluateInput, type EvaluationResult } from './evaluation';
 import { type ExportPortalInput, type ExportPortalResult, type ImportDataKind } from './import-export';
 import { type RecalculateModelResult, type SessionModelState, type SetModelValuesInput } from './model-value';
 import { type SessionHandle, type SessionRevision, type SessionState } from './session';
 
 /** Agent-visible contract version; bump on breaking API changes. */
-export const CONTRACT_VERSION = '2.0.0';
+export const CONTRACT_VERSION = '3.0.0';
 
 /** Options for constructing an {@link RSToolAgent}. */
 export interface RSToolAgentOptions {
@@ -48,8 +48,8 @@ export interface RSToolAgentContract {
   /** Return session summary (default) or full cloned state when `detail` is `'full'`. */
   getSessionState(detail?: SessionStateDetail, sessionId?: string): SessionStateResult;
 
-  /** List diagnostics for the session, optionally filtered by constituent. */
-  listDiagnostics(filters?: ListDiagnosticsFilters, sessionId?: string): DiagnosticRecord[];
+  /** List diagnostics for the session, optionally filtered by constituent or kind. */
+  listDiagnostics(filters?: ListDiagnosticsFilters, sessionId?: string): Diagnostic[];
 
   /** Parse and type-check an RSLang expression against the current schema context. */
   analyzeExpression(input: AnalyzeExpressionInput, sessionId?: string): AnalysisResult;

package/src/session/persistence.ts

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { type DiagnosticRecord, type SessionState } from '../models';
+import { type Diagnostic, type SessionState } from '../models';
 
 export interface PersistedSessionEnvelope {
   state: SessionState;
-  diagnostics: DiagnosticRecord[];
+  diagnostics: Diagnostic[];
 }
 
 const CURRENT_SESSION_FILE = '_current.json';

package/src/session/session-store.ts

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 
 import {
   CONTRACT_VERSION,
-  type DiagnosticRecord,
+  type Diagnostic,
   type ListDiagnosticsFilters,
   type SessionHandle,
   type SessionRevision,
@@ -16,7 +16,7 @@ export interface SessionStoreOptions {
 
 interface SessionEnvelope {
   state: SessionState;
-  diagnostics: DiagnosticRecord[];
+  diagnostics: Diagnostic[];
 }
 
 export class SessionStore {
@@ -97,7 +97,7 @@ export class SessionStore {
   public replaceDiagnosticsForConstituent(
     sessionId: string,
     constituentId: number | undefined,
-    records: DiagnosticRecord[]
+    records: Diagnostic[]
   ): void {
     const found = this.get(sessionId);
     found.diagnostics = found.diagnostics.filter(record => record.constituentId !== constituentId);
@@ -106,19 +106,26 @@ export class SessionStore {
     this.persist(sessionId, found);
   }
 
-  public setDiagnostics(sessionId: string, records: DiagnosticRecord[]): void {
+  public setDiagnostics(sessionId: string, records: Diagnostic[]): void {
     const found = this.get(sessionId);
     found.diagnostics = [...records];
     found.state.updatedAt = new Date().toISOString();
     this.persist(sessionId, found);
   }
 
-  public listDiagnostics(sessionId: string, filters?: ListDiagnosticsFilters): DiagnosticRecord[] {
+  public listDiagnostics(sessionId: string, filters?: ListDiagnosticsFilters): Diagnostic[] {
     const found = this.get(sessionId);
+    let records = found.diagnostics;
+    if (filters?.kind !== undefined) {
+      records = records.filter(record => record.kind === filters.kind);
+    }
+    if (filters?.severity !== undefined) {
+      records = records.filter(record => record.severity === filters.severity);
+    }
     if (filters?.constituentId === undefined) {
-      return [...found.diagnostics];
+      return [...records];
     }
-    return found.diagnostics.filter(record => record.constituentId === filters.constituentId);
+    return records.filter(record => record.constituentId === filters.constituentId);
   }
 
   public snapshot(sessionId: string): SessionEnvelope {

package/dist/common-DHJalS-Q.d.ts

@@ -1,22 +0,0 @@
-import { CstType as CstType$1 } from "@rsconcept/domain/library/rsform";
-import { BasicBinding, EvalStatus as EvalStatus$1 } from "@rsconcept/domain/library/rsmodel";
-import { ValueClass as ValueClass$1 } from "@rsconcept/domain/rslang";
-import { RSErrorCode } from "@rsconcept/domain/rslang/error";
-
-//#region src/models/common.d.ts
-/** Runtime evaluation value: number, nested array (set/tuple), or boolean 0/1. */
-type RSToolValue = number | RSToolValue[];
-/** Language or validation error with source span and optional format parameters. */
-interface RSToolErrorDescription {
-  /** Numeric error code (see {@link RSErrorCode}). */
-  code: number;
-  /** Start offset in the analyzed expression. */
-  from: number;
-  /** End offset in the analyzed expression. */
-  to: number;
-  /** Interpolation values for localized error messages. */
-  params?: readonly string[];
-}
-//#endregion
-export { RSToolErrorDescription as a, RSErrorCode as i, CstType$1 as n, RSToolValue as o, EvalStatus$1 as r, ValueClass$1 as s, BasicBinding as t };
-//# sourceMappingURL=common-DHJalS-Q.d.ts.map

package/dist/diagnostic-D9yl_mEL.d.ts

@@ -1,19 +0,0 @@
-import { a as RSToolErrorDescription } from "./common-DHJalS-Q.js";
-
-//#region src/models/diagnostic.d.ts
-/** Persisted diagnostic for a failed or warned expression in a session. */
-interface DiagnosticRecord {
-  sessionId: string;
-  /** Constituent id when the diagnostic is tied to a stored item; omitted for scratch analysis. */
-  constituentId?: number;
-  /** Expression text that was analyzed. */
-  expression: string;
-  error: RSToolErrorDescription;
-}
-/** Filters for {@link RSToolAgent.listDiagnostics}. */
-interface ListDiagnosticsFilters {
-  constituentId?: number;
-}
-//#endregion
-export { ListDiagnosticsFilters as n, DiagnosticRecord as t };
-//# sourceMappingURL=diagnostic-D9yl_mEL.d.ts.map