@wowok/agent-mcp 2.7.1 → 2.7.2

package/dist/evaluation/builtins/demand-match.js

@@ -1,153 +1 @@
-import { requiredCapabilities } from "../capability.js";
-import { getEvaluationEngine } from "../engine.js";
-import { extractDemandCapability, extractServiceCapability } from "../extract.js";
-import { relateRegion } from "../region.js";
-export const DEMAND_MATCH_EVALUATION = "demand_match";
-const REGION_SCORE = {
-    exact: 100,
-    contains: 85,
-    compatible: 60,
-    overlap: 40,
-    mismatch: 0,
-};
-const dsCaps = {
-    id: "ds_caps",
-    description: "Extract demand + service capability vectors (either may be pre-computed or raw)",
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    extract: (ctx) => ({
-        demand_cap: ctx.entities.demand_cap
-            ?? extractDemandCapability(ctx.entities.demand),
-        service_cap: ctx.entities.service_cap
-            ?? extractServiceCapability(ctx.entities.service),
-    }),
-};
-const regionRule = {
-    id: "region",
-    description: "Geographic region relation between demand and service",
-    dimension: "region",
-    weight: 15,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const d = ctx.facts.demand_cap;
-        const s = ctx.facts.service_cap;
-        const rel = relateRegion(d.region, s.region);
-        return { score: REGION_SCORE[rel], weight: 15, reason: `region ${rel}` };
-    },
-};
-const industryRule = {
-    id: "industry",
-    description: "Industry scenario match",
-    dimension: "industry",
-    weight: 20,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const d = ctx.facts.demand_cap;
-        const s = ctx.facts.service_cap;
-        if (d.industry === "general" || s.industry === "general") {
-            return { score: 50, weight: 20, reason: "industry unknown (neutral)" };
-        }
-        const score = d.industry === s.industry ? 100 : 0;
-        return { score, weight: 20, reason: `${d.industry} vs ${s.industry}` };
-    },
-};
-const priceRule = {
-    id: "price",
-    description: "Service price within demand budget",
-    dimension: "price",
-    weight: 15,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const d = ctx.facts.demand_cap;
-        const s = ctx.facts.service_cap;
-        if (d.price_max === undefined || s.price_min === undefined) {
-            return { score: 50, weight: 15, reason: "price unknown (neutral)" };
-        }
-        if (s.price_min <= d.price_max) {
-            return { score: 100, weight: 15, reason: "within budget" };
-        }
-        if (s.price_min <= (d.price_max * 110n) / 100n) {
-            return { score: 50, weight: 15, reason: "slightly over budget" };
-        }
-        return { score: 0, weight: 15, reason: "over budget" };
-    },
-};
-const trustRule = {
-    id: "trust",
-    description: "Service trust score",
-    dimension: "trust",
-    weight: 15,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const s = ctx.facts.service_cap;
-        const t = s.trust_score;
-        const score = t >= 75 ? 100 : t >= 50 ? 60 : t >= 25 ? 30 : 0;
-        return { score, weight: 15, reason: `trust ${t}` };
-    },
-};
-const capabilitiesRule = {
-    id: "capabilities",
-    description: "Demand capability requirements covered by the service",
-    dimension: "capabilities",
-    weight: 30,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const d = ctx.facts.demand_cap;
-        const s = ctx.facts.service_cap;
-        const required = requiredCapabilities(d.capabilities);
-        if (required.length === 0) {
-            return { score: 50, weight: 30, reason: "no capability requirement (neutral)" };
-        }
-        const matched = required.filter((k) => s.capabilities[k]);
-        return {
-            score: Math.round((matched.length / required.length) * 100),
-            weight: 30,
-            matched: matched,
-            mismatched: required.filter((k) => !s.capabilities[k]),
-            reason: `${matched.length}/${required.length} required capabilities covered`,
-        };
-    },
-};
-const tagsRule = {
-    id: "tags",
-    description: "Keyword/tag overlap",
-    dimension: "tags",
-    weight: 5,
-    evaluation_ids: [DEMAND_MATCH_EVALUATION],
-    evaluate: (ctx) => {
-        const d = ctx.facts.demand_cap;
-        const s = ctx.facts.service_cap;
-        const demandSet = new Set((d.keywords ?? []).map((k) => k.toLowerCase()));
-        const serviceSet = new Set([...(s.tags ?? []), ...(s.keywords ?? [])].map((k) => k.toLowerCase()));
-        if (demandSet.size === 0) {
-            return { score: 50, weight: 5, reason: "no keywords (neutral)" };
-        }
-        const overlap = [...demandSet].filter((k) => serviceSet.has(k)).length;
-        return { score: Math.round((overlap / demandSet.size) * 100), weight: 5, reason: `${overlap}/${demandSet.size} keywords` };
-    },
-};
-export function registerDemandMatchEvaluation(engine = getEvaluationEngine()) {
-    engine.registerDataSource(dsCaps);
-    for (const r of [regionRule, industryRule, priceRule, trustRule, capabilitiesRule, tagsRule]) {
-        engine.registerRule(r);
-    }
-}
-export async function matchDemandToServices(demandCap, services, injection, limit = 5) {
-    const engine = getEvaluationEngine();
-    const matches = [];
-    for (const service of services) {
-        const result = await engine.evaluate(DEMAND_MATCH_EVALUATION, { demand_cap: demandCap, service }, injection);
-        matches.push({ service, result });
-    }
-    matches.sort((a, b) => b.result.total - a.result.total);
-    return matches.slice(0, limit);
-}
-export async function matchServiceToDemands(serviceCap, demands, injection, limit = 5) {
-    const engine = getEvaluationEngine();
-    const matches = [];
-    for (const demand of demands) {
-        const result = await engine.evaluate(DEMAND_MATCH_EVALUATION, { service_cap: serviceCap, demand }, injection);
-        matches.push({ demand, result });
-    }
-    matches.sort((a, b) => b.result.total - a.result.total);
-    return matches.slice(0, limit);
-}
+import{requiredCapabilities}from'../capability.js';import{getEvaluationEngine}from'../engine.js';import{extractDemandCapability,extractServiceCapability}from'../extract.js';import{relateRegion}from'../region.js';export const DEMAND_MATCH_EVALUATION='demand_match';const REGION_SCORE={'exact':0x64,'contains':0x55,'compatible':0x3c,'overlap':0x28,'mismatch':0x0},dsCaps={'id':'ds_caps','description':'Extract\x20demand\x20+\x20service\x20capability\x20vectors\x20(either\x20may\x20be\x20pre-computed\x20or\x20raw)','evaluation_ids':[DEMAND_MATCH_EVALUATION],'extract':a=>({'demand_cap':a['entities']['demand_cap']??extractDemandCapability(a['entities']['demand']),'service_cap':a['entities']['service_cap']??extractServiceCapability(a['entities']['service'])})},regionRule={'id':'region','description':'Geographic\x20region\x20relation\x20between\x20demand\x20and\x20service','dimension':'region','weight':0xf,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['demand_cap'],c=a['facts']['service_cap'],e=relateRegion(b['region'],c['region']);return{'score':REGION_SCORE[e],'weight':0xf,'reason':'region\x20'+e};}},industryRule={'id':'industry','description':'Industry\x20scenario\x20match','dimension':'industry','weight':0x14,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['demand_cap'],c=a['facts']['service_cap'];if(b['industry']==='general'||c['industry']==='general')return{'score':0x32,'weight':0x14,'reason':'industry\x20unknown\x20(neutral)'};const e=b['industry']===c['industry']?0x64:0x0;return{'score':e,'weight':0x14,'reason':b['industry']+'\x20vs\x20'+c['industry']};}},priceRule={'id':'price','description':'Service\x20price\x20within\x20demand\x20budget','dimension':'price','weight':0xf,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['demand_cap'],c=a['facts']['service_cap'];if(b['price_max']===undefined||c['price_min']===undefined)return{'score':0x32,'weight':0xf,'reason':'price\x20unknown\x20(neutral)'};if(c['price_min']<=b['price_max'])return{'score':0x64,'weight':0xf,'reason':'within\x20budget'};if(c['price_min']<=b['price_max']*0x6en/0x64n)return{'score':0x32,'weight':0xf,'reason':'slightly\x20over\x20budget'};return{'score':0x0,'weight':0xf,'reason':'over\x20budget'};}},trustRule={'id':'trust','description':'Service\x20trust\x20score','dimension':'trust','weight':0xf,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['service_cap'],c=b['trust_score'],d=c>=0x4b?0x64:c>=0x32?0x3c:c>=0x19?0x1e:0x0;return{'score':d,'weight':0xf,'reason':'trust\x20'+c};}},capabilitiesRule={'id':'capabilities','description':'Demand\x20capability\x20requirements\x20covered\x20by\x20the\x20service','dimension':'capabilities','weight':0x1e,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['demand_cap'],c=a['facts']['service_cap'],e=requiredCapabilities(b['capabilities']);if(e['length']===0x0)return{'score':0x32,'weight':0x1e,'reason':'no\x20capability\x20requirement\x20(neutral)'};const f=e['filter'](g=>c['capabilities'][g]);return{'score':Math['round'](f['length']/e['length']*0x64),'weight':0x1e,'matched':f,'mismatched':e['filter'](g=>!c['capabilities'][g]),'reason':f['length']+'/'+e['length']+'\x20required\x20capabilities\x20covered'};}},tagsRule={'id':'tags','description':'Keyword/tag\x20overlap','dimension':'tags','weight':0x5,'evaluation_ids':[DEMAND_MATCH_EVALUATION],'evaluate':a=>{const b=a['facts']['demand_cap'],c=a['facts']['service_cap'],e=new Set((b['keywords']??[])['map'](h=>h['toLowerCase']())),f=new Set([...c['tags']??[],...c['keywords']??[]]['map'](h=>h['toLowerCase']()));if(e['size']===0x0)return{'score':0x32,'weight':0x5,'reason':'no\x20keywords\x20(neutral)'};const g=[...e]['filter'](h=>f['has'](h))['length'];return{'score':Math['round'](g/e['size']*0x64),'weight':0x5,'reason':g+'/'+e['size']+'\x20keywords'};}};export function registerDemandMatchEvaluation(a=getEvaluationEngine()){a['registerDataSource'](dsCaps);for(const b of[regionRule,industryRule,priceRule,trustRule,capabilitiesRule,tagsRule]){a['registerRule'](b);}}export async function matchDemandToServices(a,b,c,d=0x5){const e=getEvaluationEngine(),f=[];for(const g of b){const h=await e['evaluate'](DEMAND_MATCH_EVALUATION,{'demand_cap':a,'service':g},c);f['push']({'service':g,'result':h});}return f['sort']((i,j)=>j['result']['total']-i['result']['total']),f['slice'](0x0,d);}export async function matchServiceToDemands(a,b,c,d=0x5){const e=getEvaluationEngine(),f=[];for(const g of b){const h=await e['evaluate'](DEMAND_MATCH_EVALUATION,{'service_cap':a,'demand':g},c);f['push']({'demand':g,'result':h});}return f['sort']((i,j)=>j['result']['total']-i['result']['total']),f['slice'](0x0,d);}

