@lssm/lib.evolution 0.0.0-canary-20251217060834 → 0.0.0-canary-20251217072406

package/dist/ai-agent/dist/approval/index.js

@@ -0,0 +1 @@
+import "./workflow.js";

package/dist/ai-agent/dist/approval/workflow.js

@@ -0,0 +1 @@
+import { randomUUID } from "node:crypto";

package/dist/analyzer/spec-analyzer.d.ts

@@ -1,6 +1,6 @@
 import { IntentPattern, OperationMetricSample, OptimizationHint, SpecAnomaly, SpecUsageStats } from "../types.js";
-import { Logger } from "@lssm/lib.observability";
 import { LifecycleStage } from "@lssm/lib.lifecycle";
+import { Logger } from "@lssm/lib.observability";
 
 //#region src/analyzer/spec-analyzer.d.ts
 interface SpecAnalyzerOptions {

package/dist/analyzer/spec-analyzer.js

@@ -1 +1,305 @@
-import{Logger as e}from"@lssm/lib.observability";import{randomUUID as t}from"node:crypto";import{LifecycleStage as n}from"@lssm/lib.lifecycle";const r={minSampleSize:50,errorRateThreshold:.05,latencyP99ThresholdMs:750};var i=class{logger;minSampleSize;errorRateThreshold;latencyP99ThresholdMs;throughputDropThreshold;constructor(e={}){this.logger=e.logger,this.minSampleSize=e.minSampleSize??r.minSampleSize,this.errorRateThreshold=e.errorRateThreshold??r.errorRateThreshold,this.latencyP99ThresholdMs=e.latencyP99ThresholdMs??r.latencyP99ThresholdMs,this.throughputDropThreshold=e.throughputDropThreshold??.2}analyzeSpecUsage(e){if(!e.length)return this.logger?.debug(`SpecAnalyzer.analyzeSpecUsage.skip`,{reason:`no-samples`}),[];let t=new Map;for(let n of e){let e=this.operationKey(n),r=t.get(e)??[];r.push(n),t.set(e,r)}return[...t.values()].filter(e=>{let t=e.length>=this.minSampleSize;return t||this.logger?.debug(`SpecAnalyzer.analyzeSpecUsage.skipOperation`,{operation:this.operationKey(e[0]),sampleSize:e.length,minSampleSize:this.minSampleSize}),t}).map(e=>this.buildUsageStats(e))}detectAnomalies(e,t){let n=[];if(!e.length)return this.logger?.debug(`SpecAnalyzer.detectAnomalies.skip`,{reason:`no-stats`}),n;let r=new Map((t??[]).map(e=>[this.operationKey(e.operation),e]));for(let t of e){let e=[];if(t.errorRate>=this.errorRateThreshold){e.push({type:`telemetry`,description:`Error rate ${t.errorRate.toFixed(2)} exceeded threshold ${this.errorRateThreshold}`,data:{errorRate:t.errorRate}}),n.push({operation:t.operation,severity:this.toSeverity(t.errorRate/this.errorRateThreshold),metric:`error-rate`,description:`Error rate spike`,detectedAt:new Date,threshold:this.errorRateThreshold,observedValue:t.errorRate,evidence:e});continue}if(t.p99LatencyMs>=this.latencyP99ThresholdMs){e.push({type:`telemetry`,description:`P99 latency ${t.p99LatencyMs}ms exceeded threshold ${this.latencyP99ThresholdMs}ms`,data:{p99LatencyMs:t.p99LatencyMs}}),n.push({operation:t.operation,severity:this.toSeverity(t.p99LatencyMs/this.latencyP99ThresholdMs),metric:`latency`,description:`Latency regression detected`,detectedAt:new Date,threshold:this.latencyP99ThresholdMs,observedValue:t.p99LatencyMs,evidence:e});continue}let i=r.get(this.operationKey(t.operation));if(i){let r=(i.totalCalls-t.totalCalls)/i.totalCalls;r>=this.throughputDropThreshold&&(e.push({type:`telemetry`,description:`Throughput dropped by ${(r*100).toFixed(1)}% compared to baseline`,data:{baselineCalls:i.totalCalls,currentCalls:t.totalCalls}}),n.push({operation:t.operation,severity:this.toSeverity(r/this.throughputDropThreshold),metric:`throughput`,description:`Usage drop detected`,detectedAt:new Date,threshold:this.throughputDropThreshold,observedValue:r,evidence:e}))}}return n}toIntentPatterns(e,n){let r=new Map(n.map(e=>[this.operationKey(e.operation),e]));return e.map(e=>{let n=r.get(this.operationKey(e.operation)),i={score:Math.min(1,(e.observedValue??0)/(e.threshold??1)),sampleSize:n?.totalCalls??0,pValue:void 0};return{id:t(),type:this.mapMetricToIntent(e.metric),description:e.description,operation:e.operation,confidence:i,metadata:{observedValue:e.observedValue,threshold:e.threshold},evidence:e.evidence}})}suggestOptimizations(e,t,n){let r=new Map(this.groupByOperation(t)),i=[];for(let t of e){let e=this.operationKey(t.operation),a=r.get(e)??[];for(let e of a)if(e.metric===`latency`)i.push(this.applyLifecycleContext({operation:t.operation,category:`performance`,summary:`Latency regression detected`,justification:`P99 latency at ${t.p99LatencyMs}ms`,recommendedActions:[`Add batching or caching layer`,`Replay golden tests to capture slow inputs`]},n?.stage));else if(e.metric===`error-rate`){let e=Object.entries(t.topErrors).sort((e,t)=>t[1]-e[1])[0]?.[0];i.push(this.applyLifecycleContext({operation:t.operation,category:`error-handling`,summary:`Error spike detected`,justification:e?`Dominant error code ${e}`:`Increase in failures`,recommendedActions:[`Generate regression spec from failing payloads`,`Add policy guardrails before rollout`]},n?.stage))}else e.metric===`throughput`&&i.push(this.applyLifecycleContext({operation:t.operation,category:`performance`,summary:`Throughput drop detected`,justification:`Significant traffic reduction relative to baseline`,recommendedActions:[`Validate routing + feature flag bucketing`,`Backfill spec variant to rehydrate demand`]},n?.stage))}return i}operationKey(e){let t=`operation`in e?e.operation:e;return`${t.name}.v${t.version}${t.tenantId?`@${t.tenantId}`:``}`}buildUsageStats(e){let t=e.map(e=>e.durationMs).sort((e,t)=>e-t),n=e.filter(e=>!e.success),r=e.length,i=(r-n.length)/r,o=n.length/r,s=t.reduce((e,t)=>e+t,0)/r,c=n.reduce((e,t)=>(t.errorCode&&(e[t.errorCode]=(e[t.errorCode]??0)+1),e),{}),l=e.map(e=>e.timestamp.getTime()),u=new Date(Math.min(...l)),d=new Date(Math.max(...l));return{operation:e[0].operation,totalCalls:r,successRate:i,errorRate:o,averageLatencyMs:s,p95LatencyMs:a(t,.95),p99LatencyMs:a(t,.99),maxLatencyMs:Math.max(...t),lastSeenAt:d,windowStart:u,windowEnd:d,topErrors:c}}toSeverity(e){return e>=2?`high`:e>=1.3?`medium`:`low`}mapMetricToIntent(e){switch(e){case`error-rate`:return`error-spike`;case`latency`:return`latency-regression`;case`throughput`:return`throughput-drop`;default:return`schema-mismatch`}}groupByOperation(e){let t=new Map;for(let n of e){let e=this.operationKey(n.operation),r=t.get(e)??[];r.push(n),t.set(e,r)}return t}applyLifecycleContext(e,t){if(t===void 0)return e;let n=s[o(t)]?.[e.category];return n?{...e,lifecycleStage:t,lifecycleNotes:n.message,recommendedActions:c([...e.recommendedActions,...n.supplementalActions])}:{...e,lifecycleStage:t}}};function a(e,t){return e.length?e.length===1?e[0]:e[Math.min(e.length-1,Math.floor(t*e.length))]:0}const o=e=>e<=2?`early`:e===n.ProductMarketFit?`pmf`:e===n.GrowthScaleUp||e===n.ExpansionPlatform?`scale`:`mature`,s={early:{performance:{message:`Favor guardrails that protect learning velocity before heavy rewrites.`,supplementalActions:[`Wrap risky changes behind progressive delivery flags`]},"error-handling":{message:`Make failures loud and recoverable so you can learn faster.`,supplementalActions:[`Add auto-rollbacks or manual kill switches`]}},pmf:{performance:{message:`Stabilize the core use case to avoid regressions while demand grows.`,supplementalActions:[`Instrument regression tests on critical specs`]}},scale:{performance:{message:`Prioritize resilience and multi-tenant safety as volumes expand.`,supplementalActions:[`Introduce workload partitioning or isolation per tenant`]},"error-handling":{message:`Contain blast radius with policy fallbacks and circuit breakers.`,supplementalActions:[`Add circuit breakers to high-risk operations`]}},mature:{performance:{message:`Optimize for margins and predictable SLAs.`,supplementalActions:[`Capture unit-cost impacts alongside latency fixes`]},"error-handling":{message:`Prevent regressions with automated regression specs before deploy.`,supplementalActions:[`Run auto-evolution simulations on renewal scenarios`]}}},c=e=>{let t=new Set,n=[];for(let r of e)t.has(r)||(t.add(r),n.push(r));return n};export{i as SpecAnalyzer};
+import "../observability/dist/index.js";
+import { LifecycleStage } from "../lifecycle/dist/types/stages.js";
+import "../lifecycle/dist/index.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/analyzer/spec-analyzer.ts
+const DEFAULT_OPTIONS = {
+	minSampleSize: 50,
+	errorRateThreshold: .05,
+	latencyP99ThresholdMs: 750
+};
+var SpecAnalyzer = class {
+	logger;
+	minSampleSize;
+	errorRateThreshold;
+	latencyP99ThresholdMs;
+	throughputDropThreshold;
+	constructor(options = {}) {
+		this.logger = options.logger;
+		this.minSampleSize = options.minSampleSize ?? DEFAULT_OPTIONS.minSampleSize;
+		this.errorRateThreshold = options.errorRateThreshold ?? DEFAULT_OPTIONS.errorRateThreshold;
+		this.latencyP99ThresholdMs = options.latencyP99ThresholdMs ?? DEFAULT_OPTIONS.latencyP99ThresholdMs;
+		this.throughputDropThreshold = options.throughputDropThreshold ?? .2;
+	}
+	analyzeSpecUsage(samples) {
+		if (!samples.length) {
+			this.logger?.debug("SpecAnalyzer.analyzeSpecUsage.skip", { reason: "no-samples" });
+			return [];
+		}
+		const groups = /* @__PURE__ */ new Map();
+		for (const sample of samples) {
+			const key = this.operationKey(sample);
+			const arr = groups.get(key) ?? [];
+			arr.push(sample);
+			groups.set(key, arr);
+		}
+		return [...groups.values()].filter((samplesForOp) => {
+			const valid = samplesForOp.length >= this.minSampleSize;
+			if (!valid) this.logger?.debug("SpecAnalyzer.analyzeSpecUsage.skipOperation", {
+				operation: this.operationKey(samplesForOp[0]),
+				sampleSize: samplesForOp.length,
+				minSampleSize: this.minSampleSize
+			});
+			return valid;
+		}).map((operationSamples) => this.buildUsageStats(operationSamples));
+	}
+	detectAnomalies(stats, baseline) {
+		const anomalies = [];
+		if (!stats.length) {
+			this.logger?.debug("SpecAnalyzer.detectAnomalies.skip", { reason: "no-stats" });
+			return anomalies;
+		}
+		const baselineByOp = new Map((baseline ?? []).map((item) => [this.operationKey(item.operation), item]));
+		for (const stat of stats) {
+			const evidence = [];
+			if (stat.errorRate >= this.errorRateThreshold) {
+				evidence.push({
+					type: "telemetry",
+					description: `Error rate ${stat.errorRate.toFixed(2)} exceeded threshold ${this.errorRateThreshold}`,
+					data: { errorRate: stat.errorRate }
+				});
+				anomalies.push({
+					operation: stat.operation,
+					severity: this.toSeverity(stat.errorRate / this.errorRateThreshold),
+					metric: "error-rate",
+					description: "Error rate spike",
+					detectedAt: /* @__PURE__ */ new Date(),
+					threshold: this.errorRateThreshold,
+					observedValue: stat.errorRate,
+					evidence
+				});
+				continue;
+			}
+			if (stat.p99LatencyMs >= this.latencyP99ThresholdMs) {
+				evidence.push({
+					type: "telemetry",
+					description: `P99 latency ${stat.p99LatencyMs}ms exceeded threshold ${this.latencyP99ThresholdMs}ms`,
+					data: { p99LatencyMs: stat.p99LatencyMs }
+				});
+				anomalies.push({
+					operation: stat.operation,
+					severity: this.toSeverity(stat.p99LatencyMs / this.latencyP99ThresholdMs),
+					metric: "latency",
+					description: "Latency regression detected",
+					detectedAt: /* @__PURE__ */ new Date(),
+					threshold: this.latencyP99ThresholdMs,
+					observedValue: stat.p99LatencyMs,
+					evidence
+				});
+				continue;
+			}
+			const baselineStat = baselineByOp.get(this.operationKey(stat.operation));
+			if (baselineStat) {
+				const drop = (baselineStat.totalCalls - stat.totalCalls) / baselineStat.totalCalls;
+				if (drop >= this.throughputDropThreshold) {
+					evidence.push({
+						type: "telemetry",
+						description: `Throughput dropped by ${(drop * 100).toFixed(1)}% compared to baseline`,
+						data: {
+							baselineCalls: baselineStat.totalCalls,
+							currentCalls: stat.totalCalls
+						}
+					});
+					anomalies.push({
+						operation: stat.operation,
+						severity: this.toSeverity(drop / this.throughputDropThreshold),
+						metric: "throughput",
+						description: "Usage drop detected",
+						detectedAt: /* @__PURE__ */ new Date(),
+						threshold: this.throughputDropThreshold,
+						observedValue: drop,
+						evidence
+					});
+				}
+			}
+		}
+		return anomalies;
+	}
+	toIntentPatterns(anomalies, stats) {
+		const statsByOp = new Map(stats.map((item) => [this.operationKey(item.operation), item]));
+		return anomalies.map((anomaly) => {
+			const stat = statsByOp.get(this.operationKey(anomaly.operation));
+			const confidence = {
+				score: Math.min(1, (anomaly.observedValue ?? 0) / (anomaly.threshold ?? 1)),
+				sampleSize: stat?.totalCalls ?? 0,
+				pValue: void 0
+			};
+			return {
+				id: randomUUID(),
+				type: this.mapMetricToIntent(anomaly.metric),
+				description: anomaly.description,
+				operation: anomaly.operation,
+				confidence,
+				metadata: {
+					observedValue: anomaly.observedValue,
+					threshold: anomaly.threshold
+				},
+				evidence: anomaly.evidence
+			};
+		});
+	}
+	suggestOptimizations(stats, anomalies, lifecycleContext) {
+		const anomaliesByOp = new Map(this.groupByOperation(anomalies));
+		const hints = [];
+		for (const stat of stats) {
+			const opKey = this.operationKey(stat.operation);
+			const opAnomalies = anomaliesByOp.get(opKey) ?? [];
+			for (const anomaly of opAnomalies) if (anomaly.metric === "latency") hints.push(this.applyLifecycleContext({
+				operation: stat.operation,
+				category: "performance",
+				summary: "Latency regression detected",
+				justification: `P99 latency at ${stat.p99LatencyMs}ms`,
+				recommendedActions: ["Add batching or caching layer", "Replay golden tests to capture slow inputs"]
+			}, lifecycleContext?.stage));
+			else if (anomaly.metric === "error-rate") {
+				const topError = Object.entries(stat.topErrors).sort((a, b) => b[1] - a[1])[0]?.[0];
+				hints.push(this.applyLifecycleContext({
+					operation: stat.operation,
+					category: "error-handling",
+					summary: "Error spike detected",
+					justification: topError ? `Dominant error code ${topError}` : "Increase in failures",
+					recommendedActions: ["Generate regression spec from failing payloads", "Add policy guardrails before rollout"]
+				}, lifecycleContext?.stage));
+			} else if (anomaly.metric === "throughput") hints.push(this.applyLifecycleContext({
+				operation: stat.operation,
+				category: "performance",
+				summary: "Throughput drop detected",
+				justification: "Significant traffic reduction relative to baseline",
+				recommendedActions: ["Validate routing + feature flag bucketing", "Backfill spec variant to rehydrate demand"]
+			}, lifecycleContext?.stage));
+		}
+		return hints;
+	}
+	operationKey(op) {
+		const coordinate = "operation" in op ? op.operation : op;
+		return `${coordinate.name}.v${coordinate.version}${coordinate.tenantId ? `@${coordinate.tenantId}` : ""}`;
+	}
+	buildUsageStats(samples) {
+		const durations = samples.map((s) => s.durationMs).sort((a, b) => a - b);
+		const errors = samples.filter((s) => !s.success);
+		const totalCalls = samples.length;
+		const successRate = (totalCalls - errors.length) / totalCalls;
+		const errorRate = errors.length / totalCalls;
+		const averageLatencyMs = durations.reduce((sum, value) => sum + value, 0) / totalCalls;
+		const topErrors = errors.reduce((acc, sample) => {
+			if (!sample.errorCode) return acc;
+			acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;
+			return acc;
+		}, {});
+		const timestamps = samples.map((s) => s.timestamp.getTime());
+		const windowStart = new Date(Math.min(...timestamps));
+		const windowEnd = new Date(Math.max(...timestamps));
+		return {
+			operation: samples[0].operation,
+			totalCalls,
+			successRate,
+			errorRate,
+			averageLatencyMs,
+			p95LatencyMs: percentile(durations, .95),
+			p99LatencyMs: percentile(durations, .99),
+			maxLatencyMs: Math.max(...durations),
+			lastSeenAt: windowEnd,
+			windowStart,
+			windowEnd,
+			topErrors
+		};
+	}
+	toSeverity(ratio) {
+		if (ratio >= 2) return "high";
+		if (ratio >= 1.3) return "medium";
+		return "low";
+	}
+	mapMetricToIntent(metric) {
+		switch (metric) {
+			case "error-rate": return "error-spike";
+			case "latency": return "latency-regression";
+			case "throughput": return "throughput-drop";
+			default: return "schema-mismatch";
+		}
+	}
+	groupByOperation(items) {
+		const map = /* @__PURE__ */ new Map();
+		for (const item of items) {
+			const key = this.operationKey(item.operation);
+			const arr = map.get(key) ?? [];
+			arr.push(item);
+			map.set(key, arr);
+		}
+		return map;
+	}
+	applyLifecycleContext(hint, stage) {
+		if (stage === void 0) return hint;
+		const advice = LIFECYCLE_HINTS[mapStageBand(stage)]?.[hint.category];
+		if (!advice) return {
+			...hint,
+			lifecycleStage: stage
+		};
+		return {
+			...hint,
+			lifecycleStage: stage,
+			lifecycleNotes: advice.message,
+			recommendedActions: dedupeActions([...hint.recommendedActions, ...advice.supplementalActions])
+		};
+	}
+};
+function percentile(values, p) {
+	if (!values.length) return 0;
+	if (values.length === 1) return values[0];
+	return values[Math.min(values.length - 1, Math.floor(p * values.length))];
+}
+const mapStageBand = (stage) => {
+	if (stage <= 2) return "early";
+	if (stage === LifecycleStage.ProductMarketFit) return "pmf";
+	if (stage === LifecycleStage.GrowthScaleUp || stage === LifecycleStage.ExpansionPlatform) return "scale";
+	return "mature";
+};
+const LIFECYCLE_HINTS = {
+	early: {
+		performance: {
+			message: "Favor guardrails that protect learning velocity before heavy rewrites.",
+			supplementalActions: ["Wrap risky changes behind progressive delivery flags"]
+		},
+		"error-handling": {
+			message: "Make failures loud and recoverable so you can learn faster.",
+			supplementalActions: ["Add auto-rollbacks or manual kill switches"]
+		}
+	},
+	pmf: { performance: {
+		message: "Stabilize the core use case to avoid regressions while demand grows.",
+		supplementalActions: ["Instrument regression tests on critical specs"]
+	} },
+	scale: {
+		performance: {
+			message: "Prioritize resilience and multi-tenant safety as volumes expand.",
+			supplementalActions: ["Introduce workload partitioning or isolation per tenant"]
+		},
+		"error-handling": {
+			message: "Contain blast radius with policy fallbacks and circuit breakers.",
+			supplementalActions: ["Add circuit breakers to high-risk operations"]
+		}
+	},
+	mature: {
+		performance: {
+			message: "Optimize for margins and predictable SLAs.",
+			supplementalActions: ["Capture unit-cost impacts alongside latency fixes"]
+		},
+		"error-handling": {
+			message: "Prevent regressions with automated regression specs before deploy.",
+			supplementalActions: ["Run auto-evolution simulations on renewal scenarios"]
+		}
+	}
+};
+const dedupeActions = (actions) => {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const action of actions) {
+		if (seen.has(action)) continue;
+		seen.add(action);
+		ordered.push(action);
+	}
+	return ordered;
+};
+
+//#endregion
+export { SpecAnalyzer };

