@lssm/lib.observability 0.0.0-canary-20251120192244 → 0.0.0-canary-20251206160926

package/CHANGELOG.md

@@ -1,6 +1,81 @@
 # @lssm/lib.observability
 
-## 0.0.0-canary-20251120192244
+## 0.0.0-canary-20251206160926
+
+### Patch Changes
+
+- Updated dependencies [3086383]
+  - @lssm/lib.lifecycle@0.0.0-canary-20251206160926
+
+## 0.5.0
+
+### Minor Changes
+
+- Refactor to be compatible with ai-sdk v6
+
+### Patch Changes
+
+- Updated dependencies
+  - @lssm/lib.lifecycle@0.4.0
+
+## 0.4.1
+
+### Patch Changes
+
+- Fix dependencies
+- Updated dependencies
+  - @lssm/lib.lifecycle@0.3.1
+
+## 0.4.0
+
+### Minor Changes
+
+- b7621d3: Fix version
+
+### Patch Changes
+
+- Updated dependencies [b7621d3]
+  - @lssm/lib.lifecycle@0.3.0
+
+## 0.3.0
+
+### Minor Changes
+
+- fix
+
+### Patch Changes
+
+- Updated dependencies
+  - @lssm/lib.lifecycle@0.2.0
+
+## 0.2.2
+
+### Patch Changes
+
+- fix dependencies
+- Updated dependencies
+  - @lssm/lib.lifecycle@0.1.2
+
+## 0.2.1
+
+### Patch Changes
+
+- fix
+- Updated dependencies
+  - @lssm/lib.lifecycle@0.1.1
+
+## 0.2.0
+
+### Minor Changes
+
+- b1d0876: Managed platform
+
+### Patch Changes
+
+- Updated dependencies [b1d0876]
+  - @lssm/lib.lifecycle@0.1.0
+
+## 0.1.0
 
 ### Minor Changes
 

package/README.md

@@ -48,3 +48,24 @@ app.use(createTracingMiddleware());
 
 Full docs: https://contractspec.chaman.ventures/docs/libraries/observability
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/anomaly/alert-manager.d.mts

@@ -0,0 +1,20 @@
+import { AnomalySignal } from "./anomaly-detector.mjs";
+import { RootCauseAnalysis } from "./root-cause-analyzer.mjs";
+
+//#region src/anomaly/alert-manager.d.ts
+interface AlertManagerOptions {
+  cooldownMs?: number;
+  transport: (payload: {
+    signal: AnomalySignal;
+    analysis: RootCauseAnalysis;
+  }) => Promise<void> | void;
+}
+declare class AlertManager {
+  private readonly options;
+  private readonly cooldownMs;
+  private readonly lastAlert;
+  constructor(options: AlertManagerOptions);
+  notify(signal: AnomalySignal, analysis: RootCauseAnalysis): Promise<void>;
+}
+//#endregion
+export { AlertManager, AlertManagerOptions };

package/dist/anomaly/alert-manager.mjs

@@ -0,0 +1 @@
+var e=class{cooldownMs;lastAlert=new Map;constructor(e){this.options=e,this.cooldownMs=e.cooldownMs??6e4}async notify(e,t){let n=`${e.type}:${t.culprit?.id??`none`}`,r=Date.now();r-(this.lastAlert.get(n)??0)<this.cooldownMs||(await this.options.transport({signal:e,analysis:t}),this.lastAlert.set(n,r))}};export{e as AlertManager};

package/dist/anomaly/anomaly-detector.d.mts

@@ -0,0 +1,25 @@
+import { BaselineCalculator, MetricPoint } from "./baseline-calculator.mjs";
+
+//#region src/anomaly/anomaly-detector.d.ts
+interface AnomalyThresholds {
+  errorRateDelta?: number;
+  latencyDelta?: number;
+  throughputDrop?: number;
+  minSamples?: number;
+}
+interface AnomalySignal {
+  type: 'error_rate_spike' | 'latency_regression' | 'throughput_drop';
+  delta: number;
+  point: MetricPoint;
+  baseline: ReturnType<BaselineCalculator['getSnapshot']>;
+}
+declare class AnomalyDetector {
+  private readonly baseline;
+  private readonly thresholds;
+  constructor(options?: AnomalyThresholds);
+  evaluate(point: MetricPoint): AnomalySignal[];
+  private relativeDelta;
+  private relativeDrop;
+}
+//#endregion
+export { AnomalyDetector, AnomalySignal, AnomalyThresholds };

package/dist/anomaly/anomaly-detector.mjs

@@ -0,0 +1 @@
+import{BaselineCalculator as e}from"./baseline-calculator.mjs";var t=class{baseline;thresholds={errorRateDelta:.5,latencyDelta:.35,throughputDrop:.4,minSamples:10};constructor(t={}){this.baseline=new e,this.thresholds={...this.thresholds,...t}}evaluate(e){let t=this.baseline.update(e);if(t.sampleCount<this.thresholds.minSamples)return[];let n=[],r=this.relativeDelta(e.errorRate,t.errorRate);r>this.thresholds.errorRateDelta&&n.push({type:`error_rate_spike`,delta:r,point:e,baseline:t});let i=this.relativeDelta(e.latencyP99,t.latencyP99);i>this.thresholds.latencyDelta&&n.push({type:`latency_regression`,delta:i,point:e,baseline:t});let a=this.relativeDrop(e.throughput,t.throughput);return a>this.thresholds.throughputDrop&&n.push({type:`throughput_drop`,delta:a,point:e,baseline:t}),n}relativeDelta(e,t){return t===0?0:(e-t)/t}relativeDrop(e,t){return t===0?0:(t-e)/t}};export{t as AnomalyDetector};

package/dist/anomaly/baseline-calculator.d.mts