package/dist/evaluation/builtins/index.js

@@ -1,10 +1 @@
-import { getEvaluationEngine } from "../engine.js";
-import { registerDemandMatchEvaluation } from "./demand-match.js";
-import { registerServiceRiskEvaluation } from "./service-risk.js";
-export function registerBuiltinEvaluations() {
-    const engine = getEvaluationEngine();
-    registerDemandMatchEvaluation(engine);
-    registerServiceRiskEvaluation(engine);
-}
-export { registerDemandMatchEvaluation, matchDemandToServices, matchServiceToDemands, DEMAND_MATCH_EVALUATION, } from "./demand-match.js";
-export { registerServiceRiskEvaluation, assessServiceRisk, SERVICE_RISK_EVALUATION, } from "./service-risk.js";
+import{getEvaluationEngine}from'../engine.js';import{registerDemandMatchEvaluation}from'./demand-match.js';import{registerServiceRiskEvaluation}from'./service-risk.js';export function registerBuiltinEvaluations(){const a=getEvaluationEngine();registerDemandMatchEvaluation(a),registerServiceRiskEvaluation(a);}export{registerDemandMatchEvaluation,matchDemandToServices,matchServiceToDemands,DEMAND_MATCH_EVALUATION}from'./demand-match.js';export{registerServiceRiskEvaluation,assessServiceRisk,SERVICE_RISK_EVALUATION}from'./service-risk.js';

