@skastr0/pulsar-core 0.1.0

package/dist/observer-json.d.ts

@@ -0,0 +1,319 @@
+import { Schema } from "effect";
+import { type ObserverRuntimeOutput } from "./observer-model.js";
+declare const SignalFactorLedgerEntrySnapshot: 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>>;
+}>;
+export type SignalFactorLedgerEntrySnapshotValue = typeof SignalFactorLedgerEntrySnapshot.Type;
+export declare const 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>>;
+    }>>>>;
+}>;
+export type ObserverOutputPublic = typeof ObserverOutput.Type;
+export type ObserverOutput = ObserverOutputPublic & ObserverRuntimeOutput;
+export {};
+//# sourceMappingURL=observer-json.d.ts.map

package/dist/observer-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-json.d.ts","sourceRoot":"","sources":["../src/observer-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAqK3F,QAAA,MAAM,+BAA+B;;;;;;;;;EAmBnC,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAC9C,OAAO,+BAA+B,CAAC,IAAI,CAAA;AAE7C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAE7D,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,qBAAqB,CAAA"}

package/dist/observer-json.js

@@ -0,0 +1,153 @@
+import { Schema } from "effect";
+import { Category as CategorySchema } from "./category.js";
+import { ProjectModuleScope } from "./calibration.js";
+import { Diagnostic as DiagnosticSchema } from "./diagnostic.js";
+import { OBSERVER_OUTPUT_SEMANTICS } from "./observer-model.js";
+const ObserverCategorySnapshot = Schema.Struct({
+    score: Schema.Number,
+    signals: Schema.Record({ key: Schema.String, value: Schema.Number }),
+    signalCount: Schema.optional(Schema.Number),
+    applicableSignalCount: Schema.optional(Schema.Number),
+    activeSignalIds: Schema.optional(Schema.Array(Schema.String)),
+    aggregation: Schema.optional(Schema.Struct({
+        strategy: Schema.Union(Schema.Literal("weighted-mean"), Schema.Literal("language-group-mean")),
+        rawScore: Schema.Number,
+        aggregateScore: Schema.Number,
+        lowestSignalScore: Schema.Number,
+        finalScore: Schema.Number,
+        shapedByPressure: Schema.Boolean,
+        pressure: Schema.Struct({
+            strategy: Schema.Literal("pressure-pnorm-local-max"),
+            p: Schema.Number,
+            meanPressure: Schema.Number,
+            pnormPressure: Schema.Number,
+            maxLocalPressure: Schema.Number,
+            localPressure: Schema.Number,
+            finalPressure: Schema.Number,
+        }),
+        weightTotal: Schema.Number,
+        weights: Schema.Record({ key: Schema.String, value: Schema.Number }),
+    })),
+    normalization: Schema.optional(Schema.Struct({
+        strategy: Schema.Literal("language-group-mean"),
+        groups: Schema.Record({
+            key: Schema.String,
+            value: Schema.Struct({
+                score: Schema.Number,
+                signals: Schema.Array(Schema.String),
+                signalCount: Schema.Number,
+            }),
+        }),
+    })),
+});
+const ObserverCategories = Schema.Struct({
+    "architectural-drift": ObserverCategorySnapshot,
+    "dependency-entropy": ObserverCategorySnapshot,
+    "abstraction-bloat": ObserverCategorySnapshot,
+    "legibility-decay": ObserverCategorySnapshot,
+    "generated-slop": ObserverCategorySnapshot,
+    "review-pain": ObserverCategorySnapshot,
+});
+const MinimumDimensionSnapshot = Schema.Struct({
+    signal: Schema.String,
+    category: CategorySchema,
+    score: Schema.Number,
+    detail: Schema.String,
+});
+const HardGateViolationSnapshot = Schema.Struct({
+    signalId: Schema.String,
+    category: CategorySchema,
+    diagnostic: DiagnosticSchema,
+});
+const ReadinessPressureSnapshot = Schema.Struct({
+    signal_id: Schema.String,
+    category: CategorySchema,
+    score: Schema.Number,
+    raw_pressure: Schema.Number,
+    effective_pressure: Schema.Number,
+    weight: Schema.Number,
+    confidence: Schema.Number,
+    applicability: Schema.Union(Schema.Literal("applicable"), Schema.Literal("not_applicable"), Schema.Literal("insufficient_evidence"), Schema.Literal("failed")),
+});
+const ReadinessSnapshot = Schema.Struct({
+    score: Schema.Number,
+    pressure: 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: Schema.Number,
+        mean_pressure: Schema.Number,
+        pnorm_pressure: Schema.Number,
+        max_local_pressure: Schema.Number,
+        failed_signal_pressure: Schema.optional(Schema.Number),
+        hard_gate_pressure: Schema.Number,
+        hard_gate_score_cap: Schema.Number,
+        local_warning_threshold: Schema.Number,
+        local_poison_threshold: Schema.Number,
+        local_warning_gain: Schema.Number,
+        applicable_signal_count: Schema.Number,
+        ignored_signal_count: Schema.Number,
+        failed_signal_count: Schema.optional(Schema.Number),
+    }),
+    top_pressures: Schema.Array(ReadinessPressureSnapshot),
+});
+const ObserverSignalMetadataSnapshot = Schema.Struct({
+    effectiveConfidence: Schema.optional(Schema.Number),
+    baseConfidence: Schema.optional(Schema.Number),
+    computedAt: Schema.optional(Schema.String),
+    stale: Schema.optional(Schema.Boolean),
+    applicability: Schema.optional(Schema.Union(Schema.Literal("applicable"), Schema.Literal("not_applicable"), Schema.Literal("insufficient_evidence"), Schema.Literal("failed"))),
+});
+const ObserverRuntimeProfileSnapshot = Schema.Struct({
+    total_ms: Schema.Number,
+    stages: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.Struct({
+            duration_ms: Schema.Number,
+        }),
+    })),
+    signals: Schema.Record({
+        key: Schema.String,
+        value: Schema.Struct({
+            duration_ms: Schema.Number,
+            score: Schema.Number,
+            diagnostics: Schema.Number,
+        }),
+    }),
+});
+const ObserverCalibrationSnapshot = Schema.Struct({
+    fingerprint: Schema.String,
+    active_modules: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        version: Schema.String,
+        scope: ProjectModuleScope,
+        source: Schema.Literal("builtin", "package", "workspace", "repo-local"),
+        source_ref: Schema.optional(Schema.String),
+        source_fingerprint: Schema.optional(Schema.String),
+        fingerprint: Schema.String,
+    })),
+});
+const SignalFactorLedgerEntrySnapshot = Schema.Struct({
+    path: Schema.String,
+    value: Schema.Unknown,
+    source: Schema.Literal("signal-default", "computed", "vector", "module"),
+    affectsScore: Schema.Boolean,
+    title: Schema.optional(Schema.String),
+    scoreRole: Schema.optional(Schema.Literal("evidence", "threshold", "penalty", "weight", "confidence", "score-cap", "metadata")),
+    attribution: Schema.optional(Schema.Unknown),
+    mutations: Schema.optional(Schema.Array(Schema.Unknown)),
+});
+export const ObserverOutput = Schema.Struct({
+    observer_semantics: Schema.optional(Schema.Literal(OBSERVER_OUTPUT_SEMANTICS)),
+    categories: ObserverCategories,
+    minimum: Schema.Union(MinimumDimensionSnapshot, Schema.Undefined),
+    weighted_mean: Schema.Number,
+    readiness: Schema.optional(ReadinessSnapshot),
+    hard_gate_status: Schema.Literal("pass", "fail"),
+    hard_gate_violations: Schema.Array(HardGateViolationSnapshot),
+    signal_metadata: Schema.optional(Schema.Record({ key: Schema.String, value: ObserverSignalMetadataSnapshot })),
+    runtime_profile: Schema.optional(ObserverRuntimeProfileSnapshot),
+    calibration: Schema.optional(ObserverCalibrationSnapshot),
+    signal_factors: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Array(SignalFactorLedgerEntrySnapshot) })),
+});
+//# sourceMappingURL=observer-json.js.map

