@reconai/reflex-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ReconAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @reconai/reflex-core
+
+Reflex scoring and decision classification primitives used by the ReconAI SDK (`@reconai/sdk`).
+
+Most applications should depend on **`@reconai/sdk`** instead of this package directly. Use `reflex-core` only if you need the scoring math without the rest of the SDK.
+
+## Install
+
+```bash
+npm install @reconai/reflex-core
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./sirl/index";
+export type ReflexDecision = "EXECUTE" | "EXECUTE_MONITOR" | "RETRY" | "REQUIRE_APPROVAL" | "BLOCK";
+export interface ReflexSignals {
+    contextIntegrity: number;
+    behavioralConsistency: number;
+    toolRisk: number;
+    outcomeConfidence: number;
+    policyAlignment: number;
+}
+export declare function computeReflexScore(signals: ReflexSignals): number;
+export interface ReflexThresholds {
+    executeThreshold: number;
+    monitorThreshold: number;
+    retryThreshold: number;
+    approvalThreshold: number;
+}
+export declare function classifyReflexDecision(score: number): ReflexDecision;
+export declare function classifyReflexDecisionWithThresholds(score: number, thresholds?: Partial<ReflexThresholds>): ReflexDecision;
+export declare function computeAutonomyConfidenceScore(signals: ReflexSignals): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,MAAM,MAAM,cAAc,GACtB,SAAS,GACT,iBAAiB,GACjB,OAAO,GACP,kBAAkB,GAClB,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAa;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;CACzB;AAUD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CASjE;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AASD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAEpE;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,OAAO,CAAC,gBAAgB,CAAM,GACzC,cAAc,CAOhB;AAWD,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAS7E"}

package/dist/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeReflexScore = computeReflexScore;
+exports.classifyReflexDecision = classifyReflexDecision;
+exports.classifyReflexDecisionWithThresholds = classifyReflexDecisionWithThresholds;
+exports.computeAutonomyConfidenceScore = computeAutonomyConfidenceScore;
+__exportStar(require("./sirl/index"), exports);
+const WEIGHTS = {
+    contextIntegrity: 0.25,
+    behavioralConsistency: 0.2,
+    toolRisk: 0.15,
+    outcomeConfidence: 0.2,
+    policyAlignment: 0.2,
+};
+function computeReflexScore(signals) {
+    const score = signals.contextIntegrity * WEIGHTS.contextIntegrity +
+        signals.behavioralConsistency * WEIGHTS.behavioralConsistency +
+        signals.toolRisk * WEIGHTS.toolRisk +
+        signals.outcomeConfidence * WEIGHTS.outcomeConfidence +
+        signals.policyAlignment * WEIGHTS.policyAlignment;
+    return Math.round(Math.min(100, Math.max(0, score)) * 100) / 100;
+}
+const DEFAULT_THRESHOLDS = {
+    executeThreshold: 90,
+    monitorThreshold: 75,
+    retryThreshold: 60,
+    approvalThreshold: 40,
+};
+function classifyReflexDecision(score) {
+    return classifyReflexDecisionWithThresholds(score, DEFAULT_THRESHOLDS);
+}
+function classifyReflexDecisionWithThresholds(score, thresholds = {}) {
+    const t = { ...DEFAULT_THRESHOLDS, ...thresholds };
+    if (score >= t.executeThreshold)
+        return "EXECUTE";
+    if (score >= t.monitorThreshold)
+        return "EXECUTE_MONITOR";
+    if (score >= t.retryThreshold)
+        return "RETRY";
+    if (score >= t.approvalThreshold)
+        return "REQUIRE_APPROVAL";
+    return "BLOCK";
+}
+/** Autonomy Confidence Score (ACS) - weighted signal composite */
+const ACS_WEIGHTS = {
+    contextIntegrity: 0.3,
+    behavioralConsistency: 0.25,
+    policyAlignment: 0.2,
+    toolRisk: 0.15,
+    outcomeConfidence: 0.1,
+};
+function computeAutonomyConfidenceScore(signals) {
+    const score = signals.contextIntegrity * ACS_WEIGHTS.contextIntegrity +
+        signals.behavioralConsistency * ACS_WEIGHTS.behavioralConsistency +
+        signals.policyAlignment * ACS_WEIGHTS.policyAlignment +
+        signals.toolRisk * ACS_WEIGHTS.toolRisk +
+        signals.outcomeConfidence * ACS_WEIGHTS.outcomeConfidence;
+    return Math.round(Math.min(100, Math.max(0, score)) * 100) / 100;
+}

package/dist/sirl/detectors/collusion.d.ts

@@ -0,0 +1,6 @@
+import type { SIRLDetectorInput, SIRLSubscore } from "../types";
+/**
+ * Collusion likelihood from output similarity, low rationale diversity, tight coordination, resource overlap.
+ */
+export declare function detectCollusion(input: SIRLDetectorInput): SIRLSubscore;
+//# sourceMappingURL=collusion.d.ts.map

package/dist/sirl/detectors/collusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collusion.d.ts","sourceRoot":"","sources":["../../../src/sirl/detectors/collusion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAoEhE;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAuCtE"}

package/dist/sirl/detectors/collusion.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCollusion = detectCollusion;
+const normalize_1 = require("../normalize");
+function tokenize(text) {
+    const t = text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean);
+    return new Set(t);
+}
+function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    let inter = 0;
+    for (const x of a) {
+        if (b.has(x))
+            inter += 1;
+    }
+    const union = a.size + b.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
+function avgPairwiseSimilarity(texts) {
+    if (texts.length < 2)
+        return 0;
+    let sum = 0;
+    let n = 0;
+    for (let i = 0; i < texts.length; i++) {
+        for (let j = i + 1; j < texts.length; j++) {
+            sum += jaccard(tokenize(texts[i]), tokenize(texts[j]));
+            n += 1;
+        }
+    }
+    return n === 0 ? 0 : sum / n;
+}
+function rationaleDiversityScore(rationales) {
+    if (rationales.length === 0)
+        return 50;
+    const words = rationales.join(" ").toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return 50;
+    const unique = new Set(words);
+    return (0, normalize_1.clamp100)((unique.size / words.length) * 100);
+}
+/**
+ * Temporal coordination: low spread of timestamps in a short window → higher collusion risk.
+ */
+function coordinationTightness(events) {
+    if (events.length < 2)
+        return 0;
+    const ms = events.map((e) => new Date(e.timestamp).getTime()).sort((a, b) => a - b);
+    const spread = ms[ms.length - 1] - ms[0];
+    if (spread <= 0)
+        return 100;
+    // Under 1s → high risk; over 60s → low
+    return (0, normalize_1.clamp100)(100 - Math.min(100, spread / 600));
+}
+function resourceOverlapScore(events) {
+    const alloc = events.filter((e) => e.resourceUnits != null && e.resourceUnits > 0);
+    if (alloc.length < 2)
+        return 0;
+    const byAgent = new Map();
+    for (const e of alloc) {
+        byAgent.set(e.agentId, (byAgent.get(e.agentId) ?? 0) + (e.resourceUnits ?? 0));
+    }
+    const vals = [...byAgent.values()];
+    if (vals.length < 2)
+        return 0;
+    const max = Math.max(...vals);
+    const min = Math.min(...vals);
+    if (max === 0)
+        return 0;
+    return (0, normalize_1.clamp100)((1 - min / max) * 100);
+}
+/**
+ * Collusion likelihood from output similarity, low rationale diversity, tight coordination, resource overlap.
+ */
+function detectCollusion(input) {
+    const outputs = input.events
+        .filter((e) => e.type === "agent_output" && e.outputText && e.outputText.trim().length > 0)
+        .map((e) => e.outputText);
+    const rationales = input.events
+        .map((e) => e.rationaleText)
+        .filter((r) => typeof r === "string" && r.length > 0);
+    const resourceEvents = input.events.filter((e) => e.type === "resource_allocation");
+    const outputSimilarity = (0, normalize_1.clamp100)(avgPairwiseSimilarity(outputs) * 100);
+    const diversity = rationaleDiversityScore(rationales);
+    const rationaleDiversityRisk = (0, normalize_1.clamp100)(100 - diversity);
+    const relevant = input.events.filter((e) => e.type === "agent_output" || e.type === "resource_allocation");
+    const coord = coordinationTightness(relevant);
+    const resOverlap = resourceOverlapScore(resourceEvents);
+    const value = (0, normalize_1.clamp100)(0.35 * outputSimilarity +
+        0.25 * coord +
+        0.25 * resOverlap +
+        0.15 * rationaleDiversityRisk);
+    const confidence = (0, normalize_1.clamp100)(Math.min(100, (outputs.length + rationales.length + resourceEvents.length) * 12));
+    return {
+        value,
+        confidence,
+        evidence: {
+            outputSimilarity,
+            rationaleDiversityRisk,
+            coordinationTightness: coord,
+            resourceOverlap: resOverlap,
+        },
+    };
+}

package/dist/sirl/detectors/conformity.d.ts

@@ -0,0 +1,6 @@
+import type { SIRLDetectorInput, SIRLSubscore } from "../types";
+/**
+ * Conformity: dissent collapse, entropy drop, majority echo.
+ */
+export declare function detectConformity(input: SIRLDetectorInput): SIRLSubscore;
+//# sourceMappingURL=conformity.d.ts.map

package/dist/sirl/detectors/conformity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformity.d.ts","sourceRoot":"","sources":["../../../src/sirl/detectors/conformity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAuBhE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAqDvE"}

package/dist/sirl/detectors/conformity.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectConformity = detectConformity;
+const normalize_1 = require("../normalize");
+function stanceFingerprint(text) {
+    const w = text.toLowerCase().split(/\s+/).filter(Boolean).slice(0, 4);
+    return w.join("|");
+}
+function wordEntropy(texts) {
+    const words = texts.join(" ").toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return 50;
+    const freq = new Map();
+    for (const w of words) {
+        freq.set(w, (freq.get(w) ?? 0) + 1);
+    }
+    let h = 0;
+    for (const c of freq.values()) {
+        const p = c / words.length;
+        h -= p * Math.log2(p);
+    }
+    return (0, normalize_1.clamp100)((h / 8) * 100);
+}
+/**
+ * Conformity: dissent collapse, entropy drop, majority echo.
+ */
+function detectConformity(input) {
+    const rounds = input.events.filter((e) => e.type === "aggregation_round" || e.type === "agent_output");
+    const sorted = [...rounds].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const texts = sorted
+        .map((e) => e.outputText ?? e.rationaleText ?? "")
+        .filter((t) => t.length > 0);
+    if (texts.length < 2) {
+        return {
+            value: 0,
+            confidence: 0,
+            evidence: { dissentDrop: 0, entropyDrop: 0, majorityEcho: 0 },
+        };
+    }
+    const mid = Math.floor(texts.length / 2) || 1;
+    const first = texts.slice(0, mid);
+    const second = texts.slice(mid);
+    const fpFirst = new Set(first.map(stanceFingerprint));
+    const fpSecond = new Set(second.map(stanceFingerprint));
+    const dissentDrop = fpFirst.size === 0
+        ? 0
+        : (0, normalize_1.clamp100)(Math.max(0, ((fpFirst.size - fpSecond.size) / fpFirst.size) * 100));
+    const entFirst = wordEntropy(first);
+    const entSecond = wordEntropy(second);
+    const entropyDrop = (0, normalize_1.clamp100)(Math.max(0, entFirst - entSecond));
+    const allFp = texts.map(stanceFingerprint);
+    const counts = new Map();
+    for (const f of allFp) {
+        counts.set(f, (counts.get(f) ?? 0) + 1);
+    }
+    const maxC = Math.max(...counts.values());
+    const majorityEcho = (0, normalize_1.clamp100)((maxC / allFp.length) * 100);
+    const value = (0, normalize_1.clamp100)(0.4 * dissentDrop + 0.35 * entropyDrop + 0.25 * majorityEcho);
+    const confidence = (0, normalize_1.clamp100)(Math.min(100, texts.length * 15));
+    return {
+        value,
+        confidence,
+        evidence: {
+            dissentDrop,
+            entropyDrop,
+            majorityEcho,
+        },
+    };
+}

package/dist/sirl/detectors/handoff-drift.d.ts

@@ -0,0 +1,6 @@
+import type { SIRLDetectorInput, SIRLSubscore } from "../types";
+/**
+ * Sequential distortion: fact loss, constraint mutation, confidence inflation across handoffs.
+ */
+export declare function detectHandoffDrift(input: SIRLDetectorInput): SIRLSubscore;
+//# sourceMappingURL=handoff-drift.d.ts.map

package/dist/sirl/detectors/handoff-drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-drift.d.ts","sourceRoot":"","sources":["../../../src/sirl/detectors/handoff-drift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAuBhE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAwDzE"}

package/dist/sirl/detectors/handoff-drift.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectHandoffDrift = detectHandoffDrift;
+const normalize_1 = require("../normalize");
+function payloadSize(p) {
+    if (!p || typeof p !== "object")
+        return 0;
+    try {
+        return JSON.stringify(p).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function keyCount(p) {
+    if (!p || typeof p !== "object")
+        return 0;
+    return Object.keys(p).length;
+}
+function textFromPayload(p) {
+    const out = p.output ?? p.text ?? p.summary ?? p.body;
+    if (typeof out === "string")
+        return out;
+    return JSON.stringify(p);
+}
+/**
+ * Sequential distortion: fact loss, constraint mutation, confidence inflation across handoffs.
+ */
+function detectHandoffDrift(input) {
+    const handoffs = [...input.events]
+        .filter((e) => e.type === "task_handoff" && e.handoffPayload)
+        .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    if (handoffs.length < 2) {
+        return {
+            value: 0,
+            confidence: handoffs.length === 1 ? 40 : 0,
+            evidence: { factLoss: 0, constraintMutation: 0, confidenceInflation: 0 },
+        };
+    }
+    let factLoss = 0;
+    let constraintMutation = 0;
+    let confidenceInflation = 0;
+    let pairs = 0;
+    for (let i = 1; i < handoffs.length; i++) {
+        const prev = handoffs[i - 1].handoffPayload;
+        const cur = handoffs[i].handoffPayload;
+        const prevSize = payloadSize(prev);
+        const curSize = payloadSize(cur);
+        if (prevSize > 0 && curSize < prevSize) {
+            factLoss += (0, normalize_1.clamp100)(((prevSize - curSize) / prevSize) * 100);
+        }
+        const kPrev = keyCount(prev);
+        const kCur = keyCount(cur);
+        if (kPrev > 0 && kCur < kPrev) {
+            constraintMutation += (0, normalize_1.clamp100)(((kPrev - kCur) / kPrev) * 100);
+        }
+        const tPrev = textFromPayload(prev).length;
+        const tCur = textFromPayload(cur).length;
+        if (tCur > tPrev * 1.2 && tCur > 0) {
+            confidenceInflation += (0, normalize_1.clamp100)(Math.min(100, ((tCur - tPrev) / tCur) * 100));
+        }
+        pairs += 1;
+    }
+    const n = Math.max(1, pairs);
+    factLoss = (0, normalize_1.clamp100)(factLoss / n);
+    constraintMutation = (0, normalize_1.clamp100)(constraintMutation / n);
+    confidenceInflation = (0, normalize_1.clamp100)(confidenceInflation / n);
+    const value = (0, normalize_1.clamp100)(0.45 * factLoss + 0.35 * constraintMutation + 0.2 * confidenceInflation);
+    const confidence = (0, normalize_1.clamp100)(Math.min(100, handoffs.length * 25));
+    return {
+        value,
+        confidence,
+        evidence: {
+            factLoss,
+            constraintMutation,
+            confidenceInflation,
+        },
+    };
+}

package/dist/sirl/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./normalize";
+export * from "./scoring";
+export * from "./policies";
+export * from "./detectors/collusion";
+export * from "./detectors/conformity";
+export * from "./detectors/handoff-drift";
+//# sourceMappingURL=index.d.ts.map

package/dist/sirl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sirl/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}

package/dist/sirl/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./normalize"), exports);
+__exportStar(require("./scoring"), exports);
+__exportStar(require("./policies"), exports);
+__exportStar(require("./detectors/collusion"), exports);
+__exportStar(require("./detectors/conformity"), exports);
+__exportStar(require("./detectors/handoff-drift"), exports);

package/dist/sirl/normalize.d.ts

@@ -0,0 +1,6 @@
+/** Clamp to [0, 1]. */
+export declare function clamp01(x: number): number;
+/** Clamp to [0, 100]. */
+export declare function clamp100(x: number): number;
+export declare function newSirlSignalId(): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/sirl/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/sirl/normalize.ts"],"names":[],"mappings":"AAAA,uBAAuB;AACvB,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzC;AAED,yBAAyB;AACzB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/sirl/normalize.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp01 = clamp01;
+exports.clamp100 = clamp100;
+exports.newSirlSignalId = newSirlSignalId;
+/** Clamp to [0, 1]. */
+function clamp01(x) {
+    if (Number.isNaN(x) || !Number.isFinite(x))
+        return 0;
+    return Math.min(1, Math.max(0, x));
+}
+/** Clamp to [0, 100]. */
+function clamp100(x) {
+    if (Number.isNaN(x) || !Number.isFinite(x))
+        return 0;
+    return Math.min(100, Math.max(0, x));
+}
+function newSirlSignalId() {
+    return `sirl_sig_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}

