labre-mcp 0.1.0

package/dist/lib/component-detection.d.mts

@@ -0,0 +1,161 @@
+/** Detection result types */
+export declare const COMPONENT_TYPE: {
+    SOLUTION: string;
+    CAPABILITY: string;
+};
+/** Confidence threshold: below this, the caller should invoke LLM fallback */
+export declare const CONFIDENCE_THRESHOLD = 0.9;
+/**
+ * Normalize a component name for dictionary lookup.
+ * @param {string} name - Raw component name
+ * @returns {string} Normalized name (lowercase, trimmed, collapsed whitespace)
+ */
+export declare function normalizeName(name: string): string;
+/**
+ * Check if a word is a common English word (not a brand).
+ * @param {string} name - Normalized component name
+ * @returns {boolean}
+ */
+export declare function isCommonWord(name: string): boolean;
+/**
+ * Detect whether a component name is a known solution.
+ *
+ * @param {string} name - Component name
+ * @returns {{ match: boolean, confidence: number, canonical?: string, vendor?: string, category?: string, reason: string }}
+ */
+export declare function matchKnownSolution(name: string): {
+    match: boolean;
+    confidence: number;
+    canonical: string;
+    vendor: string;
+    category: string;
+    reason: string;
+} | {
+    match: boolean;
+    confidence: number;
+    reason: string;
+    canonical?: undefined;
+    vendor?: undefined;
+    category?: undefined;
+};
+/**
+ * Detect whether a component name is a known capability.
+ *
+ * @param {string} name - Component name
+ * @returns {{ match: boolean, confidence: number, canonical?: string, nature?: string, reason: string }}
+ */
+export declare function matchKnownCapability(name: string): {
+    match: boolean;
+    confidence: number;
+    canonical: string;
+    nature: string;
+    reason: string;
+} | {
+    match: boolean;
+    confidence: number;
+    reason: string;
+    canonical?: undefined;
+    nature?: undefined;
+};
+/**
+ * Apply naming convention heuristics to determine component type.
+ * Used when the name doesn't appear in either known dictionary.
+ *
+ * @param {string} name - Component name
+ * @param {string} [description] - Optional description/context
+ * @returns {{ type: string, confidence: number, signals: Array<{ pattern: string, weight: number, reason: string }> }}
+ */
+export declare function applyHeuristics(name: string, description?: string): {
+    type: string;
+    confidence: number;
+    signals: {
+        pattern: string;
+        weight: number;
+        reason: string;
+    }[];
+};
+/**
+ * @typedef {Object} ComponentTypeDetection
+ * @property {string}  type           - 'solution' or 'capability'
+ * @property {number}  confidence     - Confidence score (0–1)
+ * @property {string}  method         - Detection method used: 'known-solution' | 'known-capability' | 'heuristic'
+ * @property {string}  reason         - Human-readable explanation
+ * @property {boolean} needsFallback  - true if confidence < CONFIDENCE_THRESHOLD (caller should use LLM)
+ * @property {string}  [canonical]    - Canonical name (from dictionary, if available)
+ * @property {string}  [vendor]       - Vendor name (solutions only)
+ * @property {string}  [category]     - Category (solutions) or canonical capability name
+ * @property {string}  [nature]       - Capability nature: activity|practice|knowledge|data (capabilities only)
+ * @property {Array}   [signals]      - Heuristic signals (when method='heuristic')
+ */
+/**
+ * Detect whether a component is a solution or a capability.
+ *
+ * Routing rule enforced:
+ *   - NAMED components (products, frameworks, methodologies, standards,
+ *     named practices with a specific identity) -> SOLUTION
+ *   - GENERIC components (abstract activities, practices, data types,
+ *     knowledge areas without a specific identity) -> CAPABILITY
+ *
+ * Detection priority:
+ *   1. Known solutions dictionary (exact match -> 0.98 confidence)
+ *   2. Known capabilities dictionary (exact match -> 0.97 confidence)
+ *   3. Naming convention heuristics (max 0.89 confidence)
+ *
+ * When confidence < CONFIDENCE_THRESHOLD (0.90), the `needsFallback` flag
+ * is set to true, signaling the caller to use LLM + web search verification
+ * via the dual-verification orchestrator.
+ *
+ * @param {string} name - Component name
+ * @param {string} [description] - Optional business/usage context
+ * @returns {ComponentTypeDetection} Detection result with confidence and metadata
+ */
+export declare function detectComponentType(name: string, description?: string): {
+    type: string;
+    confidence: number;
+    method: string;
+    reason: string;
+    needsFallback: boolean;
+    canonical?: undefined;
+    vendor?: undefined;
+    category?: undefined;
+    nature?: undefined;
+    signals?: undefined;
+} | {
+    type: string;
+    confidence: number;
+    method: string;
+    reason: string;
+    needsFallback: boolean;
+    canonical: string | undefined;
+    vendor: string | undefined;
+    category: string | undefined;
+    nature?: undefined;
+    signals?: undefined;
+} | {
+    type: string;
+    confidence: number;
+    method: string;
+    reason: string;
+    needsFallback: boolean;
+    canonical: string | undefined;
+    nature: string | undefined;
+    vendor?: undefined;
+    category?: undefined;
+    signals?: undefined;
+} | {
+    type: string;
+    confidence: number;
+    method: string;
+    reason: string;
+    needsFallback: boolean;
+    signals: {
+        pattern: string;
+        weight: number;
+        reason: string;
+    }[];
+    canonical?: undefined;
+    vendor?: undefined;
+    category?: undefined;
+    nature?: undefined;
+};
+//# sourceMappingURL=component-detection.d.mts.map