package/dist/evaluation/builtins/service-risk.js

@@ -1,55 +1 @@
-import { assembleInfoPuzzle } from "../../customer/info-puzzle.js";
-import { assessWorkflowRisk, assessFundRisk, assessTrustRisk, assessBehaviorRisk, } from "../../customer/risk-assessment.js";
-import { getEvaluationEngine } from "../engine.js";
-export const SERVICE_RISK_EVALUATION = "service_risk";
-const dsPuzzle = {
-    id: "ds_puzzle",
-    description: "Assemble the service info puzzle from raw chain data",
-    evaluation_ids: [SERVICE_RISK_EVALUATION],
-    extract: (ctx) => {
-        const serviceId = ctx.entities.service_id;
-        const raw = ctx.entities.puzzle_raw;
-        const depth = ctx.entities.depth ?? "preorder";
-        return { puzzle: assembleInfoPuzzle(serviceId, raw, depth) };
-    },
-};
-function dimensionRule(id, dimension, weight, assess) {
-    return {
-        id,
-        description: `${dimension} risk dimension`,
-        dimension,
-        weight,
-        evaluation_ids: [SERVICE_RISK_EVALUATION],
-        evaluate: (ctx) => {
-            const puzzle = ctx.facts.puzzle;
-            const d = assess(puzzle);
-            const normalized = d.max_score > 0 ? Math.round((d.score / d.max_score) * 100) : 0;
-            const passed = d.checks.filter((c) => c.passed);
-            const failed = d.checks.filter((c) => !c.passed);
-            const critical = failed.filter((c) => c.advice?.startsWith("🔴"));
-            return {
-                score: normalized,
-                weight,
-                reason: critical.length > 0
-                    ? critical.map((c) => `[${d.name}] ${c.description}: ${c.advice}`).join("; ")
-                    : `${d.name} ${d.score}/${d.max_score}`,
-                matched: passed.map((c) => c.id),
-                mismatched: failed.map((c) => c.id),
-                red_flag: critical.length > 0,
-            };
-        },
-    };
-}
-const workflowRule = dimensionRule("workflow", "workflow", 35, assessWorkflowRisk);
-const fundRule = dimensionRule("fund", "fund", 25, assessFundRisk);
-const trustRule = dimensionRule("trust", "trust", 20, assessTrustRisk);
-const behaviorRule = dimensionRule("behavior", "behavior", 20, assessBehaviorRisk);
-export function registerServiceRiskEvaluation(engine = getEvaluationEngine()) {
-    engine.registerDataSource(dsPuzzle);
-    for (const r of [workflowRule, fundRule, trustRule, behaviorRule]) {
-        engine.registerRule(r);
-    }
-}
-export async function assessServiceRisk(serviceId, raw, injection, depth = "preorder") {
-    return getEvaluationEngine().evaluate(SERVICE_RISK_EVALUATION, { service_id: serviceId, puzzle_raw: raw, depth }, injection);
-}
+import{assembleInfoPuzzle}from'../../customer/info-puzzle.js';import{assessWorkflowRisk,assessFundRisk,assessTrustRisk,assessBehaviorRisk}from'../../customer/risk-assessment.js';import{getEvaluationEngine}from'../engine.js';export const SERVICE_RISK_EVALUATION='service_risk';const dsPuzzle={'id':'ds_puzzle','description':'Assemble\x20the\x20service\x20info\x20puzzle\x20from\x20raw\x20chain\x20data','evaluation_ids':[SERVICE_RISK_EVALUATION],'extract':a=>{const b=a['entities']['service_id'],c=a['entities']['puzzle_raw'],d=a['entities']['depth']??'preorder';return{'puzzle':assembleInfoPuzzle(b,c,d)};}};function dimensionRule(a,b,c,d){return{'id':a,'description':b+'\x20risk\x20dimension','dimension':b,'weight':c,'evaluation_ids':[SERVICE_RISK_EVALUATION],'evaluate':e=>{const f=e['facts']['puzzle'],g=d(f),h=g['max_score']>0x0?Math['round'](g['score']/g['max_score']*0x64):0x0,i=g['checks']['filter'](l=>l['passed']),j=g['checks']['filter'](l=>!l['passed']),k=j['filter'](l=>l['advice']?.['startsWith']('🔴'));return{'score':h,'weight':c,'reason':k['length']>0x0?k['map'](l=>'['+g['name']+']\x20'+l['description']+':\x20'+l['advice'])['join'](';\x20'):g['name']+'\x20'+g['score']+'/'+g['max_score'],'matched':i['map'](l=>l['id']),'mismatched':j['map'](l=>l['id']),'red_flag':k['length']>0x0};}};}const workflowRule=dimensionRule('workflow','workflow',0x23,assessWorkflowRisk),fundRule=dimensionRule('fund','fund',0x19,assessFundRisk),trustRule=dimensionRule('trust','trust',0x14,assessTrustRisk),behaviorRule=dimensionRule('behavior','behavior',0x14,assessBehaviorRisk);export function registerServiceRiskEvaluation(a=getEvaluationEngine()){a['registerDataSource'](dsPuzzle);for(const b of[workflowRule,fundRule,trustRule,behaviorRule]){a['registerRule'](b);}}export async function assessServiceRisk(a,b,c,d='preorder'){return getEvaluationEngine()['evaluate'](SERVICE_RISK_EVALUATION,{'service_id':a,'puzzle_raw':b,'depth':d},c);}