package/dist/observer-json.js.map

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

package/dist/observer-local-pressure.d.ts

@@ -0,0 +1,5 @@
+import type { CategoryAggregationObserverConfig, ReadinessObserverConfig } from "./vector.js";
+type LocalPressureConfig = Pick<CategoryAggregationObserverConfig | ReadinessObserverConfig, "local_poison_threshold" | "local_warning_gain" | "local_warning_threshold">;
+export declare const localSignalPressure: (maxLocalPressure: number, config: LocalPressureConfig) => number;
+export {};
+//# sourceMappingURL=observer-local-pressure.d.ts.map

package/dist/observer-local-pressure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-local-pressure.d.ts","sourceRoot":"","sources":["../src/observer-local-pressure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,uBAAuB,EACxB,MAAM,aAAa,CAAA;AAEpB,KAAK,mBAAmB,GAAG,IAAI,CAC7B,iCAAiC,GAAG,uBAAuB,EAC3D,wBAAwB,GAAG,oBAAoB,GAAG,yBAAyB,CAC5E,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC9B,kBAAkB,MAAM,EACxB,QAAQ,mBAAmB,KAC1B,MAMF,CAAA"}

package/dist/observer-local-pressure.js

@@ -0,0 +1,9 @@
+export const localSignalPressure = (maxLocalPressure, config) => {
+    if (maxLocalPressure >= config.local_poison_threshold)
+        return maxLocalPressure;
+    if (maxLocalPressure >= config.local_warning_threshold) {
+        return maxLocalPressure * config.local_warning_gain;
+    }
+    return 0;
+};
+//# sourceMappingURL=observer-local-pressure.js.map