@@ -0,0 +1,25 @@
+//#region src/anomaly/baseline-calculator.d.ts
+interface MetricPoint {
+  latencyP99: number;
+  latencyP95: number;
+  errorRate: number;
+  throughput: number;
+  timestamp: Date;
+}
+interface BaselineSnapshot {
+  latencyP99: number;
+  latencyP95: number;
+  errorRate: number;
+  throughput: number;
+  sampleCount: number;
+}
+declare class BaselineCalculator {
+  private readonly alpha;
+  private snapshot;
+  constructor(alpha?: number);
+  update(point: MetricPoint): BaselineSnapshot;
+  getSnapshot(): BaselineSnapshot;
+  private mix;
+}
+//#endregion
+export { BaselineCalculator, BaselineSnapshot, MetricPoint };

package/dist/anomaly/baseline-calculator.mjs

@@ -0,0 +1 @@
+var e=class{snapshot={latencyP99:0,latencyP95:0,errorRate:0,throughput:0,sampleCount:0};constructor(e=.2){this.alpha=e}update(e){let{sampleCount:t}=this.snapshot,n=t+1,r=t===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,e.latencyP99,r),latencyP95:this.mix(this.snapshot.latencyP95,e.latencyP95,r),errorRate:this.mix(this.snapshot.errorRate,e.errorRate,r),throughput:this.mix(this.snapshot.throughput,e.throughput,r),sampleCount:n},this.snapshot}getSnapshot(){return this.snapshot}mix(e,t,n){return this.snapshot.sampleCount===0?t:e*(1-n)+t*n}};export{e as BaselineCalculator};

package/dist/anomaly/root-cause-analyzer.d.mts

@@ -0,0 +1,22 @@
+import { AnomalySignal } from "./anomaly-detector.mjs";
+
+//#region src/anomaly/root-cause-analyzer.d.ts
+interface DeploymentEvent {
+  id: string;
+  operation: string;
+  deployedAt: Date;
+  stage?: string;
+  status: 'in_progress' | 'completed' | 'rolled_back';
+}
+interface RootCauseAnalysis {
+  signal: AnomalySignal;
+  culprit?: DeploymentEvent;
+  notes: string[];
+}
+declare class RootCauseAnalyzer {
+  private readonly lookbackMs;
+  constructor(lookbackMs?: number);
+  analyze(signal: AnomalySignal, deployments: DeploymentEvent[]): RootCauseAnalysis;
+}
+//#endregion
+export { DeploymentEvent, RootCauseAnalysis, RootCauseAnalyzer };

package/dist/anomaly/root-cause-analyzer.mjs

@@ -0,0 +1 @@
+var e=class{constructor(e=900*1e3){this.lookbackMs=e}analyze(e,t){let n=new Date(e.point.timestamp.getTime()-this.lookbackMs),r=t.filter(e=>e.deployedAt>=n).sort((e,t)=>t.deployedAt.getTime()-e.deployedAt.getTime()),i=[],a;return r.length>0?(a=r[0],i.push(`Closest deployment ${a.id} (${a.operation}) at ${a.deployedAt.toISOString()}`)):i.push(`No deployments found within lookback window.`),e.type===`latency_regression`&&i.push(`Verify recent schema changes and external dependency latency.`),e.type===`error_rate_spike`&&i.push(`Check SLO monitor for correlated incidents.`),{signal:e,culprit:a,notes:i}}};export{e as RootCauseAnalyzer};

package/dist/index.d.mts

@@ -1,5 +1,13 @@
+import { BaselineCalculator } from "./anomaly/baseline-calculator.mjs";
+import { AnomalyDetector, AnomalySignal, AnomalyThresholds } from "./anomaly/anomaly-detector.mjs";
+import { RootCauseAnalysis, RootCauseAnalyzer } from "./anomaly/root-cause-analyzer.mjs";
+import { AlertManager } from "./anomaly/alert-manager.mjs";
 import { getTracer, traceAsync, traceSync } from "./tracing/index.mjs";
 import { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics } from "./metrics/index.mjs";
 import { LogEntry, LogLevel, Logger, logger } from "./logging/index.mjs";
-import { createTracingMiddleware } from "./tracing/middleware.mjs";
-export { type LogEntry, type LogLevel, Logger, createCounter, createHistogram, createTracingMiddleware, createUpDownCounter, getMeter, getTracer, logger, standardMetrics, traceAsync, traceSync };
+import { IntentAggregator, IntentAggregatorSnapshot, TelemetrySample } from "./intent/aggregator.mjs";
+import { TracingMiddlewareOptions, createTracingMiddleware } from "./tracing/middleware.mjs";
+import { IntentDetector, IntentSignal, IntentSignalType } from "./intent/detector.mjs";
+import { EvolutionPipeline, EvolutionPipelineEvent, EvolutionPipelineOptions } from "./pipeline/evolution-pipeline.mjs";
+import { LifecycleKpiPipeline, LifecycleKpiPipelineOptions, LifecyclePipelineEvent } from "./pipeline/lifecycle-pipeline.mjs";
+export { AlertManager, AnomalyDetector, type AnomalySignal, type AnomalyThresholds, BaselineCalculator, EvolutionPipeline, type EvolutionPipelineEvent, type EvolutionPipelineOptions, IntentAggregator, type IntentAggregatorSnapshot, IntentDetector, type IntentSignal, type IntentSignalType, LifecycleKpiPipeline, type LifecycleKpiPipelineOptions, type LifecyclePipelineEvent, type LogEntry, type LogLevel, Logger, type RootCauseAnalysis, RootCauseAnalyzer, type TelemetrySample, type TracingMiddlewareOptions, createCounter, createHistogram, createTracingMiddleware, createUpDownCounter, getMeter, getTracer, logger, standardMetrics, traceAsync, traceSync };

package/dist/index.mjs