package/dist/evaluation/capability.js

@@ -1,13 +1 @@
-export const REQUIREMENT_CAPABILITY_KEYS = [
-    "has_arbitration",
-    "has_refund_path",
-    "has_milestone_nodes",
-    "has_compensation_fund",
-    "has_wip_verification",
-    "has_messenger",
-    "has_buy_guard",
-    "has_dynamic_pricing",
-];
-export function requiredCapabilities(c) {
-    return REQUIREMENT_CAPABILITY_KEYS.filter((k) => c[k] === true);
-}
+export const REQUIREMENT_CAPABILITY_KEYS=['has_arbitration','has_refund_path','has_milestone_nodes','has_compensation_fund','has_wip_verification','has_messenger','has_buy_guard','has_dynamic_pricing'];export function requiredCapabilities(a){return REQUIREMENT_CAPABILITY_KEYS['filter'](b=>a[b]===!![]);}

package/dist/evaluation/composer.js

@@ -1,40 +1 @@
-import { requiredCapabilities } from "./capability.js";
-import { relateRegion } from "./region.js";
-export function composeServicesForDemand(demand, services) {
-    const required = requiredCapabilities(demand.capabilities);
-    const remaining = new Set(required);
-    const chosen = [];
-    const candidates = services.filter((s) => relateRegion(demand.region, s.region) !== "mismatch");
-    while (remaining.size > 0) {
-        let best = null;
-        for (const s of candidates) {
-            if (chosen.some((c) => c.id === s.id))
-                continue;
-            const covered = required.filter((k) => remaining.has(k) && s.capabilities[k]);
-            if (!best || covered.length > best.covered.length) {
-                best = { id: s.id, covered };
-            }
-        }
-        if (!best || best.covered.length === 0)
-            break;
-        chosen.push(best);
-        for (const k of best.covered)
-            remaining.delete(k);
-    }
-    const coverage = required.length === 0
-        ? 100
-        : Math.round(((required.length - remaining.size) / required.length) * 100);
-    const feasibility = remaining.size === 0 ? "ready"
-        : chosen.length > 0 ? "needs_supply_chain"
-            : "infeasible";
-    return {
-        demand: demand.id,
-        services: chosen,
-        coverage_score: coverage,
-        remaining_missing: [...remaining],
-        feasibility,
-        summary: remaining.size === 0
-            ? `Composite of ${chosen.length} service(s) covers all ${required.length} requirements`
-            : `Composite of ${chosen.length} service(s) covers ${coverage}/100; missing: ${[...remaining].join(", ") || "none"}`,
-    };
-}
+import{requiredCapabilities}from'./capability.js';import{relateRegion}from'./region.js';export function composeServicesForDemand(a,b){const c=requiredCapabilities(a['capabilities']),d=new Set(c),e=[],f=b['filter'](i=>relateRegion(a['region'],i['region'])!=='mismatch');while(d['size']>0x0){let i=null;for(const j of f){if(e['some'](m=>m['id']===j['id']))continue;const l=c['filter'](m=>d['has'](m)&&j['capabilities'][m]);(!i||l['length']>i['covered']['length'])&&(i={'id':j['id'],'covered':l});}if(!i||i['covered']['length']===0x0)break;e['push'](i);for(const m of i['covered'])d['delete'](m);}const g=c['length']===0x0?0x64:Math['round']((c['length']-d['size'])/c['length']*0x64),h=d['size']===0x0?'ready':e['length']>0x0?'needs_supply_chain':'infeasible';return{'demand':a['id'],'services':e,'coverage_score':g,'remaining_missing':[...d],'feasibility':h,'summary':d['size']===0x0?'Composite\x20of\x20'+e['length']+'\x20service(s)\x20covers\x20all\x20'+c['length']+'\x20requirements':'Composite\x20of\x20'+e['length']+'\x20service(s)\x20covers\x20'+g+'/100;\x20missing:\x20'+([...d]['join'](',\x20')||'none')};}

package/dist/evaluation/engine.js