package/dist/approval/integration.js

@@ -1 +1,125 @@
-import{mkdir as e,writeFile as t}from"node:fs/promises";import{join as n}from"node:path";import{ApprovalWorkflow as r}from"@lssm/lib.ai-agent/approval";var i=class{constructor(e){this.options=e}async submit(e,t,n){return await this.options.repository.create(e),t&&this.options.approval&&await this.options.approval.requestApproval({sessionId:t.sessionId,agentId:t.agentId,tenantId:t.tenantId,toolName:`evolution.apply_suggestion`,toolCallId:e.id,toolArgs:{suggestionId:e.id},reason:n??e.proposal.summary,payload:{suggestionId:e.id}}),e}async approve(e,t,n){let r=await this.ensureSuggestion(e);await this.options.repository.updateStatus(e,`approved`,{reviewer:t,notes:n,decidedAt:new Date}),this.options.writer&&await this.options.writer.write({...r,status:`approved`,approvals:{reviewer:t,notes:n,decidedAt:new Date,status:`approved`}})}async reject(e,t,n){await this.options.repository.updateStatus(e,`rejected`,{reviewer:t,notes:n,decidedAt:new Date})}list(e){return this.options.repository.list(e)}async ensureSuggestion(e){let t=await this.options.repository.getById(e);if(!t)throw Error(`Spec suggestion ${e} not found`);return t}},a=class{outputDir;filenameTemplate;constructor(e={}){this.outputDir=e.outputDir??n(process.cwd(),`packages/libs/contracts/src/generated`),this.filenameTemplate=e.filenameTemplate??(e=>`${e.target?.name??e.intent.id}.v${e.target?.version??`next`}.suggestion.json`)}async write(r){await e(this.outputDir,{recursive:!0});let i=this.filenameTemplate(r),a=n(this.outputDir,i),o=s(r);return await t(a,JSON.stringify(o,null,2)),a}},o=class{items=new Map;async create(e){this.items.set(e.id,e)}async getById(e){return this.items.get(e)}async updateStatus(e,t,n){let r=await this.getById(e);r&&this.items.set(e,{...r,status:t,approvals:{reviewer:n?.reviewer,notes:n?.notes,decidedAt:n?.decidedAt,status:t}})}async list(e){let t=[...this.items.values()];return e?t.filter(t=>!(e.status&&t.status!==e.status||e.operationName&&t.target?.name!==e.operationName)):t}};function s(e){let{proposal:t,...n}=e,{spec:r,...i}=t;return{...n,proposal:{...i,specMeta:r?.meta},createdAt:e.createdAt.toISOString(),intent:{...e.intent,confidence:{...e.intent.confidence},evidence:e.intent.evidence}}}export{a as FileSystemSuggestionWriter,o as InMemorySpecSuggestionRepository,i as SpecSuggestionOrchestrator};
+import "../ai-agent/dist/approval/index.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/approval/integration.ts
+var SpecSuggestionOrchestrator = class {
+	constructor(options) {
+		this.options = options;
+	}
+	async submit(suggestion, session, approvalReason) {
+		await this.options.repository.create(suggestion);
+		if (session && this.options.approval) await this.options.approval.requestApproval({
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			tenantId: session.tenantId,
+			toolName: "evolution.apply_suggestion",
+			toolCallId: suggestion.id,
+			toolArgs: { suggestionId: suggestion.id },
+			reason: approvalReason ?? suggestion.proposal.summary,
+			payload: { suggestionId: suggestion.id }
+		});
+		return suggestion;
+	}
+	async approve(id, reviewer, notes) {
+		const suggestion = await this.ensureSuggestion(id);
+		await this.options.repository.updateStatus(id, "approved", {
+			reviewer,
+			notes,
+			decidedAt: /* @__PURE__ */ new Date()
+		});
+		if (this.options.writer) await this.options.writer.write({
+			...suggestion,
+			status: "approved",
+			approvals: {
+				reviewer,
+				notes,
+				decidedAt: /* @__PURE__ */ new Date(),
+				status: "approved"
+			}
+		});
+	}
+	async reject(id, reviewer, notes) {
+		await this.options.repository.updateStatus(id, "rejected", {
+			reviewer,
+			notes,
+			decidedAt: /* @__PURE__ */ new Date()
+		});
+	}
+	list(filters) {
+		return this.options.repository.list(filters);
+	}
+	async ensureSuggestion(id) {
+		const suggestion = await this.options.repository.getById(id);
+		if (!suggestion) throw new Error(`Spec suggestion ${id} not found`);
+		return suggestion;
+	}
+};
+var FileSystemSuggestionWriter = class {
+	outputDir;
+	filenameTemplate;
+	constructor(options = {}) {
+		this.outputDir = options.outputDir ?? join(process.cwd(), "packages/libs/contracts/src/generated");
+		this.filenameTemplate = options.filenameTemplate ?? ((suggestion) => `${suggestion.target?.name ?? suggestion.intent.id}.v${suggestion.target?.version ?? "next"}.suggestion.json`);
+	}
+	async write(suggestion) {
+		await mkdir(this.outputDir, { recursive: true });
+		const filename = this.filenameTemplate(suggestion);
+		const filepath = join(this.outputDir, filename);
+		const payload = serializeSuggestion(suggestion);
+		await writeFile(filepath, JSON.stringify(payload, null, 2));
+		return filepath;
+	}
+};
+var InMemorySpecSuggestionRepository = class {
+	items = /* @__PURE__ */ new Map();
+	async create(suggestion) {
+		this.items.set(suggestion.id, suggestion);
+	}
+	async getById(id) {
+		return this.items.get(id);
+	}
+	async updateStatus(id, status, metadata) {
+		const suggestion = await this.getById(id);
+		if (!suggestion) return;
+		this.items.set(id, {
+			...suggestion,
+			status,
+			approvals: {
+				reviewer: metadata?.reviewer,
+				notes: metadata?.notes,
+				decidedAt: metadata?.decidedAt,
+				status
+			}
+		});
+	}
+	async list(filters) {
+		const values = [...this.items.values()];
+		if (!filters) return values;
+		return values.filter((item) => {
+			if (filters.status && item.status !== filters.status) return false;
+			if (filters.operationName && item.target?.name !== filters.operationName) return false;
+			return true;
+		});
+	}
+};
+function serializeSuggestion(suggestion) {
+	const { proposal, ...rest } = suggestion;
+	const { spec, ...proposalRest } = proposal;
+	return {
+		...rest,
+		proposal: {
+			...proposalRest,
+			specMeta: spec?.meta
+		},
+		createdAt: suggestion.createdAt.toISOString(),
+		intent: {
+			...suggestion.intent,
+			confidence: { ...suggestion.intent.confidence },
+			evidence: suggestion.intent.evidence
+		}
+	};
+}
+
+//#endregion
+export { FileSystemSuggestionWriter, InMemorySpecSuggestionRepository, SpecSuggestionOrchestrator };

