@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-GTU2Z2WW.cjs

@@ -0,0 +1,262 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/compiler/identity/AgentRiskRegistry.ts
+function getAgentRiskRegistry(config) {
+  if (!globalRegistry) {
+    globalRegistry = new AgentRiskRegistry(config);
+  }
+  return globalRegistry;
+}
+function isDangerousOperation(operation) {
+  return DANGEROUS_OPERATIONS.includes(operation);
+}
+var DEFAULT_THRESHOLDS, AgentRiskRegistry, globalRegistry, DANGEROUS_OPERATIONS; exports.TIER_COMPOSITION_RISK_CAP = void 0;
+var init_AgentRiskRegistry = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/identity/AgentRiskRegistry.ts"() {
+    DEFAULT_THRESHOLDS = {
+      medium: 15,
+      high: 40,
+      quarantined: 75
+    };
+    AgentRiskRegistry = class {
+      constructor(config = {}) {
+        /** agentId -> ring of recent events (oldest first). */
+        this.events = /* @__PURE__ */ new Map();
+        /** Lifetime counters (not decayed). */
+        this.lifetimeEvents = /* @__PURE__ */ new Map();
+        this.lifetimeSuccesses = /* @__PURE__ */ new Map();
+        this.halfLifeMs = config.halfLifeMs ?? 60 * 60 * 1e3;
+        this.tierThresholds = {
+          medium: config.tierThresholds?.medium ?? DEFAULT_THRESHOLDS.medium,
+          high: config.tierThresholds?.high ?? DEFAULT_THRESHOLDS.high,
+          quarantined: config.tierThresholds?.quarantined ?? DEFAULT_THRESHOLDS.quarantined
+        };
+        this.successCreditPerOp = config.successCreditPerOp ?? 5;
+        this.maxEventsPerAgent = config.maxEventsPerAgent ?? 256;
+        this.now = config.now ?? (() => Date.now());
+        if (this.tierThresholds.medium >= this.tierThresholds.high) {
+          throw new Error("AgentRiskRegistry: tierThresholds.medium must be < high");
+        }
+        if (this.tierThresholds.high >= this.tierThresholds.quarantined) {
+          throw new Error("AgentRiskRegistry: tierThresholds.high must be < quarantined");
+        }
+        if (this.halfLifeMs <= 0) {
+          throw new Error("AgentRiskRegistry: halfLifeMs must be > 0");
+        }
+      }
+      /**
+       * Record a confabulation event from a `ConfabulationValidationResult`.
+       *
+       * Severity is taken from the result's `riskScore`. If the result is `valid`
+       * (no errors) this records a *success*, not a confabulation event — clean
+       * passes lower the agent's running score.
+       */
+      recordValidation(agentId, result) {
+        if (result.valid && result.errors.length === 0) {
+          this.recordSuccess(agentId);
+          return;
+        }
+        const severity = Math.max(1, Math.min(100, Math.round(result.riskScore)));
+        const reason = this.summarizeErrors(result.errors);
+        this.recordEvent({
+          agentId,
+          severity,
+          reason,
+          timestamp: this.now()
+        });
+      }
+      /**
+       * Record a custom risk event (e.g. from a downstream consumer that detected
+       * confabulation outside the standard validator path).
+       */
+      recordEvent(event) {
+        const ring = this.events.get(event.agentId) ?? [];
+        ring.push(event);
+        if (ring.length > this.maxEventsPerAgent) {
+          ring.shift();
+        }
+        this.events.set(event.agentId, ring);
+        this.lifetimeEvents.set(
+          event.agentId,
+          (this.lifetimeEvents.get(event.agentId) ?? 0) + 1
+        );
+      }
+      /**
+       * Record a successful (clean) operation. Reduces the agent's accrued score
+       * by `successCreditPerOp` (post-decay, floored at 0).
+       *
+       * Implemented as a synthetic *negative* event so that decay still applies:
+       * we push a sentinel with negative severity. `getScore` clamps to >=0.
+       */
+      recordSuccess(agentId) {
+        if (this.successCreditPerOp <= 0) {
+          this.lifetimeSuccesses.set(
+            agentId,
+            (this.lifetimeSuccesses.get(agentId) ?? 0) + 1
+          );
+          return;
+        }
+        const ring = this.events.get(agentId) ?? [];
+        ring.push({
+          agentId,
+          severity: -this.successCreditPerOp,
+          reason: "clean-validation",
+          timestamp: this.now()
+        });
+        if (ring.length > this.maxEventsPerAgent) {
+          ring.shift();
+        }
+        this.events.set(agentId, ring);
+        this.lifetimeSuccesses.set(
+          agentId,
+          (this.lifetimeSuccesses.get(agentId) ?? 0) + 1
+        );
+      }
+      /**
+       * Compute the current decayed risk score for an agent (0-100).
+       *
+       * Each event contributes `severity * 0.5 ^ (age / halfLifeMs)`. Negative
+       * (success) events reduce the running total. Final score is clamped to
+       * [0, 100].
+       */
+      getScore(agentId) {
+        const ring = this.events.get(agentId);
+        if (!ring || ring.length === 0) return 0;
+        const now = this.now();
+        let score = 0;
+        for (const ev of ring) {
+          const ageMs = Math.max(0, now - ev.timestamp);
+          const decay = Math.pow(0.5, ageMs / this.halfLifeMs);
+          score += ev.severity * decay;
+        }
+        return Math.max(0, Math.min(100, score));
+      }
+      /**
+       * Classify an agent into a `RiskTier`. Pure function of `getScore`.
+       */
+      getTier(agentId) {
+        const score = this.getScore(agentId);
+        if (score >= this.tierThresholds.quarantined) return "quarantined" /* QUARANTINED */;
+        if (score >= this.tierThresholds.high) return "high" /* HIGH */;
+        if (score >= this.tierThresholds.medium) return "medium" /* MEDIUM */;
+        return "low" /* LOW */;
+      }
+      /**
+       * Snapshot of an agent's current state (for diagnostics / dashboards).
+       */
+      getSnapshot(agentId) {
+        const ring = this.events.get(agentId) ?? [];
+        const positiveEvents = ring.filter((e) => e.severity > 0);
+        const lastPositive = positiveEvents[positiveEvents.length - 1];
+        return {
+          agentId,
+          score: this.getScore(agentId),
+          tier: this.getTier(agentId),
+          recentEventCount: positiveEvents.length,
+          lifetimeEventCount: this.lifetimeEvents.get(agentId) ?? 0,
+          lifetimeSuccessCount: this.lifetimeSuccesses.get(agentId) ?? 0,
+          lastEventAt: lastPositive ? lastPositive.timestamp : null
+        };
+      }
+      /**
+       * Force-set an agent's tier by clearing history and inserting a calibration
+       * event. Used by orchestrators to quarantine a known-bad agent or to
+       * reinstate a rehabilitated one.
+       *
+       * Note: this is an *administrative* operation, not a normal flow. The
+       * caller is responsible for authorization.
+       *
+       * The inserted event is severity = midpoint of the requested tier band
+       * so that small amounts of decay between `setTier` and the next read
+       * don't bump the agent into a lower tier.
+       */
+      setTier(agentId, tier) {
+        this.events.delete(agentId);
+        if (tier === "low" /* LOW */) {
+          return;
+        }
+        let severity;
+        switch (tier) {
+          case "medium" /* MEDIUM */:
+            severity = (this.tierThresholds.medium + this.tierThresholds.high) / 2;
+            break;
+          case "high" /* HIGH */:
+            severity = (this.tierThresholds.high + this.tierThresholds.quarantined) / 2;
+            break;
+          case "quarantined" /* QUARANTINED */:
+            severity = Math.min(100, this.tierThresholds.quarantined + 10);
+            break;
+        }
+        this.recordEvent({
+          agentId,
+          severity,
+          reason: `administrative:set-tier:${tier}`,
+          timestamp: this.now()
+        });
+      }
+      /**
+       * Clear all history for an agent. Resets to LOW tier.
+       */
+      clear(agentId) {
+        this.events.delete(agentId);
+        this.lifetimeEvents.delete(agentId);
+        this.lifetimeSuccesses.delete(agentId);
+      }
+      /**
+       * Clear all state in the registry. Useful for tests.
+       */
+      clearAll() {
+        this.events.clear();
+        this.lifetimeEvents.clear();
+        this.lifetimeSuccesses.clear();
+      }
+      /**
+       * List all agents currently tracked (have at least one event).
+       */
+      listAgents() {
+        return Array.from(this.events.keys());
+      }
+      /**
+       * Configured tier thresholds (read-only view).
+       */
+      getThresholds() {
+        return { ...this.tierThresholds };
+      }
+      /**
+       * Configured half-life in ms (read-only).
+       */
+      getHalfLifeMs() {
+        return this.halfLifeMs;
+      }
+      // ---------------------------------------------------------------------------
+      // PRIVATE HELPERS
+      // ---------------------------------------------------------------------------
+      summarizeErrors(errors) {
+        if (errors.length === 0) return "no-errors";
+        if (errors.length === 1) return errors[0].code;
+        return `${errors[0].code}+${errors.length - 1}-more`;
+      }
+    };
+    globalRegistry = null;
+    DANGEROUS_OPERATIONS = [
+      "write",
+      "transform",
+      "execute"
+    ];
+    exports.TIER_COMPOSITION_RISK_CAP = {
+      ["low" /* LOW */]: 50,
+      ["medium" /* MEDIUM */]: 25,
+      ["high" /* HIGH */]: 10,
+      ["quarantined" /* QUARANTINED */]: -1
+      // sentinel: any composition denied
+    };
+  }
+});
+
+exports.getAgentRiskRegistry = getAgentRiskRegistry;
+exports.init_AgentRiskRegistry = init_AgentRiskRegistry;
+exports.isDangerousOperation = isDangerousOperation;
+//# sourceMappingURL=chunk-GTU2Z2WW.cjs.map
+//# sourceMappingURL=chunk-GTU2Z2WW.cjs.map