@skastr0/pulsar-core 0.1.0

package/dist/time-series-dates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-dates.js","sourceRoot":"","sources":["../src/time-series-dates.ts"],"names":[],"mappings":"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"}

package/dist/time-series-metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Category } from "./category.js";
+import type { ObserverOutput, toObserverJson } from "./observer.js";
+import type { WeightedEntry } from "./time-series-compaction-types.js";
+export declare const aggregateCategoryMetadata: (weightedEntries: ReadonlyArray<WeightedEntry>, category: Category, totalWeight: number) => Partial<ReturnType<typeof toObserverJson>["categories"][Category]>;
+export declare const aggregateSignalMetadata: (weightedEntries: ReadonlyArray<WeightedEntry>) => ObserverOutput["signal_metadata"] | undefined;
+//# sourceMappingURL=time-series-metadata.d.ts.map

package/dist/time-series-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-metadata.d.ts","sourceRoot":"","sources":["../src/time-series-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAEtE,eAAO,MAAM,yBAAyB,GACpC,iBAAiB,aAAa,CAAC,aAAa,CAAC,EAC7C,UAAU,QAAQ,EAClB,aAAa,MAAM,KAClB,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,CAiCnE,CAAA;AAED,eAAO,MAAM,uBAAuB,GAClC,iBAAiB,aAAa,CAAC,aAAa,CAAC,KAC5C,cAAc,CAAC,iBAAiB,CAAC,GAAG,SA8CtC,CAAA"}

package/dist/time-series-metadata.js

@@ -0,0 +1,72 @@
+export const aggregateCategoryMetadata = (weightedEntries, category, totalWeight) => {
+    const snapshots = weightedEntries.map(({ entry }) => entry.observerOutput.categories[category]);
+    const withSignalCount = snapshots.every((snapshot) => snapshot.signalCount !== undefined);
+    const withApplicableSignalCount = snapshots.every((snapshot) => snapshot.applicableSignalCount !== undefined);
+    const withActiveSignalIds = snapshots.every((snapshot) => snapshot.activeSignalIds !== undefined);
+    return {
+        ...(withSignalCount
+            ? {
+                signalCount: weightedEntries.reduce((sum, { entry, weight }) => sum + (entry.observerOutput.categories[category].signalCount ?? 0) * weight, 0) / totalWeight,
+            }
+            : {}),
+        ...(withApplicableSignalCount
+            ? {
+                applicableSignalCount: weightedEntries.reduce((sum, { entry, weight }) => sum + (entry.observerOutput.categories[category].applicableSignalCount ?? 0) * weight, 0) / totalWeight,
+            }
+            : {}),
+        ...(withActiveSignalIds
+            ? {
+                activeSignalIds: [...new Set(snapshots.flatMap((snapshot) => snapshot.activeSignalIds ?? []))].sort(),
+            }
+            : {}),
+    };
+};
+export const aggregateSignalMetadata = (weightedEntries) => {
+    if (weightedEntries.length === 0 ||
+        weightedEntries.some(({ entry }) => entry.observerOutput.signal_metadata === undefined)) {
+        return undefined;
+    }
+    const signalIds = [
+        ...new Set(weightedEntries.flatMap(({ entry }) => Object.keys(entry.observerOutput.signal_metadata ?? {}))),
+    ].sort();
+    return Object.fromEntries(signalIds.map((signalId) => {
+        const metadata = weightedEntries.flatMap(({ entry, weight }) => {
+            const item = entry.observerOutput.signal_metadata?.[signalId];
+            return item === undefined ? [] : [{ item, weight }];
+        });
+        const hasMetadataForEverySource = metadata.length === weightedEntries.length;
+        const applicabilityValues = new Set(metadata.map(({ item }) => item.applicability).filter((value) => value !== undefined));
+        const computedAt = metadata
+            .map(({ item }) => item.computedAt)
+            .filter((value) => value !== undefined)
+            .sort()
+            .at(-1);
+        const effectiveConfidence = averageOptional(metadata, ({ item }) => item.effectiveConfidence);
+        const baseConfidence = averageOptional(metadata, ({ item }) => item.baseConfidence);
+        return [
+            signalId,
+            {
+                ...(effectiveConfidence !== undefined ? { effectiveConfidence } : {}),
+                ...(baseConfidence !== undefined ? { baseConfidence } : {}),
+                ...(computedAt !== undefined ? { computedAt } : {}),
+                ...(metadata.some(({ item }) => item.stale === true) ? { stale: true } : {}),
+                ...(hasMetadataForEverySource && applicabilityValues.size === 1
+                    ? { applicability: [...applicabilityValues][0] }
+                    : {}),
+            },
+        ];
+    }));
+};
+const averageOptional = (entries, value) => {
+    let total = 0;
+    let weight = 0;
+    for (const entry of entries) {
+        const item = value(entry);
+        if (item === undefined)
+            continue;
+        total += item * entry.weight;
+        weight += entry.weight;
+    }
+    return weight === 0 ? undefined : total / weight;
+};
+//# sourceMappingURL=time-series-metadata.js.map