package/dist/generator/ai-spec-generator.js

@@ -1,19 +1,185 @@
-import{randomUUID as e}from"node:crypto";import{Output as t,generateText as n}from"ai";import*as r from"zod";const i=r.object({summary:r.string().describe(`Brief summary of the proposed change`),rationale:r.string().describe(`Detailed explanation of why this change is needed`),changeType:r.enum([`new-spec`,`revision`,`policy-update`,`schema-update`]).describe(`Type of change being proposed`),recommendedActions:r.array(r.string()).describe(`List of specific actions to implement the change`),estimatedImpact:r.enum([`low`,`medium`,`high`]).describe(`Estimated impact of implementing this change`),riskLevel:r.enum([`low`,`medium`,`high`]).describe(`Risk level associated with this change`),diff:r.string().optional().describe(`Optional diff or code snippet showing the change`)});var a=class{model;config;systemPrompt;constructor(e){this.model=e.model,this.config=e.evolutionConfig??{},this.systemPrompt=e.systemPrompt??`You are a ContractSpec evolution expert. Your role is to analyze telemetry data, anomalies, and usage patterns to suggest improvements to API contracts and specifications.
+import { randomUUID } from "node:crypto";
+import { Output, generateText } from "ai";
+import * as z from "zod";
+
+//#region src/generator/ai-spec-generator.ts
+/**
+* Zod schema for AI-generated spec suggestions.
+*/
+const SpecSuggestionProposalSchema = z.object({
+	summary: z.string().describe("Brief summary of the proposed change"),
+	rationale: z.string().describe("Detailed explanation of why this change is needed"),
+	changeType: z.enum([
+		"new-spec",
+		"revision",
+		"policy-update",
+		"schema-update"
+	]).describe("Type of change being proposed"),
+	recommendedActions: z.array(z.string()).describe("List of specific actions to implement the change"),
+	estimatedImpact: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).describe("Estimated impact of implementing this change"),
+	riskLevel: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).describe("Risk level associated with this change"),
+	diff: z.string().optional().describe("Optional diff or code snippet showing the change")
+});
+/**
+* AI-powered spec generator using AI SDK v6.
+*
+* Uses structured output (Output.object) to generate
+* well-formed spec suggestions from intent patterns.
+*/
+var AISpecGenerator = class {
+	model;
+	config;
+	systemPrompt;
+	constructor(options) {
+		this.model = options.model;
+		this.config = options.evolutionConfig ?? {};
+		this.systemPrompt = options.systemPrompt ?? `You are a ContractSpec evolution expert. Your role is to analyze telemetry data, anomalies, and usage patterns to suggest improvements to API contracts and specifications.
 
 When generating suggestions:
 1. Be specific and actionable
 2. Consider backwards compatibility
 3. Prioritize stability and reliability
 4. Explain the rationale clearly
-5. Estimate impact and risk accurately`}async generateFromIntent(e,r={}){let a=this.buildPrompt(e,r),{output:o}=await n({model:this.model,system:this.systemPrompt,prompt:a,output:t.object({schema:i})});return this.buildSuggestion(e,o)}async generateBatch(e,t={}){let n=t.maxConcurrent??3,r=[];for(let t=0;t<e.length;t+=n){let i=e.slice(t,t+n),a=await Promise.all(i.map(e=>this.generateFromIntent(e)));r.push(...a)}return r}async enhanceSuggestion(e){let r=`Review and enhance this spec suggestion:
+5. Estimate impact and risk accurately`;
+	}
+	/**
+	* Generate a spec suggestion from an intent pattern using AI.
+	*/
+	async generateFromIntent(intent, options = {}) {
+		const prompt = this.buildPrompt(intent, options);
+		const { output } = await generateText({
+			model: this.model,
+			system: this.systemPrompt,
+			prompt,
+			output: Output.object({ schema: SpecSuggestionProposalSchema })
+		});
+		return this.buildSuggestion(intent, output);
+	}
+	/**
+	* Generate multiple suggestions for a batch of intents.
+	*/
+	async generateBatch(intents, options = {}) {
+		const maxConcurrent = options.maxConcurrent ?? 3;
+		const results = [];
+		for (let i = 0; i < intents.length; i += maxConcurrent) {
+			const batch = intents.slice(i, i + maxConcurrent);
+			const batchResults = await Promise.all(batch.map((intent) => this.generateFromIntent(intent)));
+			results.push(...batchResults);
+		}
+		return results;
+	}
+	/**
+	* Validate and enhance an existing suggestion using AI.
+	*/
+	async enhanceSuggestion(suggestion) {
+		const prompt = `Review and enhance this spec suggestion:
 
-Intent: ${e.intent.type} - ${e.intent.description}
-Current Summary: ${e.proposal.summary}
-Current Rationale: ${e.proposal.rationale}
+Intent: ${suggestion.intent.type} - ${suggestion.intent.description}
+Current Summary: ${suggestion.proposal.summary}
+Current Rationale: ${suggestion.proposal.rationale}
 
 Evidence:
-${e.evidence.map(e=>`- ${e.type}: ${e.description}`).join(`
-`)}
+${suggestion.evidence.map((e) => `- ${e.type}: ${e.description}`).join("\n")}
+
+Please provide an improved version with more specific recommendations.`;
+		const { output } = await generateText({
+			model: this.model,
+			system: this.systemPrompt,
+			prompt,
+			output: Output.object({ schema: SpecSuggestionProposalSchema })
+		});
+		return {
+			...suggestion,
+			proposal: {
+				...suggestion.proposal,
+				summary: output.summary,
+				rationale: output.rationale,
+				changeType: output.changeType,
+				diff: output.diff,
+				metadata: {
+					...suggestion.proposal.metadata,
+					aiEnhanced: true,
+					recommendedActions: output.recommendedActions,
+					estimatedImpact: output.estimatedImpact,
+					riskLevel: output.riskLevel
+				}
+			}
+		};
+	}
+	buildPrompt(intent, options) {
+		const parts = [
+			`Analyze this intent pattern and generate a spec suggestion:`,
+			``,
+			`Intent Type: ${intent.type}`,
+			`Description: ${intent.description}`,
+			`Confidence: ${(intent.confidence.score * 100).toFixed(0)}% (sample size: ${intent.confidence.sampleSize})`
+		];
+		if (intent.operation) parts.push(`Operation: ${intent.operation.name} v${intent.operation.version}`);
+		if (intent.evidence.length > 0) {
+			parts.push(``, `Evidence:`);
+			for (const evidence of intent.evidence) parts.push(`- [${evidence.type}] ${evidence.description}`);
+		}
+		if (intent.metadata) parts.push(``, `Metadata: ${JSON.stringify(intent.metadata, null, 2)}`);
+		if (options.existingSpec) parts.push(``, `Existing Spec:`, "```json", JSON.stringify(options.existingSpec, null, 2), "```");
+		if (options.additionalContext) parts.push(``, `Additional Context:`, options.additionalContext);
+		return parts.join("\n");
+	}
+	buildSuggestion(intent, aiOutput) {
+		const now = /* @__PURE__ */ new Date();
+		const proposal = {
+			summary: aiOutput.summary,
+			rationale: aiOutput.rationale,
+			changeType: aiOutput.changeType,
+			diff: aiOutput.diff,
+			metadata: {
+				aiGenerated: true,
+				recommendedActions: aiOutput.recommendedActions,
+				estimatedImpact: aiOutput.estimatedImpact,
+				riskLevel: aiOutput.riskLevel
+			}
+		};
+		return {
+			id: randomUUID(),
+			intent,
+			target: intent.operation,
+			proposal,
+			confidence: intent.confidence.score,
+			priority: this.calculatePriority(intent, aiOutput),
+			createdAt: now,
+			createdBy: "ai-spec-generator",
+			status: this.determineInitialStatus(intent),
+			evidence: intent.evidence,
+			tags: ["ai-generated", intent.type]
+		};
+	}
+	calculatePriority(intent, aiOutput) {
+		const impactScore = aiOutput.estimatedImpact === "high" ? 1 : aiOutput.estimatedImpact === "medium" ? .5 : .25;
+		const intentScore = intent.confidence.score;
+		const urgency = intent.type === "error-spike" ? .3 : intent.type === "latency-regression" ? .2 : 0;
+		const combined = impactScore * .4 + intentScore * .4 + urgency;
+		if (combined >= .7) return "high";
+		if (combined >= .4) return "medium";
+		return "low";
+	}
+	determineInitialStatus(intent) {
+		if (this.config.autoApproveThreshold && intent.confidence.score >= this.config.autoApproveThreshold && !this.config.requireApproval) return "approved";
+		return "pending";
+	}
+};
+/**
+* Create an AI-powered spec generator.
+*/
+function createAISpecGenerator(config) {
+	return new AISpecGenerator(config);
+}
 
-Please provide an improved version with more specific recommendations.`,{output:a}=await n({model:this.model,system:this.systemPrompt,prompt:r,output:t.object({schema:i})});return{...e,proposal:{...e.proposal,summary:a.summary,rationale:a.rationale,changeType:a.changeType,diff:a.diff,metadata:{...e.proposal.metadata,aiEnhanced:!0,recommendedActions:a.recommendedActions,estimatedImpact:a.estimatedImpact,riskLevel:a.riskLevel}}}}buildPrompt(e,t){let n=[`Analyze this intent pattern and generate a spec suggestion:`,``,`Intent Type: ${e.type}`,`Description: ${e.description}`,`Confidence: ${(e.confidence.score*100).toFixed(0)}% (sample size: ${e.confidence.sampleSize})`];if(e.operation&&n.push(`Operation: ${e.operation.name} v${e.operation.version}`),e.evidence.length>0){n.push(``,`Evidence:`);for(let t of e.evidence)n.push(`- [${t.type}] ${t.description}`)}return e.metadata&&n.push(``,`Metadata: ${JSON.stringify(e.metadata,null,2)}`),t.existingSpec&&n.push(``,`Existing Spec:`,"```json",JSON.stringify(t.existingSpec,null,2),"```"),t.additionalContext&&n.push(``,`Additional Context:`,t.additionalContext),n.join(`
-`)}buildSuggestion(t,n){let r=new Date,i={summary:n.summary,rationale:n.rationale,changeType:n.changeType,diff:n.diff,metadata:{aiGenerated:!0,recommendedActions:n.recommendedActions,estimatedImpact:n.estimatedImpact,riskLevel:n.riskLevel}};return{id:e(),intent:t,target:t.operation,proposal:i,confidence:t.confidence.score,priority:this.calculatePriority(t,n),createdAt:r,createdBy:`ai-spec-generator`,status:this.determineInitialStatus(t),evidence:t.evidence,tags:[`ai-generated`,t.type]}}calculatePriority(e,t){let n=t.estimatedImpact===`high`?1:t.estimatedImpact===`medium`?.5:.25,r=e.confidence.score,i=e.type===`error-spike`?.3:e.type===`latency-regression`?.2:0,a=n*.4+r*.4+i;return a>=.7?`high`:a>=.4?`medium`:`low`}determineInitialStatus(e){return this.config.autoApproveThreshold&&e.confidence.score>=this.config.autoApproveThreshold&&!this.config.requireApproval?`approved`:`pending`}};function o(e){return new a(e)}export{a as AISpecGenerator,o as createAISpecGenerator};
+//#endregion
+export { AISpecGenerator, createAISpecGenerator };