package/dist/observer-local-pressure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-local-pressure.js","sourceRoot":"","sources":["../src/observer-local-pressure.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,gBAAwB,EACxB,MAA2B,EACnB,EAAE;IACV,IAAI,gBAAgB,IAAI,MAAM,CAAC,sBAAsB;QAAE,OAAO,gBAAgB,CAAA;IAC9E,IAAI,gBAAgB,IAAI,MAAM,CAAC,uBAAuB,EAAE,CAAC;QACvD,OAAO,gBAAgB,GAAG,MAAM,CAAC,kBAAkB,CAAA;IACrD,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC,CAAA"}

package/dist/observer-minimum.d.ts

@@ -0,0 +1,26 @@
+import type { Registry } from "./registry.js";
+import type { SignalRunResult } from "./runner.js";
+import type { HardGateViolation, MinimumDimension } from "./observer-model.js";
+/**
+ * Lowest applicable repo-quality signal across all categories. Ties resolve by the
+ * CATEGORIES constant order (architectural-drift < dependency-entropy
+ * < abstraction-bloat < legibility-decay < generated-slop < review-pain),
+ * then by signal id alphabetically as a final tiebreak.
+ *
+ * Failed, non-applicable, and insufficient-evidence signals are surfaced
+ * through readiness metadata, not as quality dimensions.
+ *
+ * Returns undefined when no applicable signals produced a result.
+ */
+export declare const findMinimum: (registry: Registry, signalResults: ReadonlyMap<string, SignalRunResult>) => MinimumDimension | undefined;
+/**
+ * A signal fails the hard gate iff:
+ *   1. its enforcement ceiling includes "hard-gate", AND
+ *   2. it emitted one or more diagnostics at severity "block".
+ *
+ * The pulsar-vector weight plays no part in this decision. A Tier 1
+ * structural signal at weight 0.1 still fails the gate per architecture:
+ *   "Structural violations fail the gate regardless of weight."
+ */
+export declare const collectHardGateViolations: (registry: Registry, signalResults: ReadonlyMap<string, SignalRunResult>) => ReadonlyArray<HardGateViolation>;
+//# sourceMappingURL=observer-minimum.d.ts.map

package/dist/observer-minimum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-minimum.d.ts","sourceRoot":"","sources":["../src/observer-minimum.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG9E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,UAAU,QAAQ,EAClB,eAAe,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,KAClD,gBAAgB,GAAG,SAwCrB,CAAA;AAgBD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,UAAU,QAAQ,EAClB,eAAe,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,KAClD,aAAa,CAAC,iBAAiB,CAgBjC,CAAA"}

package/dist/observer-minimum.js