@@ -1,175 +1 @@
-import { REQUIREMENT_PASS_THRESHOLD, effectiveWeight, isDataSourceEnabled, isRuleEnabled, normalizeInjection, } from "./user-injection.js";
-const LEVELS = [
-    { min: 85, level: "low" },
-    { min: 70, level: "medium_low" },
-    { min: 50, level: "medium_high" },
-    { min: 0, level: "high" },
-];
-export function levelFromScore(score) {
-    for (const l of LEVELS) {
-        if (score >= l.min)
-            return l.level;
-    }
-    return "high";
-}
-function appliesTo(ids, evaluationId) {
-    if (!ids || ids.length === 0)
-        return true;
-    return ids.includes(evaluationId);
-}
-export class EvaluationEngine {
-    static instance = null;
-    dataSources = new Map();
-    rules = new Map();
-    static Instance() {
-        if (!EvaluationEngine.instance) {
-            EvaluationEngine.instance = new EvaluationEngine();
-        }
-        return EvaluationEngine.instance;
-    }
-    registerDataSource(ds) {
-        if (!ds.id || this.dataSources.has(ds.id))
-            return false;
-        this.dataSources.set(ds.id, ds);
-        return true;
-    }
-    unregisterDataSource(id) {
-        return this.dataSources.delete(id);
-    }
-    registerRule(rule) {
-        if (!rule.id || this.rules.has(rule.id))
-            return false;
-        this.rules.set(rule.id, rule);
-        return true;
-    }
-    unregisterRule(id) {
-        return this.rules.delete(id);
-    }
-    getRule(id) {
-        return this.rules.get(id);
-    }
-    listRules() {
-        return Array.from(this.rules.values());
-    }
-    getDataSource(id) {
-        return this.dataSources.get(id);
-    }
-    listDataSources() {
-        return Array.from(this.dataSources.values());
-    }
-    async evaluate(evaluationId, entities, injection) {
-        const inj = normalizeInjection(injection);
-        const ctx = {
-            evaluation_id: evaluationId,
-            entities,
-            facts: {},
-            injection: inj,
-            now: Date.now(),
-        };
-        const trace = [];
-        for (const ds of this.dataSources.values()) {
-            if (!appliesTo(ds.evaluation_ids, evaluationId))
-                continue;
-            if (!isDataSourceEnabled(ds.id, inj)) {
-                trace.push({ kind: "override", id: ds.id, detail: "data source disabled by user override" });
-                continue;
-            }
-            if (ds.isEnabled && !ds.isEnabled(ctx))
-                continue;
-            const extracted = await ds.extract(ctx);
-            Object.assign(ctx.facts, extracted);
-            trace.push({
-                kind: "data_source",
-                id: ds.id,
-                detail: `extracted ${Object.keys(extracted).length} fact(s)`,
-            });
-        }
-        const breakdown = [];
-        const redFlags = [];
-        for (const rule of this.rules.values()) {
-            if (!appliesTo(rule.evaluation_ids, evaluationId))
-                continue;
-            if (!isRuleEnabled(rule.id, inj)) {
-                trace.push({ kind: "override", id: rule.id, detail: "rule disabled by user override" });
-                continue;
-            }
-            if (rule.isEnabled && !rule.isEnabled(ctx))
-                continue;
-            const contribution = rule.evaluate(ctx);
-            if (!contribution)
-                continue;
-            const weight = effectiveWeight(rule, inj);
-            breakdown.push({
-                rule_id: rule.id,
-                dimension: rule.dimension,
-                score: contribution.score,
-                weight,
-                reason: contribution.reason,
-                matched: contribution.matched,
-                mismatched: contribution.mismatched,
-                red_flag: contribution.red_flag,
-            });
-            if (contribution.red_flag) {
-                redFlags.push(contribution.reason ?? `${rule.id} triggered a hard block`);
-            }
-            trace.push({ kind: "rule", id: rule.id, detail: `score=${contribution.score} weight=${weight}` });
-        }
-        const total = aggregateScore(breakdown);
-        let blocked = redFlags.length > 0;
-        for (const req of inj.requirements ?? []) {
-            const item = breakdown.find((b) => b.rule_id === req.rule_id);
-            if (req.condition === "require") {
-                if (!item || item.score < REQUIREMENT_PASS_THRESHOLD || item.red_flag) {
-                    blocked = true;
-                    redFlags.push(req.note ?? `Requirement requires rule '${req.rule_id}' to pass`);
-                }
-            }
-            else if (req.condition === "forbid") {
-                if (item && item.red_flag) {
-                    blocked = true;
-                    redFlags.push(req.note ?? `Requirement forbids rule '${req.rule_id}' from triggering`);
-                }
-            }
-        }
-        const summary = buildSummary(evaluationId, total, breakdown, redFlags, blocked);
-        return {
-            evaluation_id: evaluationId,
-            total,
-            level: levelFromScore(total),
-            breakdown,
-            red_flags: redFlags,
-            blocked,
-            trace,
-            summary,
-        };
-    }
-}
-function aggregateScore(breakdown) {
-    if (breakdown.length === 0)
-        return 0;
-    let weighted = 0;
-    let weightSum = 0;
-    for (const b of breakdown) {
-        weighted += b.score * b.weight;
-        weightSum += b.weight;
-    }
-    if (weightSum <= 0)
-        return 0;
-    return clamp(Math.round(weighted / weightSum), 0, 100);
-}
-function clamp(n, min, max) {
-    return Math.max(min, Math.min(max, n));
-}
-function buildSummary(evaluationId, total, breakdown, redFlags, blocked) {
-    const parts = [`Evaluation '${evaluationId}': score ${total}/100`];
-    if (blocked) {
-        parts.push(`BLOCKED (${redFlags.length} red flag(s))`);
-    }
-    else {
-        parts.push(`${breakdown.length} rule(s) evaluated`);
-    }
-    return parts.join(" — ");
-}
-export function getEvaluationEngine() {
-    return EvaluationEngine.Instance();
-}
+import{REQUIREMENT_PASS_THRESHOLD,effectiveWeight,isDataSourceEnabled,isRuleEnabled,normalizeInjection}from'./user-injection.js';const LEVELS=[{'min':0x55,'level':'low'},{'min':0x46,'level':'medium_low'},{'min':0x32,'level':'medium_high'},{'min':0x0,'level':'high'}];export function levelFromScore(a){for(const b of LEVELS){if(a>=b['min'])return b['level'];}return'high';}function appliesTo(a,b){if(!a||a['length']===0x0)return!![];return a['includes'](b);}export class EvaluationEngine{static ['instance']=null;['dataSources']=new Map();['rules']=new Map();static['Instance'](){return!EvaluationEngine['instance']&&(EvaluationEngine['instance']=new EvaluationEngine()),EvaluationEngine['instance'];}['registerDataSource'](a){if(!a['id']||this['dataSources']['has'](a['id']))return![];return this['dataSources']['set'](a['id'],a),!![];}['unregisterDataSource'](a){return this['dataSources']['delete'](a);}['registerRule'](a){if(!a['id']||this['rules']['has'](a['id']))return![];return this['rules']['set'](a['id'],a),!![];}['unregisterRule'](a){return this['rules']['delete'](a);}['getRule'](a){return this['rules']['get'](a);}['listRules'](){return Array['from'](this['rules']['values']());}['getDataSource'](a){return this['dataSources']['get'](a);}['listDataSources'](){return Array['from'](this['dataSources']['values']());}async['evaluate'](a,b,c){const d=normalizeInjection(c),e={'evaluation_id':a,'entities':b,'facts':{},'injection':d,'now':Date['now']()},f=[],g=Array['from'](this['dataSources']['values']())['filter'](m=>appliesTo(m['evaluation_ids'],a))['sort']((m,n)=>(m['priority']??0x0)-(n['priority']??0x0));for(const m of g){if(!isDataSourceEnabled(m['id'],d)){f['push']({'kind':'override','id':m['id'],'detail':'data\x20source\x20disabled\x20by\x20user\x20override'});continue;}if(m['isEnabled']&&!m['isEnabled'](e))continue;const n=await m['extract'](e);Object['assign'](e['facts'],n),f['push']({'kind':'data_source','id':m['id'],'detail':'extracted\x20'+Object['keys'](n)['length']+'\x20fact(s)'});}const h=[],i=[];for(const o of this['rules']['values']()){if(!appliesTo(o['evaluation_ids'],a))continue;if(!isRuleEnabled(o['id'],d)){f['push']({'kind':'override','id':o['id'],'detail':'rule\x20disabled\x20by\x20user\x20override'});continue;}if(o['isEnabled']&&!o['isEnabled'](e))continue;const p=o['evaluate'](e);if(!p)continue;const q=effectiveWeight(o,d);h['push']({'rule_id':o['id'],'dimension':o['dimension'],'score':p['score'],'weight':q,'reason':p['reason'],'matched':p['matched'],'mismatched':p['mismatched'],'red_flag':p['red_flag']}),p['red_flag']&&i['push'](p['reason']??o['id']+'\x20triggered\x20a\x20hard\x20block'),f['push']({'kind':'rule','id':o['id'],'detail':'score='+p['score']+'\x20weight='+q});}const j=aggregateScore(h);let k=i['length']>0x0;for(const r of d['requirements']??[]){const s=h['find'](t=>t['rule_id']===r['rule_id']);if(r['condition']==='require')(!s||s['score']<REQUIREMENT_PASS_THRESHOLD||s['red_flag'])&&(k=!![],i['push'](r['note']??'Requirement\x20requires\x20rule\x20\x27'+r['rule_id']+'\x27\x20to\x20pass'));else r['condition']==='forbid'&&(s&&s['red_flag']&&(k=!![],i['push'](r['note']??'Requirement\x20forbids\x20rule\x20\x27'+r['rule_id']+'\x27\x20from\x20triggering')));}const l=buildSummary(a,j,h,i,k);return{'evaluation_id':a,'total':j,'level':levelFromScore(j),'breakdown':h,'red_flags':i,'blocked':k,'trace':f,'summary':l};}}function aggregateScore(a){if(a['length']===0x0)return 0x0;let c=0x0,d=0x0;for(const e of a){c+=e['score']*e['weight'],d+=e['weight'];}if(d<=0x0)return 0x0;return clamp(Math['round'](c/d),0x0,0x64);}function clamp(a,b,c){return Math['max'](b,Math['min'](c,a));}function buildSummary(a,b,c,d,e){const f=['Evaluation\x20\x27'+a+'\x27:\x20score\x20'+b+'/100'];return e?f['push']('BLOCKED\x20('+d['length']+'\x20red\x20flag(s))'):f['push'](c['length']+'\x20rule(s)\x20evaluated'),f['join']('\x20—\x20');}export function getEvaluationEngine(){return EvaluationEngine['Instance']();}