package/dist/generator/spec-generator.d.ts

@@ -1,7 +1,7 @@
 import { EvolutionConfig, IntentPattern, OperationCoordinate, SpecSuggestion, SpecSuggestionProposal, SuggestionStatus } from "../types.js";
-import { Logger } from "@lssm/lib.observability";
 import { ContractSpec, ResourceRefDescriptor } from "@lssm/lib.contracts";
 import { AnySchemaModel } from "@lssm/lib.schema";
+import { Logger } from "@lssm/lib.observability";
 
 //#region src/generator/spec-generator.d.ts
 type AnyContract = ContractSpec<AnySchemaModel, AnySchemaModel | ResourceRefDescriptor<boolean>>;

package/dist/generator/spec-generator.js

@@ -1 +1,120 @@
-import{Logger as e}from"@lssm/lib.observability";import{randomUUID as t}from"node:crypto";var n=class{config;logger;clock;getSpec;constructor(e={}){this.config=e.config??{},this.logger=e.logger,this.clock=e.clock??(()=>new Date),this.getSpec=e.getSpec}generateFromIntent(e,n={}){let r=this.clock(),i=n.summary??`${this.intentToVerb(e.type)} ${e.operation?.name??`operation`}`,a=n.rationale??[e.description,e.metadata?.observedValue?`Observed ${e.metadata.observedValue}`:void 0].filter(Boolean).join(` — `);return{id:t(),intent:e,target:e.operation,proposal:{summary:i,rationale:a,changeType:n.changeType??this.inferChangeType(e),kind:n.kind,spec:n.spec,diff:n.diff,metadata:n.metadata},confidence:e.confidence.score,priority:this.intentToPriority(e),createdAt:r,createdBy:n.createdBy??`auto-evolution`,status:n.status??`pending`,evidence:e.evidence,tags:n.tags}}generateVariant(e,t,n,i={}){if(!this.getSpec)throw Error(`SpecGenerator requires getSpec() to generate variants`);let a=this.getSpec(e.name,e.version);if(!a)throw Error(`Cannot generate variant; spec ${e.name}.v${e.version} not found`);let o=r(a,t);return this.generateFromIntent(n,{...i,spec:o})}validateSuggestion(e,t=this.config){let n=[];t.minConfidence!=null&&e.confidence<t.minConfidence&&n.push(`Confidence ${e.confidence.toFixed(2)} below minimum ${t.minConfidence}`),t.requireApproval&&e.status===`approved`&&n.push(`Suggestion cannot be auto-approved when approval is required`),e.proposal.spec&&!e.proposal.spec.meta?.name&&n.push(`Proposal spec must include meta.name`),e.proposal.summary||n.push(`Proposal summary is required`);let r=n.length===0;return r||this.logger?.warn(`SpecGenerator.validateSuggestion.failed`,{suggestionId:e.id,reasons:n}),{ok:r,reasons:n}}intentToVerb(e){switch(e){case`error-spike`:return`Stabilize`;case`latency-regression`:return`Optimize`;case`missing-operation`:return`Introduce`;case`throughput-drop`:return`Rebalance`;default:return`Adjust`}}intentToPriority(e){let t=e.confidence.score;return e.type===`error-spike`||t>=.8?`high`:t>=.5?`medium`:`low`}inferChangeType(e){switch(e.type){case`missing-operation`:return`new-spec`;case`schema-mismatch`:return`schema-update`;case`error-spike`:return`policy-update`;default:return`revision`}}};function r(e,t){return{...e,...t,meta:{...e.meta,...t.meta},io:{...e.io,...t.io},policy:{...e.policy,...t.policy},telemetry:{...e.telemetry,...t.telemetry},sideEffects:{...e.sideEffects,...t.sideEffects}}}export{n as SpecGenerator};
+import "../observability/dist/index.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/generator/spec-generator.ts
+var SpecGenerator = class {
+	config;
+	logger;
+	clock;
+	getSpec;
+	constructor(options = {}) {
+		this.config = options.config ?? {};
+		this.logger = options.logger;
+		this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+		this.getSpec = options.getSpec;
+	}
+	generateFromIntent(intent, options = {}) {
+		const now = this.clock();
+		const summary = options.summary ?? `${this.intentToVerb(intent.type)} ${intent.operation?.name ?? "operation"}`;
+		const rationale = options.rationale ?? [intent.description, intent.metadata?.observedValue ? `Observed ${intent.metadata.observedValue}` : void 0].filter(Boolean).join(" — ");
+		return {
+			id: randomUUID(),
+			intent,
+			target: intent.operation,
+			proposal: {
+				summary,
+				rationale,
+				changeType: options.changeType ?? this.inferChangeType(intent),
+				kind: options.kind,
+				spec: options.spec,
+				diff: options.diff,
+				metadata: options.metadata
+			},
+			confidence: intent.confidence.score,
+			priority: this.intentToPriority(intent),
+			createdAt: now,
+			createdBy: options.createdBy ?? "auto-evolution",
+			status: options.status ?? "pending",
+			evidence: intent.evidence,
+			tags: options.tags
+		};
+	}
+	generateVariant(operation, patch, intent, options = {}) {
+		if (!this.getSpec) throw new Error("SpecGenerator requires getSpec() to generate variants");
+		const base = this.getSpec(operation.name, operation.version);
+		if (!base) throw new Error(`Cannot generate variant; spec ${operation.name}.v${operation.version} not found`);
+		const merged = mergeContract(base, patch);
+		return this.generateFromIntent(intent, {
+			...options,
+			spec: merged
+		});
+	}
+	validateSuggestion(suggestion, config = this.config) {
+		const reasons = [];
+		if (config.minConfidence != null && suggestion.confidence < config.minConfidence) reasons.push(`Confidence ${suggestion.confidence.toFixed(2)} below minimum ${config.minConfidence}`);
+		if (config.requireApproval && suggestion.status === "approved") reasons.push("Suggestion cannot be auto-approved when approval is required");
+		if (suggestion.proposal.spec && !suggestion.proposal.spec.meta?.name) reasons.push("Proposal spec must include meta.name");
+		if (!suggestion.proposal.summary) reasons.push("Proposal summary is required");
+		const ok = reasons.length === 0;
+		if (!ok) this.logger?.warn("SpecGenerator.validateSuggestion.failed", {
+			suggestionId: suggestion.id,
+			reasons
+		});
+		return {
+			ok,
+			reasons
+		};
+	}
+	intentToVerb(intent) {
+		switch (intent) {
+			case "error-spike": return "Stabilize";
+			case "latency-regression": return "Optimize";
+			case "missing-operation": return "Introduce";
+			case "throughput-drop": return "Rebalance";
+			default: return "Adjust";
+		}
+	}
+	intentToPriority(intent) {
+		const severity = intent.confidence.score;
+		if (intent.type === "error-spike" || severity >= .8) return "high";
+		if (severity >= .5) return "medium";
+		return "low";
+	}
+	inferChangeType(intent) {
+		switch (intent.type) {
+			case "missing-operation": return "new-spec";
+			case "schema-mismatch": return "schema-update";
+			case "error-spike": return "policy-update";
+			default: return "revision";
+		}
+	}
+};
+function mergeContract(base, patch) {
+	return {
+		...base,
+		...patch,
+		meta: {
+			...base.meta,
+			...patch.meta
+		},
+		io: {
+			...base.io,
+			...patch.io
+		},
+		policy: {
+			...base.policy,
+			...patch.policy
+		},
+		telemetry: {
+			...base.telemetry,
+			...patch.telemetry
+		},
+		sideEffects: {
+			...base.sideEffects,
+			...patch.sideEffects
+		}
+	};
+}
+
+//#endregion
+export { SpecGenerator };