package/dist/sirl/policies.d.ts

@@ -0,0 +1,6 @@
+import type { SIRLAnalysisResult, SIRLPolicyDecision } from "./types";
+/**
+ * Threshold-based policy (0–100 scales). Order: freeze → replan → flag → review → observe.
+ */
+export declare function evaluateSIRLPolicies(result: Pick<SIRLAnalysisResult, "subscores" | "dominantPatternType">, collectiveReflexScore: number): SIRLPolicyDecision;
+//# sourceMappingURL=policies.d.ts.map

package/dist/sirl/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../src/sirl/policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEtE;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,qBAAqB,CAAC,EACrE,qBAAqB,EAAE,MAAM,GAC5B,kBAAkB,CA2BpB"}

package/dist/sirl/policies.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateSIRLPolicies = evaluateSIRLPolicies;
+/**
+ * Threshold-based policy (0–100 scales). Order: freeze → replan → flag → review → observe.
+ */
+function evaluateSIRLPolicies(result, collectiveReflexScore) {
+    const c = result.subscores.collusionLikelihood;
+    const f = result.subscores.conformityIndex;
+    const h = result.subscores.sequentialDistortionRate;
+    const reasons = [];
+    if (c.value > 80 && c.confidence > 70) {
+        reasons.push("collusion_likelihood_and_confidence_high");
+        return { recommendedAction: "FREEZE_CHAIN", reasons };
+    }
+    if (h.value > 70) {
+        reasons.push("handoff_sequential_distortion_high");
+        return { recommendedAction: "REPLAN", reasons };
+    }
+    if (f.value > 65 && collectiveReflexScore < 55) {
+        reasons.push("conformity_high_with_low_crs");
+        return { recommendedAction: "FLAG", reasons };
+    }
+    if (collectiveReflexScore < 45) {
+        reasons.push("crs_below_threshold");
+        return { recommendedAction: "REQUIRE_REVIEW", reasons };
+    }
+    return { recommendedAction: "OBSERVE", reasons: ["within_thresholds"] };
+}