package/dist/evaluation/extract.js

@@ -1,115 +1 @@
-import { parseRegion } from "./region.js";
-import { findSimilarIndustries, inferTraitsFromDescription } from "../knowledge/industry-generalizer.js";
-const BUILTIN_SCENARIOS = [
-    "freelance", "rental", "education", "travel", "subscription", "retail",
-];
-function enrichFromDescription(description) {
-    const text = description?.trim();
-    if (!text) {
-        return { industry: "general", industry_confidence: 0, tags: [], keywords: [] };
-    }
-    const { traits, confidence, matched_keywords } = inferTraitsFromDescription(text);
-    const similar = findSimilarIndustries(traits, 3);
-    const top = similar[0];
-    const industry = top && BUILTIN_SCENARIOS.includes(top.industry)
-        ? top.industry
-        : "general";
-    const hasSignal = matched_keywords.length > 0 || (top?.similarity ?? 0) > 0.2;
-    return {
-        industry: hasSignal ? industry : "general",
-        industry_confidence: hasSignal ? Math.max(confidence, top?.similarity ?? 0) : 0,
-        tags: hasSignal ? similar.slice(0, 3).map((s) => s.industry) : [],
-        keywords: matched_keywords,
-    };
-}
-export function extractServiceCapability(input, overrides) {
-    const sales = input.sales ?? [];
-    const prices = sales
-        .map((s) => toBigInt(s.price))
-        .filter((p) => p !== undefined);
-    const arbitrations = input.arbitrations ?? [];
-    const compensation = toBigInt(input.compensation_fund) ?? 0n;
-    const enriched = enrichFromDescription(input.description);
-    const capabilities = {
-        has_arbitration: arbitrations.length > 0,
-        has_refund_path: arbitrations.length > 0 && compensation > 0n,
-        has_milestone_nodes: false,
-        has_compensation_fund: compensation > 0n,
-        has_wip_verification: sales.some((s) => !!s.wip_hash),
-        has_messenger: input.um != null,
-        has_buy_guard: input.buy_guard != null,
-        has_dynamic_pricing: false,
-        is_published: input.bPublished === true,
-        is_paused: input.bPaused === true,
-    };
-    const base = {
-        id: input.object,
-        kind: "service",
-        owner: input.owner ?? "",
-        industry: enriched.industry,
-        industry_confidence: enriched.industry_confidence,
-        region: parseRegion(input.location),
-        price_min: prices.length > 0 ? minBigInt(prices) : undefined,
-        price_max: prices.length > 0 ? maxBigInt(prices) : undefined,
-        token_type: "",
-        ticket_size: "medium",
-        trust_score: 50,
-        reputation_like_ratio: 1,
-        arbitration_independent: false,
-        merchant_history_count: 0,
-        capabilities,
-        tags: enriched.tags,
-        keywords: enriched.keywords,
-    };
-    return { ...base, ...overrides };
-}
-export function extractDemandCapability(input, overrides) {
-    const enriched = enrichFromDescription(input.description);
-    const base = {
-        id: input.object,
-        kind: "demand",
-        owner: input.owner ?? "",
-        industry: enriched.industry,
-        industry_confidence: enriched.industry_confidence,
-        region: parseRegion(input.location),
-        price_min: undefined,
-        price_max: undefined,
-        token_type: "",
-        ticket_size: "medium",
-        trust_score: 50,
-        reputation_like_ratio: 1,
-        arbitration_independent: false,
-        merchant_history_count: 0,
-        capabilities: {
-            has_arbitration: false,
-            has_refund_path: false,
-            has_milestone_nodes: false,
-            has_compensation_fund: false,
-            has_wip_verification: false,
-            has_messenger: input.um != null,
-            has_buy_guard: false,
-            has_dynamic_pricing: false,
-            is_published: true,
-            is_paused: false,
-        },
-        tags: enriched.tags,
-        keywords: enriched.keywords,
-    };
-    return { ...base, ...overrides };
-}
-function toBigInt(v) {
-    if (v === undefined || v === null)
-        return undefined;
-    try {
-        return BigInt(v);
-    }
-    catch {
-        return undefined;
-    }
-}
-function minBigInt(values) {
-    return values.reduce((a, b) => (a < b ? a : b));
-}
-function maxBigInt(values) {
-    return values.reduce((a, b) => (a > b ? a : b));
-}
+import{parseRegion}from'./region.js';import{findSimilarIndustries,inferTraitsFromDescription}from'../knowledge/industry-generalizer.js';const BUILTIN_SCENARIOS=['freelance','rental','education','travel','subscription','retail'];function enrichFromDescription(a){const b=a?.['trim']();if(!b)return{'industry':'general','industry_confidence':0x0,'tags':[],'keywords':[]};const {traits:c,confidence:d,matched_keywords:e}=inferTraitsFromDescription(b),f=findSimilarIndustries(c,0x3),g=f[0x0],h=g&&BUILTIN_SCENARIOS['includes'](g['industry'])?g['industry']:'general',i=e['length']>0x0||(g?.['similarity']??0x0)>0.2;return{'industry':i?h:'general','industry_confidence':i?Math['max'](d,g?.['similarity']??0x0):0x0,'tags':i?f['slice'](0x0,0x3)['map'](j=>j['industry']):[],'keywords':e};}export function extractServiceCapability(a,b){const c=a['sales']??[],d=c['map'](j=>toBigInt(j['price']))['filter'](j=>j!==undefined),e=a['arbitrations']??[],f=toBigInt(a['compensation_fund'])??0x0n,g=enrichFromDescription(a['description']),h={'has_arbitration':e['length']>0x0,'has_refund_path':e['length']>0x0&&f>0x0n,'has_milestone_nodes':![],'has_compensation_fund':f>0x0n,'has_wip_verification':c['some'](j=>!!j['wip_hash']),'has_messenger':a['um']!=null,'has_buy_guard':a['buy_guard']!=null,'has_dynamic_pricing':![],'is_published':a['bPublished']===!![],'is_paused':a['bPaused']===!![]},i={'id':a['object'],'kind':'service','owner':a['owner']??'','industry':g['industry'],'industry_confidence':g['industry_confidence'],'region':parseRegion(a['location']),'price_min':d['length']>0x0?minBigInt(d):undefined,'price_max':d['length']>0x0?maxBigInt(d):undefined,'token_type':'','ticket_size':'medium','trust_score':0x32,'reputation_like_ratio':0x1,'arbitration_independent':![],'merchant_history_count':0x0,'capabilities':h,'tags':g['tags'],'keywords':g['keywords']};return{...i,...b};}export function extractDemandCapability(a,b){const c=enrichFromDescription(a['description']),d={'id':a['object'],'kind':'demand','owner':a['owner']??'','industry':c['industry'],'industry_confidence':c['industry_confidence'],'region':parseRegion(a['location']),'price_min':undefined,'price_max':undefined,'token_type':'','ticket_size':'medium','trust_score':0x32,'reputation_like_ratio':0x1,'arbitration_independent':![],'merchant_history_count':0x0,'capabilities':{'has_arbitration':![],'has_refund_path':![],'has_milestone_nodes':![],'has_compensation_fund':![],'has_wip_verification':![],'has_messenger':a['um']!=null,'has_buy_guard':![],'has_dynamic_pricing':![],'is_published':!![],'is_paused':![]},'tags':c['tags'],'keywords':c['keywords']};return{...d,...b};}function toBigInt(a){if(a===undefined||a===null)return undefined;try{return BigInt(a);}catch{return undefined;}}function minBigInt(a){return a['reduce']((c,d)=>c<d?c:d);}function maxBigInt(a){return a['reduce']((c,d)=>c>d?c:d);}