package/dist/index.js

@@ -1 +1,6 @@
-import{SpecAnalyzer as e}from"./analyzer/spec-analyzer.js";import{SpecGenerator as t}from"./generator/spec-generator.js";import{AISpecGenerator as n,createAISpecGenerator as r}from"./generator/ai-spec-generator.js";import{FileSystemSuggestionWriter as i,InMemorySpecSuggestionRepository as a,SpecSuggestionOrchestrator as o}from"./approval/integration.js";export{n as AISpecGenerator,i as FileSystemSuggestionWriter,a as InMemorySpecSuggestionRepository,e as SpecAnalyzer,t as SpecGenerator,o as SpecSuggestionOrchestrator,r as createAISpecGenerator};
+import { SpecAnalyzer } from "./analyzer/spec-analyzer.js";
+import { SpecGenerator } from "./generator/spec-generator.js";
+import { AISpecGenerator, createAISpecGenerator } from "./generator/ai-spec-generator.js";
+import { FileSystemSuggestionWriter, InMemorySpecSuggestionRepository, SpecSuggestionOrchestrator } from "./approval/integration.js";
+
+export { AISpecGenerator, FileSystemSuggestionWriter, InMemorySpecSuggestionRepository, SpecAnalyzer, SpecGenerator, SpecSuggestionOrchestrator, createAISpecGenerator };