@@ -1 +1 @@
-import{getTracer as e,traceAsync as t,traceSync as n}from"./tracing/index.mjs";import{createCounter as r,createHistogram as i,createUpDownCounter as a,getMeter as o,standardMetrics as s}from"./metrics/index.mjs";import{Logger as c,logger as l}from"./logging/index.mjs";import{createTracingMiddleware as u}from"./tracing/middleware.mjs";export{c as Logger,r as createCounter,i as createHistogram,u as createTracingMiddleware,a as createUpDownCounter,o as getMeter,e as getTracer,l as logger,s as standardMetrics,t as traceAsync,n as traceSync};
+import{getTracer as e,traceAsync as t,traceSync as n}from"./tracing/index.mjs";import{createCounter as r,createHistogram as i,createUpDownCounter as a,getMeter as o,standardMetrics as s}from"./metrics/index.mjs";import{Logger as c,logger as l}from"./logging/index.mjs";import{createTracingMiddleware as u}from"./tracing/middleware.mjs";import{IntentAggregator as d}from"./intent/aggregator.mjs";import{IntentDetector as f}from"./intent/detector.mjs";import{EvolutionPipeline as p}from"./pipeline/evolution-pipeline.mjs";import{LifecycleKpiPipeline as m}from"./pipeline/lifecycle-pipeline.mjs";import{BaselineCalculator as h}from"./anomaly/baseline-calculator.mjs";import{AnomalyDetector as g}from"./anomaly/anomaly-detector.mjs";import{RootCauseAnalyzer as _}from"./anomaly/root-cause-analyzer.mjs";import{AlertManager as v}from"./anomaly/alert-manager.mjs";export{v as AlertManager,g as AnomalyDetector,h as BaselineCalculator,p as EvolutionPipeline,d as IntentAggregator,f as IntentDetector,m as LifecycleKpiPipeline,c as Logger,_ as RootCauseAnalyzer,r as createCounter,i as createHistogram,u as createTracingMiddleware,a as createUpDownCounter,o as getMeter,e as getTracer,l as logger,s as standardMetrics,t as traceAsync,n as traceSync};

package/dist/intent/aggregator.d.mts