package/dist/sirl/scoring.d.ts

@@ -0,0 +1,24 @@
+import type { SIRLAnalysisResult, SIRLDetectorInput, SIRLSubscore, TrustCompositeWeights } from "./types";
+/** v1 CRS weights — risk terms 0–1 after dividing subscore.value by 100. */
+export declare const SIRL_CRS_WEIGHTS: {
+    readonly collusionLikelihood: 0.3;
+    readonly conformityIndex: 0.2;
+    readonly sequentialDistortionRate: 0.2;
+    readonly resourceSkewScore: 0.15;
+    readonly coalitionDriftScore: 0.1;
+    readonly silentPropagationRisk: 0.05;
+};
+/**
+ * Collective Reflex Score 0–100 from risk subscores (each 0–100).
+ */
+export declare function computeCollectiveReflexScore(subscores: {
+    collusionLikelihood: SIRLSubscore;
+    conformityIndex: SIRLSubscore;
+    sequentialDistortionRate: SIRLSubscore;
+    resourceSkewScore?: SIRLSubscore;
+    coalitionDriftScore?: SIRLSubscore;
+    silentPropagationRisk?: SIRLSubscore;
+}, weights?: Partial<typeof SIRL_CRS_WEIGHTS>): number;
+export declare function computeTrustComposite(individualReflexScore: number, collectiveReflexScore: number, weights?: Partial<TrustCompositeWeights>): number;
+export declare function analyzeSIRL(input: SIRLDetectorInput): SIRLAnalysisResult;
+//# sourceMappingURL=scoring.d.ts.map