package/dist/lifecycle/dist/index.js

@@ -0,0 +1,4 @@
+import { LifecycleStage } from "./types/stages.js";
+import "./types/signals.js";
+import "./types/milestones.js";
+import "./utils/formatters.js";

package/dist/lifecycle/dist/types/milestones.js

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

package/dist/lifecycle/dist/types/signals.js

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

package/dist/lifecycle/dist/types/stages.js

@@ -0,0 +1,151 @@
+//#region ../lifecycle/dist/types/stages.js
+let LifecycleStage = /* @__PURE__ */ function(LifecycleStage$1) {
+	LifecycleStage$1[LifecycleStage$1["Exploration"] = 0] = "Exploration";
+	LifecycleStage$1[LifecycleStage$1["ProblemSolutionFit"] = 1] = "ProblemSolutionFit";
+	LifecycleStage$1[LifecycleStage$1["MvpEarlyTraction"] = 2] = "MvpEarlyTraction";
+	LifecycleStage$1[LifecycleStage$1["ProductMarketFit"] = 3] = "ProductMarketFit";
+	LifecycleStage$1[LifecycleStage$1["GrowthScaleUp"] = 4] = "GrowthScaleUp";
+	LifecycleStage$1[LifecycleStage$1["ExpansionPlatform"] = 5] = "ExpansionPlatform";
+	LifecycleStage$1[LifecycleStage$1["MaturityRenewal"] = 6] = "MaturityRenewal";
+	return LifecycleStage$1;
+}({});
+const LIFECYCLE_STAGE_ORDER = [
+	LifecycleStage.Exploration,
+	LifecycleStage.ProblemSolutionFit,
+	LifecycleStage.MvpEarlyTraction,
+	LifecycleStage.ProductMarketFit,
+	LifecycleStage.GrowthScaleUp,
+	LifecycleStage.ExpansionPlatform,
+	LifecycleStage.MaturityRenewal
+];
+const LIFECYCLE_STAGE_META = {
+	[LifecycleStage.Exploration]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ProblemSolutionFit]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.MvpEarlyTraction]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ProductMarketFit]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.GrowthScaleUp]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ExpansionPlatform]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.MaturityRenewal]: {
+		id: LifecycleStage.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"
+		]
+	}
+};
+
+//#endregion
+export { LifecycleStage };

