| const complianceChecklist = { |
| trade: [ |
| { item: '合同主体与身份真实', positive: ['身份证', '主体', '本人', '授权', '委托书', '营业执照'], negative: ['代签', '不露面', '身份不明'], question: '交易双方主体、身份、授权文件是否真实完整？' }, |
| { item: '权属/处分权清晰', positive: ['产权清晰', '无抵押', '无查封', '可过户', '房东同意', '证照齐全'], negative: ['抵押', '查封', '贷款未结清', '产权不清', '无权处分'], question: '标的是否存在抵押、查封、未解押、共有权人不同意或无权处分？' }, |
| { item: '标的描述明确', positive: ['面积', '房号', '车架号', '里程', '设备清单', '附属设施'], negative: ['模糊', '口头', '说不清'], question: '标的物位置、编号、面积/型号、附属物和交付状态是否写清？' }, |
| { item: '价款与付款节点明确', positive: ['定金', '首付', '尾款', '监管', '付款节点', '价格'], negative: ['口头付款', '私下转账', '不写'], question: '价款、定金、首付、尾款、资金监管和付款节点是否明确？' }, |
| { item: '交付/过户/验收节点明确', positive: ['交付', '过户', '验收', '检测', '交接', '节点'], negative: ['拖延', '不配合', '无法过户'], question: '交付、过户、验收、检测和资料移交的时间节点是否明确？' }, |
| { item: '违约责任与解除条件明确', positive: ['违约', '赔偿', '退款', '解除', '逾期', '定金罚则'], negative: ['没违约', '不退', '口头承诺'], question: '逾期、无法过户、质量问题、资金不到位时的违约责任和解除条件是什么？' }, |
| { item: '强制性规定/限购限贷/税费合规', positive: ['限购', '贷款', '税费', '资质', '备案', '合规'], negative: ['规避', '阴阳合同', '逃税', '借名'], question: '是否涉及限购限贷、税费、备案、资质、阴阳合同或借名交易风险？' }, |
| { item: '证据留存与争议解决', positive: ['书面', '聊天记录', '录音', '收据', '发票', '争议解决', '管辖'], negative: ['只口头', '无凭证'], question: '关键沟通、付款凭证、验收证据、争议解决和管辖条款是否留存？' }, |
| ], |
| career: [ |
| { item: '劳动/合作主体清晰', positive: ['劳动合同', '公司', '主体', '岗位'], negative: ['外包不明', '主体不清'], question: '用工主体、岗位、汇报关系是否清晰？' }, |
| { item: '薪酬绩效书面明确', positive: ['薪酬', '绩效', '奖金', '提成', '书面'], negative: ['口头', '画饼'], question: '薪酬、奖金、绩效、提成和晋升承诺是否有书面依据？' }, |
| { item: '工时加班与休假合规', positive: ['加班费', '调休', '工时', '休假'], negative: ['长期加班', '无加班费'], question: '工时、加班、调休、休假是否符合劳动规则和公司制度？' }, |
| { item: '权责边界与成果归属', positive: ['职责', '权限', '成果', '归属', '授权'], negative: ['权责不清', '背锅'], question: '职责、权限、成果归属和责任边界是否明确？' }, |
| { item: '离职/竞业/保密风险', positive: ['保密', '竞业', '离职', '交接'], negative: ['限制不清', '违约金'], question: '是否涉及保密、竞业限制、违约金、离职交接或知识产权归属？' }, |
| ], |
| partner: [ |
| { item: '合作主体与授权', positive: ['合同', '主体', '授权', '公司', '个人'], negative: ['代签', '主体不清'], question: '合作主体、授权和签约身份是否明确？' }, |
| { item: '贡献/分工/交付物明确', positive: ['分工', '交付', '节点', '贡献', '责任'], negative: ['口头', '模糊'], question: '各方贡献、分工、交付物和验收节点是否明确？' }, |
| { item: '收益分配与结算规则明确', positive: ['分配', '结算', '比例', '账期', '透明'], negative: ['不透明', '拖款'], question: '收益分配、成本承担、结算周期和账目透明规则是否明确？' }, |
| { item: '风险承担和违约退出机制', positive: ['违约', '退出', '赔偿', '止损', '解除'], negative: ['背锅', '无法退出'], question: '违约、亏损、责任承担、退出和清算机制是否明确？' }, |
| { item: '知识产权/客户资源/数据归属', positive: ['知识产权', '客户', '数据', '账号', '归属'], negative: ['抢客户', '账号被卡'], question: '客户资源、账号、数据、知识产权和后续使用权归谁？' }, |
| { item: '证据留存与争议解决', positive: ['书面', '记录', '收据', '管辖', '仲裁'], negative: ['只口头', '无凭证'], question: '关键沟通、交付证据、账目和争议解决条款是否留存？' }, |
| ], |
| }; |
| function clamp(value, min = 0, max = 1) { |
| return Math.min(max, Math.max(min, value)); |
| } |
| function round(value, digits = 3) { |
| const base = 10 ** digits; |
| return Math.round(value * base) / base; |
| } |
| function findEvidence(text, words) { |
| return words.filter((word) => text.includes(word)); |
| } |
| function softmax(values) { |
| const max = Math.max(...values); |
| const exps = values.map((value) => Math.exp(value - max)); |
| const sum = exps.reduce((total, value) => total + value, 0); |
| return exps.map((value) => value / sum); |
| } |
| function weightedAverage(features, weightSelector) { |
| const totalWeight = features.reduce((sum, item) => sum + weightSelector(item), 0); |
| if (totalWeight === 0) |
| return 0.5; |
| return features.reduce((sum, item) => sum + item.value * weightSelector(item), 0) / totalWeight; |
| } |
| function normalizeWeights(weights) { |
| const total = Object.values(weights).reduce((sum, value) => sum + Math.max(value, 0.0001), 0); |
| return Object.fromEntries(Object.entries(weights).map(([key, value]) => [key, round(Math.max(value, 0.0001) / total)])); |
| } |
| function bucketImportance(features, predicate) { |
| const bucket = features.filter(predicate); |
| if (bucket.length === 0) |
| return 0.5; |
| return round(clamp(bucket.reduce((sum, item) => sum + item.weight * (0.55 + item.confidence * 0.45), 0) / bucket.length)); |
| } |
| function deriveContractFormulaWeights(features) { |
| const textOf = (item) => featureText(item); |
| const needImportance = bucketImportance(features, (item) => /需求|匹配|收益|benefit|matching|need|utility|价值/i.test(textOf(item))); |
| const riskImportance = bucketImportance(features, (item) => /风险|损失|底线|下行|不确定|risk|loss|floor|uncertain|downside/i.test(textOf(item))); |
| const controlImportance = bucketImportance(features, isControlFeature); |
| const reliabilityImportance = bucketImportance(features, isReliabilityFeature); |
| const referenceImportance = bucketImportance(features, (item) => /参照|公允|市场|预期|reference|market|anchor|expectation/i.test(textOf(item))); |
| const surplusImportance = bucketImportance(features, (item) => /共同|剩余|互补|双赢|surplus|win|reciprocal|互惠/i.test(textOf(item))); |
| return { |
| matching: normalizeWeights({ |
| nash: 0.32 * (0.72 + needImportance * 0.56), |
| reference: 0.2 * (0.72 + referenceImportance * 0.56), |
| surplus: 0.16 * (0.72 + surplusImportance * 0.56), |
| outsideOption: 0.12, |
| antiHoldUp: 0.1 * (0.72 + riskImportance * 0.56), |
| control: 0.1 * (0.72 + controlImportance * 0.56), |
| }), |
| holdUp: normalizeWeights({ |
| risk: 0.38 * (0.72 + riskImportance * 0.56), |
| gap: 0.2 * (0.72 + referenceImportance * 0.56), |
| missing: 0.16, |
| control: 0.14 * (0.72 + controlImportance * 0.56), |
| reliability: 0.12 * (0.72 + reliabilityImportance * 0.56), |
| }), |
| score: normalizeWeights({ |
| winWin: 0.42 * (0.72 + surplusImportance * 0.56), |
| matching: 0.24 * (0.72 + needImportance * 0.56), |
| reference: 0.16 * (0.72 + referenceImportance * 0.56), |
| coverage: 0.1, |
| surplus: 0.08 * (0.72 + surplusImportance * 0.56), |
| }), |
| }; |
| } |
| function normalizeDynamicFactor(input, index) { |
| const safeLabel = input.label || `开放参数 ${index + 1}`; |
| const safeCategory = input.category || '开放因素'; |
| const value = Number(input.value); |
| const confidence = Number(input.confidence); |
| const weight = Number(input.weight); |
| if (!Number.isFinite(value) || !Number.isFinite(confidence) || !Number.isFinite(weight)) { |
| throw new Error(`Invalid open factor numeric fields: ${safeLabel}`); |
| } |
| return { |
| key: input.key || `open_${index + 1}_${safeLabel.slice(0, 12)}`, |
| label: safeLabel, |
| category: safeCategory, |
| source: 'open', |
| value: round(clamp(value)), |
| confidence: round(clamp(confidence)), |
| weight: round(clamp(weight, 0, 1)), |
| evidence: input.evidence && input.evidence.length > 0 ? input.evidence : ['开放参数抽取器识别'], |
| missing: false, |
| }; |
| } |
| function dynamicWeight(input, kind) { |
| if (!input) |
| throw new Error(`Missing open factor for ${kind} weight`); |
| const value = kind === 'user' |
| ? input.userWeight |
| : kind === 'other' |
| ? input.otherWeight |
| : kind === 'risk' |
| ? input.riskWeight |
| : input.refWeight; |
| const numericValue = Number(value); |
| if (!Number.isFinite(numericValue)) { |
| throw new Error(`Missing ${kind} weight for open factor: ${input.label || input.key || 'unknown'}`); |
| } |
| return clamp(numericValue, 0, 1); |
| } |
| function featureText(item) { |
| return `${item.key} ${item.label} ${item.category} ${item.evidence.join(' ')}`; |
| } |
| function isControlFeature(item) { |
| return /控制权|理论2|拍板|决定权|否决权|验收权|退出权|暂停|解除|转移|托管|授权|权限|归属|账号|数据|代码|IP|知识产权|付款节点|尾款|交付|验收|职责边界|资源调度|最终决定|共同确认|control|rights|decision|veto|approval|ownership|authority|permission|handover|acceptance|payment|milestone|escrow|exit|terminate|pause/i.test(featureText(item)); |
| } |
| function isStateTriggerFeature(item) { |
| return /状态|触发|逾期|不达标|未达标|验收不通过|验收失败|验收不合格|付款异常|资源不到位|融资失败|融资|现金流|资金|无法转岗|无法转AI|不能保证|不保证|职责扩大|职责泛化|延期|暂停|解除|退出|退款|退货|尾款|里程碑|cliff|vesting|回购|清算|转移|共同决策|state|trigger|contingency|delay|overdue|fail|failure|refund|return|vesting|buyback|liquidation|fallback|walkaway|funding|financing|runway|cashflow|cannot guarantee|not guaranteed/i.test(featureText(item)); |
| } |
| function isReliabilityFeature(item) { |
| return /理论4|可信|履约|信任|信誉|证据|案例|书面|合同|透明|可查|第三方|发票|授权|质保|SLA|验收标准|项目经理|正规|历史|记录|资金|融资|现金流|口头|画饼|不确定|拒绝写|不透明|无案例|没案例|reliability|trust|credible|evidence|case|written|contract|transparent|verifiable|third|invoice|warranty|runway|funding|financing|verbal|uncertain|refuse/i.test(featureText(item)); |
| } |
| function buildControlRights(features, specs) { |
| const controlFeatures = features.filter(isControlFeature); |
| const controlSignalFeatures = controlFeatures.filter((item) => item.source === 'open' || !item.missing); |
| const controlBasis = controlSignalFeatures.length > 0 ? controlSignalFeatures : controlFeatures; |
| const controlAlignment = round(controlBasis.length > 0 ? weightedAverage(controlBasis, (item) => item.weight * (0.7 + item.confidence * 0.3)) : 0.42); |
| const residualControlRisk = round(clamp(1 - controlAlignment)); |
| const specificInvestment = round(weightedAverage(features.filter((item) => /专用|资产|投入|资源|客户|数据|账号|技术|装修|项目|成果|成长|品牌|股权|IP|知识产权/.test(`${item.label}${item.category}${item.evidence.join('')}`)), (item) => item.weight * (0.7 + item.confidence * 0.3))); |
| const investmentIncentiveFit = round(clamp(0.58 * controlAlignment + 0.42 * (1 - Math.abs(specificInvestment - controlAlignment)))); |
| const stateControlFeatures = features.filter((item) => item.key === 'state_control_transfer' || isStateTriggerFeature(item)); |
| const stateSignalFeatures = stateControlFeatures.filter((item) => item.source === 'open' || !item.missing); |
| const stateBasis = stateSignalFeatures.length > 0 ? stateSignalFeatures : stateControlFeatures; |
| const stateContingencyReadiness = round(stateBasis.length > 0 |
| ? weightedAverage(stateBasis, (item) => item.weight * (0.65 + item.confidence * 0.35)) |
| : 0.35); |
| const missingControlQuestions = specs |
| .filter((spec) => spec.category.includes('控制权')) |
| .filter((spec) => !features.some((item) => item.key === spec.key && !item.missing)) |
| .map((spec) => spec.question); |
| const uniqueMissingControlQuestions = [...new Set(missingControlQuestions)].slice(0, 3); |
| const recommendedAllocation = residualControlRisk >= 0.58 |
| ? '存在后续被锁定风险：凡涉及付款、验收、账号、客户、数据、IP、预算、方向、资源投入和责任承担的事项，都需要分项配置控制权，并设置逾期、不达标、违约或不投入时的暂停、转移、解除和退出机制。' |
| : stateContingencyReadiness < 0.5 |
| ? '基础控制权可谈，但状态变化机制不足：需要补充逾期、不达标、验收失败、资源不到位时的暂停、转移、解除或共同决策条款。' |
| : '控制权配置相对可接受：继续把关键事项写成分项决策权、触发条件和证据留存。'; |
| return { |
| controlAlignment, |
| residualControlRisk, |
| investmentIncentiveFit, |
| stateContingencyReadiness, |
| recommendedAllocation, |
| missingControlQuestions: uniqueMissingControlQuestions, |
| }; |
| } |
| function buildBayesianReliability(text, features = []) { |
| const prior = 0.52; |
| const positiveSignals = [ |
| { word: '书面', likelihood: 1.45 }, |
| { word: '透明', likelihood: 1.35 }, |
| { word: '可查', likelihood: 1.28 }, |
| { word: '第三方', likelihood: 1.28 }, |
| { word: '资金到位', likelihood: 1.38 }, |
| { word: '贷款已预批', likelihood: 1.32 }, |
| { word: '定金', likelihood: 1.22 }, |
| { word: '共同确认', likelihood: 1.3 }, |
| { word: '明确', likelihood: 1.22 }, |
| { word: '按时', likelihood: 1.3 }, |
| { word: '兑现', likelihood: 1.36 }, |
| { word: '后台数据', likelihood: 1.28 }, |
| { word: '愿意写', likelihood: 1.42 }, |
| { word: '验收标准', likelihood: 1.24 }, |
| { word: '违约责任', likelihood: 1.2 }, |
| { word: 'written', likelihood: 1.42 }, |
| { word: 'transparent', likelihood: 1.32 }, |
| { word: 'verifiable', likelihood: 1.28 }, |
| { word: 'third party', likelihood: 1.26 }, |
| { word: 'preapproved', likelihood: 1.32 }, |
| { word: 'deposit', likelihood: 1.22 }, |
| { word: 'clear terms', likelihood: 1.3 }, |
| { word: 'acceptance criteria', likelihood: 1.24 }, |
| { word: 'penalty clause', likelihood: 1.2 }, |
| ]; |
| const negativeSignals = [ |
| { word: '口头', likelihood: 0.66 }, |
| { word: '画饼', likelihood: 0.58 }, |
| { word: '不透明', likelihood: 0.52 }, |
| { word: '拒绝写', likelihood: 0.42 }, |
| { word: '后面再说', likelihood: 0.55 }, |
| { word: '先签', likelihood: 0.62 }, |
| { word: '拖延', likelihood: 0.65 }, |
| { word: '变卦', likelihood: 0.48 }, |
| { word: '反复', likelihood: 0.6 }, |
| { word: '结算慢', likelihood: 0.58 }, |
| { word: '无承诺', likelihood: 0.56 }, |
| { word: '没有承诺', likelihood: 0.56 }, |
| { word: '不愿提供', likelihood: 0.5 }, |
| { word: '最终决策都由他', likelihood: 0.5 }, |
| { word: '单方决定', likelihood: 0.48 }, |
| { word: '账号归属没有写清', likelihood: 0.5 }, |
| { word: 'verbal', likelihood: 0.62 }, |
| { word: 'refuses to write', likelihood: 0.42 }, |
| { word: 'refuse to write', likelihood: 0.42 }, |
| { word: 'later', likelihood: 0.6 }, |
| { word: 'not transparent', likelihood: 0.52 }, |
| { word: 'delayed settlement', likelihood: 0.58 }, |
| { word: 'unclear ownership', likelihood: 0.5 }, |
| { word: 'single-sided decision', likelihood: 0.48 }, |
| { word: 'no veto right', likelihood: 0.52 }, |
| ]; |
| const hasPositiveSignal = (word) => { |
| if (!text.includes(word)) |
| return false; |
| if (word === '透明' && text.includes('不透明')) |
| return false; |
| if (word === '书面' && /拒绝.{0,4}书面|不愿.{0,4}书面/.test(text)) |
| return false; |
| if (text.includes(`not ${word}`) || text.includes(`no ${word}`) || text.includes(`without ${word}`)) |
| return false; |
| return true; |
| }; |
| let odds = prior / (1 - prior); |
| const positiveEvidence = []; |
| const negativeEvidence = []; |
| for (const signal of positiveSignals) { |
| if (hasPositiveSignal(signal.word)) { |
| odds *= signal.likelihood; |
| positiveEvidence.push(signal.word); |
| } |
| } |
| for (const signal of negativeSignals) { |
| if (text.includes(signal.word)) { |
| odds *= signal.likelihood; |
| negativeEvidence.push(signal.word); |
| } |
| } |
| for (const item of features.filter(isReliabilityFeature)) { |
| const strength = item.weight * (0.55 + item.confidence * 0.45); |
| const evidenceLabel = item.evidence[0] || item.label; |
| if (item.value >= 0.62) { |
| odds *= 1 + (item.value - 0.5) * strength; |
| positiveEvidence.push(evidenceLabel); |
| } |
| else if (item.value <= 0.42) { |
| odds *= Math.max(0.35, 1 - (0.5 - item.value) * strength * 1.45); |
| negativeEvidence.push(evidenceLabel); |
| } |
| } |
| const posterior = round(clamp(odds / (1 + odds))); |
| const reliabilityLevel = posterior >= 0.68 ? 'high' : posterior >= 0.45 ? 'medium' : 'low'; |
| const interpretation = reliabilityLevel === 'high' |
| ? '对方可信履约信号较强，可以继续推进，但仍需把关键承诺写成可验证条件。' |
| : reliabilityLevel === 'medium' |
| ? '对方可信履约能力尚未充分验证，适合继续谈，但必须用书面条件、验收标准和退出机制降低不确定性。' |
| : '对方可信履约信号偏弱，不宜依赖口头承诺，应先要求书面确认、履约担保或降低投入。'; |
| return { |
| prior, |
| posterior, |
| evidenceCount: positiveEvidence.length + negativeEvidence.length, |
| positiveEvidence, |
| negativeEvidence, |
| reliabilityLevel, |
| interpretation, |
| }; |
| } |
| function buildSuccessPanel(input) { |
| const weightedSum = (terms) => terms.reduce((sum, term) => sum + term.value * term.coefficient, 0); |
| const withContribution = (terms) => terms.map((term) => ({ ...term, value: round(term.value), contribution: round(term.value * term.coefficient) })); |
| const sigmoid = (value) => 1 / (1 + Math.exp(-value)); |
| const terms = [ |
| { label: '当前匹配质量', value: input.matchingEquilibrium, weight: 0.24, direction: 1 }, |
| { label: '双方总剩余', value: input.totalSurplus, weight: 0.16, direction: 1 }, |
| { label: '对方可信履约', value: input.reliability, weight: 0.18, direction: 1 }, |
| { label: '控制权配置', value: input.controlAlignment, weight: 0.14, direction: 1 }, |
| { label: '信息完整度', value: input.coverage, weight: 0.09, direction: 1 }, |
| { label: '替代选择压力', value: input.outsideOptionPressure, weight: 0.07, direction: 1 }, |
| { label: '状态触发机制', value: input.stateContingencyReadiness, weight: 0.08, direction: 1 }, |
| { label: '被卡住风险', value: input.holdUpRisk, weight: 0.16, direction: -1 }, |
| { label: '预期缺口', value: input.expectationGap, weight: 0.11, direction: -1 }, |
| { label: '下行损失风险', value: input.downsideProbability, weight: 0.1, direction: -1 }, |
| ]; |
| const positiveScore = terms |
| .filter((term) => term.direction === 1) |
| .reduce((sum, term) => sum + term.weight * term.value, 0); |
| const negativeScore = terms |
| .filter((term) => term.direction === -1) |
| .reduce((sum, term) => sum + term.weight * term.value, 0); |
| const successRaw = positiveScore - negativeScore; |
| const neutralRaw = 0.38 + 0.32 * input.coverage + 0.22 * (1 - Math.abs(0.5 - input.matchingEquilibrium)) - 0.18 * Math.abs(positiveScore - negativeScore); |
| const failureRaw = negativeScore + 0.22 * (1 - input.reliability) + 0.16 * (1 - input.controlAlignment) - positiveScore * 0.45; |
| const [success, neutral, failure] = softmax([successRaw * 4.2, neutralRaw * 2.4, failureRaw * 4.2]).map((value) => round(value)); |
| const bargainingFactors = [ |
| { label: '双方总剩余', value: input.totalSurplus, coefficient: 1.05 }, |
| { label: '当前匹配质量', value: input.matchingEquilibrium, coefficient: 1 }, |
| { label: '替代选择压力', value: input.outsideOptionPressure, coefficient: 0.62 }, |
| { label: '对方可信履约', value: input.reliability, coefficient: 0.54 }, |
| { label: '信息完整度', value: input.coverage, coefficient: 0.48 }, |
| { label: '预期缺口', value: input.expectationGap, coefficient: -0.8 }, |
| { label: '被卡住风险', value: input.holdUpRisk, coefficient: -0.62 }, |
| ]; |
| const currentNegotiation = round(clamp(sigmoid(-1.05 + weightedSum(bargainingFactors)))); |
| const concessionGainFactors = [ |
| { label: '高价值低成本交换空间', value: input.outsideOptionPressure, coefficient: 0.38 }, |
| { label: '预期缺口可修复度', value: 1 - input.expectationGap, coefficient: 0.32 }, |
| { label: '状态触发机制可设计度', value: input.stateContingencyReadiness, coefficient: 0.24 }, |
| { label: '控制权可锁定度', value: input.controlAlignment, coefficient: 0.22 }, |
| { label: '对方可信履约', value: input.reliability, coefficient: 0.18 }, |
| ]; |
| const concessionCostFactors = [ |
| { label: '下行损失风险', value: input.downsideProbability, coefficient: 0.32 }, |
| { label: '被卡住风险', value: input.holdUpRisk, coefficient: 0.28 }, |
| { label: '控制权不足导致的让步损耗', value: 1 - input.controlAlignment, coefficient: 0.22 }, |
| { label: '对方可信不足导致的让步损耗', value: 1 - input.reliability, coefficient: 0.18 }, |
| ]; |
| const concessionGain = round(clamp(weightedSum(concessionGainFactors))); |
| const concessionCost = round(clamp(weightedSum(concessionCostFactors))); |
| const paretoImprovement = round(clamp(concessionGain - concessionCost + 0.5)); |
| const afterConcession = round(clamp(currentNegotiation + |
| 0.42 * paretoImprovement * (1 - currentNegotiation) - |
| 0.16 * concessionCost)); |
| const survivalFactors = [ |
| { label: '对方可信履约', value: input.reliability, coefficient: 0.34 }, |
| { label: '控制权配置', value: input.controlAlignment, coefficient: 0.24 }, |
| { label: '状态触发机制', value: input.stateContingencyReadiness, coefficient: 0.22 }, |
| { label: '信息完整度', value: input.coverage, coefficient: 0.1 }, |
| { label: '抗下行损失能力', value: 1 - input.downsideProbability, coefficient: 0.1 }, |
| ]; |
| const hazardFactors = [ |
| { label: '被卡住风险', value: input.holdUpRisk, coefficient: 0.34 }, |
| { label: '预期缺口', value: input.expectationGap, coefficient: 0.24 }, |
| { label: '下行损失风险', value: input.downsideProbability, coefficient: 0.22 }, |
| { label: '可信履约不足', value: 1 - input.reliability, coefficient: 0.2 }, |
| ]; |
| const baseSurvival = round(clamp(weightedSum(survivalFactors))); |
| const hazard = round(clamp(weightedSum(hazardFactors))); |
| const fulfillment = round(clamp(baseSurvival * Math.exp(-0.72 * hazard))); |
| const grade = success >= 0.62 && failure <= 0.22 ? 'advantage' : failure >= 0.42 ? 'danger' : 'balanced'; |
| const positive = terms |
| .filter((term) => term.direction === 1) |
| .map((term) => ({ label: term.label, value: round(term.value), impact: round(term.weight * term.value) })) |
| .sort((a, b) => b.impact - a.impact) |
| .slice(0, 5); |
| const negative = terms |
| .filter((term) => term.direction === -1) |
| .map((term) => ({ label: term.label, value: round(term.value), impact: round(term.weight * term.value) })) |
| .sort((a, b) => b.impact - a.impact) |
| .slice(0, 5); |
| return { |
| success, |
| neutral, |
| failure, |
| stages: { |
| currentNegotiation, |
| afterConcession, |
| fulfillment, |
| }, |
| stageModels: { |
| currentNegotiation: { |
| model: 'bargaining-scorecard', |
| factors: withContribution(bargainingFactors), |
| }, |
| afterConcession: { |
| model: 'mechanism-counterfactual', |
| concessionGain, |
| concessionCost, |
| paretoImprovement, |
| factors: [...withContribution(concessionGainFactors), ...withContribution(concessionCostFactors.map((term) => ({ ...term, coefficient: -term.coefficient })))], |
| }, |
| fulfillment: { |
| model: 'bayesian-survival', |
| baseSurvival, |
| hazard, |
| factors: [...withContribution(survivalFactors), ...withContribution(hazardFactors.map((term) => ({ ...term, coefficient: -term.coefficient })))], |
| }, |
| }, |
| grade, |
| formulaVersion: 'success-panel-deterministic-1.2', |
| drivers: { |
| positive, |
| negative, |
| }, |
| }; |
| } |
| function buildQuestions(features, specs) { |
| const missingKeys = features |
| .filter((item) => item.missing) |
| .sort((a, b) => b.weight - a.weight) |
| .map((item) => item.key); |
| const questions = missingKeys |
| .map((key) => specs.find((spec) => spec.key === key)?.question) |
| .filter((question) => Boolean(question)); |
| return [...new Set(questions)].slice(0, 5); |
| } |
| function missingSpecQuestions(_features, specs, gapType) { |
| return specs |
| .filter((spec) => spec.gapType === gapType || (gapType === 'user-only' && spec.gapType === 'hybrid')) |
| .sort((a, b) => b.weight - a.weight) |
| .map((spec) => spec.question); |
| } |
| function hasObservedFeature(features, key) { |
| return features.some((item) => item.key === key && !item.missing); |
| } |
| function buildInformationSufficiency(text, features, specs, coverage) { |
| const openFeatures = features.filter((item) => item.source === 'open' && !item.missing); |
| const openText = openFeatures.flatMap((item) => [item.key, item.label, item.category, ...item.evidence]).join(' '); |
| const combinedText = `${text} ${openText}`; |
| const hasOpenDecisionMaterial = openFeatures.length >= 3; |
| const concreteArrangement = (text.length >= 30 || hasOpenDecisionMaterial) && /offer|报价|价格|年薪|薪酬|合作|合伙|买|卖|签|外包|入职|试用|房|车|项目|供应商|服务商|承包商|代理|渠道|平台|资源方|需求方|承诺方|交易对手|合同|岗位|公司|团队|客户|付款|交付|验收|股权|期权|分成|返点|佣金|授权|控制权|条件包|路径|安排|标的|候选|方案|A|B|C|D|对方|买家|卖家|candidate|supplier|vendor|contractor|partner|proposal|payment|delivery|acceptance|equity|option|budget|deadline|IP|data|code|control/i.test(combinedText); |
| const exchangeTerms = /报价|价格|年薪|薪酬|付款|交付|验收|股权|期权|职责|岗位|负责|期限|现金流|融资|提成|分成|返点|佣金|预算|首付|贷款|让价|降价|万|元|资源|授权|控制权|退出|区域|账号|数据|代码|IP|客户归属|quote|price|salary|payment|delivery|acceptance|budget|deadline|runway|funding|financing|scope|responsibility|ownership|rights|exit/i.test(combinedText); |
| const userNeedSignals = [ |
| 'user_core_need', |
| 'need_priority_order', |
| 'time_horizon', |
| 'capability_fit', |
| 'constraint_floor', |
| ].filter((key) => hasObservedFeature(features, key)).length; |
| const controlSignals = hasObservedFeature(features, 'residual_control') || hasObservedFeature(features, 'state_control_transfer'); |
| const marketSignals = hasObservedFeature(features, 'market_anchor') || /市场|行情|同类|竞品|同行|成交|挂牌|薪酬|报价|替代|备选|多家|多个|竞争|搜索补充|公开资料|公开信息|quote|price|market|alternative|competition|benchmark/i.test(combinedText); |
| const reliabilitySignals = /书面|透明|可查|证明|案例|记录|口碑|兑现|拖延|不透明|融资|现金流|贷款|首付|履约|违约|written|contract|case|record|reliable|funding|runway|financing|breach/i.test(combinedText); |
| const userQuestions = [...new Set(missingSpecQuestions(features, specs, 'user-only'))].slice(0, 3); |
| const searchQuestions = [...new Set(missingSpecQuestions(features, specs, 'searchable'))].slice(0, 3); |
| const hybridQuestions = [...new Set(missingSpecQuestions(features, specs, 'hybrid'))].slice(0, 2); |
| const userOnlyMissing = specs |
| .filter((spec) => spec.gapType === 'user-only' || spec.gapType === 'hybrid') |
| .map((spec) => spec.label); |
| const searchableMissing = specs |
| .filter((spec) => spec.gapType === 'searchable' || spec.gapType === 'hybrid') |
| .map((spec) => spec.label); |
| let score = 0; |
| if (concreteArrangement) |
| score += 0.28; |
| if (exchangeTerms) |
| score += 0.16; |
| score += Math.min(userNeedSignals, 3) * 0.12; |
| if (marketSignals) |
| score += 0.11; |
| if (controlSignals) |
| score += 0.1; |
| if (reliabilitySignals) |
| score += 0.08; |
| score += Math.min(coverage, 1) * 0.15; |
| score = round(clamp(score), 3); |
| const reasons = [ |
| concreteArrangement ? '已经有具体安排或候选对象' : '还没有具体安排或候选对象', |
| exchangeTerms ? '已经有核心交换条件' : '缺少价格、薪酬、付款、交付、职责或期限等核心条件', |
| userNeedSignals > 0 ? `已有${userNeedSignals}类用户需求/约束线索` : '缺少用户本人目标、取舍或底线', |
| marketSignals ? '已有市场/替代选择线索，或可由 GPT 搜索补足' : '缺少市场情况或替代选择参照', |
| controlSignals ? '已有控制权或状态变化线索' : '缺少关键事项谁说了算、出问题如何处理', |
| ]; |
| const blocking = !hasOpenDecisionMaterial && (!concreteArrangement || (!exchangeTerms && userNeedSignals === 0)); |
| const level = blocking ? 'insufficient' : score >= 0.72 ? 'sufficient' : 'preliminary'; |
| return { |
| level, |
| score, |
| blocking, |
| reasons, |
| userOnlyMissing: [...new Set(userOnlyMissing)].slice(0, 5), |
| searchableMissing: [...new Set(searchableMissing)].slice(0, 5), |
| userQuestions: [...new Set([...userQuestions, ...hybridQuestions])].slice(0, 3), |
| searchQuestions, |
| }; |
| } |
| function hasComputableDecisionSignal(dynamicFeatures, coverage, metrics) { |
| const observedOpenFeatures = dynamicFeatures.filter((item) => !item.missing); |
| if (observedOpenFeatures.length < 2) |
| return false; |
| const dynamicText = observedOpenFeatures |
| .flatMap((item) => [item.key, item.label, item.category, ...item.evidence]) |
| .join(' '); |
| const hasExchangeSignal = /报价|价格|年薪|薪酬|付款|交付|验收|职责|岗位|负责|期限|现金流|融资|股权|期权|分成|预算|资源|客户|代码|数据|IP|授权|控制权|退出|quote|price|salary|payment|delivery|acceptance|budget|deadline|funding|financing|scope|responsibility|ownership|rights|exit/i.test(dynamicText); |
| const hasRiskOrValueSignal = /风险|收益|价值|能力|案例|履约|可信|控制权|不确定|成本|底线|替代|市场|匹配|risk|value|capability|case|reliable|control|uncertain|cost|floor|alternative|market|fit/i.test(dynamicText); |
| const hasMetricSeparation = metrics.winWin >= 0.52 |
| || metrics.mismatch >= 0.34 |
| || metrics.currentNegotiation >= 0.6 |
| || metrics.fulfillment <= 0.42 |
| || metrics.userUtility >= 0.55 |
| || metrics.counterpartyUtility >= 0.55 |
| || metrics.totalSurplus >= 0.54; |
| return (hasExchangeSignal && hasRiskOrValueSignal) || (coverage >= 0.45 && hasMetricSeparation) || observedOpenFeatures.length >= 4; |
| } |
| function buildComplianceReview(text) { |
| const rules = Object.values(complianceChecklist).flat(); |
| const checklist = rules.map((rule) => { |
| const positive = findEvidence(text, rule.positive); |
| const negative = findEvidence(text, rule.negative); |
| const status = negative.length > 0 ? 'risk' : positive.length > 0 ? 'observed' : 'missing'; |
| return { |
| item: rule.item, |
| status, |
| evidence: [...positive, ...negative].length > 0 ? [...positive, ...negative] : [rule.question], |
| }; |
| }); |
| const missing = checklist.filter((item) => item.status === 'missing').map((item) => item.item); |
| const risks = checklist.filter((item) => item.status === 'risk').map((item) => item.item); |
| const observed = checklist.filter((item) => item.status === 'observed').length; |
| const score = Math.round(((observed + risks.length * 0.35) / checklist.length) * 100); |
| const status = risks.length > 0 ? 'blocking' : missing.length > Math.ceil(checklist.length / 2) ? 'warning' : 'pass'; |
| return { |
| status, |
| score, |
| missing, |
| risks, |
| checklist, |
| }; |
| } |
| export function analyzeContract(text, openFactors = []) { |
| const moduleId = 'universal'; |
| const dynamicFeatures = openFactors.map(normalizeDynamicFactor); |
| const specs = []; |
| |
| |
| const features = dynamicFeatures; |
| const specByIdentity = new Map(specs.map((spec) => [`${spec.key}::${spec.label}`, spec])); |
| const specForFeature = (item) => specByIdentity.get(`${item.key}::${item.label}`); |
| const dynamicByKey = new Map(dynamicFeatures.map((feature, index) => [feature.key, openFactors[index]])); |
| const observed = dynamicFeatures.length; |
| const totalAvailable = Math.max(dynamicFeatures.length, 1); |
| const coverage = round(observed / totalAvailable); |
| const missingHighWeightFactors = []; |
| const requiredSpecs = specs.filter((spec) => spec.required); |
| const missingRequiredSpecs = []; |
| const informationSufficiency = buildInformationSufficiency(text, features, specs, coverage); |
| const complianceReview = buildComplianceReview(text); |
| const controlRights = buildControlRights(features, specs); |
| const bayesianReliability = buildBayesianReliability(text, features); |
| const formulaWeights = deriveContractFormulaWeights(features); |
| const factorWeight = (item) => item.weight * (0.7 + item.confidence * 0.3); |
| const reliabilityAdjustment = 0.75 + bayesianReliability.posterior * 0.5; |
| const userUtility = round(weightedAverage(features, (item) => factorWeight(item) * (specForFeature(item)?.userWeight ?? dynamicWeight(dynamicByKey.get(item.key), 'user')))); |
| const counterpartyUtility = round(clamp(weightedAverage(features, (item) => factorWeight(item) * (specForFeature(item)?.otherWeight ?? dynamicWeight(dynamicByKey.get(item.key), 'other'))) * reliabilityAdjustment)); |
| const riskExposure = round(clamp(1 - weightedAverage(features, (item) => factorWeight(item) * (specForFeature(item)?.riskWeight ?? dynamicWeight(dynamicByKey.get(item.key), 'risk'))) + (1 - bayesianReliability.posterior) * 0.12)); |
| const referenceAlignment = round(weightedAverage(features, (item) => factorWeight(item) * (specForFeature(item)?.refWeight ?? dynamicWeight(dynamicByKey.get(item.key), 'ref')))); |
| const informationPenalty = round((1 - Math.min(coverage + dynamicFeatures.length * 0.035, 1)) * 0.18); |
| const expectationGap = round(clamp(1 - referenceAlignment + informationPenalty)); |
| const fairnessReference = round(clamp(0.5 * referenceAlignment + 0.3 * userUtility + 0.2 * counterpartyUtility)); |
| const holdUpRisk = round(clamp(formulaWeights.holdUp.risk * riskExposure |
| + formulaWeights.holdUp.gap * expectationGap |
| + formulaWeights.holdUp.missing * (1 - coverage) |
| + formulaWeights.holdUp.control * controlRights.residualControlRisk |
| + formulaWeights.holdUp.reliability * (1 - bayesianReliability.posterior))); |
| const renegotiationRisk = round(clamp(0.38 * expectationGap + 0.29 * riskExposure + 0.18 * (1 - fairnessReference) + 0.15 * (1 - controlRights.stateContingencyReadiness))); |
| const outsideOptionPressure = round(clamp(1 - Math.abs(userUtility - counterpartyUtility))); |
| const totalSurplus = round((userUtility + counterpartyUtility) / 2); |
| const nashProduct = round(Math.sqrt(Math.max(userUtility, 0) * Math.max(counterpartyUtility, 0))); |
| const matchingEquilibrium = round(clamp(formulaWeights.matching.nash * nashProduct |
| + formulaWeights.matching.reference * referenceAlignment |
| + formulaWeights.matching.surplus * totalSurplus |
| + formulaWeights.matching.outsideOption * outsideOptionPressure |
| + formulaWeights.matching.antiHoldUp * (1 - holdUpRisk) |
| + formulaWeights.matching.control * controlRights.investmentIncentiveFit)); |
| const [winWin, neutral, mismatch] = softmax([ |
| 2.9 * matchingEquilibrium + 1.0 * totalSurplus + 0.58 * coverage + 0.48 * controlRights.controlAlignment + 0.42 * bayesianReliability.posterior - 1.45 * holdUpRisk, |
| 1.2 * coverage + 0.9 * referenceAlignment - 0.3 * Math.abs(userUtility - counterpartyUtility), |
| 2.5 * holdUpRisk + 1.65 * renegotiationRisk + 1.15 * expectationGap - 1.25 * totalSurplus, |
| ]).map((value) => round(value)); |
| const stateUtilities = [ |
| { state: '双赢匹配', probability: winWin, utility: round(1.2 * totalSurplus + 0.5 * matchingEquilibrium) }, |
| { state: '中性波动', probability: neutral, utility: round(0.25 * totalSurplus - 0.1 * renegotiationRisk) }, |
| { state: '错配损耗', probability: mismatch, utility: round(-1 * (0.7 + holdUpRisk + riskExposure)) }, |
| ]; |
| const expectedUtility = round(stateUtilities.reduce((sum, item) => sum + item.probability * item.utility, 0)); |
| const variance = round(stateUtilities.reduce((sum, item) => sum + item.probability * (item.utility - expectedUtility) ** 2, 0)); |
| const cvarLoss = round(mismatch * Math.abs(stateUtilities[2].utility)); |
| const successPanel = buildSuccessPanel({ |
| matchingEquilibrium, |
| totalSurplus, |
| outsideOptionPressure, |
| coverage, |
| holdUpRisk, |
| expectationGap, |
| downsideProbability: mismatch, |
| controlAlignment: controlRights.controlAlignment, |
| stateContingencyReadiness: controlRights.stateContingencyReadiness, |
| reliability: bayesianReliability.posterior, |
| }); |
| const rawScore = Math.round(clamp(formulaWeights.score.winWin * winWin |
| + formulaWeights.score.matching * matchingEquilibrium |
| + formulaWeights.score.reference * referenceAlignment |
| + formulaWeights.score.coverage * coverage |
| + formulaWeights.score.surplus * totalSurplus) * 100); |
| const computableDecisionSignal = hasComputableDecisionSignal(dynamicFeatures, coverage, { |
| winWin, |
| mismatch, |
| currentNegotiation: successPanel.stages.currentNegotiation, |
| fulfillment: successPanel.stages.fulfillment, |
| userUtility, |
| counterpartyUtility, |
| totalSurplus, |
| }); |
| const requiredBlocking = informationSufficiency.blocking && !computableDecisionSignal; |
| const adjustedInformationSufficiency = requiredBlocking |
| ? informationSufficiency |
| : { |
| ...informationSufficiency, |
| blocking: false, |
| level: informationSufficiency.level === 'insufficient' ? 'preliminary' : informationSufficiency.level, |
| reasons: informationSufficiency.blocking |
| ? [...informationSufficiency.reasons, '开放参数已经足以形成当前初步判断，剩余信息用于校验、排序和优化条件'] |
| : informationSufficiency.reasons, |
| }; |
| const score = requiredBlocking ? Math.min(rawScore, 68) : rawScore; |
| const verdict = requiredBlocking |
| ? '必要信息不足，不能下最终结论' |
| : winWin >= 0.55 && mismatch < 0.25 ? '可优化双赢匹配' : mismatch >= 0.38 ? '高风险错配' : '信息不足或中性波动'; |
| const decision = requiredBlocking |
| ? '先补齐价格、时间、当前市场情况、替代选择等必要条件，再做最终验算' |
| : verdict === '可优化双赢匹配' |
| ? '可以继续推进，但必须先把关键利益、责任、控制权和退出条件结构化' |
| : verdict === '高风险错配' |
| ? '暂停按原条件推进，除非关键风险能通过书面条件、分阶段验证或退出机制消除' |
| : '优先补齐高权重缺失因素，再做最终决策'; |
| return { |
| moduleId, |
| moduleName: '全量因子决策引擎', |
| verdict, |
| decision, |
| score, |
| formulas: { |
| generalizedDistribution: 'F(U)=Σ p_s·1(U_s<=u); E[U]=Σp_s·U_s; Var(U)=Σp_s·(U_s-E[U])²; CVaR_loss=P(loss)·|U_loss|', |
| referenceContract: 'A_ref=Σ(w_ref_i·v_i·conf_i)/Σw_ref_i; Gap=1-A_ref+InfoPenalty; HoldUp=0.52·Risk+0.28·Gap+0.20·Missing', |
| bilateralMatching: 'M=0.36·sqrt(U_user·U_other)+0.24·A_ref+0.18·Surplus+0.12·OutsideOption+0.10·(1-HoldUp)', |
| }, |
| features, |
| factorCoverage: { |
| total: totalAvailable, |
| observed, |
| coverage, |
| missingHighWeightFactors, |
| openFactorCount: dynamicFeatures.length, |
| }, |
| requiredFactors: { |
| total: requiredSpecs.length, |
| observed: requiredSpecs.length - missingRequiredSpecs.length, |
| missing: missingRequiredSpecs.map((spec) => spec.label), |
| blocking: requiredBlocking, |
| }, |
| informationSufficiency: adjustedInformationSufficiency, |
| complianceReview, |
| distribution: { winWin, neutral, mismatch }, |
| successPanel, |
| generalizedDistribution: { |
| expectedUtility, |
| variance, |
| downsideProbability: mismatch, |
| cvarLoss, |
| stateUtilities, |
| }, |
| referenceContract: { |
| referenceAlignment, |
| expectationGap, |
| holdUpRisk, |
| renegotiationRisk, |
| fairnessReference, |
| }, |
| controlRights, |
| bayesianReliability, |
| bilateralMatching: { |
| userUtility, |
| counterpartyUtility, |
| outsideOptionPressure, |
| totalSurplus, |
| nashProduct, |
| matchingEquilibrium, |
| }, |
| missingQuestions: buildQuestions(features, specs), |
| modelPayload: { |
| engineVersion: 'contract-engine-universal-factor-matrix-1.1', |
| theoryBasis: ['广义分布函数模型', '不完全参照点契约', '双边匹配均衡', '贝叶斯后验更新', '开放式不定参数矩阵'], |
| constraints: ['大模型只能解释和表达计算结果', '不得替代后台概率分布自行主观判断', '信息不足时必须优先追问高权重缺失因素'], |
| }, |
| }; |
| } |
|
|