package/dist/lib/component-detection.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-detection.d.mts","sourceRoot":"","sources":["../../src/lib/component-detection.mts"],"names":[],"mappings":"AAuBA,6BAA6B;AAC7B,eAAO,MAAM,cAAc;;;CAG1B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,MAAO,CAAC;AAIzC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;EA8B9C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;EA6BhD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,GAAE,MAAW;;;;;;;;EA2ErE;AAID;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,GAAE,MAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDzE"}

package/dist/lib/component-detection.mjs

@@ -0,0 +1,267 @@
+// Component Type Detection
+//
+// Detects whether a Wardley Map component is a SOLUTION (named product,
+// framework, methodology, standard) or a CAPABILITY (abstract activity,
+// practice, data type, knowledge area).
+//
+// Detection priority:
+//   1. Known solutions dictionary (exact match → 0.98 confidence)
+//   2. Known capabilities dictionary (exact match → 0.97 confidence)
+//   3. Naming convention heuristics (max 0.89 confidence)
+//
+// Extracted from solution-capability-router.mjs for single-responsibility.
+import { KNOWN_SOLUTIONS, KNOWN_CAPABILITIES, SOLUTION_PATTERNS, CAPABILITY_PATTERNS, COMMON_ENGLISH_WORDS, } from './known-dictionaries.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+/** Detection result types */
+export const COMPONENT_TYPE = {
+    SOLUTION: 'solution',
+    CAPABILITY: 'capability',
+};
+/** Confidence threshold: below this, the caller should invoke LLM fallback */
+export const CONFIDENCE_THRESHOLD = 0.90;
+// ─── Detection Functions ──────────────────────────────────────────────────────
+/**
+ * Normalize a component name for dictionary lookup.
+ * @param {string} name - Raw component name
+ * @returns {string} Normalized name (lowercase, trimmed, collapsed whitespace)
+ */
+export function normalizeName(name) {
+    return (name || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/**
+ * Check if a word is a common English word (not a brand).
+ * @param {string} name - Normalized component name
+ * @returns {boolean}
+ */
+export function isCommonWord(name) {
+    return COMMON_ENGLISH_WORDS.has(name.toLowerCase());
+}
+/**
+ * Detect whether a component name is a known solution.
+ *
+ * @param {string} name - Component name
+ * @returns {{ match: boolean, confidence: number, canonical?: string, vendor?: string, category?: string, reason: string }}
+ */
+export function matchKnownSolution(name) {
+    const normalized = normalizeName(name);
+    const entry = KNOWN_SOLUTIONS.get(normalized);
+    if (entry) {
+        return {
+            match: true,
+            confidence: 0.98,
+            canonical: entry.canonical,
+            vendor: entry.vendor,
+            category: entry.category,
+            reason: `exact match in known solutions dictionary: "${entry.canonical}"`,
+        };
+    }
+    // Try partial matching: check if the normalized name starts with or contains a known solution
+    for (const [key, entry] of KNOWN_SOLUTIONS) {
+        if (normalized.startsWith(key + ' ') || normalized.endsWith(' ' + key)) {
+            return {
+                match: true,
+                confidence: 0.92,
+                canonical: entry.canonical,
+                vendor: entry.vendor,
+                category: entry.category,
+                reason: `partial match in known solutions dictionary: "${entry.canonical}" within "${name}"`,
+            };
+        }
+    }
+    return { match: false, confidence: 0, reason: 'no match in known solutions dictionary' };
+}
+/**
+ * Detect whether a component name is a known capability.
+ *
+ * @param {string} name - Component name
+ * @returns {{ match: boolean, confidence: number, canonical?: string, nature?: string, reason: string }}
+ */
+export function matchKnownCapability(name) {
+    const normalized = normalizeName(name);
+    const entry = KNOWN_CAPABILITIES.get(normalized);
+    if (entry) {
+        return {
+            match: true,
+            confidence: 0.97,
+            canonical: entry.canonical,
+            nature: entry.nature,
+            reason: `exact match in known capabilities dictionary: "${entry.canonical}"`,
+        };
+    }
+    // Check if the name contains a known capability phrase
+    for (const [key, entry] of KNOWN_CAPABILITIES) {
+        // Only match multi-word keys as substrings (avoid "bi" matching inside "mobile")
+        if (key.length > 3 && normalized.includes(key)) {
+            return {
+                match: true,
+                confidence: 0.88,
+                canonical: entry.canonical,
+                nature: entry.nature,
+                reason: `substring match in known capabilities: "${entry.canonical}" within "${name}"`,
+            };
+        }
+    }
+    return { match: false, confidence: 0, reason: 'no match in known capabilities dictionary' };
+}
+/**
+ * Apply naming convention heuristics to determine component type.
+ * Used when the name doesn't appear in either known dictionary.
+ *
+ * @param {string} name - Component name
+ * @param {string} [description] - Optional description/context
+ * @returns {{ type: string, confidence: number, signals: Array<{ pattern: string, weight: number, reason: string }> }}
+ */
+export function applyHeuristics(name, description = '') {
+    const solutionSignals = [];
+    const capabilitySignals = [];
+    const combined = `${name} ${description}`.trim();
+    // Test solution patterns
+    for (const sp of SOLUTION_PATTERNS) {
+        if (sp.pattern.test(name)) {
+            // Skip "capitalized proper noun" for common English words
+            if (sp.reason === 'capitalized proper noun' && isCommonWord(normalizeName(name))) {
+                continue;
+            }
+            solutionSignals.push({
+                pattern: sp.pattern.toString(),
+                weight: sp.weight,
+                reason: sp.reason,
+            });
+        }
+    }
+    // Test capability patterns
+    for (const cp of CAPABILITY_PATTERNS) {
+        if (cp.pattern.test(name) || cp.pattern.test(combined)) {
+            capabilitySignals.push({
+                pattern: cp.pattern.toString(),
+                weight: cp.weight,
+                reason: cp.reason,
+            });
+        }
+    }
+    // Aggregate weights
+    const solutionScore = solutionSignals.reduce((sum, s) => sum + s.weight, 0);
+    const capabilityScore = capabilitySignals.reduce((sum, s) => sum + s.weight, 0);
+    // Normalize scores to confidence: cap at 0.89 (heuristic-based can't reach dictionary-level confidence)
+    const maxPossibleSolution = SOLUTION_PATTERNS.reduce((s, p) => s + p.weight, 0);
+    const maxPossibleCapability = CAPABILITY_PATTERNS.reduce((s, p) => s + p.weight, 0);
+    if (solutionScore > capabilityScore && solutionScore > 0) {
+        const rawConfidence = Math.min(solutionScore / maxPossibleSolution, 1.0);
+        // Scale to [0.50, 0.89] range — heuristics alone cap at 0.89
+        const confidence = Math.round((0.50 + rawConfidence * 0.39) * 100) / 100;
+        return {
+            type: COMPONENT_TYPE.SOLUTION,
+            confidence,
+            signals: solutionSignals,
+        };
+    }
+    if (capabilityScore > solutionScore && capabilityScore > 0) {
+        const rawConfidence = Math.min(capabilityScore / maxPossibleCapability, 1.0);
+        const confidence = Math.round((0.50 + rawConfidence * 0.39) * 100) / 100;
+        return {
+            type: COMPONENT_TYPE.CAPABILITY,
+            confidence,
+            signals: capabilitySignals,
+        };
+    }
+    // No signals detected — default to capability with low confidence
+    if (solutionScore === 0 && capabilityScore === 0) {
+        return {
+            type: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0.40,
+            signals: [{ pattern: 'default', weight: 0, reason: 'no heuristic signals matched — defaulting to capability' }],
+        };
+    }
+    // Tied — default to capability with low confidence
+    return {
+        type: COMPONENT_TYPE.CAPABILITY,
+        confidence: 0.45,
+        signals: [...capabilitySignals, ...solutionSignals],
+    };
+}
+// ─── Main Detection Function ──────────────────────────────────────────────────
+/**
+ * @typedef {Object} ComponentTypeDetection
+ * @property {string}  type           - 'solution' or 'capability'
+ * @property {number}  confidence     - Confidence score (0–1)
+ * @property {string}  method         - Detection method used: 'known-solution' | 'known-capability' | 'heuristic'
+ * @property {string}  reason         - Human-readable explanation
+ * @property {boolean} needsFallback  - true if confidence < CONFIDENCE_THRESHOLD (caller should use LLM)
+ * @property {string}  [canonical]    - Canonical name (from dictionary, if available)
+ * @property {string}  [vendor]       - Vendor name (solutions only)
+ * @property {string}  [category]     - Category (solutions) or canonical capability name
+ * @property {string}  [nature]       - Capability nature: activity|practice|knowledge|data (capabilities only)
+ * @property {Array}   [signals]      - Heuristic signals (when method='heuristic')
+ */
+/**
+ * Detect whether a component is a solution or a capability.
+ *
+ * Routing rule enforced:
+ *   - NAMED components (products, frameworks, methodologies, standards,
+ *     named practices with a specific identity) -> SOLUTION
+ *   - GENERIC components (abstract activities, practices, data types,
+ *     knowledge areas without a specific identity) -> CAPABILITY
+ *
+ * Detection priority:
+ *   1. Known solutions dictionary (exact match -> 0.98 confidence)
+ *   2. Known capabilities dictionary (exact match -> 0.97 confidence)
+ *   3. Naming convention heuristics (max 0.89 confidence)
+ *
+ * When confidence < CONFIDENCE_THRESHOLD (0.90), the `needsFallback` flag
+ * is set to true, signaling the caller to use LLM + web search verification
+ * via the dual-verification orchestrator.
+ *
+ * @param {string} name - Component name
+ * @param {string} [description] - Optional business/usage context
+ * @returns {ComponentTypeDetection} Detection result with confidence and metadata
+ */
+export function detectComponentType(name, description = '') {
+    if (!name || typeof name !== 'string' || name.trim().length === 0) {
+        return {
+            type: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'error',
+            reason: 'empty or invalid component name',
+            needsFallback: true,
+        };
+    }
+    const trimmedName = name.trim();
+    // Priority 1: Check known solutions dictionary
+    const solutionMatch = matchKnownSolution(trimmedName);
+    if (solutionMatch.match) {
+        return {
+            type: COMPONENT_TYPE.SOLUTION,
+            confidence: solutionMatch.confidence,
+            method: 'known-solution',
+            reason: solutionMatch.reason,
+            needsFallback: solutionMatch.confidence < CONFIDENCE_THRESHOLD,
+            canonical: solutionMatch.canonical,
+            vendor: solutionMatch.vendor,
+            category: solutionMatch.category,
+        };
+    }
+    // Priority 2: Check known capabilities dictionary
+    const capabilityMatch = matchKnownCapability(trimmedName);
+    if (capabilityMatch.match) {
+        return {
+            type: COMPONENT_TYPE.CAPABILITY,
+            confidence: capabilityMatch.confidence,
+            method: 'known-capability',
+            reason: capabilityMatch.reason,
+            needsFallback: capabilityMatch.confidence < CONFIDENCE_THRESHOLD,
+            canonical: capabilityMatch.canonical,
+            nature: capabilityMatch.nature,
+        };
+    }
+    // Priority 3: Apply naming convention heuristics
+    const heuristic = applyHeuristics(trimmedName, description);
+    return {
+        type: heuristic.type,
+        confidence: heuristic.confidence,
+        method: 'heuristic',
+        reason: heuristic.signals.map(s => s.reason).join('; '),
+        needsFallback: heuristic.confidence < CONFIDENCE_THRESHOLD,
+        signals: heuristic.signals,
+    };
+}
+//# sourceMappingURL=component-detection.mjs.map

package/dist/lib/component-detection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-detection.mjs","sourceRoot":"","sources":["../../src/lib/component-detection.mts"],"names":[],"mappings":"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"}

package/dist/lib/degradation/collector.d.mts

@@ -0,0 +1,50 @@
+import type { Degradable, DegradationEvent, DegradationSeverity } from './types.mjs';
+type RecordInput = Omit<DegradationEvent, 'at'> & {
+    at?: string;
+};
+export declare class DegradationCollector {
+    private readonly events;
+    private readonly logger;
+    private degradedFlag;
+    /**
+     * @param logger Logger name passed to mcp-notifications (typically the tool name).
+     */
+    constructor(logger: string);
+    /**
+     * Record a degradation event. Emits an MCP log notification at the
+     * matching severity (info/warning/error). Sets `degraded: true` for any
+     * severity above `info`.
+     */
+    record(event: RecordInput): void;
+    /**
+     * Convenience: record an error caught in a try/catch as a degradation event.
+     *
+     * Defaults to `severity: 'warning'` and `recoverable: true` because the
+     * caller already handled the failure with a fallback. Pass `recoverable:
+     * false` when the dependency is required and the fallback is a stub.
+     */
+    recordError(source: string, err: unknown, opts?: {
+        recoverable?: boolean;
+        severity?: DegradationSeverity;
+    }): void;
+    /**
+     * Merge events from another collector into this one (e.g. a per-component
+     * sub-collector merged into the batch collector for `evaluateMap`).
+     *
+     * Does NOT re-emit log notifications — the source collector already did.
+     */
+    merge(other: DegradationCollector): void;
+    /** Read-only snapshot of recorded events in capture order. */
+    getEvents(): DegradationEvent[];
+    /** True if at least one warning- or error-level event was recorded. */
+    hasDegraded(): boolean;
+    /**
+     * Wrap a tool result in the standard `Degradable<T>` envelope.
+     * Always safe to call even when no events were recorded — yields
+     * `{ result, degraded: false, degradationEvents: [] }`.
+     */
+    wrap<T>(result: T): Degradable<T>;
+    private emitLog;
+}
+export {};
+//# sourceMappingURL=collector.d.mts.map

package/dist/lib/degradation/collector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.d.mts","sourceRoot":"","sources":["../../../src/lib/degradation/collector.mts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAQrB,KAAK,WAAW,GAAG,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,YAAY,CAAS;IAE7B;;OAEG;gBACS,MAAM,EAAE,MAAM;IAI1B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAUhC;;;;;;OAMG;IACH,WAAW,CACT,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;KAAO,GACnE,IAAI;IAWP;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI;IAOxC,8DAA8D;IAC9D,SAAS,IAAI,gBAAgB,EAAE;IAI/B,uEAAuE;IACvE,WAAW,IAAI,OAAO;IAItB;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAQjC,OAAO,CAAC,OAAO;CAKhB"}

package/dist/lib/degradation/collector.mjs

@@ -0,0 +1,93 @@
+// DegradationCollector — captures degradation events for a single
+// MCP tool invocation and emits MCP log notifications as side effects.
+//
+// Tools receive a collector via `withMcpDegradation` (mcp-wrapper.mts)
+// and pass it down through their pipeline so that any external call can
+// record fallback events without throwing.
+import { logInfo, logWarning, logError, } from '../mcp-notifications.mjs';
+import { toErrorMessage } from '../errors.mjs';
+export class DegradationCollector {
+    events = [];
+    logger;
+    degradedFlag = false;
+    /**
+     * @param logger Logger name passed to mcp-notifications (typically the tool name).
+     */
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Record a degradation event. Emits an MCP log notification at the
+     * matching severity (info/warning/error). Sets `degraded: true` for any
+     * severity above `info`.
+     */
+    record(event) {
+        const fullEvent = {
+            ...event,
+            at: event.at ?? new Date().toISOString(),
+        };
+        this.events.push(fullEvent);
+        if (fullEvent.severity !== 'info')
+            this.degradedFlag = true;
+        this.emitLog(fullEvent.severity, `[${fullEvent.source}] ${fullEvent.reason}`);
+    }
+    /**
+     * Convenience: record an error caught in a try/catch as a degradation event.
+     *
+     * Defaults to `severity: 'warning'` and `recoverable: true` because the
+     * caller already handled the failure with a fallback. Pass `recoverable:
+     * false` when the dependency is required and the fallback is a stub.
+     */
+    recordError(source, err, opts = {}) {
+        const message = toErrorMessage(err) || 'unknown error';
+        this.record({
+            source,
+            reason: message,
+            severity: opts.severity ?? 'warning',
+            recoverable: opts.recoverable ?? true,
+            detail: { error: message },
+        });
+    }
+    /**
+     * Merge events from another collector into this one (e.g. a per-component
+     * sub-collector merged into the batch collector for `evaluateMap`).
+     *
+     * Does NOT re-emit log notifications — the source collector already did.
+     */
+    merge(other) {
+        for (const evt of other.events) {
+            this.events.push(evt);
+            if (evt.severity !== 'info')
+                this.degradedFlag = true;
+        }
+    }
+    /** Read-only snapshot of recorded events in capture order. */
+    getEvents() {
+        return [...this.events];
+    }
+    /** True if at least one warning- or error-level event was recorded. */
+    hasDegraded() {
+        return this.degradedFlag;
+    }
+    /**
+     * Wrap a tool result in the standard `Degradable<T>` envelope.
+     * Always safe to call even when no events were recorded — yields
+     * `{ result, degraded: false, degradationEvents: [] }`.
+     */
+    wrap(result) {
+        return {
+            result,
+            degraded: this.degradedFlag,
+            degradationEvents: this.getEvents(),
+        };
+    }
+    emitLog(severity, message) {
+        if (severity === 'error')
+            logError(this.logger, message);
+        else if (severity === 'warning')
+            logWarning(this.logger, message);
+        else
+            logInfo(this.logger, message);
+    }
+}
+//# sourceMappingURL=collector.mjs.map

package/dist/lib/degradation/collector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.mjs","sourceRoot":"","sources":["../../../src/lib/degradation/collector.mts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,uEAAuE;AACvE,EAAE;AACF,uEAAuE;AACvE,wEAAwE;AACxE,2CAA2C;AAO3C,OAAO,EACL,OAAO,EACP,UAAU,EACV,QAAQ,GACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAI/C,MAAM,OAAO,oBAAoB;IACd,MAAM,GAAuB,EAAE,CAAC;IAChC,MAAM,CAAS;IACxB,YAAY,GAAG,KAAK,CAAC;IAE7B;;OAEG;IACH,YAAY,MAAc;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAkB;QACvB,MAAM,SAAS,GAAqB;YAClC,GAAG,KAAK;YACR,EAAE,EAAE,KAAK,CAAC,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACzC,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5B,IAAI,SAAS,CAAC,QAAQ,KAAK,MAAM;YAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CACT,MAAc,EACd,GAAY,EACZ,OAAkE,EAAE;QAEpE,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC;QACvD,IAAI,CAAC,MAAM,CAAC;YACV,MAAM;YACN,MAAM,EAAE,OAAO;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,SAAS;YACpC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,IAAI;YACrC,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE;SAC3B,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAA2B;QAC/B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACtB,IAAI,GAAG,CAAC,QAAQ,KAAK,MAAM;gBAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACxD,CAAC;IACH,CAAC;IAED,8DAA8D;IAC9D,SAAS;QACP,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,uEAAuE;IACvE,WAAW;QACT,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAI,MAAS;QACf,OAAO;YACL,MAAM;YACN,QAAQ,EAAE,IAAI,CAAC,YAAY;YAC3B,iBAAiB,EAAE,IAAI,CAAC,SAAS,EAAE;SACpC,CAAC;IACJ,CAAC;IAEO,OAAO,CAAC,QAA6B,EAAE,OAAe;QAC5D,IAAI,QAAQ,KAAK,OAAO;YAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;aACpD,IAAI,QAAQ,KAAK,SAAS;YAAE,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;YAC7D,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,CAAC;CACF"}

package/dist/lib/degradation/context.d.mts

@@ -0,0 +1,22 @@
+import type { DegradationCollector } from './collector.mjs';
+/**
+ * Run `fn` with `collector` available to every async call below it.
+ * Used internally by `withMcpDegradation`.
+ */
+export declare function runWithCollector<T>(collector: DegradationCollector, fn: () => Promise<T> | T): Promise<T> | T;
+/**
+ * Return the collector for the current async context, or `undefined`
+ * when no MCP invocation is in flight.
+ *
+ * Callers should treat `undefined` as "no degradation tracking active"
+ * — typically that means they were invoked outside the MCP server (e.g.
+ * a unit test or a script) and can skip recording.
+ */
+export declare function getCurrentCollector(): DegradationCollector | undefined;
+/**
+ * Run `fn` with the given collector, returning a `Promise<T>`.
+ * Convenience for async callers that want a Promise back regardless of
+ * whether `fn` is synchronous.
+ */
+export declare function withCollector<T>(collector: DegradationCollector, fn: () => Promise<T> | T): Promise<T>;
+//# sourceMappingURL=context.d.mts.map

package/dist/lib/degradation/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","sourceRoot":"","sources":["../../../src/lib/degradation/context.mts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAI5D;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAE7G;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,oBAAoB,GAAG,SAAS,CAEtE;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,SAAS,EAAE,oBAAoB,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC,CAEZ"}

package/dist/lib/degradation/context.mjs

@@ -0,0 +1,39 @@
+// Per-invocation degradation context using Node's AsyncLocalStorage.
+//
+// The MCP wrapper enters a context for each tool invocation; any code in
+// the resulting async call tree can reach the collector via
+// `getCurrentCollector()` without having to thread it through function
+// signatures.
+//
+// This is intentionally optional — code that runs outside an MCP
+// invocation (unit tests, CLI scripts) sees `undefined` and can fall
+// back to a no-op or a locally created collector.
+import { AsyncLocalStorage } from 'node:async_hooks';
+const storage = new AsyncLocalStorage();
+/**
+ * Run `fn` with `collector` available to every async call below it.
+ * Used internally by `withMcpDegradation`.
+ */
+export function runWithCollector(collector, fn) {
+    return storage.run(collector, fn);
+}
+/**
+ * Return the collector for the current async context, or `undefined`
+ * when no MCP invocation is in flight.
+ *
+ * Callers should treat `undefined` as "no degradation tracking active"
+ * — typically that means they were invoked outside the MCP server (e.g.
+ * a unit test or a script) and can skip recording.
+ */
+export function getCurrentCollector() {
+    return storage.getStore();
+}
+/**
+ * Run `fn` with the given collector, returning a `Promise<T>`.
+ * Convenience for async callers that want a Promise back regardless of
+ * whether `fn` is synchronous.
+ */
+export async function withCollector(collector, fn) {
+    return await Promise.resolve(storage.run(collector, fn));
+}
+//# sourceMappingURL=context.mjs.map

package/dist/lib/degradation/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","sourceRoot":"","sources":["../../../src/lib/degradation/context.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,EAAE;AACF,yEAAyE;AACzE,4DAA4D;AAC5D,uEAAuE;AACvE,cAAc;AACd,EAAE;AACF,iEAAiE;AACjE,qEAAqE;AACrE,kDAAkD;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,MAAM,OAAO,GAAG,IAAI,iBAAiB,EAAwB,CAAC;AAE9D;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAI,SAA+B,EAAE,EAAwB;IAC3F,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,SAA+B,EAC/B,EAAwB;IAExB,OAAO,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;AAC3D,CAAC"}