agentboss 0.1.0

package/server/analysis/dimensions/ai-tools.js

@@ -0,0 +1,161 @@
+/**
+ * E2 — AI Tool Coverage.
+ *
+ * Captures how well the AI environment picks, chains and recovers from
+ * tools.
+ *   • tool_pick   — fraction of tool calls NOT followed by a tool switch
+ *                   or user override
+ *   • chain_eff   — calls-per-user-intent ratio against a baseline of 1.0
+ *                   (lower is better; baselines are crude heuristics)
+ *   • self_heal   — after a tool error, fraction where the next same-tool
+ *                   call succeeds
+ *
+ * See spec §4.5.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const { queryAll } = require('../../db/queries');
+const { explainIndicator, rollupDimension, scoreToLevel, E2 } = require('../thresholds-v2');
+const { makeEvidence } = require('../evidence-builder');
+
+// Baseline calls-per-intent by difficulty.  Hand-tuned: trivial tasks
+// shouldn't need more than 2 tools, heavy ones legitimately use 8+.
+const BASELINE_CALLS_PER_INTENT = { 1: 1.5, 2: 3, 3: 6, 4: 10 };
+
+function analyze(db, session, difficulty = 2) {
+  const calls = queryAll(
+    db,
+    `SELECT tool_name, status, error_message, timestamp
+       FROM unified_tool_call
+      WHERE session_id = ?
+      ORDER BY timestamp ASC`,
+    [session.id]
+  );
+
+  const userMsgs = queryAll(
+    db,
+    `SELECT timestamp
+       FROM unified_message
+      WHERE session_id = ? AND role = 'user'
+      ORDER BY timestamp ASC`,
+    [session.id]
+  );
+
+  // ---- tool_pick: not-followed-by-switch ratio ----
+  // A "good" tool call is one whose next call (if any) is the SAME tool
+  // OR whose next event is the user accepting (no immediate switch).
+  // Lacking a clean "intent boundary", we use: fraction of calls that
+  // are NOT immediately followed by a different tool within 30 seconds.
+  let tool_pick = null;
+  if (calls.length > 0) {
+    let good = 0;
+    for (let i = 0; i < calls.length; i++) {
+      const cur = calls[i];
+      const next = calls[i + 1];
+      // Error calls are never "good picks"
+      if (cur.status === 'error') continue;
+      if (!next) { good++; continue; }
+      const dt = new Date(next.timestamp) - new Date(cur.timestamp);
+      const sameTool = next.tool_name === cur.tool_name;
+      if (sameTool || dt > 30_000) good++;
+    }
+    tool_pick = good / calls.length;
+  }
+
+  // ---- chain_eff: calls per user intent ratio ----
+  // intent ~ user message that prompted assistant action.  We use total
+  // user messages as the count of intents (minus initial trivial ones).
+  let chain_eff = null;
+  if (calls.length > 0 && userMsgs.length > 0) {
+    const intents = Math.max(1, userMsgs.length);
+    const callsPerIntent = calls.length / intents;
+    const baseline = BASELINE_CALLS_PER_INTENT[difficulty] || 3;
+    chain_eff = callsPerIntent / baseline; // 1.0 = matches baseline
+  }
+
+  // ---- self_heal: post-error recovery ----
+  // For each error call, look at the next call with the same tool_name.
+  // If that succeeds (status != 'error') → counted as healed.
+  let healEligible = 0;
+  let healed = 0;
+  for (let i = 0; i < calls.length; i++) {
+    const cur = calls[i];
+    if (cur.status !== 'error') continue;
+    // find next same-tool call
+    for (let j = i + 1; j < calls.length; j++) {
+      if (calls[j].tool_name === cur.tool_name) {
+        healEligible++;
+        if (calls[j].status !== 'error') healed++;
+        break;
+      }
+    }
+  }
+  const self_heal = healEligible > 0 ? healed / healEligible : null;
+
+  const tpE = explainIndicator(E2.tool_pick, tool_pick, difficulty);
+  const ceE = explainIndicator(E2.chain_eff, chain_eff, difficulty);
+  const shE = explainIndicator(E2.self_heal, self_heal, difficulty);
+
+  const subScores = {
+    tool_pick: tpE.score,
+    chain_eff: ceE.score,
+    self_heal: shE.score,
+  };
+  const subLevels = {
+    tool_pick: tpE.level,
+    chain_eff: ceE.level,
+    self_heal: shE.level,
+  };
+
+  const baseline = BASELINE_CALLS_PER_INTENT[difficulty] || 3;
+  const callsPerIntent = (calls.length > 0 && userMsgs.length > 0)
+    ? calls.length / Math.max(1, userMsgs.length)
+    : null;
+
+  const subEvidence = {
+    tool_pick: makeEvidence({
+      key: 'tool_pick', label: '工具选择准确率',
+      what: calls.length > 0
+        ? `没有立即被切换或报错的工具调用占比：${calls.length} 次工具调用中有 ${Math.round((tool_pick || 0) * calls.length)} 次属于"选对了"。占比越高越好。`
+        : '本会话无工具调用。',
+      expl: tpE,
+      unit: '%',
+      difficulty,
+    }),
+    chain_eff: makeEvidence({
+      key: 'chain_eff', label: '工具链编排效率',
+      what: callsPerIntent != null
+        ? `平均每个用户意图所用工具数 / 该难度的基线：${calls.length} 次工具 / ${userMsgs.length} 条用户消息 = ${callsPerIntent.toFixed(2)} 次/意图；难度 ${difficulty} 基线 ${baseline} 次/意图。比值越接近 1 越好。`
+        : '工具调用数或用户消息数为 0，无法评估。',
+      expl: ceE,
+      unit: 'x',
+      difficulty,
+    }),
+    self_heal: makeEvidence({
+      key: 'self_heal', label: '错误自愈率',
+      what: healEligible > 0
+        ? `每次工具错误后，下一次同名工具调用成功的比例：${healed} / ${healEligible}。比例越高代表 AI 越能自我恢复。`
+        : '本会话无工具报错，无需自愈。',
+      expl: shE,
+      unit: '%',
+      difficulty,
+    }),
+  };
+
+  const score = rollupDimension('E2', subScores);
+  const level = scoreToLevel(score);
+
+  return {
+    subScores,
+    subLevels,
+    subEvidence,
+    raw: { tool_pick, chain_eff, self_heal, callCount: calls.length, intents: userMsgs.length, healEligible, healed, baseline, callsPerIntent },
+    score,
+    level,
+  };
+}
+
+module.exports = { analyze };

package/server/analysis/dimensions/judgement.js

@@ -0,0 +1,107 @@
+/**
+ * H2 — Judgement & Decision.
+ *
+ * Captures whether the human pushes back when the AI is wrong instead
+ * of rubber-stamping output.
+ *   • challenge    — challenge / questioning rate
+ *   • override     — override-the-AI rate (band metric)
+ *   • accept_rate  — passive-acceptance rate (ideal band 60-85%)
+ *
+ * See spec §4.2.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const {
+  fetchMessages,
+  userMessages,
+  matchesAny,
+  CHALLENGE_PATTERNS,
+  OVERRIDE_PATTERNS,
+  ACCEPT_PATTERNS,
+} = require('../text-signals');
+const { explainIndicator, rollupDimension, scoreToLevel, H2 } = require('../thresholds-v2');
+const { makeEvidence } = require('../evidence-builder');
+const { mergeIndicator, dimensionSource } = require('./llm-merge');
+
+function analyze(db, session, difficulty = 2, llmCell = null) {
+  const messages = fetchMessages(db, session.id);
+  const users = userMessages(messages);
+  const haveText = users.some((m) => m.text && m.text.length > 0);
+
+  let challenge = null;
+  let override = null;
+  let accept = null;
+  let challengeHits = 0;
+  let overrideHits = 0;
+  let overrideEligible = 0;
+  let acceptHits = 0;
+
+  if (haveText && users.length > 0) {
+    challengeHits = users.filter((m) => matchesAny(m.text, CHALLENGE_PATTERNS)).length;
+    challenge = challengeHits / users.length;
+
+    // Override rate: user messages directly after an assistant reply
+    // that explicitly override its choice.
+    for (let i = 0; i < messages.length; i++) {
+      const m = messages[i];
+      if (m.role !== 'user') continue;
+      const prev = i > 0 ? messages[i - 1] : null;
+      if (!prev || prev.role !== 'assistant') continue;
+      overrideEligible++;
+      if (m.text && matchesAny(m.text, OVERRIDE_PATTERNS)) overrideHits++;
+    }
+    override = overrideEligible > 0 ? overrideHits / overrideEligible : null;
+
+    // Accept rate: short pure-affirmation messages.
+    acceptHits = users.filter((m) => {
+      const t = (m.text || '').trim();
+      if (!t || t.length > 30) return false;
+      return matchesAny(t, ACCEPT_PATTERNS);
+    }).length;
+    accept = acceptHits / users.length;
+  }
+
+  const challengeE = explainIndicator(H2.challenge,   challenge, difficulty);
+  const overrideE  = explainIndicator(H2.override,    override,  difficulty);
+  const acceptE    = explainIndicator(H2.accept_rate, accept,    difficulty);
+
+  const rule = {
+    challenge:   { score: challengeE.score, level: challengeE.level },
+    override:    { score: overrideE.score,  level: overrideE.level },
+    accept_rate: { score: acceptE.score,    level: acceptE.level },
+  };
+  const cell = llmCell || {};
+  const m = {
+    challenge:   mergeIndicator(cell.challenge,   rule.challenge.score,   rule.challenge.level),
+    override:    mergeIndicator(cell.override,    rule.override.score,    rule.override.level),
+    accept_rate: mergeIndicator(cell.accept_rate, rule.accept_rate.score, rule.accept_rate.level),
+  };
+
+  const subScores = { challenge: m.challenge.score, override: m.override.score, accept_rate: m.accept_rate.score };
+  const subLevels = { challenge: m.challenge.level, override: m.override.level, accept_rate: m.accept_rate.level };
+
+  const subEvidence = {
+    challenge:   makeEvidence({ key: 'challenge',   label: '合理质疑率', what: m.challenge.evidence   || (haveText ? `规则版：质疑关键词命中 ${challengeHits}/${users.length}。` : '无文本，无法识别。'), expl: challengeE, unit: '%', difficulty }),
+    override:    makeEvidence({ key: 'override',    label: '推翻率',     what: m.override.evidence    || (haveText ? `规则版：推翻关键词命中 ${overrideHits}/${overrideEligible}。` : '无文本，无法识别。'), expl: overrideE, unit: '%', difficulty }),
+    accept_rate: makeEvidence({ key: 'accept_rate', label: '顺从/采纳判断', what: m.accept_rate.evidence || (haveText ? `规则版（兜底）：纯肯定短消息占比 ${acceptHits}/${users.length}。LLM 开启后改为判断"采纳前是否有判断"。` : '无文本，无法识别。'), expl: acceptE, unit: '%', difficulty }),
+  };
+
+  const score = rollupDimension('H2', subScores);
+  const level = scoreToLevel(score);
+  const judgeSource = dimensionSource([m.challenge.source, m.override.source, m.accept_rate.source]);
+
+  return {
+    subScores,
+    subLevels,
+    subEvidence,
+    raw: { challenge, override, accept_rate: accept, difficulty, haveText, challengeHits, overrideHits, overrideEligible, acceptHits },
+    score,
+    level,
+    judgeSource,
+  };
+}
+
+module.exports = { analyze };

package/server/analysis/dimensions/llm-merge.js

@@ -0,0 +1,57 @@
+// server/analysis/dimensions/llm-merge.js
+'use strict';
+
+const { LEVEL_SCORE, scoreToLevel } = require('../thresholds-v2');
+
+/** Minimum LLM self-reported confidence to trust over the rule fallback. */
+const CONF_THRESHOLD = 0.5;
+
+/**
+ * Merge one LLM-judged indicator cell with the rule-derived score.
+ *
+ * The LLM may report either a granular 0–100 `score` (preferred — gives
+ * non-blocky sub-scores) or, for back-compat with older cached payloads, a
+ * discrete `level` (1–4).  With a score we derive the level band via
+ * scoreToLevel; with only a level we fall back to the level's centred score.
+ *
+ * @param {{score:?number, level:?number, confidence:?number, evidence:?string}|null|undefined} cell
+ * @param {number|null} ruleScore   centred score from explainIndicator (fallback)
+ * @param {number|null} ruleLevel
+ * @returns {{score:number|null, level:number|null, source:'llm'|'rules', evidence:string|null}}
+ */
+function mergeIndicator(cell, ruleScore, ruleLevel) {
+  if (cell && typeof cell.confidence === 'number' && cell.confidence >= CONF_THRESHOLD) {
+    // Preferred: granular 0–100 score (kept to one decimal).
+    if (typeof cell.score === 'number' && Number.isFinite(cell.score)
+        && cell.score >= 0 && cell.score <= 100) {
+      const score = Math.round(cell.score * 10) / 10;
+      return { score, level: scoreToLevel(score), source: 'llm', evidence: cell.evidence || null };
+    }
+    // Back-compat: discrete level → centred score.
+    if (Number.isInteger(cell.level) && cell.level >= 1 && cell.level <= 4) {
+      return { score: LEVEL_SCORE[cell.level], level: cell.level, source: 'llm', evidence: cell.evidence || null };
+    }
+  }
+  return {
+    score: ruleScore ?? null,
+    level: ruleLevel ?? null,
+    source: 'rules',
+    evidence: null,
+  };
+}
+
+/**
+ * Aggregate per-indicator sources into a dimension-level source label.
+ * @param {Array<'llm'|'rules'|null>} sources
+ * @returns {'llm'|'rules'|'mixed'|null}
+ */
+function dimensionSource(sources) {
+  const used = sources.filter(Boolean);
+  if (!used.length) return null;
+  const hasLlm = used.includes('llm');
+  const hasRules = used.includes('rules');
+  if (hasLlm && hasRules) return 'mixed';
+  return hasLlm ? 'llm' : 'rules';
+}
+
+module.exports = { mergeIndicator, dimensionSource, CONF_THRESHOLD };