package/dist/time-series-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-metadata.js","sourceRoot":"","sources":["../src/time-series-metadata.ts"],"names":[],"mappings":"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"}

package/dist/time-series-model.d.ts

@@ -0,0 +1,419 @@
+import { Effect, Option, Schema } from "effect";
+import { type ObserverOutput } from "./observer.js";
+export declare const TIME_SERIES_DIRECTORY: "time-series";
+export declare const DEFAULT_TIME_SERIES_COMPACTION_THRESHOLD = 10000;
+export declare const DEFAULT_TIME_SERIES_RAW_RETENTION_DAYS = 90;
+declare const TimeSeriesReadFailed_base: Schema.TaggedErrorClass<TimeSeriesReadFailed, "TimeSeriesReadFailed", {
+    readonly _tag: Schema.tag<"TimeSeriesReadFailed">;
+} & {
+    repoPath: typeof Schema.String;
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class TimeSeriesReadFailed extends TimeSeriesReadFailed_base {
+}
+declare const TimeSeriesWriteFailed_base: Schema.TaggedErrorClass<TimeSeriesWriteFailed, "TimeSeriesWriteFailed", {
+    readonly _tag: Schema.tag<"TimeSeriesWriteFailed">;
+} & {
+    repoPath: typeof Schema.String;
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class TimeSeriesWriteFailed extends TimeSeriesWriteFailed_base {
+}
+declare const TimeSeriesLockFailed_base: Schema.TaggedErrorClass<TimeSeriesLockFailed, "TimeSeriesLockFailed", {
+    readonly _tag: Schema.tag<"TimeSeriesLockFailed">;
+} & {
+    repoPath: typeof Schema.String;
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class TimeSeriesLockFailed extends TimeSeriesLockFailed_base {
+}
+export type TimeSeriesError = TimeSeriesReadFailed | TimeSeriesWriteFailed | TimeSeriesLockFailed;
+export declare const TimeSeriesAggregate: Schema.Struct<{
+    kind: Schema.Literal<["weekly-average"]>;
+    from: typeof Schema.String;
+    to: typeof Schema.String;
+    sample_count: typeof Schema.Number;
+    commit_shas: Schema.Array$<typeof Schema.String>;
+    observer_semantics: Schema.optional<Schema.Literal<["readiness-aware", "legacy-compatibility"]>>;
+    readiness_sample_count: Schema.optional<typeof Schema.Number>;
+    compatibility_reason: Schema.optional<typeof Schema.String>;
+}>;
+export type TimeSeriesAggregate = typeof TimeSeriesAggregate.Type;
+declare const SignalDiagnostics: Schema.Record$<typeof Schema.String, Schema.Array$<Schema.Struct<{
+    severity: Schema.Literal<["info", "warn", "block"]>;
+    message: typeof Schema.String;
+    location: Schema.optional<Schema.Struct<{
+        file: typeof Schema.String;
+        line: Schema.optional<typeof Schema.Number>;
+        column: Schema.optional<typeof Schema.Number>;
+    }>>;
+    data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>>>;
+type SignalDiagnostics = typeof SignalDiagnostics.Type;
+export declare const TimeSeriesEntry: Schema.Struct<{
+    sha: typeof Schema.String;
+    timestamp: typeof Schema.String;
+    observerOutput: Schema.Struct<{
+        observer_semantics: Schema.optional<Schema.Literal<["applicability-aware-readiness-v1"]>>;
+        categories: Schema.Struct<{
+            "architectural-drift": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+            "dependency-entropy": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+            "abstraction-bloat": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+            "legibility-decay": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+            "generated-slop": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+            "review-pain": Schema.Struct<{
+                score: typeof Schema.Number;
+                signals: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                signalCount: Schema.optional<typeof Schema.Number>;
+                applicableSignalCount: Schema.optional<typeof Schema.Number>;
+                activeSignalIds: Schema.optional<Schema.Array$<typeof Schema.String>>;
+                aggregation: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Union<[Schema.Literal<["weighted-mean"]>, Schema.Literal<["language-group-mean"]>]>;
+                    rawScore: typeof Schema.Number;
+                    aggregateScore: typeof Schema.Number;
+                    lowestSignalScore: typeof Schema.Number;
+                    finalScore: typeof Schema.Number;
+                    shapedByPressure: typeof Schema.Boolean;
+                    pressure: Schema.Struct<{
+                        strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                        p: typeof Schema.Number;
+                        meanPressure: typeof Schema.Number;
+                        pnormPressure: typeof Schema.Number;
+                        maxLocalPressure: typeof Schema.Number;
+                        localPressure: typeof Schema.Number;
+                        finalPressure: typeof Schema.Number;
+                    }>;
+                    weightTotal: typeof Schema.Number;
+                    weights: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+                }>>;
+                normalization: Schema.optional<Schema.Struct<{
+                    strategy: Schema.Literal<["language-group-mean"]>;
+                    groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                        score: typeof Schema.Number;
+                        signals: Schema.Array$<typeof Schema.String>;
+                        signalCount: typeof Schema.Number;
+                    }>>;
+                }>>;
+            }>;
+        }>;
+        minimum: Schema.Union<[Schema.Struct<{
+            signal: typeof Schema.String;
+            category: Schema.Literal<["architectural-drift", "dependency-entropy", "abstraction-bloat", "legibility-decay", "generated-slop", "review-pain"]>;
+            score: typeof Schema.Number;
+            detail: typeof Schema.String;
+        }>, typeof Schema.Undefined]>;
+        weighted_mean: typeof Schema.Number;
+        readiness: Schema.optional<Schema.Struct<{
+            score: typeof Schema.Number;
+            pressure: typeof Schema.Number;
+            status: Schema.Union<[Schema.Literal<["green"]>, Schema.Literal<["yellow"]>, Schema.Literal<["red"]>, Schema.Literal<["blocked"]>, Schema.Literal<["unknown"]>, Schema.Literal<["failed"]>]>;
+            aggregation: Schema.Struct<{
+                strategy: Schema.Literal<["pressure-pnorm-local-max"]>;
+                p: typeof Schema.Number;
+                mean_pressure: typeof Schema.Number;
+                pnorm_pressure: typeof Schema.Number;
+                max_local_pressure: typeof Schema.Number;
+                failed_signal_pressure: Schema.optional<typeof Schema.Number>;
+                hard_gate_pressure: typeof Schema.Number;
+                hard_gate_score_cap: typeof Schema.Number;
+                local_warning_threshold: typeof Schema.Number;
+                local_poison_threshold: typeof Schema.Number;
+                local_warning_gain: typeof Schema.Number;
+                applicable_signal_count: typeof Schema.Number;
+                ignored_signal_count: typeof Schema.Number;
+                failed_signal_count: Schema.optional<typeof Schema.Number>;
+            }>;
+            top_pressures: Schema.Array$<Schema.Struct<{
+                signal_id: typeof Schema.String;
+                category: Schema.Literal<["architectural-drift", "dependency-entropy", "abstraction-bloat", "legibility-decay", "generated-slop", "review-pain"]>;
+                score: typeof Schema.Number;
+                raw_pressure: typeof Schema.Number;
+                effective_pressure: typeof Schema.Number;
+                weight: typeof Schema.Number;
+                confidence: typeof Schema.Number;
+                applicability: Schema.Union<[Schema.Literal<["applicable"]>, Schema.Literal<["not_applicable"]>, Schema.Literal<["insufficient_evidence"]>, Schema.Literal<["failed"]>]>;
+            }>>;
+        }>>;
+        hard_gate_status: Schema.Literal<["pass", "fail"]>;
+        hard_gate_violations: Schema.Array$<Schema.Struct<{
+            signalId: typeof Schema.String;
+            category: Schema.Literal<["architectural-drift", "dependency-entropy", "abstraction-bloat", "legibility-decay", "generated-slop", "review-pain"]>;
+            diagnostic: Schema.Struct<{
+                severity: Schema.Literal<["info", "warn", "block"]>;
+                message: typeof Schema.String;
+                location: Schema.optional<Schema.Struct<{
+                    file: typeof Schema.String;
+                    line: Schema.optional<typeof Schema.Number>;
+                    column: Schema.optional<typeof Schema.Number>;
+                }>>;
+                data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+            }>;
+        }>>;
+        signal_metadata: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+            effectiveConfidence: Schema.optional<typeof Schema.Number>;
+            baseConfidence: Schema.optional<typeof Schema.Number>;
+            computedAt: Schema.optional<typeof Schema.String>;
+            stale: Schema.optional<typeof Schema.Boolean>;
+            applicability: Schema.optional<Schema.Union<[Schema.Literal<["applicable"]>, Schema.Literal<["not_applicable"]>, Schema.Literal<["insufficient_evidence"]>, Schema.Literal<["failed"]>]>>;
+        }>>>;
+        runtime_profile: Schema.optional<Schema.Struct<{
+            total_ms: typeof Schema.Number;
+            stages: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+                duration_ms: typeof Schema.Number;
+            }>>>;
+            signals: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                duration_ms: typeof Schema.Number;
+                score: typeof Schema.Number;
+                diagnostics: typeof Schema.Number;
+            }>>;
+        }>>;
+        calibration: Schema.optional<Schema.Struct<{
+            fingerprint: typeof Schema.String;
+            active_modules: Schema.Array$<Schema.Struct<{
+                id: typeof Schema.String;
+                version: typeof Schema.String;
+                scope: Schema.Literal<["core", "language", "ecosystem", "technology", "framework", "organization", "repository"]>;
+                source: Schema.Literal<["builtin", "package", "workspace", "repo-local"]>;
+                source_ref: Schema.optional<typeof Schema.String>;
+                source_fingerprint: Schema.optional<typeof Schema.String>;
+                fingerprint: typeof Schema.String;
+            }>>;
+        }>>;
+        signal_factors: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<Schema.Struct<{
+            path: typeof Schema.String;
+            value: typeof Schema.Unknown;
+            source: Schema.Literal<["signal-default", "computed", "vector", "module"]>;
+            affectsScore: typeof Schema.Boolean;
+            title: Schema.optional<typeof Schema.String>;
+            scoreRole: Schema.optional<Schema.Literal<["evidence", "threshold", "penalty", "weight", "confidence", "score-cap", "metadata"]>>;
+            attribution: Schema.optional<typeof Schema.Unknown>;
+            mutations: Schema.optional<Schema.Array$<typeof Schema.Unknown>>;
+        }>>>>;
+    }>;
+    signalDiagnostics: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<Schema.Struct<{
+        severity: Schema.Literal<["info", "warn", "block"]>;
+        message: typeof Schema.String;
+        location: Schema.optional<Schema.Struct<{
+            file: typeof Schema.String;
+            line: Schema.optional<typeof Schema.Number>;
+            column: Schema.optional<typeof Schema.Number>;
+        }>>;
+        data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>>>>;
+    inactiveSignals: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    source: Schema.Literal<["raw", "weekly-average"]>;
+    aggregate: Schema.optional<Schema.Struct<{
+        kind: Schema.Literal<["weekly-average"]>;
+        from: typeof Schema.String;
+        to: typeof Schema.String;
+        sample_count: typeof Schema.Number;
+        commit_shas: Schema.Array$<typeof Schema.String>;
+        observer_semantics: Schema.optional<Schema.Literal<["readiness-aware", "legacy-compatibility"]>>;
+        readiness_sample_count: Schema.optional<typeof Schema.Number>;
+        compatibility_reason: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+export type TimeSeriesEntry = typeof TimeSeriesEntry.Type;
+export interface TimeSeriesRange {
+    readonly from?: string;
+    readonly to?: string;
+}
+export interface TimeSeriesReader {
+    readonly entries: (range?: TimeSeriesRange) => Effect.Effect<ReadonlyArray<TimeSeriesEntry>, TimeSeriesError>;
+    readonly latest: Effect.Effect<Option.Option<TimeSeriesEntry>, TimeSeriesError>;
+    readonly atSha: (sha: string) => Effect.Effect<Option.Option<TimeSeriesEntry>, TimeSeriesError>;
+}
+export interface TimeSeriesAppendResult {
+    readonly status: "written" | "duplicate";
+    readonly entry: TimeSeriesEntry;
+}
+export type TimeSeriesEntrySubscriber = (entry: TimeSeriesEntry) => void | Promise<void>;
+export interface TimeSeriesWriter {
+    readonly append: (entry: TimeSeriesEntry) => Effect.Effect<TimeSeriesAppendResult, TimeSeriesError>;
+    readonly appendObservation: (sha: string, observerOutput: ObserverOutput) => Effect.Effect<TimeSeriesAppendResult, TimeSeriesError>;
+    readonly onEntry: (subscriber: TimeSeriesEntrySubscriber) => void;
+}
+export interface TimeSeriesServices {
+    readonly repoId: string;
+    readonly filePath: string;
+    readonly reader: TimeSeriesReader;
+    readonly writer: TimeSeriesWriter;
+}
+export interface TimeSeriesOptions {
+    readonly repoId?: string;
+    readonly compactionThreshold?: number;
+    readonly rawRetentionDays?: number;
+    readonly lockTimeoutMs?: number;
+    readonly lockRetryMs?: number;
+}
+export declare const signalDiagnosticsFromObserver: (observerOutput: ObserverOutput) => SignalDiagnostics;
+export {};
+//# sourceMappingURL=time-series-model.d.ts.map

package/dist/time-series-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-model.d.ts","sourceRoot":"","sources":["../src/time-series-model.ts"],"names":[],"mappings":"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"}

package/dist/time-series-model.js

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+import { Diagnostic as DiagnosticSchema } from "./diagnostic.js";
+import { ObserverOutput as ObserverOutputSchema, } from "./observer.js";
+export const TIME_SERIES_DIRECTORY = "time-series";
+export const DEFAULT_TIME_SERIES_COMPACTION_THRESHOLD = 10_000;
+export const DEFAULT_TIME_SERIES_RAW_RETENTION_DAYS = 90;
+export class TimeSeriesReadFailed extends Schema.TaggedError()("TimeSeriesReadFailed", {
+    repoPath: Schema.String,
+    filePath: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class TimeSeriesWriteFailed extends Schema.TaggedError()("TimeSeriesWriteFailed", {
+    repoPath: Schema.String,
+    filePath: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class TimeSeriesLockFailed extends Schema.TaggedError()("TimeSeriesLockFailed", {
+    repoPath: Schema.String,
+    filePath: Schema.String,
+    message: Schema.String,
+}) {
+}
+export const TimeSeriesAggregate = Schema.Struct({
+    kind: Schema.Literal("weekly-average"),
+    from: Schema.String,
+    to: Schema.String,
+    sample_count: Schema.Number,
+    commit_shas: Schema.Array(Schema.String),
+    observer_semantics: Schema.optional(Schema.Literal("readiness-aware", "legacy-compatibility")),
+    readiness_sample_count: Schema.optional(Schema.Number),
+    compatibility_reason: Schema.optional(Schema.String),
+});
+const SignalDiagnostics = Schema.Record({
+    key: Schema.String,
+    value: Schema.Array(DiagnosticSchema),
+});
+export const TimeSeriesEntry = Schema.Struct({
+    sha: Schema.String,
+    timestamp: Schema.String,
+    observerOutput: ObserverOutputSchema,
+    signalDiagnostics: Schema.optional(SignalDiagnostics),
+    inactiveSignals: Schema.optional(Schema.Array(Schema.String)),
+    source: Schema.Literal("raw", "weekly-average"),
+    aggregate: Schema.optional(TimeSeriesAggregate),
+});
+export const signalDiagnosticsFromObserver = (observerOutput) => Object.fromEntries([...observerOutput.signalResults.entries()]
+    .filter(([, result]) => result.diagnostics.length > 0)
+    .map(([signalId, result]) => [signalId, result.diagnostics]));
+//# sourceMappingURL=time-series-model.js.map

package/dist/time-series-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-model.js","sourceRoot":"","sources":["../src/time-series-model.ts"],"names":[],"mappings":"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"}

package/dist/time-series-readiness.d.ts

@@ -0,0 +1,4 @@
+import type { ReadinessOutput } from "./observer.js";
+import type { WeightedEntry } from "./time-series-compaction-types.js";
+export declare const aggregateReadiness: (weightedEntries: ReadonlyArray<WeightedEntry>, totalWeight: number) => ReadinessOutput | undefined;
+//# sourceMappingURL=time-series-readiness.d.ts.map

package/dist/time-series-readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-readiness.d.ts","sourceRoot":"","sources":["../src/time-series-readiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAEtE,eAAO,MAAM,kBAAkB,GAC7B,iBAAiB,aAAa,CAAC,aAAa,CAAC,EAC7C,aAAa,MAAM,KAClB,eAAe,GAAG,SAuCpB,CAAA"}