package/dist/lifecycle/dist/utils/formatters.js

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

package/dist/observability/dist/index.js

@@ -0,0 +1,8 @@
+import "./tracing/index.js";
+import { createCounter, createHistogram, getMeter } from "./metrics/index.js";
+import { Logger } from "./logging/index.js";
+import "./tracing/middleware.js";
+import "./intent/aggregator.js";
+import "./intent/detector.js";
+import "./pipeline/evolution-pipeline.js";
+import "./pipeline/lifecycle-pipeline.js";

package/dist/observability/dist/intent/aggregator.js

@@ -0,0 +1,4 @@
+//#region ../observability/dist/intent/aggregator.mjs
+const DEFAULT_WINDOW_MS = 900 * 1e3;
+
+//#endregion

package/dist/observability/dist/intent/detector.js

@@ -0,0 +1 @@
+import { randomUUID } from "node:crypto";

package/dist/observability/dist/lifecycle/dist/index.js

@@ -0,0 +1,4 @@
+import "./types/stages.js";
+import "./utils/formatters.js";
+import "./types/signals.js";
+import "./types/milestones.js";

package/dist/observability/dist/lifecycle/dist/types/milestones.js

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

package/dist/observability/dist/lifecycle/dist/types/signals.js

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

package/dist/observability/dist/lifecycle/dist/types/stages.js