package/dist/evaluation/game-strategy.d.ts

@@ -0,0 +1,27 @@
+import type { CommercialRole } from "../role/types.js";
+export type OperationOutcome = "completion" | "refund" | "advance";
+export type RiskAppetite = "conservative" | "balanced" | "aggressive";
+export declare const OUTCOME_SEMANTICS: Record<OperationOutcome, string[]>;
+export interface RoleInterests {
+    prefer: string[];
+    avoid: string[];
+    sensitivity: number;
+}
+export declare const ROLE_INTERESTS: Record<CommercialRole, RoleInterests>;
+export declare function classifyOutcome(consequence?: string): OperationOutcome;
+export declare function appetiteMultiplier(appetite?: RiskAppetite): number;
+export declare function interestsOf(role: CommercialRole): RoleInterests;
+export interface PersonaDrive {
+    risk_appetite?: RiskAppetite;
+    requirements?: string[];
+}
+export declare function resolveInterests(role: CommercialRole, drive?: PersonaDrive): RoleInterests;
+export interface OutcomeEvaluation {
+    gain_score: number;
+    risk_score: number;
+    net_score: number;
+    gains: string[];
+    risks: string[];
+}
+export declare function evaluateOutcome(outcome: OperationOutcome, role: CommercialRole, drive?: PersonaDrive): OutcomeEvaluation;
+export declare function consistencyScore(outcome: OperationOutcome, role: CommercialRole): number;