@@ -0,0 +1,94 @@
+import { CATEGORIES } from "./category.js";
+import { signalApplicabilityOf } from "./observer-score-utils.js";
+/**
+ * Lowest applicable repo-quality signal across all categories. Ties resolve by the
+ * CATEGORIES constant order (architectural-drift < dependency-entropy
+ * < abstraction-bloat < legibility-decay < generated-slop < review-pain),
+ * then by signal id alphabetically as a final tiebreak.
+ *
+ * Failed, non-applicable, and insufficient-evidence signals are surfaced
+ * through readiness metadata, not as quality dimensions.
+ *
+ * Returns undefined when no applicable signals produced a result.
+ */
+export const findMinimum = (registry, signalResults) => {
+    if (signalResults.size === 0)
+        return undefined;
+    const categoryOrder = new Map(CATEGORIES.map((c, i) => [c, i]));
+    let best;
+    for (const signal of registry.sorted) {
+        const result = signalResults.get(signal.id);
+        if (result === undefined)
+            continue;
+        if (signalApplicabilityOf(result) !== "applicable")
+            continue;
+        if (best === undefined) {
+            best = { signal, result };
+            continue;
+        }
+        if (result.score < best.result.score) {
+            best = { signal, result };
+            continue;
+        }
+        if (result.score === best.result.score) {
+            const thisOrder = categoryOrder.get(signal.category) ?? Number.MAX_SAFE_INTEGER;
+            const bestOrder = categoryOrder.get(best.signal.category) ?? Number.MAX_SAFE_INTEGER;
+            if (thisOrder < bestOrder) {
+                best = { signal, result };
+            }
+            else if (thisOrder === bestOrder && signal.id < best.signal.id) {
+                best = { signal, result };
+            }
+        }
+    }
+    if (best === undefined)
+        return undefined;
+    return {
+        signal: best.signal.id,
+        category: best.signal.category,
+        score: best.result.score,
+        detail: buildMinimumDetail(best.result.diagnostics),
+    };
+};
+/**
+ * Condense the first one or two diagnostic messages into a single
+ * human-readable detail string. Empty when the signal emitted no
+ * diagnostics (rare but possible — a perfect-score signal with nothing
+ * to say).
+ */
+const buildMinimumDetail = (diagnostics) => {
+    if (diagnostics.length === 0)
+        return "";
+    if (diagnostics.length === 1)
+        return diagnostics[0].message;
+    return `${diagnostics[0].message}; ${diagnostics[1].message}`;
+};
+/**
+ * A signal fails the hard gate iff:
+ *   1. its enforcement ceiling includes "hard-gate", AND
+ *   2. it emitted one or more diagnostics at severity "block".
+ *
+ * The pulsar-vector weight plays no part in this decision. A Tier 1
+ * structural signal at weight 0.1 still fails the gate per architecture:
+ *   "Structural violations fail the gate regardless of weight."
+ */
+export const collectHardGateViolations = (registry, signalResults) => {
+    const violations = [];
+    for (const signal of registry.sorted) {
+        if (!signal.enforcement.includes("hard-gate"))
+            continue;
+        const result = signalResults.get(signal.id);
+        if (result === undefined)
+            continue;
+        const blocking = result.diagnostics.filter((d) => d.severity === "block");
+        for (const diagnostic of blocking) {
+            violations.push({
+                signalId: signal.id,
+                category: signal.category,
+                diagnostic,
+            });
+        }
+    }
+    return violations;
+};
+//# sourceMappingURL=observer-minimum.js.map

package/dist/observer-minimum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-minimum.js","sourceRoot":"","sources":["../src/observer-minimum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAiB,MAAM,eAAe,CAAA;AAMzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,QAAkB,EAClB,aAAmD,EACrB,EAAE;IAChC,IAAI,aAAa,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IAE9C,MAAM,aAAa,GAAG,IAAI,GAAG,CAC3B,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAU,CAAC,CAC1C,CAAA;IAED,IAAI,IAAqE,CAAA;IACzE,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QAC3C,IAAI,MAAM,KAAK,SAAS;YAAE,SAAQ;QAClC,IAAI,qBAAqB,CAAC,MAAM,CAAC,KAAK,YAAY;YAAE,SAAQ;QAC5D,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;YACzB,SAAQ;QACV,CAAC;QACD,IAAI,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACrC,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;YACzB,SAAQ;QACV,CAAC;QACD,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACvC,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAA;YAC/E,MAAM,SAAS,GACb,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAA;YACpE,IAAI,SAAS,GAAG,SAAS,EAAE,CAAC;gBAC1B,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;YAC3B,CAAC;iBAAM,IAAI,SAAS,KAAK,SAAS,IAAI,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;gBACjE,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;YAC3B,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IAExC,OAAO;QACL,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;QACtB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;QAC9B,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK;QACxB,MAAM,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;KACpD,CAAA;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,kBAAkB,GAAG,CACzB,WAAsC,EAC9B,EAAE;IACV,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IACvC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,WAAW,CAAC,CAAC,CAAE,CAAC,OAAO,CAAA;IAC5D,OAAO,GAAG,WAAW,CAAC,CAAC,CAAE,CAAC,OAAO,KAAK,WAAW,CAAC,CAAC,CAAE,CAAC,OAAO,EAAE,CAAA;AACjE,CAAC,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,QAAkB,EAClB,aAAmD,EACjB,EAAE;IACpC,MAAM,UAAU,GAA6B,EAAE,CAAA;IAC/C,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC;YAAE,SAAQ;QACvD,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QAC3C,IAAI,MAAM,KAAK,SAAS;YAAE,SAAQ;QAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAA;QACzE,KAAK,MAAM,UAAU,IAAI,QAAQ,EAAE,CAAC;YAClC,UAAU,CAAC,IAAI,CAAC;gBACd,QAAQ,EAAE,MAAM,CAAC,EAAE;gBACnB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,UAAU;aACX,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC,CAAA"}