@@ -0,0 +1,142 @@
+//#region ../observability/dist/lifecycle/dist/types/stages.mjs
+let LifecycleStage = /* @__PURE__ */ function(LifecycleStage$1) {
+	LifecycleStage$1[LifecycleStage$1["Exploration"] = 0] = "Exploration";
+	LifecycleStage$1[LifecycleStage$1["ProblemSolutionFit"] = 1] = "ProblemSolutionFit";
+	LifecycleStage$1[LifecycleStage$1["MvpEarlyTraction"] = 2] = "MvpEarlyTraction";
+	LifecycleStage$1[LifecycleStage$1["ProductMarketFit"] = 3] = "ProductMarketFit";
+	LifecycleStage$1[LifecycleStage$1["GrowthScaleUp"] = 4] = "GrowthScaleUp";
+	LifecycleStage$1[LifecycleStage$1["ExpansionPlatform"] = 5] = "ExpansionPlatform";
+	LifecycleStage$1[LifecycleStage$1["MaturityRenewal"] = 6] = "MaturityRenewal";
+	return LifecycleStage$1;
+}({});
+LifecycleStage.Exploration, LifecycleStage.ProblemSolutionFit, LifecycleStage.MvpEarlyTraction, LifecycleStage.ProductMarketFit, LifecycleStage.GrowthScaleUp, LifecycleStage.ExpansionPlatform, LifecycleStage.MaturityRenewal;
+const LIFECYCLE_STAGE_META = {
+	[LifecycleStage.Exploration]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ProblemSolutionFit]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.MvpEarlyTraction]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ProductMarketFit]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.GrowthScaleUp]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.ExpansionPlatform]: {
+		id: LifecycleStage.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"
+		]
+	},
+	[LifecycleStage.MaturityRenewal]: {
+		id: LifecycleStage.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"
+		]
+	}
+};
+
+//#endregion

package/dist/observability/dist/lifecycle/dist/utils/formatters.js

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

package/dist/observability/dist/logging/index.js

@@ -0,0 +1,39 @@
+import { context, trace } from "@opentelemetry/api";
+
+//#region ../observability/dist/logging/index.mjs
+var Logger = class {
+	constructor(serviceName) {
+		this.serviceName = serviceName;
+	}
+	log(level, message, meta = {}) {
+		const span = trace.getSpan(context.active());
+		const traceId = span?.spanContext().traceId;
+		const spanId = span?.spanContext().spanId;
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			service: this.serviceName,
+			level,
+			message,
+			traceId,
+			spanId,
+			...meta
+		};
+		console.log(JSON.stringify(entry));
+	}
+	debug(message, meta) {
+		this.log("debug", message, meta);
+	}
+	info(message, meta) {
+		this.log("info", message, meta);
+	}
+	warn(message, meta) {
+		this.log("warn", message, meta);
+	}
+	error(message, meta) {
+		this.log("error", message, meta);
+	}
+};
+const logger = new Logger(process.env.OTEL_SERVICE_NAME || "unknown-service");
+
+//#endregion
+export { Logger };

package/dist/observability/dist/metrics/index.js

@@ -0,0 +1,22 @@
+import { metrics } from "@opentelemetry/api";
+
+//#region ../observability/dist/metrics/index.mjs
+const DEFAULT_METER_NAME = "@lssm/lib.observability";
+function getMeter(name = DEFAULT_METER_NAME) {
+	return metrics.getMeter(name);
+}
+function createCounter(name, description, meterName) {
+	return getMeter(meterName).createCounter(name, { description });
+}
+function createHistogram(name, description, meterName) {
+	return getMeter(meterName).createHistogram(name, { description });
+}
+const standardMetrics = {
+	httpRequests: createCounter("http_requests_total", "Total HTTP requests"),
+	httpDuration: createHistogram("http_request_duration_seconds", "HTTP request duration"),
+	operationErrors: createCounter("operation_errors_total", "Total operation errors"),
+	workflowDuration: createHistogram("workflow_duration_seconds", "Workflow execution duration")
+};
+
+//#endregion
+export { createCounter, createHistogram, getMeter };

package/dist/observability/dist/pipeline/evolution-pipeline.js

@@ -0,0 +1,3 @@
+import "../intent/aggregator.js";
+import "../intent/detector.js";
+import "node:events";

package/dist/observability/dist/pipeline/lifecycle-pipeline.js

@@ -0,0 +1,4 @@
+import "../metrics/index.js";
+import "../lifecycle/dist/utils/formatters.js";
+import "../lifecycle/dist/index.js";
+import "node:events";

package/dist/observability/dist/tracing/index.js

@@ -0,0 +1 @@
+import { trace } from "@opentelemetry/api";

package/dist/observability/dist/tracing/middleware.js

@@ -0,0 +1,2 @@
+import "./index.js";
+import "../metrics/index.js";

package/dist/types.d.ts

@@ -1,6 +1,6 @@
-import { LifecycleStage } from "@lssm/lib.lifecycle";
 import { ContractSpec, OpKind, ResourceRefDescriptor } from "@lssm/lib.contracts";
 import { AnySchemaModel } from "@lssm/lib.schema";
+import { LifecycleStage } from "@lssm/lib.lifecycle";
 
 //#region src/types.d.ts
 type AnomalySeverity = 'low' | 'medium' | 'high';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.evolution",
-  "version": "0.0.0-canary-20251217060834",
+  "version": "0.0.0-canary-20251217072406",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -25,18 +25,18 @@
   "dependencies": {
     "ai": "beta",
     "zod": "^4.1.13",
-    "@lssm/lib.ai-agent": "0.0.0-canary-20251217060834",
-    "@lssm/lib.contracts": "0.0.0-canary-20251217060834",
-    "@lssm/lib.lifecycle": "0.0.0-canary-20251217060834",
-    "@lssm/lib.observability": "0.0.0-canary-20251217060834",
-    "@lssm/lib.schema": "0.0.0-canary-20251217060834"
+    "@lssm/lib.ai-agent": "0.0.0-canary-20251217072406",
+    "@lssm/lib.contracts": "0.0.0-canary-20251217072406",
+    "@lssm/lib.lifecycle": "0.0.0-canary-20251217072406",
+    "@lssm/lib.observability": "0.0.0-canary-20251217072406",
+    "@lssm/lib.schema": "0.0.0-canary-20251217072406"
   },
   "peerDependencies": {
     "@prisma/client": "7.1.0"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217060834",
-    "@lssm/tool.typescript": "0.0.0-canary-20251217060834",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217072406",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217072406",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },