@vorionsys/atsf-core 0.2.0 → 0.2.1

package/dist/phase6/weight-presets/canonical.js

@@ -0,0 +1,122 @@
+/**
+ * Q4: Weight Presets - Canonical Trust Weights
+ * ACI specification canonical trust scoring weights
+ *
+ * The canonical weights define the baseline trust computation formula:
+ * - Base weights from ACI spec (standardized across implementations)
+ * - Immutable reference values
+ * - Used as foundation for delta application
+ *
+ * Trust Score Computation:
+ * score = (successRatio × 400) +
+ *         (authorizationHistory × 200) +
+ *         (cascadePreventionScore × 150) +
+ *         (executionEfficiency × 150) +
+ *         (behaviorStability × 100)
+ *
+ * Total weight: 1000 points
+ */
+/**
+ * Success Ratio Weight (0-400 points)
+ * Measures the fraction of decisions that succeeded without error
+ * Formula: successCount / totalDecisions
+ * Weight: 40% of total score
+ */
+export const WEIGHT_SUCCESS_RATIO = 400;
+/**
+ * Authorization History Weight (0-200 points)
+ * Measures alignment between attempted and authorized actions
+ * Penalizes agents that frequently attempt unauthorized actions
+ * Formula: (authorizedCount / attemptedCount) × WEIGHT_AUTHORIZATION_HISTORY
+ * Weight: 20% of total score
+ */
+export const WEIGHT_AUTHORIZATION_HISTORY = 200;
+/**
+ * Cascade Prevention Score Weight (0-150 points)
+ * Measures how well an agent's errors are contained
+ * Penalizes agents whose failures cause downstream cascades
+ * Formula: 1 - (cascadeFailures / totalFailures) × WEIGHT_CASCADE_PREVENTION
+ * Weight: 15% of total score
+ */
+export const WEIGHT_CASCADE_PREVENTION = 150;
+/**
+ * Execution Efficiency Weight (0-150 points)
+ * Measures resource consumption vs. business value delivered
+ * Penalizes agents that waste computational resources
+ * Formula: (businessValuePerResource) / (maxValuePerResource) × WEIGHT_EXECUTION_EFFICIENCY
+ * Weight: 15% of total score
+ */
+export const WEIGHT_EXECUTION_EFFICIENCY = 150;
+/**
+ * Behavior Stability Weight (0-100 points)
+ * Measures consistency of agent behavior over time
+ * Detects pattern drift which could indicate compromise
+ * Formula: 1 - (patternDriftDistance) × WEIGHT_BEHAVIOR_STABILITY
+ * Weight: 10% of total score
+ */
+export const WEIGHT_BEHAVIOR_STABILITY = 100;
+/**
+ * Canonical weights aggregated
+ */
+export const CANONICAL_TRUST_WEIGHTS = {
+    successRatio: WEIGHT_SUCCESS_RATIO,
+    authorizationHistory: WEIGHT_AUTHORIZATION_HISTORY,
+    cascadePrevention: WEIGHT_CASCADE_PREVENTION,
+    executionEfficiency: WEIGHT_EXECUTION_EFFICIENCY,
+    behaviorStability: WEIGHT_BEHAVIOR_STABILITY,
+};
+/**
+ * Total weight sum (should always be 1000)
+ */
+export const TOTAL_TRUST_WEIGHT = Object.values(CANONICAL_TRUST_WEIGHTS).reduce((sum, weight) => sum + weight, 0);
+/**
+ * Validate that canonical weights sum to 1000
+ */
+export function validateCanonicalWeights() {
+    return TOTAL_TRUST_WEIGHT === 1000;
+}
+/**
+ * Get normalized weight (0-1) for a metric
+ */
+export function getNormalizedWeight(metric) {
+    const weight = CANONICAL_TRUST_WEIGHTS[metric];
+    return weight / TOTAL_TRUST_WEIGHT;
+}
+/**
+ * Get all canonical weight metrics with descriptions
+ */
+export function getCanonicalWeightMetrics() {
+    return [
+        {
+            name: 'Success Ratio',
+            weight: WEIGHT_SUCCESS_RATIO,
+            percentage: (WEIGHT_SUCCESS_RATIO / TOTAL_TRUST_WEIGHT) * 100,
+            description: 'Fraction of decisions that succeeded without error',
+        },
+        {
+            name: 'Authorization History',
+            weight: WEIGHT_AUTHORIZATION_HISTORY,
+            percentage: (WEIGHT_AUTHORIZATION_HISTORY / TOTAL_TRUST_WEIGHT) * 100,
+            description: 'Alignment between attempted and authorized actions',
+        },
+        {
+            name: 'Cascade Prevention',
+            weight: WEIGHT_CASCADE_PREVENTION,
+            percentage: (WEIGHT_CASCADE_PREVENTION / TOTAL_TRUST_WEIGHT) * 100,
+            description: 'How well agent errors are contained and prevented from cascading',
+        },
+        {
+            name: 'Execution Efficiency',
+            weight: WEIGHT_EXECUTION_EFFICIENCY,
+            percentage: (WEIGHT_EXECUTION_EFFICIENCY / TOTAL_TRUST_WEIGHT) * 100,
+            description: 'Resource consumption vs. business value delivered',
+        },
+        {
+            name: 'Behavior Stability',
+            weight: WEIGHT_BEHAVIOR_STABILITY,
+            percentage: (WEIGHT_BEHAVIOR_STABILITY / TOTAL_TRUST_WEIGHT) * 100,
+            description: 'Consistency of agent behavior over time (detects drift)',
+        },
+    ];
+}
+//# sourceMappingURL=canonical.js.map