package/dist/sirl/scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.d.ts","sourceRoot":"","sources":["../../src/sirl/scoring.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAIjB,YAAY,EAEZ,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAEjB,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB;;;;;;;CAOnB,CAAC;AAIX;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE;IACT,mBAAmB,EAAE,YAAY,CAAC;IAClC,eAAe,EAAE,YAAY,CAAC;IAC9B,wBAAwB,EAAE,YAAY,CAAC;IACvC,iBAAiB,CAAC,EAAE,YAAY,CAAC;IACjC,mBAAmB,CAAC,EAAE,YAAY,CAAC;IACnC,qBAAqB,CAAC,EAAE,YAAY,CAAC;CACtC,EACD,OAAO,GAAE,OAAO,CAAC,OAAO,gBAAgB,CAAM,GAC7C,MAAM,CAaR;AAOD,wBAAgB,qBAAqB,CACnC,qBAAqB,EAAE,MAAM,EAC7B,qBAAqB,EAAE,MAAM,EAC7B,OAAO,GAAE,OAAO,CAAC,qBAAqB,CAAM,GAC3C,MAAM,CAOR;AAuED,wBAAgB,WAAW,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB,CA8BxE"}

package/dist/sirl/scoring.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIRL_CRS_WEIGHTS = void 0;
+exports.computeCollectiveReflexScore = computeCollectiveReflexScore;
+exports.computeTrustComposite = computeTrustComposite;
+exports.analyzeSIRL = analyzeSIRL;
+const collusion_1 = require("./detectors/collusion");
+const conformity_1 = require("./detectors/conformity");
+const handoff_drift_1 = require("./detectors/handoff-drift");
+const normalize_1 = require("./normalize");
+const policies_1 = require("./policies");
+/** v1 CRS weights — risk terms 0–1 after dividing subscore.value by 100. */
+exports.SIRL_CRS_WEIGHTS = {
+    collusionLikelihood: 0.3,
+    conformityIndex: 0.2,
+    sequentialDistortionRate: 0.2,
+    resourceSkewScore: 0.15,
+    coalitionDriftScore: 0.1,
+    silentPropagationRisk: 0.05,
+};
+const ZERO = { value: 0, confidence: 0, evidence: {} };
+/**
+ * Collective Reflex Score 0–100 from risk subscores (each 0–100).
+ */
+function computeCollectiveReflexScore(subscores, weights = {}) {
+    const w = { ...exports.SIRL_CRS_WEIGHTS, ...weights };
+    const r = (s) => s.value / 100;
+    const rawRisk = r(subscores.collusionLikelihood) * w.collusionLikelihood +
+        r(subscores.conformityIndex) * w.conformityIndex +
+        r(subscores.sequentialDistortionRate) * w.sequentialDistortionRate +
+        r(subscores.resourceSkewScore ?? ZERO) * w.resourceSkewScore +
+        r(subscores.coalitionDriftScore ?? ZERO) * w.coalitionDriftScore +
+        r(subscores.silentPropagationRisk ?? ZERO) * w.silentPropagationRisk;
+    const crs = 100 * (1 - Math.min(1, Math.max(0, rawRisk)));
+    return Math.round(Math.min(100, Math.max(0, crs)) * 100) / 100;
+}
+const DEFAULT_TRUST_COMPOSITE = {
+    individualReflex: 0.6,
+    collectiveReflex: 0.4,
+};
+function computeTrustComposite(individualReflexScore, collectiveReflexScore, weights = {}) {
+    const w = { ...DEFAULT_TRUST_COMPOSITE, ...weights };
+    const sum = w.individualReflex + w.collectiveReflex;
+    const n = sum > 0 ? sum : 1;
+    const score = (individualReflexScore * w.individualReflex + collectiveReflexScore * w.collectiveReflex) / n;
+    return Math.round(Math.min(100, Math.max(0, score)) * 100) / 100;
+}
+function dominantPattern(c, f, h) {
+    const scores = [
+        { t: "COLLUSION", v: c.value },
+        { t: "CONFORMITY", v: f.value },
+        { t: "SEQUENTIAL_DISTORTION", v: h.value },
+    ];
+    scores.sort((a, b) => b.v - a.v);
+    const top = scores[0];
+    if (top.v < 15)
+        return null;
+    return top.t;
+}
+function buildSignals(input, subscores, action) {
+    const ts = new Date().toISOString();
+    const agentIds = [...new Set(input.events.map((e) => e.agentId).filter(Boolean))];
+    const out = [];
+    const push = (patternType, sub, explanation) => {
+        if (sub.value < 25 && sub.confidence < 30)
+            return;
+        out.push({
+            id: (0, normalize_1.newSirlSignalId)(),
+            orgId: input.orgId,
+            missionId: input.missionId,
+            taskId: input.taskId ?? null,
+            agentIds,
+            patternType,
+            severity: sub.value / 100,
+            confidence: sub.confidence / 100,
+            timestamp: ts,
+            evidence: {
+                outputSimilarity: sub.evidence.outputSimilarity ?? 0,
+                dissentDrop: sub.evidence.dissentDrop ?? 0,
+                handoffMutationRate: sub.evidence.constraintMutation ?? sub.evidence.factLoss ?? 0,
+                resourceSkew: sub.evidence.resourceOverlap ?? 0,
+                dependencyDepth: 0,
+                clusterDensity: 0,
+            },
+            explanation,
+            recommendedAction: action,
+        });
+    };
+    push("COLLUSION", subscores.collusionLikelihood, "Collusion-like similarity / coordination vs rationale diversity.");
+    push("CONFORMITY", subscores.conformityIndex, "Dissent / entropy collapse vs majority echo.");
+    push("SEQUENTIAL_DISTORTION", subscores.sequentialDistortionRate, "Handoff payload shrink or constraint loss across relay steps.");
+    return out.slice(0, 5);
+}
+function analyzeSIRL(input) {
+    const collusionLikelihood = (0, collusion_1.detectCollusion)(input);
+    const conformityIndex = (0, conformity_1.detectConformity)(input);
+    const sequentialDistortionRate = (0, handoff_drift_1.detectHandoffDrift)(input);
+    const subscores = {
+        collusionLikelihood,
+        conformityIndex,
+        sequentialDistortionRate,
+    };
+    const collectiveReflexScore = computeCollectiveReflexScore(subscores);
+    const dominantPatternType = dominantPattern(collusionLikelihood, conformityIndex, sequentialDistortionRate);
+    const policy = (0, policies_1.evaluateSIRLPolicies)({ subscores, dominantPatternType }, collectiveReflexScore);
+    const signals = buildSignals(input, subscores, policy.recommendedAction);
+    return {
+        collectiveReflexScore,
+        subscores,
+        dominantPatternType,
+        recommendedAction: policy.recommendedAction,
+        policyReasons: policy.reasons,
+        signals,
+    };
+}