package/server/analysis/dimensions/output-quality.js

@@ -0,0 +1,167 @@
+/**
+ * O1 — AI Output Quality.
+ *
+ * Sub-indicators:
+ *   • first_take    — fraction of assistant turns NOT followed by an
+ *                     immediate user correction
+ *   • code_style    — LLM-judged (rule fallback returns 0.7 neutral)
+ *   • completeness  — assistant text mentions edge/error/test concepts
+ *                     (LLM judge is more accurate; rules give a proxy)
+ *
+ * See spec §4.6.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const {
+  fetchMessages,
+  matchesAny,
+} = require('../text-signals');
+const { explainIndicator, rollupDimension, scoreToLevel, O1 } = require('../thresholds-v2');
+const { mergeIndicator, dimensionSource } = require('./llm-merge');
+const { makeEvidence } = require('../evidence-builder');
+
+const CORRECTION_PATTERNS = [
+  /改一下/, /不对/, /(再|重新)(写|来|改|做)/, /(错|有问题|有bug)/, /漏了/, /换/,
+  /fix that/i, /that'?s wrong/i, /redo/i, /try again/i, /not quite/i,
+];
+
+const COMPLETENESS_PATTERNS = [
+  /边界/, /异常/, /错误处理/, /测试/, /单元测试/, /回退/, /兜底/,
+  /edge case/i, /error handling/i, /test/i, /fallback/i, /exception/i,
+];
+
+function analyzeRules(db, session, difficulty = 2) {
+  const messages = fetchMessages(db, session.id);
+  const haveText = messages.some((m) => m.text && m.text.length > 0);
+
+  let first_take = null;
+  let assistantTurns = 0;
+  let correctionsAfter = 0;
+
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m.role !== 'assistant') continue;
+    assistantTurns++;
+    const next = i + 1 < messages.length ? messages[i + 1] : null;
+    if (!next || next.role !== 'user' || !next.text) continue;
+    if (matchesAny(next.text, CORRECTION_PATTERNS)) correctionsAfter++;
+  }
+  if (assistantTurns > 0) {
+    first_take = 1 - correctionsAfter / assistantTurns;
+  }
+
+  const code_style = haveText ? 0.7 : null;
+
+  let completeness = null;
+  let completenessHits = 0;
+  let assistantMsgsWithText = 0;
+  if (haveText) {
+    const assistantMsgs = messages.filter((m) => m.role === 'assistant' && m.text);
+    assistantMsgsWithText = assistantMsgs.length;
+    if (assistantMsgs.length > 0) {
+      completenessHits = assistantMsgs.filter((m) => matchesAny(m.text, COMPLETENESS_PATTERNS)).length;
+      completeness = completenessHits / assistantMsgs.length;
+    }
+  }
+
+  const ftE = explainIndicator(O1.first_take,   first_take,   difficulty);
+  const csE = explainIndicator(O1.code_style,   code_style,   difficulty);
+  const cpE = explainIndicator(O1.completeness, completeness, difficulty);
+
+  const subScores = {
+    first_take:   ftE.score,
+    code_style:   csE.score,
+    completeness: cpE.score,
+  };
+  const subLevels = {
+    first_take:   ftE.level,
+    code_style:   csE.level,
+    completeness: cpE.level,
+  };
+
+  const subEvidence = buildSubEvidence(
+    { ft: ftE, cs: csE, cp: cpE },
+    {
+      mode: 'rules', haveText, assistantTurns, correctionsAfter,
+      assistantMsgsWithText, completenessHits,
+    },
+    difficulty
+  );
+
+  const score = rollupDimension('O1', subScores);
+  const level = scoreToLevel(score);
+
+  return {
+    subScores,
+    subLevels,
+    subEvidence,
+    raw: { first_take, code_style, completeness, assistantTurns, correctionsAfter, completenessHits, assistantMsgsWithText },
+    score,
+    level,
+    judgeSource: 'rules',
+    llmJudge: null,
+  };
+}
+
+/** Public entry — synchronous.  `llmCell` is llmJudge.O1 (or null). */
+function analyze(db, session, difficulty = 2, llmCell = null) {
+  const ruleResult = analyzeRules(db, session, difficulty);
+  if (!llmCell) return ruleResult;
+
+  const cell = llmCell;
+  const m = {
+    first_take:   mergeIndicator(cell.first_take,   ruleResult.subScores.first_take,   ruleResult.subLevels.first_take),
+    code_style:   mergeIndicator(cell.code_style,   ruleResult.subScores.code_style,   ruleResult.subLevels.code_style),
+    completeness: mergeIndicator(cell.completeness, ruleResult.subScores.completeness, ruleResult.subLevels.completeness),
+  };
+
+  const subScores = { first_take: m.first_take.score, code_style: m.code_style.score, completeness: m.completeness.score };
+  const subLevels = { first_take: m.first_take.level, code_style: m.code_style.level, completeness: m.completeness.level };
+
+  const subEvidence = {
+    first_take:   { ...ruleResult.subEvidence.first_take,   what: m.first_take.evidence   || ruleResult.subEvidence.first_take.what,   level: subLevels.first_take,   score: subScores.first_take },
+    code_style:   { ...ruleResult.subEvidence.code_style,   what: m.code_style.evidence   || ruleResult.subEvidence.code_style.what,   level: subLevels.code_style,   score: subScores.code_style },
+    completeness: { ...ruleResult.subEvidence.completeness, what: m.completeness.evidence || ruleResult.subEvidence.completeness.what, level: subLevels.completeness, score: subScores.completeness },
+  };
+
+  const score = rollupDimension('O1', subScores);
+  const level = scoreToLevel(score);
+  const judgeSource = dimensionSource([m.first_take.source, m.code_style.source, m.completeness.source]);
+
+  return { subScores, subLevels, subEvidence, raw: { llmCell: cell, ruleRaw: ruleResult.raw }, score, level, judgeSource, llmJudge: null };
+}
+
+function buildSubEvidence(expls, ctx, difficulty) {
+  const { ft, cs, cp } = expls;
+
+  // rules
+  const { haveText, assistantTurns, correctionsAfter, assistantMsgsWithText, completenessHits } = ctx;
+  return {
+    first_take: makeEvidence({
+      key: 'first_take', label: '一次采纳率',
+      what: assistantTurns > 0
+        ? `规则版：1 - (AI 回合后用户立即纠错的比例) = 1 - ${correctionsAfter} / ${assistantTurns} 个 AI 回合。`
+        : '规则版：无 AI 回合可评估。',
+      expl: ft, unit: '%', difficulty,
+    }),
+    code_style: makeEvidence({
+      key: 'code_style', label: '代码规范性',
+      what: haveText
+        ? '规则版无法评估代码规范，默认给中性 0.7 分。开启 LLM judge 可获得真实评估。'
+        : '消息文本缺失，无法评估。',
+      expl: cs, unit: '%', difficulty,
+    }),
+    completeness: makeEvidence({
+      key: 'completeness', label: '方案完备性',
+      what: assistantMsgsWithText > 0
+        ? `规则版：AI 消息中含完备性关键词（"边界"、"异常"、"测试"等）的比例：${completenessHits} / ${assistantMsgsWithText}。`
+        : '规则版：无 AI 文本，无法评估。',
+      expl: cp, unit: '%', difficulty,
+    }),
+  };
+}
+
+module.exports = { analyze, analyzeRules };