package/dist/evaluation/game-strategy.js

@@ -0,0 +1 @@
+export const OUTCOME_SEMANTICS={'completion':['fund_released_to_merchant','refund_leverage_given_up'],'refund':['fund_returned_to_buyer','arbitration_review_triggered'],'advance':['node_advanced']};export const ROLE_INTERESTS={'customer':{'prefer':['fund_returned_to_buyer'],'avoid':['fund_released_to_merchant','refund_leverage_given_up'],'sensitivity':0x1},'merchant':{'prefer':['fund_released_to_merchant'],'avoid':['fund_returned_to_buyer','arbitration_review_triggered'],'sensitivity':0x1},'collaborator':{'prefer':['node_advanced'],'avoid':[],'sensitivity':0x1},'supplier':{'prefer':['fund_released_to_merchant','node_advanced'],'avoid':['fund_returned_to_buyer'],'sensitivity':0x1},'prospect':{'prefer':['fund_returned_to_buyer'],'avoid':['fund_released_to_merchant','arbitration_review_triggered','refund_leverage_given_up'],'sensitivity':0x1},'arbitrator':{'prefer':[],'avoid':['arbitration_review_triggered'],'sensitivity':0x1},'system':{'prefer':[],'avoid':[],'sensitivity':0x1}};export function classifyOutcome(a){if(a?.['startsWith']('Completion'))return'completion';if(a?.['startsWith']('Refund'))return'refund';return'advance';}export function appetiteMultiplier(a){switch(a){case'conservative':return 1.5;case'aggressive':return 0.6;default:return 0x1;}}export function interestsOf(a){return ROLE_INTERESTS[a]??{'prefer':[],'avoid':[],'sensitivity':0x1};}function dedupe(a){return Array['from'](new Set(a));}export function resolveInterests(a,b){const c=interestsOf(a),d=c['sensitivity']*appetiteMultiplier(b?.['risk_appetite']),e=[...c['prefer']],f=[...c['avoid']];for(const g of b?.['requirements']??[]){const h=g['toLowerCase'](),i=/forbid|never|\bno\b/['test'](h);if(h['includes']('arbitration')&&i)f['push']('arbitration_review_triggered');if(h['includes']('refund')&&!i)e['push']('fund_returned_to_buyer');if((h['includes']('upfront')||h['includes']('before\x20delivery'))&&i)f['push']('fund_released_to_merchant');if(h['includes']('milestone')&&!i)e['push']('node_advanced');}return{'prefer':dedupe(e),'avoid':dedupe(f),'sensitivity':d};}export function evaluateOutcome(a,b,c){const d=OUTCOME_SEMANTICS[a]??[],e=resolveInterests(b,c),f=e['sensitivity'],g=[],h=[];for(const l of d){if(e['prefer']['includes'](l))g['push'](l);if(e['avoid']['includes'](l))h['push'](l);}const i=g['length']*0x14,j=Math['round'](h['length']*0x19*f),k=Math['max'](0x0,Math['min'](0x64,0x3c+i-j));return{'gain_score':i,'risk_score':j,'net_score':k,'gains':g,'risks':h};}export function consistencyScore(a,b){return evaluateOutcome(a,b)['net_score'];}