package/dist/sirl/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * ΔSIRL — Social Intelligence Risk Layer types.
+ */
+export declare const SIRL_PATTERN_TYPES: readonly ["COLLUSION", "CONFORMITY", "RESOURCE_SKEW", "SEQUENTIAL_DISTORTION", "COALITION_DRIFT", "SILENT_PROPAGATION"];
+export type SIRLPatternType = (typeof SIRL_PATTERN_TYPES)[number];
+export declare const SIRL_EVENT_TYPES: readonly ["agent_output", "task_handoff", "resource_allocation", "aggregation_round", "policy_escalation"];
+export type SIRLInteractionEventType = (typeof SIRL_EVENT_TYPES)[number];
+export declare const SIRL_RECOMMENDED_ACTIONS: readonly ["OBSERVE", "FLAG", "REQUIRE_REVIEW", "FREEZE_CHAIN", "SPLIT_CLUSTER", "REPLAN"];
+export type SIRLRecommendedAction = (typeof SIRL_RECOMMENDED_ACTIONS)[number];
+export interface SIRLInteractionEvent {
+    orgId: string;
+    missionId: string;
+    taskId?: string;
+    agentId: string;
+    agentClusterId?: string;
+    type: SIRLInteractionEventType;
+    timestamp: string;
+    outputText?: string;
+    rationaleText?: string;
+    handoffPayload?: Record<string, unknown>;
+    resourceUnits?: number;
+    targetAgentId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SIRLDetectorInput {
+    orgId: string;
+    missionId: string;
+    taskId?: string;
+    windowStart?: string;
+    windowEnd?: string;
+    events: SIRLInteractionEvent[];
+}
+/** Detector output: value and confidence on 0–100 scale. */
+export interface SIRLSubscore {
+    value: number;
+    confidence: number;
+    evidence: Record<string, number>;
+}
+export interface SIRLSubscores {
+    collusionLikelihood: SIRLSubscore;
+    conformityIndex: SIRLSubscore;
+    sequentialDistortionRate: SIRLSubscore;
+    resourceSkewScore?: SIRLSubscore;
+    coalitionDriftScore?: SIRLSubscore;
+    silentPropagationRisk?: SIRLSubscore;
+}
+export interface SIRLSignalEvidence {
+    outputSimilarity: number;
+    dissentDrop: number;
+    handoffMutationRate: number;
+    resourceSkew: number;
+    dependencyDepth: number;
+    clusterDensity: number;
+}
+export interface SIRLSignal {
+    id: string;
+    orgId: string;
+    missionId: string;
+    taskId: string | null;
+    agentIds: string[];
+    patternType: SIRLPatternType;
+    severity: number;
+    confidence: number;
+    timestamp: string;
+    evidence: SIRLSignalEvidence;
+    explanation: string;
+    recommendedAction: SIRLRecommendedAction;
+}
+export interface SIRLAnalysisResult {
+    collectiveReflexScore: number;
+    subscores: SIRLSubscores;
+    dominantPatternType: SIRLPatternType | null;
+    recommendedAction: SIRLRecommendedAction;
+    policyReasons: string[];
+    signals: SIRLSignal[];
+}
+export interface SIRLPolicyDecision {
+    recommendedAction: SIRLRecommendedAction;
+    reasons: string[];
+}
+/** Runtime ghost row for dashboards / replay (not necessarily Prisma-shaped). */
+export interface GhostLogSocialEntry {
+    id: string;
+    orgId: string;
+    missionId: string;
+    parentEventId: string | null;
+    agentClusterId: string;
+    interactionPatternType: string;
+    collectiveReflexScore: number;
+    conformityIndex: number;
+    collusionLikelihood: number;
+    notes: string;
+    timestamp: string;
+}
+export interface PersistedGhostLogSocialEntry {
+    id: string;
+    orgId: string;
+    missionId: string;
+    taskId?: string;
+    agentClusterId?: string;
+    patternType: string;
+    collectiveReflexScore: number;
+    conformityIndex?: number;
+    collusionLikelihood?: number;
+    sequentialDistortionRate?: number;
+    explanation?: string;
+    recommendedAction: string;
+    createdAt: string;
+}
+export interface TrustCompositeWeights {
+    individualReflex: number;
+    collectiveReflex: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/sirl/types.d.ts.map

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

package/dist/sirl/types.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * ΔSIRL — Social Intelligence Risk Layer types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIRL_RECOMMENDED_ACTIONS = exports.SIRL_EVENT_TYPES = exports.SIRL_PATTERN_TYPES = void 0;
+exports.SIRL_PATTERN_TYPES = [
+    "COLLUSION",
+    "CONFORMITY",
+    "RESOURCE_SKEW",
+    "SEQUENTIAL_DISTORTION",
+    "COALITION_DRIFT",
+    "SILENT_PROPAGATION",
+];
+exports.SIRL_EVENT_TYPES = [
+    "agent_output",
+    "task_handoff",
+    "resource_allocation",
+    "aggregation_round",
+    "policy_escalation",
+];
+exports.SIRL_RECOMMENDED_ACTIONS = [
+    "OBSERVE",
+    "FLAG",
+    "REQUIRE_REVIEW",
+    "FREEZE_CHAIN",
+    "SPLIT_CLUSTER",
+    "REPLAN",
+];

package/dist/sirl.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Social Intelligence Risk Layer (SIRL) — types and Collective Reflex Score (CRS).
+ * Grounded in emergent multi-agent risk: interaction dynamics, not lone-agent alignment.
+ */
+export declare const SIRL_PATTERN_TYPES: readonly ["COLLUSION", "CONFORMITY", "RESOURCE_SKEW", "SEQUENTIAL_DISTORTION", "COALITION_DRIFT", "SILENT_PROPAGATION"];
+export type SIRLPatternType = (typeof SIRL_PATTERN_TYPES)[number];
+export declare const SIRL_RECOMMENDED_ACTIONS: readonly ["OBSERVE", "FLAG", "REQUIRE_REVIEW", "FREEZE_CHAIN", "SPLIT_CLUSTER", "REPLAN"];
+export type SIRLRecommendedAction = (typeof SIRL_RECOMMENDED_ACTIONS)[number];
+/** Subscores in [0, 1]; higher = more risk (except where noted in callers). */
+export interface SIRLSubscores {
+    collusionLikelihood: number;
+    conformityIndex: number;
+    sequentialDistortionRate: number;
+    resourceSkewScore: number;
+    coalitionDriftScore: number;
+    silentPropagationRisk: number;
+}
+/** v1 weights — tune per workflow; sum need not be 1 (they apply to risk terms). */
+export declare const SIRL_CRS_WEIGHTS: {
+    readonly collusionLikelihood: 0.3;
+    readonly conformityIndex: 0.2;
+    readonly sequentialDistortionRate: 0.2;
+    readonly resourceSkewScore: 0.15;
+    readonly coalitionDriftScore: 0.1;
+    readonly silentPropagationRisk: 0.05;
+};
+/**
+ * Collective Reflex Score: trust in the interaction pattern, 0–100 (aligned with {@link computeReflexScore}).
+ * CRS = 100 * (1 - weighted sum of risk subscores).
+ */
+export declare function computeCollectiveReflexScore(subscores: SIRLSubscores, weights?: Partial<typeof SIRL_CRS_WEIGHTS>): number;
+export interface TrustCompositeWeights {
+    individualReflex: number;
+    collectiveReflex: number;
+}
+/** IRS and CRS on 0–100; returns 0–100. */
+export declare function computeTrustComposite(individualReflexScore: number, collectiveReflexScore: number, weights?: Partial<TrustCompositeWeights>): number;
+export interface SIRLSignalEvidence {
+    outputSimilarity: number;
+    dissentDrop: number;
+    handoffMutationRate: number;
+    resourceSkew: number;
+    dependencyDepth: number;
+    clusterDensity: number;
+}
+export interface SIRLSignal {
+    id: string;
+    orgId: string;
+    missionId: string;
+    taskId: string | null;
+    agentIds: string[];
+    patternType: SIRLPatternType;
+    severity: number;
+    confidence: number;
+    timestamp: string;
+    evidence: SIRLSignalEvidence;
+    explanation: string;
+    recommendedAction: SIRLRecommendedAction;
+}
+export interface SIRLAnalysisResult {
+    collectiveReflexScore: number;
+    conformityIndex: number;
+    collusionLikelihood: number;
+    sequentialDistortionRate: number;
+    resourceSkewScore: number;
+    coalitionDriftScore: number;
+    silentPropagationRisk: number;
+    recommendedAction: SIRLRecommendedAction;
+    signals: SIRLSignal[];
+}
+export interface SIRLAnalysisRequest {
+    orgId: string;
+    missionId: string;
+    taskId?: string;
+    window?: {
+        start: string;
+        end: string;
+    };
+    agentIds?: string[];
+}
+/** Optional GhostLog enrichment row for social / multi-agent causal replay. */
+export interface GhostLogSocialEntry {
+    id: string;
+    orgId: string;
+    missionId: string;
+    parentEventId: string | null;
+    agentClusterId: string;
+    interactionPatternType: string;
+    collectiveReflexScore: number;
+    conformityIndex: number;
+    collusionLikelihood: number;
+    notes: string;
+    timestamp: string;
+}
+//# sourceMappingURL=sirl.d.ts.map

package/dist/sirl.d.ts.map

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

package/dist/sirl.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Social Intelligence Risk Layer (SIRL) — types and Collective Reflex Score (CRS).
+ * Grounded in emergent multi-agent risk: interaction dynamics, not lone-agent alignment.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIRL_CRS_WEIGHTS = exports.SIRL_RECOMMENDED_ACTIONS = exports.SIRL_PATTERN_TYPES = void 0;
+exports.computeCollectiveReflexScore = computeCollectiveReflexScore;
+exports.computeTrustComposite = computeTrustComposite;
+exports.SIRL_PATTERN_TYPES = [
+    "COLLUSION",
+    "CONFORMITY",
+    "RESOURCE_SKEW",
+    "SEQUENTIAL_DISTORTION",
+    "COALITION_DRIFT",
+    "SILENT_PROPAGATION",
+];
+exports.SIRL_RECOMMENDED_ACTIONS = [
+    "OBSERVE",
+    "FLAG",
+    "REQUIRE_REVIEW",
+    "FREEZE_CHAIN",
+    "SPLIT_CLUSTER",
+    "REPLAN",
+];
+/** v1 weights — tune per workflow; sum need not be 1 (they apply to risk terms). */
+exports.SIRL_CRS_WEIGHTS = {
+    collusionLikelihood: 0.3,
+    conformityIndex: 0.2,
+    sequentialDistortionRate: 0.2,
+    resourceSkewScore: 0.15,
+    coalitionDriftScore: 0.1,
+    silentPropagationRisk: 0.05,
+};
+/**
+ * Collective Reflex Score: trust in the interaction pattern, 0–100 (aligned with {@link computeReflexScore}).
+ * CRS = 100 * (1 - weighted sum of risk subscores).
+ */
+function computeCollectiveReflexScore(subscores, weights = {}) {
+    const w = { ...exports.SIRL_CRS_WEIGHTS, ...weights };
+    const rawRisk = subscores.collusionLikelihood * w.collusionLikelihood +
+        subscores.conformityIndex * w.conformityIndex +
+        subscores.sequentialDistortionRate * w.sequentialDistortionRate +
+        subscores.resourceSkewScore * w.resourceSkewScore +
+        subscores.coalitionDriftScore * w.coalitionDriftScore +
+        subscores.silentPropagationRisk * w.silentPropagationRisk;
+    const crs = 100 * (1 - Math.min(1, Math.max(0, rawRisk)));
+    return Math.round(Math.min(100, Math.max(0, crs)) * 100) / 100;
+}
+const DEFAULT_TRUST_COMPOSITE = {
+    individualReflex: 0.6,
+    collectiveReflex: 0.4,
+};
+/** IRS and CRS on 0–100; returns 0–100. */
+function computeTrustComposite(individualReflexScore, collectiveReflexScore, weights = {}) {
+    const w = { ...DEFAULT_TRUST_COMPOSITE, ...weights };
+    const sum = w.individualReflex + w.collectiveReflex;
+    const n = sum > 0 ? sum : 1;
+    const score = (individualReflexScore * w.individualReflex +
+        collectiveReflexScore * w.collectiveReflex) /
+        n;
+    return Math.round(Math.min(100, Math.max(0, score)) * 100) / 100;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@reconai/reflex-core",
+  "version": "0.1.0",
+  "description": "Reflex score and decision classification primitives for ReconAI.",
+  "private": false,
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vitest": "^3.0.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}