package/dist/phase6/weight-presets/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../../../src/phase6/weight-presets/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,YAAY,EAAE,oBAAoB;IAClC,oBAAoB,EAAE,4BAA4B;IAClD,iBAAiB,EAAE,yBAAyB;IAC5C,mBAAmB,EAAE,2BAA2B;IAChD,iBAAiB,EAAE,yBAAyB;CACpC,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAC7E,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,EAC7B,CAAC,CACF,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,kBAAkB,KAAK,IAAI,CAAC;AACrC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAA4C;IAC9E,MAAM,MAAM,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC;IAC/C,OAAO,MAAM,GAAG,kBAAkB,CAAC;AACrC,CAAC;AAYD;;GAEG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL;YACE,IAAI,EAAE,eAAe;YACrB,MAAM,EAAE,oBAAoB;YAC5B,UAAU,EAAE,CAAC,oBAAoB,GAAG,kBAAkB,CAAC,GAAG,GAAG;YAC7D,WAAW,EAAE,oDAAoD;SAClE;QACD;YACE,IAAI,EAAE,uBAAuB;YAC7B,MAAM,EAAE,4BAA4B;YACpC,UAAU,EAAE,CAAC,4BAA4B,GAAG,kBAAkB,CAAC,GAAG,GAAG;YACrE,WAAW,EAAE,oDAAoD;SAClE;QACD;YACE,IAAI,EAAE,oBAAoB;YAC1B,MAAM,EAAE,yBAAyB;YACjC,UAAU,EAAE,CAAC,yBAAyB,GAAG,kBAAkB,CAAC,GAAG,GAAG;YAClE,WAAW,EAAE,kEAAkE;SAChF;QACD;YACE,IAAI,EAAE,sBAAsB;YAC5B,MAAM,EAAE,2BAA2B;YACnC,UAAU,EAAE,CAAC,2BAA2B,GAAG,kBAAkB,CAAC,GAAG,GAAG;YACpE,WAAW,EAAE,mDAAmD;SACjE;QACD;YACE,IAAI,EAAE,oBAAoB;YAC1B,MAAM,EAAE,yBAAyB;YACjC,UAAU,EAAE,CAAC,yBAAyB,GAAG,kBAAkB,CAAC,GAAG,GAAG;YAClE,WAAW,EAAE,yDAAyD;SACvE;KACF,CAAC;AACJ,CAAC"}