@@ -0,0 +1,59 @@
+//#region src/intent/aggregator.d.ts
+interface TelemetrySample {
+  operation: {
+    name: string;
+    version: number;
+  };
+  durationMs: number;
+  success: boolean;
+  timestamp: Date;
+  errorCode?: string;
+  tenantId?: string;
+  traceId?: string;
+  actorId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface AggregatedOperationMetrics {
+  operation: {
+    name: string;
+    version: number;
+  };
+  totalCalls: number;
+  successRate: number;
+  errorRate: number;
+  averageLatencyMs: number;
+  p95LatencyMs: number;
+  p99LatencyMs: number;
+  maxLatencyMs: number;
+  windowStart: Date;
+  windowEnd: Date;
+  topErrors: Record<string, number>;
+}
+interface OperationSequence {
+  steps: string[];
+  tenantId?: string;
+  count: number;
+}
+interface IntentAggregatorSnapshot {
+  metrics: AggregatedOperationMetrics[];
+  sequences: OperationSequence[];
+  sampleCount: number;
+  windowStart?: Date;
+  windowEnd?: Date;
+}
+interface IntentAggregatorOptions {
+  windowMs?: number;
+  sequenceSampleSize?: number;
+}
+declare class IntentAggregator {
+  private readonly windowMs;
+  private readonly sequenceSampleSize;
+  private readonly samples;
+  constructor(options?: IntentAggregatorOptions);
+  add(sample: TelemetrySample): void;
+  flush(now?: Date): IntentAggregatorSnapshot;
+  private aggregateMetrics;
+  private buildSequences;
+}
+//#endregion
+export { AggregatedOperationMetrics, IntentAggregator, IntentAggregatorOptions, IntentAggregatorSnapshot, OperationSequence, TelemetrySample };

package/dist/intent/aggregator.mjs

@@ -0,0 +1 @@
+var e=class{windowMs;sequenceSampleSize;samples=[];constructor(e={}){this.windowMs=e.windowMs??9e5,this.sequenceSampleSize=e.sequenceSampleSize??1e3}add(e){this.samples.push(e)}flush(e=new Date){let t=e.getTime()-this.windowMs,n=this.samples.filter(e=>e.timestamp.getTime()>=t);this.samples.length=0;let r=this.aggregateMetrics(n),i=this.buildSequences(n),a=n.map(e=>e.timestamp.getTime());return{metrics:r,sequences:i,sampleCount:n.length,windowStart:a.length?new Date(Math.min(...a)):void 0,windowEnd:a.length?new Date(Math.max(...a)):void 0}}aggregateMetrics(e){if(!e.length)return[];let n=new Map;for(let t of e){let e=`${t.operation.name}.v${t.operation.version}`,r=n.get(e)??[];r.push(t),n.set(e,r)}return[...n.values()].map(e=>{let n=e.map(e=>e.durationMs).sort((e,t)=>e-t),r=e.filter(e=>!e.success),i=e.length,a=r.reduce((e,t)=>(t.errorCode&&(e[t.errorCode]=(e[t.errorCode]??0)+1),e),{}),o=e.map(e=>e.timestamp.getTime());return{operation:e[0].operation,totalCalls:i,successRate:(i-r.length)/i,errorRate:r.length/i,averageLatencyMs:n.reduce((e,t)=>e+t,0)/i,p95LatencyMs:t(n,.95),p99LatencyMs:t(n,.99),maxLatencyMs:Math.max(...n),windowStart:new Date(Math.min(...o)),windowEnd:new Date(Math.max(...o)),topErrors:a}})}buildSequences(e){let t=new Map;for(let n of e.slice(-this.sequenceSampleSize)){if(!n.traceId)continue;let e=t.get(n.traceId)??[];e.push(n),t.set(n.traceId,e)}let n={};for(let[e,r]of t.entries()){let e=r.sort((e,t)=>e.timestamp.getTime()-t.timestamp.getTime()),t=e.map(e=>e.operation.name);if(t.length<2)continue;let i=`${t.join(`>`)}@${e[0]?.tenantId??`global`}`,a=n[i];a?a.count+=1:n[i]={steps:t,tenantId:e[0]?.tenantId,count:1}}return Object.values(n).sort((e,t)=>t.count-e.count)}};function t(e,t){return e.length?e.length===1?e[0]:e[Math.min(e.length-1,Math.floor(t*e.length))]:0}export{e as IntentAggregator};

package/dist/intent/detector.d.mts

@@ -0,0 +1,31 @@
+import { AggregatedOperationMetrics, OperationSequence } from "./aggregator.mjs";
+
+//#region src/intent/detector.d.ts
+type IntentSignalType = 'latency-regression' | 'error-spike' | 'throughput-drop' | 'missing-workflow-step';
+interface IntentSignal {
+  id: string;
+  type: IntentSignalType;
+  operation?: AggregatedOperationMetrics['operation'];
+  confidence: number;
+  description: string;
+  metadata?: Record<string, unknown>;
+  evidence: {
+    type: 'metric' | 'sequence' | 'anomaly';
+    description: string;
+    data?: Record<string, unknown>;
+  }[];
+}
+interface IntentDetectorOptions {
+  errorRateThreshold?: number;
+  latencyP99ThresholdMs?: number;
+  throughputDropThreshold?: number;
+  minSequenceLength?: number;
+}
+declare class IntentDetector {
+  private readonly options;
+  constructor(options?: IntentDetectorOptions);
+  detectFromMetrics(current: AggregatedOperationMetrics[], previous?: AggregatedOperationMetrics[]): IntentSignal[];
+  detectSequentialIntents(sequences: OperationSequence[]): IntentSignal[];
+}
+//#endregion
+export { IntentDetector, IntentDetectorOptions, IntentSignal, IntentSignalType };

package/dist/intent/detector.mjs

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";const t={errorRateThreshold:.05,latencyP99ThresholdMs:750,throughputDropThreshold:.3,minSequenceLength:3};var n=class{options;constructor(e={}){this.options={errorRateThreshold:e.errorRateThreshold??t.errorRateThreshold,latencyP99ThresholdMs:e.latencyP99ThresholdMs??t.latencyP99ThresholdMs,throughputDropThreshold:e.throughputDropThreshold??t.throughputDropThreshold,minSequenceLength:e.minSequenceLength??t.minSequenceLength}}detectFromMetrics(t,n){let r=[],i=new Map((n??[]).map(e=>[`${e.operation.name}.v${e.operation.version}`,e]));for(let n of t){if(n.errorRate>=this.options.errorRateThreshold){r.push({id:e(),type:`error-spike`,operation:n.operation,confidence:Math.min(1,n.errorRate/this.options.errorRateThreshold),description:`Error rate ${n.errorRate.toFixed(2)} exceeded threshold`,metadata:{errorRate:n.errorRate,topErrors:n.topErrors},evidence:[{type:`metric`,description:`error-rate`,data:{errorRate:n.errorRate,threshold:this.options.errorRateThreshold}}]});continue}if(n.p99LatencyMs>=this.options.latencyP99ThresholdMs){r.push({id:e(),type:`latency-regression`,operation:n.operation,confidence:Math.min(1,n.p99LatencyMs/this.options.latencyP99ThresholdMs),description:`P99 latency ${n.p99LatencyMs}ms exceeded threshold`,metadata:{p99LatencyMs:n.p99LatencyMs},evidence:[{type:`metric`,description:`p99-latency`,data:{p99LatencyMs:n.p99LatencyMs,threshold:this.options.latencyP99ThresholdMs}}]});continue}let t=i.get(`${n.operation.name}.v${n.operation.version}`);if(t){let i=(t.totalCalls-n.totalCalls)/Math.max(t.totalCalls,1);i>=this.options.throughputDropThreshold&&r.push({id:e(),type:`throughput-drop`,operation:n.operation,confidence:Math.min(1,i/this.options.throughputDropThreshold),description:`Throughput dropped ${(i*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls},evidence:[{type:`metric`,description:`throughput-drop`,data:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls}}]})}}return r}detectSequentialIntents(t){let n=[];for(let r of t){if(r.steps.length<this.options.minSequenceLength)continue;let t=r.steps.join(` → `);n.push({id:e(),type:`missing-workflow-step`,confidence:.6,description:`Repeated workflow detected: ${t}`,metadata:{steps:r.steps,tenantId:r.tenantId,occurrences:r.count},evidence:[{type:`sequence`,description:`sequential-calls`,data:{steps:r.steps,count:r.count}}]})}return n}};export{n as IntentDetector};

package/dist/lifecycle/dist/index.mjs

@@ -0,0 +1 @@
+import{e,n as t,t as n}from"./types/stages.mjs";import"./types/axes.mjs";import"./types/signals.mjs";import"./types/milestones.mjs";import{o as r,r as i}from"./utils/formatters.mjs";

package/dist/lifecycle/dist/types/axes.mjs

@@ -0,0 +1 @@
+(function(e){return e.Sketch=`Sketch`,e.Prototype=`Prototype`,e.Mvp=`MVP`,e.V1=`V1`,e.Ecosystem=`Ecosystem`,e})({}),function(e){return e.Solo=`Solo`,e.TinyTeam=`TinyTeam`,e.FunctionalOrg=`FunctionalOrg`,e.MultiTeam=`MultiTeam`,e.Bureaucratic=`Bureaucratic`,e}({}),function(e){return e.Bootstrapped=`Bootstrapped`,e.PreSeed=`PreSeed`,e.Seed=`Seed`,e.SeriesAorB=`SeriesAorB`,e.LateStage=`LateStage`,e}({});

package/dist/lifecycle/dist/types/milestones.mjs

@@ -0,0 +1 @@
+import"./stages.mjs";

package/dist/lifecycle/dist/types/signals.mjs

@@ -0,0 +1 @@
+import"./stages.mjs";

package/dist/lifecycle/dist/types/stages.mjs

@@ -0,0 +1 @@
+let e=function(e){return e[e.Exploration=0]=`Exploration`,e[e.ProblemSolutionFit=1]=`ProblemSolutionFit`,e[e.MvpEarlyTraction=2]=`MvpEarlyTraction`,e[e.ProductMarketFit=3]=`ProductMarketFit`,e[e.GrowthScaleUp=4]=`GrowthScaleUp`,e[e.ExpansionPlatform=5]=`ExpansionPlatform`,e[e.MaturityRenewal=6]=`MaturityRenewal`,e}({});const t=[e.Exploration,e.ProblemSolutionFit,e.MvpEarlyTraction,e.ProductMarketFit,e.GrowthScaleUp,e.ExpansionPlatform,e.MaturityRenewal],n={[e.Exploration]:{id:e.Exploration,order:0,slug:`exploration`,name:`Exploration / Ideation`,question:`Is there a problem worth my time?`,signals:[`20+ discovery interviews`,`Clear problem statement`,`Named ICP`],traps:[`Branding before discovery`,`Premature tooling decisions`],focusAreas:[`Customer discovery`,`Problem definition`,`Segment clarity`]},[e.ProblemSolutionFit]:{id:e.ProblemSolutionFit,order:1,slug:`problem-solution-fit`,name:`Problem–Solution Fit`,question:`Do people care enough about this solution?`,signals:[`Prototype reuse`,`Referral energy`,`Pre-pay interest`],traps:[`“Market is huge” without users`,`Skipping qualitative loops`],focusAreas:[`Solution hypothesis`,`Value messaging`,`Feedback capture`]},[e.MvpEarlyTraction]:{id:e.MvpEarlyTraction,order:2,slug:`mvp-early-traction`,name:`MVP & Early Traction`,question:`Can we get real usage and learn fast?`,signals:[`20–50 named active users`,`Weekly releases`,`Noisy feedback`],traps:[`Overbuilt infra for 10 users`,`Undefined retention metric`],focusAreas:[`Activation`,`Cohort tracking`,`Feedback rituals`]},[e.ProductMarketFit]:{id:e.ProductMarketFit,order:3,slug:`product-market-fit`,name:`Product–Market Fit`,question:`Is this pulling us forward?`,signals:[`Retention without heroics`,`Organic word-of-mouth`,`Value stories`],traps:[`Hero growth that does not scale`,`Ignoring churn signals`],focusAreas:[`Retention`,`Reliability`,`ICP clarity`]},[e.GrowthScaleUp]:{id:e.GrowthScaleUp,order:4,slug:`growth-scale-up`,name:`Growth / Scale-up`,question:`Can we grow this repeatably?`,signals:[`Predictable channels`,`Specialized hires`,`Unit economics on track`],traps:[`Paid spend masking retention gaps`,`Infra debt blocking launches`],focusAreas:[`Ops systems`,`Growth loops`,`Reliability engineering`]},[e.ExpansionPlatform]:{id:e.ExpansionPlatform,order:5,slug:`expansion-platform`,name:`Expansion / Platform`,question:`What is the next growth curve?`,signals:[`Stable core metrics`,`Partner/API demand`,`Ecosystem pull`],traps:[`Platform theater before wedge is solid`],focusAreas:[`Partnerships`,`APIs`,`New market validation`]},[e.MaturityRenewal]:{id:e.MaturityRenewal,order:6,slug:`maturity-renewal`,name:`Maturity / Renewal`,question:`Optimize, reinvent, or sunset?`,signals:[`Margin focus`,`Portfolio bets`,`Narrative refresh`],traps:[`Assuming past success is enough`],focusAreas:[`Cost optimization`,`Reinvention bets`,`Sunset planning`]}};export{e,n,t};

package/dist/lifecycle/dist/utils/formatters.mjs

@@ -0,0 +1 @@
+import{n as e,t}from"../types/stages.mjs";const n=e=>[`Product: ${e.product}`,`Company: ${e.company}`,`Capital: ${e.capital}`],r=t=>e[t].name;export{r as o,n as r};

package/dist/logging/index.d.mts

@@ -16,5 +16,4 @@ declare class Logger {
 }
 declare const logger: Logger;
 //#endregion
-export { LogEntry, LogLevel, Logger, logger };
-//# sourceMappingURL=index.d.mts.map
+export { LogEntry, LogLevel, Logger, logger };

package/dist/logging/index.mjs

@@ -1,2 +1 @@
-import{context as e,trace as t}from"@opentelemetry/api";var n=class{constructor(e){this.serviceName=e}log(n,r,i={}){let a=t.getSpan(e.active()),o=a?.spanContext().traceId,s=a?.spanContext().spanId,c={timestamp:new Date().toISOString(),service:this.serviceName,level:n,message:r,traceId:o,spanId:s,...i};console.log(JSON.stringify(c))}debug(e,t){this.log(`debug`,e,t)}info(e,t){this.log(`info`,e,t)}warn(e,t){this.log(`warn`,e,t)}error(e,t){this.log(`error`,e,t)}};const r=new n(process.env.OTEL_SERVICE_NAME||`unknown-service`);export{n as Logger,r as logger};
-//# sourceMappingURL=index.mjs.map
+import{context as e,trace as t}from"@opentelemetry/api";var n=class{constructor(e){this.serviceName=e}log(n,r,i={}){let a=t.getSpan(e.active()),o=a?.spanContext().traceId,s=a?.spanContext().spanId,c={timestamp:new Date().toISOString(),service:this.serviceName,level:n,message:r,traceId:o,spanId:s,...i};console.log(JSON.stringify(c))}debug(e,t){this.log(`debug`,e,t)}info(e,t){this.log(`info`,e,t)}warn(e,t){this.log(`warn`,e,t)}error(e,t){this.log(`error`,e,t)}};const r=new n(process.env.OTEL_SERVICE_NAME||`unknown-service`);export{n as Logger,r as logger};

package/dist/metrics/index.d.mts

@@ -13,5 +13,4 @@ declare const standardMetrics: {
   workflowDuration: Histogram<_opentelemetry_api0.Attributes>;
 };
 //#endregion
-export { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics };
-//# sourceMappingURL=index.d.mts.map
+export { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics };

package/dist/metrics/index.mjs

@@ -1,2 +1 @@
-import{metrics as e}from"@opentelemetry/api";function t(t=`@lssm/lib.observability`){return e.getMeter(t)}function n(e,n,r){return t(r).createCounter(e,{description:n})}function r(e,n,r){return t(r).createUpDownCounter(e,{description:n})}function i(e,n,r){return t(r).createHistogram(e,{description:n})}const a={httpRequests:n(`http_requests_total`,`Total HTTP requests`),httpDuration:i(`http_request_duration_seconds`,`HTTP request duration`),operationErrors:n(`operation_errors_total`,`Total operation errors`),workflowDuration:i(`workflow_duration_seconds`,`Workflow execution duration`)};export{n as createCounter,i as createHistogram,r as createUpDownCounter,t as getMeter,a as standardMetrics};
-//# sourceMappingURL=index.mjs.map
+import{metrics as e}from"@opentelemetry/api";function t(t=`@lssm/lib.observability`){return e.getMeter(t)}function n(e,n,r){return t(r).createCounter(e,{description:n})}function r(e,n,r){return t(r).createUpDownCounter(e,{description:n})}function i(e,n,r){return t(r).createHistogram(e,{description:n})}const a={httpRequests:n(`http_requests_total`,`Total HTTP requests`),httpDuration:i(`http_request_duration_seconds`,`HTTP request duration`),operationErrors:n(`operation_errors_total`,`Total operation errors`),workflowDuration:i(`workflow_duration_seconds`,`Workflow execution duration`)};export{n as createCounter,i as createHistogram,r as createUpDownCounter,t as getMeter,a as standardMetrics};

package/dist/pipeline/evolution-pipeline.d.mts

@@ -0,0 +1,39 @@
+import { IntentAggregator, IntentAggregatorSnapshot, TelemetrySample } from "../intent/aggregator.mjs";
+import { IntentDetector, IntentSignal } from "../intent/detector.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/evolution-pipeline.d.ts
+type EvolutionPipelineEvent = {
+  type: 'intent.detected';
+  payload: IntentSignal;
+} | {
+  type: 'telemetry.window';
+  payload: {
+    sampleCount: number;
+  };
+};
+interface EvolutionPipelineOptions {
+  detector?: IntentDetector;
+  aggregator?: IntentAggregator;
+  emitter?: EventEmitter;
+  onIntent?: (intent: IntentSignal) => Promise<void> | void;
+  onSnapshot?: (snapshot: IntentAggregatorSnapshot) => Promise<void> | void;
+}
+declare class EvolutionPipeline {
+  private readonly detector;
+  private readonly aggregator;
+  private readonly emitter;
+  private readonly onIntent?;
+  private readonly onSnapshot?;
+  private timer?;
+  private previousMetrics?;
+  constructor(options?: EvolutionPipelineOptions);
+  ingest(sample: TelemetrySample): void;
+  on(listener: (event: EvolutionPipelineEvent) => void): void;
+  start(intervalMs?: number): void;
+  stop(): void;
+  run(): Promise<void>;
+  private emit;
+}
+//#endregion
+export { EvolutionPipeline, EvolutionPipelineEvent, EvolutionPipelineOptions };

package/dist/pipeline/evolution-pipeline.mjs

@@ -0,0 +1 @@
+import{IntentAggregator as e}from"../intent/aggregator.mjs";import{IntentDetector as t}from"../intent/detector.mjs";import{EventEmitter as n}from"node:events";var r=class{detector;aggregator;emitter;onIntent;onSnapshot;timer;previousMetrics;constructor(r={}){this.detector=r.detector??new t,this.aggregator=r.aggregator??new e,this.emitter=r.emitter??new n,this.onIntent=r.onIntent,this.onSnapshot=r.onSnapshot}ingest(e){this.aggregator.add(e)}on(e){this.emitter.on(`event`,e)}start(e=300*1e3){this.stop(),this.timer=setInterval(()=>{this.run()},e)}stop(){this.timer&&=(clearInterval(this.timer),void 0)}async run(){let e=this.aggregator.flush();if(this.emit({type:`telemetry.window`,payload:{sampleCount:e.sampleCount}}),this.onSnapshot&&await this.onSnapshot(e),!e.sampleCount)return;let t=this.detector.detectFromMetrics(e.metrics,this.previousMetrics),n=this.detector.detectSequentialIntents(e.sequences);this.previousMetrics=e.metrics;let r=[...t,...n];for(let e of r)this.onIntent&&await this.onIntent(e),this.emit({type:`intent.detected`,payload:e})}emit(e){this.emitter.emit(`event`,e)}};export{r as EvolutionPipeline};

package/dist/pipeline/lifecycle-pipeline.d.mts

@@ -0,0 +1,43 @@
+import { EventEmitter } from "node:events";
+import { LifecycleAssessment, LifecycleStage } from "@lssm/lib.lifecycle";
+
+//#region src/pipeline/lifecycle-pipeline.d.ts
+type LifecyclePipelineEvent = {
+  type: 'assessment.recorded';
+  payload: {
+    tenantId?: string;
+    stage: LifecycleStage;
+  };
+} | {
+  type: 'stage.changed';
+  payload: {
+    tenantId?: string;
+    previousStage?: LifecycleStage;
+    nextStage: LifecycleStage;
+  };
+} | {
+  type: 'confidence.low';
+  payload: {
+    tenantId?: string;
+    confidence: number;
+  };
+};
+interface LifecycleKpiPipelineOptions {
+  meterName?: string;
+  emitter?: EventEmitter;
+  lowConfidenceThreshold?: number;
+}
+declare class LifecycleKpiPipeline {
+  private readonly assessmentCounter;
+  private readonly confidenceHistogram;
+  private readonly stageUpDownCounter;
+  private readonly emitter;
+  private readonly lowConfidenceThreshold;
+  private readonly currentStageByTenant;
+  constructor(options?: LifecycleKpiPipelineOptions);
+  recordAssessment(assessment: LifecycleAssessment, tenantId?: string): void;
+  on(listener: (event: LifecyclePipelineEvent) => void): void;
+  private ensureStageCounters;
+}
+//#endregion
+export { LifecycleKpiPipeline, LifecycleKpiPipelineOptions, LifecyclePipelineEvent };

package/dist/pipeline/lifecycle-pipeline.mjs

@@ -0,0 +1 @@
+import{createCounter as e,createHistogram as t,createUpDownCounter as n}from"../metrics/index.mjs";import{o as r}from"../lifecycle/dist/utils/formatters.mjs";import"../lifecycle/dist/index.mjs";import{EventEmitter as i}from"node:events";var a=class{assessmentCounter;confidenceHistogram;stageUpDownCounter;emitter;lowConfidenceThreshold;currentStageByTenant=new Map;constructor(r={}){let a=r.meterName??`@lssm/lib.lifecycle-kpi`;this.assessmentCounter=e(`lifecycle_assessments_total`,`Total lifecycle assessments`,a),this.confidenceHistogram=t(`lifecycle_assessment_confidence`,`Lifecycle assessment confidence distribution`,a),this.stageUpDownCounter=n(`lifecycle_stage_tenants`,`Current tenants per lifecycle stage`,a),this.emitter=r.emitter??new i,this.lowConfidenceThreshold=r.lowConfidenceThreshold??.4}recordAssessment(e,t){let n={stage:r(e.stage),tenantId:t};this.assessmentCounter.add(1,n),this.confidenceHistogram.record(e.confidence,n),this.ensureStageCounters(e.stage,t),this.emitter.emit(`event`,{type:`assessment.recorded`,payload:{tenantId:t,stage:e.stage}}),e.confidence<this.lowConfidenceThreshold&&this.emitter.emit(`event`,{type:`confidence.low`,payload:{tenantId:t,confidence:e.confidence}})}on(e){this.emitter.on(`event`,e)}ensureStageCounters(e,t){if(!t)return;let n=this.currentStageByTenant.get(t);n!==e&&(n!==void 0&&this.stageUpDownCounter.add(-1,{stage:r(n),tenantId:t}),this.stageUpDownCounter.add(1,{stage:r(e),tenantId:t}),this.currentStageByTenant.set(t,e),this.emitter.emit(`event`,{type:`stage.changed`,payload:{tenantId:t,previousStage:n,nextStage:e}}))}};export{a as LifecycleKpiPipeline};

package/dist/tracing/index.d.mts

@@ -5,5 +5,4 @@ declare function getTracer(name?: string): Tracer;
 declare function traceAsync<T>(name: string, fn: (span: Span) => Promise<T>, tracerName?: string): Promise<T>;
 declare function traceSync<T>(name: string, fn: (span: Span) => T, tracerName?: string): T;
 //#endregion
-export { getTracer, traceAsync, traceSync };
-//# sourceMappingURL=index.d.mts.map
+export { getTracer, traceAsync, traceSync };

package/dist/tracing/index.mjs

@@ -1,2 +1 @@
-import{SpanStatusCode as e,context as t,trace as n}from"@opentelemetry/api";function r(e=`@lssm/lib.observability`){return n.getTracer(e)}async function i(t,n,i){return r(i).startActiveSpan(t,async t=>{try{let r=await n(t);return t.setStatus({code:e.OK}),r}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}function a(t,n,i){return r(i).startActiveSpan(t,t=>{try{let r=n(t);return t.setStatus({code:e.OK}),r}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}export{r as getTracer,i as traceAsync,a as traceSync};
-//# sourceMappingURL=index.mjs.map
+import{SpanStatusCode as e,context as t,trace as n}from"@opentelemetry/api";function r(e=`@lssm/lib.observability`){return n.getTracer(e)}async function i(t,n,i){return r(i).startActiveSpan(t,async t=>{try{let r=await n(t);return t.setStatus({code:e.OK}),r}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}function a(t,n,i){return r(i).startActiveSpan(t,t=>{try{let r=n(t);return t.setStatus({code:e.OK}),r}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}export{r as getTracer,i as traceAsync,a as traceSync};

package/dist/tracing/middleware.d.mts

@@ -1,5 +1,18 @@
+import { TelemetrySample } from "../intent/aggregator.mjs";
+
 //#region src/tracing/middleware.d.ts
-declare function createTracingMiddleware(): (req: Request, next: () => Promise<Response>) => Promise<Response>;
+interface TracingMiddlewareOptions {
+  resolveOperation?: (input: {
+    req: Request;
+    res?: Response;
+  }) => {
+    name: string;
+    version: number;
+  } | undefined;
+  onSample?: (sample: TelemetrySample) => void;
+  tenantResolver?: (req: Request) => string | undefined;
+  actorResolver?: (req: Request) => string | undefined;
+}
+declare function createTracingMiddleware(options?: TracingMiddlewareOptions): (req: Request, next: () => Promise<Response>) => Promise<Response>;
 //#endregion
-export { createTracingMiddleware };
-//# sourceMappingURL=middleware.d.mts.map
+export { TracingMiddlewareOptions, createTracingMiddleware };

package/dist/tracing/middleware.mjs

@@ -1,2 +1 @@
-import{traceAsync as e}from"./index.mjs";import{standardMetrics as t}from"../metrics/index.mjs";function n(){return async(n,r)=>{let i=n.method,a=new URL(n.url).pathname;t.httpRequests.add(1,{method:i,path:a});let o=performance.now();return e(`HTTP ${i} ${a}`,async e=>{e.setAttribute(`http.method`,i),e.setAttribute(`http.url`,n.url);try{let n=await r();e.setAttribute(`http.status_code`,n.status);let s=(performance.now()-o)/1e3;return t.httpDuration.record(s,{method:i,path:a,status:n.status.toString()}),n}catch(e){throw t.operationErrors.add(1,{method:i,path:a}),e}})}}export{n as createTracingMiddleware};
-//# sourceMappingURL=middleware.mjs.map
+import{traceAsync as e}from"./index.mjs";import{standardMetrics as t}from"../metrics/index.mjs";function n(n={}){return async(i,a)=>{let o=i.method,s=new URL(i.url).pathname;t.httpRequests.add(1,{method:o,path:s});let c=performance.now();return e(`HTTP ${o} ${s}`,async e=>{e.setAttribute(`http.method`,o),e.setAttribute(`http.url`,i.url);try{let l=await a();e.setAttribute(`http.status_code`,l.status);let u=(performance.now()-c)/1e3;return t.httpDuration.record(u,{method:o,path:s,status:l.status.toString()}),r({req:i,res:l,span:e,success:!0,durationMs:u*1e3,options:n}),l}catch(a){throw t.operationErrors.add(1,{method:o,path:s}),r({req:i,span:e,success:!1,durationMs:performance.now()-c,error:a,options:n}),a}})}}function r({req:e,res:t,span:n,success:r,durationMs:i,error:a,options:o}){if(!o.onSample||!o.resolveOperation)return;let s=o.resolveOperation({req:e,res:t});if(!s)return;let c={operation:s,durationMs:i,success:r,timestamp:new Date,errorCode:!r&&a instanceof Error?a.name:r?void 0:`unknown`,tenantId:o.tenantResolver?.(e),actorId:o.actorResolver?.(e),traceId:n.spanContext().traceId,metadata:{method:e.method,path:new URL(e.url).pathname,status:t?.status}};o.onSample(c)}export{n as createTracingMiddleware};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@lssm/lib.observability",
-  "version": "0.0.0-canary-20251120192244",
+  "version": "0.0.0-canary-20251206160926",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "scripts": {
+    "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "build": "bun build:bundle && bun build:types",
     "build:bundle": "tsdown",
     "build:types": "tsc --noEmit",
@@ -12,22 +13,35 @@
     "lint": "bun lint:fix",
     "lint:fix": "eslint src --fix",
     "lint:check": "eslint src",
-    "test": "vitest run"
+    "test": "bun run"
+  },
+  "dependencies": {
+    "@lssm/lib.lifecycle": "workspace:*"
   },
   "peerDependencies": {
     "@opentelemetry/api": "*"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "vitest": "^1.0.0"
+    "typescript": "^5.0.0"
   },
   "exports": {
     ".": "./dist/index.mjs",
+    "./anomaly/alert-manager": "./dist/anomaly/alert-manager.mjs",
+    "./anomaly/anomaly-detector": "./dist/anomaly/anomaly-detector.mjs",
+    "./anomaly/baseline-calculator": "./dist/anomaly/baseline-calculator.mjs",
+    "./anomaly/root-cause-analyzer": "./dist/anomaly/root-cause-analyzer.mjs",
+    "./intent/aggregator": "./dist/intent/aggregator.mjs",
+    "./intent/detector": "./dist/intent/detector.mjs",
     "./logging": "./dist/logging/index.mjs",
     "./metrics": "./dist/metrics/index.mjs",
+    "./pipeline/evolution-pipeline": "./dist/pipeline/evolution-pipeline.mjs",
+    "./pipeline/lifecycle-pipeline": "./dist/pipeline/lifecycle-pipeline.mjs",
     "./tracing": "./dist/tracing/index.mjs",
     "./tracing/middleware": "./dist/tracing/middleware.mjs",
     "./*": "./*"
   },
-  "module": "./dist/index.mjs"
+  "module": "./dist/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/.turbo/turbo-build.log

@@ -1,29 +0,0 @@
-$ bun build:bundle && bun build:types
-$ tsdown
-ℹ tsdown v0.15.12 powered by rolldown v1.0.0-beta.45
-ℹ Using tsdown config: /home/runner/work/contractspec/contractspec/packages/libs/observability/tsdown.config.js
-ℹ entry: src/index.ts, src/logging/index.ts, src/metrics/index.ts, src/tracing/index.ts, src/tracing/middleware.ts
-ℹ target: esnext
-ℹ tsconfig: tsconfig.json
-ℹ Build start
-ℹ dist/metrics/index.mjs             0.73 kB │ gzip: 0.36 kB
-ℹ dist/tracing/index.mjs             0.71 kB │ gzip: 0.34 kB
-ℹ dist/tracing/middleware.mjs        0.65 kB │ gzip: 0.39 kB
-ℹ dist/logging/index.mjs             0.59 kB │ gzip: 0.38 kB
-ℹ dist/index.mjs                     0.54 kB │ gzip: 0.24 kB
-ℹ dist/tracing/index.mjs.map         2.34 kB │ gzip: 0.77 kB
-ℹ dist/logging/index.mjs.map         2.10 kB │ gzip: 0.85 kB
-ℹ dist/metrics/index.mjs.map         1.87 kB │ gzip: 0.68 kB
-ℹ dist/tracing/middleware.mjs.map    1.75 kB │ gzip: 0.80 kB
-ℹ dist/metrics/index.d.mts.map       0.42 kB │ gzip: 0.26 kB
-ℹ dist/logging/index.d.mts.map       0.36 kB │ gzip: 0.24 kB
-ℹ dist/tracing/index.d.mts.map       0.33 kB │ gzip: 0.23 kB
-ℹ dist/tracing/middleware.d.mts.map  0.17 kB │ gzip: 0.15 kB
-ℹ dist/metrics/index.d.mts           0.94 kB │ gzip: 0.34 kB
-ℹ dist/logging/index.d.mts           0.66 kB │ gzip: 0.31 kB
-ℹ dist/index.d.mts                   0.53 kB │ gzip: 0.22 kB
-ℹ dist/tracing/index.d.mts           0.43 kB │ gzip: 0.23 kB
-ℹ dist/tracing/middleware.d.mts      0.24 kB │ gzip: 0.17 kB
-ℹ 18 files, total: 15.38 kB
-✔ Build complete in 35694ms
-$ tsc --noEmit

package/dist/logging/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/logging/index.ts"],"sourcesContent":[],"mappings":";KAEY,QAAA;AAAA,UAEK,QAAA,CAFG;EAEH,KAAA,EACR,QADgB;EAMZ,OAAA,EAAM,MAAA;EA0Ba,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;AAQD,cAlClB,MAAA,CAkCkB;EAIC,iBAAA,WAAA;EAAM,WAAA,CAAA,WAAA,EAAA,MAAA;EAKzB,QAAA,GAEZ;gCAnB+B;+BAID;+BAIA;gCAIC;;cAKnB,QAAM"}