package/server/analysis/dimensions/problem-definition.js

@@ -0,0 +1,104 @@
+/**
+ * H1 — Problem Definition.
+ *
+ * Captures the human ability to turn a vague need into a precise,
+ * AI-executable problem.  Three sub-indicators:
+ *   • clarity   — AI proactive-question count in the first 30%
+ *   • converge  — number of user-message rounds to convergence
+ *   • drift     — direction-change events
+ *
+ * See docs/superpowers/specs/2026-06-13-capability-model-v2.md §4.1.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const { queryAll } = require('../../db/queries');
+const {
+  fetchMessages,
+  userMessages,
+  matchesAny,
+  DRIFT_PATTERNS,
+} = require('../text-signals');
+const { explainIndicator, rollupDimension, scoreToLevel, H1 } = require('../thresholds-v2');
+const { makeEvidence } = require('../evidence-builder');
+const { mergeIndicator, dimensionSource } = require('./llm-merge');
+
+function analyze(db, session, difficulty = 2, llmCell = null) {
+  const messages = fetchMessages(db, session.id);
+  const users = userMessages(messages);
+
+  // ---- clarity: count of `question` tool calls in first 30% ----------
+  const toolCalls = queryAll(
+    db,
+    `SELECT tool_name, timestamp
+       FROM unified_tool_call
+      WHERE session_id = ?
+      ORDER BY timestamp ASC`,
+    [session.id]
+  );
+  let clarity = 0;
+  let clarityCutoff = 0;
+  if (toolCalls.length > 0) {
+    clarityCutoff = Math.max(1, Math.floor(toolCalls.length * 0.3));
+    clarity = toolCalls.slice(0, clarityCutoff).filter((t) => t.tool_name === 'question').length;
+  }
+
+  // ---- converge: number of user messages -----------------------------
+  const converge = users.length;
+
+  // ---- drift: keyword spotting on user text -------------------------
+  const haveText = users.some((m) => m.text && m.text.length > 0);
+
+  let drift = null;
+  if (haveText) {
+    drift = users.filter((m) => matchesAny(m.text, DRIFT_PATTERNS)).length;
+  }
+
+  // ---- eval each ----------------------------------------------------
+  const clarityE  = explainIndicator(H1.clarity,  clarity,  difficulty);
+  const convergeE = explainIndicator(H1.converge, converge, difficulty);
+  const driftE    = explainIndicator(H1.drift,    drift,    difficulty);
+
+  // Rule baseline per indicator (level + centred score).
+  const rule = {
+    clarity:  { score: clarityE.score,  level: clarityE.level },
+    converge: { score: convergeE.score, level: convergeE.level },
+    drift:    { score: driftE.score,    level: driftE.level },
+  };
+
+  // Merge LLM cell (if any) over the rule baseline.
+  const cell = llmCell || {};
+  const m = {
+    clarity:  mergeIndicator(cell.clarity,  rule.clarity.score,  rule.clarity.level),
+    converge: mergeIndicator(cell.converge, rule.converge.score, rule.converge.level),
+    drift:    mergeIndicator(cell.drift,    rule.drift.score,    rule.drift.level),
+  };
+
+  const subScores = { clarity: m.clarity.score, converge: m.converge.score, drift: m.drift.score };
+  const subLevels = { clarity: m.clarity.level, converge: m.converge.level, drift: m.drift.level };
+
+  // Evidence: prefer the LLM's cited rationale when that indicator used the LLM.
+  const subEvidence = {
+    clarity:  makeEvidence({ key: 'clarity',  label: '初始指令清晰度', what: m.clarity.evidence  || `规则版：前 30% 工具调用中 question 次数 ${clarity}（共 ${toolCalls.length} 次调用）。`, expl: clarityE,  unit: '次', difficulty }),
+    converge: makeEvidence({ key: 'converge', label: '任务收敛轮次',   what: m.converge.evidence || `规则版：用户消息 ${converge} 条。`, expl: convergeE, unit: '轮', difficulty }),
+    drift:    makeEvidence({ key: 'drift',    label: '方向变更次数',   what: m.drift.evidence    || (haveText ? `规则版：方向变更关键词命中 ${drift} 条。` : '用户消息无文本，无法识别。'), expl: driftE, unit: '次', difficulty }),
+  };
+
+  const score = rollupDimension('H1', subScores);
+  const level = scoreToLevel(score);
+  const judgeSource = dimensionSource([m.clarity.source, m.converge.source, m.drift.source]);
+
+  return {
+    subScores,
+    subLevels,
+    subEvidence,
+    raw: { clarity, converge, drift, difficulty, haveText, toolCallCount: toolCalls.length, clarityCutoff },
+    score,
+    level,
+    judgeSource,
+  };
+}
+
+module.exports = { analyze };