package/dist/phase6/weight-presets/deltas.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Q4: Weight Presets - Delta Weights
+ * Axiom-specific customization weights that override canonical defaults
+ *
+ * Architecture:
+ * - Deltas are applied as offsets to canonical weights
+ * - Enable domain-specific tuning without modifying standards
+ * - Tracked for audit and compliance
+ * - Can be per-domain, per-tenant, or per-agent
+ */
+import { CANONICAL_TRUST_WEIGHTS } from './canonical.js';
+/**
+ * Direction of weight adjustment
+ */
+export type WeightAdjustmentDirection = 'increase' | 'decrease';
+/**
+ * Weight delta specification
+ */
+export interface WeightDelta {
+    metric: keyof typeof CANONICAL_TRUST_WEIGHTS;
+    adjustment: number;
+    reason: string;
+    appliedAt: Date;
+    appliedBy: string;
+    domain?: string;
+    expiresAt?: Date;
+}
+/**
+ * Tracking info for merged weights
+ */
+export interface WeightMergeRecord {
+    agentId?: string;
+    domain?: string;
+    canonicalWeights: Record<string, number>;
+    deltaWeights: WeightDelta[];
+    mergedWeights: Record<string, number>;
+    mergedAt: Date;
+    reason: string;
+}
+/**
+ * Common delta presets for Axiom domains
+ */
+export declare const AXIOM_DELTA_PRESETS: {
+    /**
+     * Healthcare domain: Emphasize safety, cascade prevention
+     * - Increase cascade prevention (+50 points)
+     * - Increase behavior stability (+30 points)
+     * - Decrease execution efficiency (-20 points, cost acceptable for safety)
+     */
+    readonly healthcare: readonly [{
+        readonly metric: "cascadePrevention";
+        readonly adjustment: 50;
+        readonly reason: "Healthcare domain requires maximum cascade prevention";
+    }, {
+        readonly metric: "behaviorStability";
+        readonly adjustment: 30;
+        readonly reason: "Healthcare requires consistent, predictable behavior";
+    }, {
+        readonly metric: "executionEfficiency";
+        readonly adjustment: -20;
+        readonly reason: "Healthcare prioritizes safety over resource efficiency";
+    }];
+    /**
+     * Finance domain: Emphasize authorization, success ratio
+     * - Increase success ratio (+40 points)
+     * - Increase authorization history (+30 points)
+     * - Decrease behavior stability (-10 points, market conditions vary)
+     */
+    readonly finance: readonly [{
+        readonly metric: "successRatio";
+        readonly adjustment: 40;
+        readonly reason: "Finance requires high success rate for transaction safety";
+    }, {
+        readonly metric: "authorizationHistory";
+        readonly adjustment: 30;
+        readonly reason: "Finance requires strict authorization compliance";
+    }, {
+        readonly metric: "behaviorStability";
+        readonly adjustment: -10;
+        readonly reason: "Finance agents adapt to market conditions";
+    }];
+    /**
+     * Manufacturing domain: Emphasize execution efficiency, cascade prevention
+     * - Increase execution efficiency (+50 points)
+     * - Increase cascade prevention (+20 points)
+     * - Decrease behavior stability (-15 points, production varies)
+     */
+    readonly manufacturing: readonly [{
+        readonly metric: "executionEfficiency";
+        readonly adjustment: 50;
+        readonly reason: "Manufacturing optimizes for throughput and resource utilization";
+    }, {
+        readonly metric: "cascadePrevention";
+        readonly adjustment: 20;
+        readonly reason: "Manufacturing prevents production line cascades";
+    }, {
+        readonly metric: "behaviorStability";
+        readonly adjustment: -15;
+        readonly reason: "Manufacturing behavior adapts to production parameters";
+    }];
+    /**
+     * Research domain: Emphasize behavior stability, success ratio
+     * - Increase behavior stability (+40 points)
+     * - Increase success ratio (+20 points)
+     * - Decrease authorization history (-15 points, requires more autonomy for exploration)
+     */
+    readonly research: readonly [{
+        readonly metric: "behaviorStability";
+        readonly adjustment: 40;
+        readonly reason: "Research requires reproducible, consistent behavior";
+    }, {
+        readonly metric: "successRatio";
+        readonly adjustment: 20;
+        readonly reason: "Research emphasizes successful experiments";
+    }, {
+        readonly metric: "authorizationHistory";
+        readonly adjustment: -15;
+        readonly reason: "Research agents need autonomy for exploratory work";
+    }];
+};
+/**
+ * Apply a delta to canonical weights
+ */
+export declare function applyDelta(canonicalWeights: Record<string, number>, delta: WeightDelta): Record<string, number>;
+/**
+ * Apply multiple deltas to canonical weights
+ */
+export declare function applyDeltas(canonicalWeights: Record<string, number>, deltas: WeightDelta[]): Record<string, number>;
+/**
+ * Validate that delta adjustments don't create invalid weights
+ */
+export declare function validateDeltaAdjustments(canonicalWeights: Record<string, number>, deltas: WeightDelta[]): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Get delta adjustments for a specific domain
+ */
+export declare function getDeltasForDomain(domain: string): WeightDelta[];
+/**
+ * Track weight merge operation
+ */
+export declare function recordWeightMerge(record: WeightMergeRecord): WeightMergeRecord;
+//# sourceMappingURL=deltas.d.ts.map

package/dist/phase6/weight-presets/deltas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltas.d.ts","sourceRoot":"","sources":["../../../src/phase6/weight-presets/deltas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,uBAAuB,EAAsB,MAAM,gBAAgB,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,UAAU,GAAG,UAAU,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,OAAO,uBAAuB,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,QAAQ,EAAE,IAAI,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;OAKG;;;;;;;;;;;;;;IAmBH;;;;;OAKG;;;;;;;;;;;;;;IAmBH;;;;;OAKG;;;;;;;;;;;;;;IAmBH;;;;;OAKG;;;;;;;;;;;;;;CAkBK,CAAC;AAEX;;GAEG;AACH,wBAAgB,UAAU,CACxB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,KAAK,EAAE,WAAW,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxB;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,MAAM,EAAE,WAAW,EAAE,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAExB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,MAAM,EAAE,WAAW,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA+BtC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAYhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,CAK9E"}

package/dist/phase6/weight-presets/deltas.js

@@ -0,0 +1,184 @@
+/**
+ * Q4: Weight Presets - Delta Weights
+ * Axiom-specific customization weights that override canonical defaults
+ *
+ * Architecture:
+ * - Deltas are applied as offsets to canonical weights
+ * - Enable domain-specific tuning without modifying standards
+ * - Tracked for audit and compliance
+ * - Can be per-domain, per-tenant, or per-agent
+ */
+/**
+ * Common delta presets for Axiom domains
+ */
+export const AXIOM_DELTA_PRESETS = {
+    /**
+     * Healthcare domain: Emphasize safety, cascade prevention
+     * - Increase cascade prevention (+50 points)
+     * - Increase behavior stability (+30 points)
+     * - Decrease execution efficiency (-20 points, cost acceptable for safety)
+     */
+    healthcare: [
+        {
+            metric: 'cascadePrevention',
+            adjustment: 50,
+            reason: 'Healthcare domain requires maximum cascade prevention',
+        },
+        {
+            metric: 'behaviorStability',
+            adjustment: 30,
+            reason: 'Healthcare requires consistent, predictable behavior',
+        },
+        {
+            metric: 'executionEfficiency',
+            adjustment: -20,
+            reason: 'Healthcare prioritizes safety over resource efficiency',
+        },
+    ],
+    /**
+     * Finance domain: Emphasize authorization, success ratio
+     * - Increase success ratio (+40 points)
+     * - Increase authorization history (+30 points)
+     * - Decrease behavior stability (-10 points, market conditions vary)
+     */
+    finance: [
+        {
+            metric: 'successRatio',
+            adjustment: 40,
+            reason: 'Finance requires high success rate for transaction safety',
+        },
+        {
+            metric: 'authorizationHistory',
+            adjustment: 30,
+            reason: 'Finance requires strict authorization compliance',
+        },
+        {
+            metric: 'behaviorStability',
+            adjustment: -10,
+            reason: 'Finance agents adapt to market conditions',
+        },
+    ],
+    /**
+     * Manufacturing domain: Emphasize execution efficiency, cascade prevention
+     * - Increase execution efficiency (+50 points)
+     * - Increase cascade prevention (+20 points)
+     * - Decrease behavior stability (-15 points, production varies)
+     */
+    manufacturing: [
+        {
+            metric: 'executionEfficiency',
+            adjustment: 50,
+            reason: 'Manufacturing optimizes for throughput and resource utilization',
+        },
+        {
+            metric: 'cascadePrevention',
+            adjustment: 20,
+            reason: 'Manufacturing prevents production line cascades',
+        },
+        {
+            metric: 'behaviorStability',
+            adjustment: -15,
+            reason: 'Manufacturing behavior adapts to production parameters',
+        },
+    ],
+    /**
+     * Research domain: Emphasize behavior stability, success ratio
+     * - Increase behavior stability (+40 points)
+     * - Increase success ratio (+20 points)
+     * - Decrease authorization history (-15 points, requires more autonomy for exploration)
+     */
+    research: [
+        {
+            metric: 'behaviorStability',
+            adjustment: 40,
+            reason: 'Research requires reproducible, consistent behavior',
+        },
+        {
+            metric: 'successRatio',
+            adjustment: 20,
+            reason: 'Research emphasizes successful experiments',
+        },
+        {
+            metric: 'authorizationHistory',
+            adjustment: -15,
+            reason: 'Research agents need autonomy for exploratory work',
+        },
+    ],
+};
+/**
+ * Apply a delta to canonical weights
+ */
+export function applyDelta(canonicalWeights, delta) {
+    // Check expiration
+    if (delta.expiresAt && new Date() > delta.expiresAt) {
+        return canonicalWeights; // Don't apply expired delta
+    }
+    const adjusted = { ...canonicalWeights };
+    const currentValue = adjusted[delta.metric];
+    // Apply adjustment with bounds checking
+    const newValue = Math.max(0, Math.min(1000, currentValue + delta.adjustment));
+    adjusted[delta.metric] = newValue;
+    return adjusted;
+}
+/**
+ * Apply multiple deltas to canonical weights
+ */
+export function applyDeltas(canonicalWeights, deltas) {
+    return deltas.reduce((weights, delta) => applyDelta(weights, delta), canonicalWeights);
+}
+/**
+ * Validate that delta adjustments don't create invalid weights
+ */
+export function validateDeltaAdjustments(canonicalWeights, deltas) {
+    const errors = [];
+    // Check total weight doesn't exceed limit
+    let totalAdjustment = 0;
+    for (const delta of deltas) {
+        totalAdjustment += delta.adjustment;
+    }
+    if (totalAdjustment < -1000) {
+        errors.push('Total delta adjustments cannot reduce weights below 0');
+    }
+    if (totalAdjustment > 1000) {
+        errors.push('Total delta adjustments cannot exceed 1000 additional points');
+    }
+    // Check individual metrics stay in valid range
+    const adjusted = applyDeltas(canonicalWeights, deltas);
+    for (const [metric, value] of Object.entries(adjusted)) {
+        if (value < 0) {
+            errors.push(`Metric ${metric} cannot have negative weight`);
+        }
+        if (value > 1000) {
+            errors.push(`Metric ${metric} cannot exceed 1000 points`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Get delta adjustments for a specific domain
+ */
+export function getDeltasForDomain(domain) {
+    const preset = AXIOM_DELTA_PRESETS[domain];
+    if (!preset) {
+        return [];
+    }
+    return preset.map((delta) => ({
+        ...delta,
+        appliedAt: new Date(),
+        appliedBy: 'system',
+        domain,
+    }));
+}
+/**
+ * Track weight merge operation
+ */
+export function recordWeightMerge(record) {
+    return {
+        ...record,
+        mergedAt: new Date(),
+    };
+}
+//# sourceMappingURL=deltas.js.map

package/dist/phase6/weight-presets/deltas.js.map

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

package/dist/phase6/weight-presets/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Q4: Weight Presets
+ * Hybrid weight system: canonical ACI weights + Axiom domain deltas
+ */
+export { WEIGHT_SUCCESS_RATIO, WEIGHT_AUTHORIZATION_HISTORY, WEIGHT_CASCADE_PREVENTION, WEIGHT_EXECUTION_EFFICIENCY, WEIGHT_BEHAVIOR_STABILITY, CANONICAL_TRUST_WEIGHTS, TOTAL_TRUST_WEIGHT, validateCanonicalWeights, getNormalizedWeight, getCanonicalWeightMetrics, type CanonicalWeightMetric, } from './canonical.js';
+export { AXIOM_DELTA_PRESETS, applyDelta, applyDeltas, validateDeltaAdjustments, getDeltasForDomain, recordWeightMerge, type WeightDelta, type WeightAdjustmentDirection, type WeightMergeRecord, } from './deltas.js';
+export { mergeWeights, mergeAndValidateWeights, createWeightAuditRecord, compareWeights, formatWeightsForDisplay, computeTrustScore, type MergeStrategy, type MergedTrustWeights, type WeightComputationAudit, } from './merger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/phase6/weight-presets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/phase6/weight-presets/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC5B,yBAAyB,EACzB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,WAAW,EACX,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,cAAc,EACd,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAC"}

package/dist/phase6/weight-presets/index.js

@@ -0,0 +1,8 @@
+/**
+ * Q4: Weight Presets
+ * Hybrid weight system: canonical ACI weights + Axiom domain deltas
+ */
+export { WEIGHT_SUCCESS_RATIO, WEIGHT_AUTHORIZATION_HISTORY, WEIGHT_CASCADE_PREVENTION, WEIGHT_EXECUTION_EFFICIENCY, WEIGHT_BEHAVIOR_STABILITY, CANONICAL_TRUST_WEIGHTS, TOTAL_TRUST_WEIGHT, validateCanonicalWeights, getNormalizedWeight, getCanonicalWeightMetrics, } from './canonical.js';
+export { AXIOM_DELTA_PRESETS, applyDelta, applyDeltas, validateDeltaAdjustments, getDeltasForDomain, recordWeightMerge, } from './deltas.js';
+export { mergeWeights, mergeAndValidateWeights, createWeightAuditRecord, compareWeights, formatWeightsForDisplay, computeTrustScore, } from './merger.js';
+//# sourceMappingURL=index.js.map

package/dist/phase6/weight-presets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/phase6/weight-presets/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC5B,yBAAyB,EACzB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,GAE1B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,WAAW,EACX,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,GAIlB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,cAAc,EACd,uBAAuB,EACvB,iBAAiB,GAIlB,MAAM,aAAa,CAAC"}

package/dist/phase6/weight-presets/merger.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Q4: Weight Presets - Weight Merger
+ * Combines canonical ACI weights with Axiom deltas to produce final trust weights
+ *
+ * Architecture:
+ * - Deterministic merge process
+ * - Audit trail of all weight decisions
+ * - Supports multiple merge strategies
+ * - Version tracking
+ */
+import { type WeightDelta } from './deltas.js';
+/**
+ * Merge strategy determines how weights are combined
+ */
+export type MergeStrategy = 'canonical' | 'deltaOverride' | 'blended';
+/**
+ * Final merged weights result
+ */
+export interface MergedTrustWeights {
+    successRatio: number;
+    authorizationHistory: number;
+    cascadePrevention: number;
+    executionEfficiency: number;
+    behaviorStability: number;
+}
+/**
+ * Weight computation audit record
+ */
+export interface WeightComputationAudit {
+    timestamp: Date;
+    agentId?: string;
+    domain?: string;
+    strategy: MergeStrategy;
+    canonicalWeights: MergedTrustWeights;
+    appliedDeltas: WeightDelta[];
+    finalWeights: MergedTrustWeights;
+    totalWeight: number;
+    valid: boolean;
+}
+/**
+ * Merge canonical weights with delta adjustments
+ */
+export declare function mergeWeights(deltas?: WeightDelta[], strategy?: MergeStrategy): MergedTrustWeights;
+/**
+ * Merge weights and validate the result
+ */
+export declare function mergeAndValidateWeights(deltas?: WeightDelta[], strategy?: MergeStrategy): {
+    weights: MergedTrustWeights;
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create an audit record for weight computation
+ */
+export declare function createWeightAuditRecord(canonicalWeights: MergedTrustWeights, appliedDeltas: WeightDelta[], finalWeights: MergedTrustWeights, strategy?: MergeStrategy, agentId?: string, domain?: string): WeightComputationAudit;
+/**
+ * Compare canonical vs. merged weights to show impact of deltas
+ */
+export declare function compareWeights(finalWeights: MergedTrustWeights, canonicalWeights?: MergedTrustWeights): Record<string, {
+    canonical: number;
+    final: number;
+    delta: number;
+    percentChange: number;
+}>;
+/**
+ * Format weights for display
+ */
+export declare function formatWeightsForDisplay(weights: MergedTrustWeights): string;
+/**
+ * Compute agent's final trust score using merged weights
+ */
+export declare function computeTrustScore(weights: MergedTrustWeights, metrics: {
+    successRatio: number;
+    authorizationHistory: number;
+    cascadePrevention: number;
+    executionEfficiency: number;
+    behaviorStability: number;
+}): number;
+//# sourceMappingURL=merger.d.ts.map

package/dist/phase6/weight-presets/merger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merger.d.ts","sourceRoot":"","sources":["../../../src/phase6/weight-presets/merger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,eAAe,GAAG,SAAS,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,gBAAgB,EAAE,kBAAkB,CAAC;IACrC,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,YAAY,EAAE,kBAAkB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,GAAE,WAAW,EAAO,EAC1B,QAAQ,GAAE,aAA+B,GACxC,kBAAkB,CA0DpB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,GAAE,WAAW,EAAO,EAC1B,QAAQ,GAAE,aAA+B,GACxC;IACD,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CA+BA;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,kBAAkB,EACpC,aAAa,EAAE,WAAW,EAAE,EAC5B,YAAY,EAAE,kBAAkB,EAChC,QAAQ,GAAE,aAA+B,EACzC,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,GACd,sBAAsB,CAcxB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,kBAAkB,EAChC,gBAAgB,GAAE,kBAA4C,GAC7D,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB5F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAiB3E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE;IACP,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GACA,MAAM,CAUR"}