agentboss 0.1.0

package/server/analysis/report-builder.js

@@ -0,0 +1,581 @@
+/**
+ * Report builder for Agent Boss API responses.
+ *
+ * Assembles structured report payloads by fetching v2 dimension scores,
+ * daily summaries, and session lists from boss.db.
+ *
+ * @author Felix
+ */
+
+const {
+  queryAll,
+  getSessionsByDateRange,
+  getSessionById,
+  getAnalysisBySession,
+  getDailySummaries,
+  getAnalysisState,
+  getOverviewTopProjects,
+} = require('../db/queries');
+const { mapTopProjects } = require('../utils/project');
+
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a Date as YYYY-MM-DD.
+ * @param {Date} d
+ * @returns {string}
+ */
+function _fmt(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+/**
+ * Get yesterday's date as YYYY-MM-DD.
+ * @returns {string}
+ */
+function _yesterday() {
+  const d = new Date();
+  d.setDate(d.getDate() - 1);
+  return _fmt(d);
+}
+
+/**
+ * Get the Monday of the current ISO week (or the week containing the given
+ * date).
+ * @param {Date} [d]
+ * @returns {string}
+ */
+function _mondayOf(d) {
+  const dt = d ? new Date(d) : new Date();
+  const day = dt.getDay(); // 0=Sun … 6=Sat
+  const diff = day === 0 ? 6 : day - 1;
+  dt.setDate(dt.getDate() - diff);
+  return _fmt(dt);
+}
+
+/**
+ * Get the date N days ago as YYYY-MM-DD.
+ * @param {number} n
+ * @returns {string}
+ */
+function _daysAgo(n) {
+  const d = new Date();
+  d.setDate(d.getDate() - n);
+  return _fmt(d);
+}
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute current v2 dimensions (H1/H2/E1/E2/O1 averaged across the
+ * date range; H3 from the rolling aggregator over the same window).
+ *
+ * @param {object} db
+ * @param {string} fromDate
+ * @param {string} toDate
+ * @returns {{ H1:number|null, H2:number|null, H3:number|null, E1:number|null, E2:number|null, O1:number|null }}
+ */
+function getCurrentDimensionsV2(db, fromDate, toDate) {
+  const sessions = getSessionsByDateRange(db, fromDate, toDate, undefined, 10000, 0);
+
+  const acc = { H1: { s: 0, n: 0 }, H2: { s: 0, n: 0 }, E1: { s: 0, n: 0 }, E2: { s: 0, n: 0 }, O1: { s: 0, n: 0 } };
+
+  for (const s of sessions) {
+    const a = getAnalysisBySession(db, s.id);
+    if (!a || a.status !== 'done') continue;
+    for (const [k, col] of [['H1','score_h1'],['H2','score_h2'],['E1','score_e1'],['E2','score_e2'],['O1','score_o1']]) {
+      if (a[col] != null) { acc[k].s += a[col]; acc[k].n++; }
+    }
+  }
+
+  const result = {};
+  for (const [k, v] of Object.entries(acc)) {
+    result[k] = v.n > 0 ? Math.round((v.s / v.n) * 10) / 10 : null;
+  }
+
+  // H3 is a rolling aggregate — compute on demand for this window.
+  let h3 = null;
+  try {
+    const { analyzeRange } = require('./dimensions/system-thinking');
+    const r = analyzeRange(db, fromDate, toDate);
+    h3 = r.score;
+  } catch (_) { h3 = null; }
+  result.H3 = h3;
+
+  // ENV = "AI 能力环境诊断" = average of E1 (knowledge) and E2 (tools).
+  // Only computed when at least one side is present.
+  if (result.E1 != null && result.E2 != null) {
+    result.ENV = Math.round(((result.E1 + result.E2) / 2) * 10) / 10;
+  } else if (result.E1 != null) {
+    result.ENV = result.E1;
+  } else if (result.E2 != null) {
+    result.ENV = result.E2;
+  } else {
+    result.ENV = null;
+  }
+
+  return result;
+}
+
+/**
+ * Combine E1 + E2 into the v2.1 "AI 能力环境诊断" composite for a single
+ * session.  Returns null if both inputs are null.
+ *
+ * @param {number|null} e1
+ * @param {number|null} e2
+ * @returns {number|null}
+ */
+function envScore(e1, e2) {
+  if (e1 == null && e2 == null) return null;
+  if (e1 == null) return e2;
+  if (e2 == null) return e1;
+  return Math.round(((e1 + e2) / 2) * 10) / 10;
+}
+
+/**
+ * Map a 0-100 score to the same L1-L4 buckets the rest of v2 uses
+ * (≥85 L4 · ≥65 L3 · ≥40 L2 · else L1).  Mirrors thresholds-v2#scoreToLevel
+ * — duplicated here to avoid pulling a server/analysis dep into the
+ * report builder.
+ *
+ * @param {number|null} score
+ * @returns {1|2|3|4|null}
+ */
+function levelFromScore(score) {
+  if (score == null) return null;
+  if (score >= 85) return 4;
+  if (score >= 65) return 3;
+  if (score >= 40) return 2;
+  return 1;
+}
+
+/**
+ * Build stats summary from daily_summary row(s) or compute from sessions.
+ * @param {object} db
+ * @param {string} fromDate
+ * @param {string} toDate
+ * @returns {object}
+ */
+function buildStats(db, fromDate, toDate) {
+  const summaries = getDailySummaries(db, fromDate, toDate);
+
+  let sessions = 0;
+  let cost = 0;
+  let activeMinutes = 0;
+  let totalTokens = 0;
+  let errors = 0;
+
+  for (const s of summaries) {
+    sessions += s.session_count || 0;
+    cost += s.cost_usd || 0;
+    activeMinutes += s.active_minutes || 0;
+    totalTokens += (s.tokens_input || 0) + (s.tokens_output || 0) + (s.tokens_reasoning || 0);
+    errors += s.error_count || 0;
+  }
+
+  return {
+    sessions,
+    cost: Math.round(cost * 100) / 100,
+    activeMinutes,
+    totalTokens,
+    errors,
+    avgCost: sessions > 0 ? Math.round((cost / sessions) * 100) / 100 : 0,
+    avgActiveMinutes: sessions > 0 ? Math.round(activeMinutes / sessions) : 0,
+    avgTokens: sessions > 0 ? Math.round(totalTokens / sessions) : 0,
+    avgErrors: sessions > 0 ? Math.round((errors / sessions) * 100) / 100 : 0,
+  };
+}
+
+/**
+ * Build session list with per-session scores and metadata.
+ *
+ * Subagents (parent_session_id IS NOT NULL) are skipped here so the
+ * "会话列表" UI shows top-level work only.  Aggregate stats on the
+ * same page (stats, dimensions, daily_summary, collab bill) are
+ * computed by other queries that still include them — see the comment
+ * on the parent_session_id column in schema.js for the rationale.
+ *
+ * @param {object} db
+ * @param {string} fromDate
+ * @param {string} toDate
+ * @returns {object[]}
+ */
+function buildSessionList(db, fromDate, toDate) {
+  const sessions = getSessionsByDateRange(db, fromDate, toDate, undefined, 10000, 0);
+  const list = [];
+
+  for (const s of sessions) {
+    if (s.parent_session_id) continue;        // skip subagents
+    const analysis = getAnalysisBySession(db, s.id);
+    list.push({
+      id: s.id,
+      title: s.title || '(untitled)',
+      source: s.source,
+      // date/startedAt let the UI group sessions by day (weekly report)
+      date: s.date,
+      startedAt: s.started_at,
+      cost: Math.round((s.cost_usd || 0) * 100) / 100,
+      duration: s.duration_minutes || 0,
+      // v2 main-axis scores (UI averages H1/H2/H3/ENV/O1 into a single
+      // composite column).  ENV is derived from E1 + E2 client-side via
+      // its own column would explode the row width.
+      scoreH1: analysis ? analysis.score_h1 : null,
+      scoreH2: analysis ? analysis.score_h2 : null,
+      scoreH3: analysis ? analysis.score_h3 : null,
+      scoreEnv: analysis ? envScore(analysis.score_e1, analysis.score_e2) : null,
+      scoreO1: analysis ? analysis.score_o1 : null,
+      status: analysis ? analysis.status : 'pending',
+    });
+  }
+
+  return list;
+}
+
+/**
+ * Build analysis status from the analysis_state table and session data.
+ * @param {object} db
+ * @param {string} fromDate
+ * @param {string} toDate
+ * @returns {{ status: string, analyzedCount: number, totalCount: number }}
+ */
+function buildAnalysisStatus(db, fromDate, toDate) {
+  const state = getAnalysisState(db);
+  const sessions = getSessionsByDateRange(db, fromDate, toDate, undefined, 10000, 0);
+  let analyzed = 0;
+
+  for (const s of sessions) {
+    const a = getAnalysisBySession(db, s.id);
+    if (a && a.status === 'done') analyzed++;
+  }
+
+  return {
+    status: state ? state.status : 'idle',
+    analyzedCount: analyzed,
+    totalCount: sessions.length,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Build yesterday report data.
+ * @param {object} db  sql.js Database instance
+ * @returns {object}   Report payload for the API
+ */
+function buildYesterdayReport(db) {
+  const date = _yesterday();
+  const fromDate = date;
+  const toDate = date;
+
+  // 1. Stats
+  const stats = buildStats(db, fromDate, toDate);
+
+  // 2. Dimensions v2 (H1/H2/H3/E1/E2/O1)
+  const currentV2 = getCurrentDimensionsV2(db, fromDate, toDate);
+
+  // 3. Sessions
+  const sessionList = buildSessionList(db, fromDate, toDate);
+
+  // 4. Top projects (canonical-key de-duped, top 5 by cost).  Pull a
+  // larger candidate pool so collapsing duplicates leaves enough rows.
+  const topProjectsRaw = getOverviewTopProjects(db, fromDate, toDate, 40);
+  const topProjects = mapTopProjects(topProjectsRaw, 5);
+
+  // 5. Analysis status
+  const analysisStatus = buildAnalysisStatus(db, fromDate, toDate);
+
+  return {
+    date,
+    stats,
+    dimensionsV2: { current: currentV2 },
+    sessions: sessionList,
+    topProjects,
+    analysisStatus,
+  };
+}
+
+/**
+ * Build weekly report data.
+ * @param {object} db
+ * @param {string} [weekStart]  ISO date of Monday, defaults to current week
+ * @returns {object}
+ */
+function buildWeeklyReport(db, weekStart) {
+  const monday = weekStart || _mondayOf();
+  const sundayDate = new Date(monday + 'T00:00:00');
+  sundayDate.setDate(sundayDate.getDate() + 6);
+  const sunday = _fmt(sundayDate);
+
+  // 1. Stats
+  const stats = buildStats(db, monday, sunday);
+
+  // 2. Dimensions v2 — H1..O1 over the week, H3 over the same rolling window.
+  const currentV2 = getCurrentDimensionsV2(db, monday, sunday);
+
+  // 3. Sessions
+  const sessionList = buildSessionList(db, monday, sunday);
+
+  // 4. Daily breakdown (one summary per day)
+  const dailyBreakdown = getDailySummaries(db, monday, sunday).map((s) => ({
+    date: s.date,
+    sessions: s.session_count || 0,
+    cost: Math.round((s.cost_usd || 0) * 100) / 100,
+    activeMinutes: s.active_minutes || 0,
+    errors: s.error_count || 0,
+  }));
+
+  // 5. Top projects within the week (canonical-key de-duped, top 5 by cost).
+  const topProjectsRaw = getOverviewTopProjects(db, monday, sunday, 40);
+  const topProjects = mapTopProjects(topProjectsRaw, 5);
+
+  // 6. Analysis status
+  const analysisStatus = buildAnalysisStatus(db, monday, sunday);
+
+  return {
+    weekStart: monday,
+    weekEnd: sunday,
+    stats,
+    dimensionsV2: { current: currentV2 },
+    sessions: sessionList,
+    topProjects,
+    dailyBreakdown,
+    analysisStatus,
+  };
+}
+
+/**
+ * Build session detail data.
+ * @param {object} db
+ * @param {string} sessionId
+ * @returns {object|null}  null if session not found
+ */
+function buildSessionDetail(db, sessionId) {
+  const session = getSessionById(db, sessionId);
+  if (!session) return null;
+
+  const analysis = getAnalysisBySession(db, sessionId);
+
+  // v2: parse sub_scores_v2 if present.
+  let subScoresV2 = null;
+  let subLevelsV2 = null;
+  let subEvidenceV2 = null;
+  if (analysis && analysis.sub_scores_v2) {
+    try {
+      const parsed = JSON.parse(analysis.sub_scores_v2);
+      subScoresV2   = parsed.subScores   || null;
+      subLevelsV2   = parsed.subLevels   || null;
+      subEvidenceV2 = parsed.subEvidence || null;
+    } catch (_e) { /* ignore */ }
+  }
+
+  // v2: LLM judge payload — raw 0..1 values, per-field scoring evidence
+  // (details) and the one-line rationale, keyed e1/o1.
+  let llmJudgeV2 = null;
+  if (analysis && analysis.llm_judge_v2) {
+    try { llmJudgeV2 = JSON.parse(analysis.llm_judge_v2); }
+    catch (_e) { /* ignore */ }
+  }
+
+  // Per-session AI advice (see server/llm/advice.js).  Bundled into the
+  // session-detail response so the SPA renders cached suggestions on the
+  // first paint without a second round-trip.  null if never generated.
+  let advice = null;
+  if (analysis && analysis.llm_advice) {
+    try { advice = JSON.parse(analysis.llm_advice); }
+    catch (_e) { /* ignore */ }
+  }
+
+  // Tool call breakdown
+  const toolBreakdown = queryAll(
+    db,
+    `SELECT tool_name, COUNT(*) AS total,
+            SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) AS errors
+     FROM unified_tool_call
+     WHERE session_id = ?
+     GROUP BY tool_name
+     ORDER BY total DESC`,
+    [sessionId]
+  );
+
+  // Per-tool sample invocations (up to N most recent) for UI hover details.
+  // We fetch a flat list ordered by tool then time-desc, then bucket in JS so
+  // we don't issue one query per tool.
+  const SAMPLE_LIMIT_PER_TOOL = 5;
+  const allCalls = queryAll(
+    db,
+    `SELECT tool_name, status, error_message, target_file, timestamp
+       FROM unified_tool_call
+      WHERE session_id = ?
+      ORDER BY tool_name ASC, timestamp DESC`,
+    [sessionId]
+  );
+  const samplesByTool = {};
+  for (const c of allCalls) {
+    const list = samplesByTool[c.tool_name] || (samplesByTool[c.tool_name] = []);
+    if (list.length < SAMPLE_LIMIT_PER_TOOL) {
+      list.push({
+        timestamp: c.timestamp,
+        status: c.status,
+        errorMessage: c.error_message,
+        targetFile: c.target_file,
+      });
+    }
+  }
+
+  // Message timeline summary + full transcript (for the "原始对话" panel).
+  // `text` is the 4KB-capped payload the ETL writes; tool calls live in
+  // unified_tool_call and we mix them into the same timeline below.
+  const messages = queryAll(
+    db,
+    `SELECT id, role, content_length, is_error, timestamp, text, model_id, tokens_input, tokens_output
+     FROM unified_message
+     WHERE session_id = ?
+     ORDER BY timestamp`,
+    [sessionId]
+  );
+
+  const userMessages = messages.filter((m) => m.role === 'user');
+  const assistantMessages = messages.filter((m) => m.role === 'assistant');
+
+  // Interleave messages and tool calls by timestamp so the transcript
+  // reads in true chronological order.
+  const toolCallsForTimeline = queryAll(
+    db,
+    `SELECT id, tool_name, status, error_message, target_file, timestamp
+     FROM unified_tool_call
+     WHERE session_id = ?
+     ORDER BY timestamp`,
+    [sessionId]
+  );
+
+  const transcript = [
+    ...messages.map((m) => ({
+      kind: 'message',
+      id: m.id,
+      role: m.role,
+      text: m.text || '',
+      isError: !!m.is_error,
+      timestamp: m.timestamp,
+      contentLength: m.content_length || 0,
+      modelId: m.model_id || null,
+      tokensInput: m.tokens_input || 0,
+      tokensOutput: m.tokens_output || 0,
+    })),
+    ...toolCallsForTimeline.map((t) => ({
+      kind: 'tool',
+      id: t.id,
+      tool: t.tool_name,
+      status: t.status,
+      errorMessage: t.error_message,
+      targetFile: t.target_file,
+      timestamp: t.timestamp,
+    })),
+  ].sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));
+
+  return {
+    id: session.id,
+    source: session.source,
+    date: session.date,
+    title: session.title || '(untitled)',
+    project: session.project,
+    model: session.model,
+    startedAt: session.started_at,
+    endedAt: session.ended_at,
+    durationMinutes: session.duration_minutes || 0,
+    activeMinutes: session.active_minutes || 0,
+    cost: Math.round((session.cost_usd || 0) * 100) / 100,
+    tokens: {
+      input: session.tokens_input || 0,
+      output: session.tokens_output || 0,
+      reasoning: session.tokens_reasoning || 0,
+      cacheRead: session.tokens_cache_read || 0,
+      cacheWrite: session.tokens_cache_write || 0,
+    },
+    messageCount: session.message_count || 0,
+    errorCount: session.error_count || 0,
+    toolCallCount: session.tool_call_count || 0,
+    reverted: !!session.reverted,
+    summary: {
+      additions: session.summary_additions || 0,
+      deletions: session.summary_deletions || 0,
+      files: session.summary_files || 0,
+    },
+    // v2 capability model — see docs/superpowers/specs/2026-06-13-…
+    // ENV is a *display* dimension that fuses E1 + E2 into "AI 能力环境
+    // 诊断" so the UI can show 5 axes instead of 6.  E1 / E2 stay in the
+    // payload for callers who want the raw breakdown.
+    dimensionsV2: analysis
+      ? {
+          H1:  analysis.score_h1,
+          H2:  analysis.score_h2,
+          H3:  analysis.score_h3,
+          E1:  analysis.score_e1,
+          E2:  analysis.score_e2,
+          ENV: envScore(analysis.score_e1, analysis.score_e2),
+          O1:  analysis.score_o1,
+        }
+      : null,
+    levelsV2: analysis
+      ? {
+          H1:  analysis.level_h1,
+          H2:  analysis.level_h2,
+          H3:  analysis.level_h3,
+          E1:  analysis.level_e1,
+          E2:  analysis.level_e2,
+          // ENV level derived from its score band (≥85 L4, ≥65 L3, ≥40 L2)
+          ENV: levelFromScore(envScore(analysis.score_e1, analysis.score_e2)),
+          O1:  analysis.level_o1,
+        }
+      : null,
+    subScoresV2,
+    subLevelsV2,
+    subEvidenceV2,
+    llmJudgeV2,
+    advice,
+    difficulty: analysis ? analysis.difficulty : null,
+    judgeSource: analysis ? analysis.judge_source : null,
+    analysisStatus: analysis ? analysis.status : 'pending',
+    toolBreakdown: toolBreakdown.map((t) => ({
+      tool: t.tool_name,
+      total: t.total,
+      errors: t.errors,
+      samples: samplesByTool[t.tool_name] || [],
+    })),
+    transcript,
+    messageSummary: {
+      userCount: userMessages.length,
+      assistantCount: assistantMessages.length,
+      avgUserLength:
+        userMessages.length > 0
+          ? Math.round(
+              userMessages.reduce((s, m) => s + (m.content_length || 0), 0) /
+                userMessages.length
+            )
+          : 0,
+      avgAssistantLength:
+        assistantMessages.length > 0
+          ? Math.round(
+              assistantMessages.reduce((s, m) => s + (m.content_length || 0), 0) /
+                assistantMessages.length
+            )
+          : 0,
+      errorMessages: messages.filter((m) => m.is_error).length,
+    },
+  };
+}
+
+module.exports = {
+  buildYesterdayReport,
+  buildWeeklyReport,
+  buildSessionDetail,
+  getCurrentDimensionsV2,
+};

package/server/analysis/scoring-v2.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { classifySession } = require('./difficulty');
+const problemDef    = require('./dimensions/problem-definition');
+const judgement     = require('./dimensions/judgement');
+const aiTools       = require('./dimensions/ai-tools');
+const aiKnowledge   = require('./dimensions/ai-knowledge');
+const outputQuality = require('./dimensions/output-quality');
+const { analyzeSessionLLM } = require('../llm/session-analyzer');
+const { dimensionSource } = require('./dimensions/llm-merge');
+const { rollupDimension, scoreToLevel } = require('./thresholds-v2');
+
+/**
+ * Score a single session through the v2.1 dimensions.
+ * ONE consolidated LLM call per session returns BOTH the dimension scores
+ * AND the collaboration advice.  All difficulties (including trivial) are
+ * assessed; the prompt is difficulty-conditioned so short sessions are
+ * graded on an easier curve.
+ *
+ * @param {object} db
+ * @param {object} session
+ * @param {object} [opts]   { force?: boolean }  bypass the analyzer cache
+ */
+async function analyzeSessionV2(db, session, opts = {}) {
+  const difficulty = classifySession(session);
+
+  // E2 (tool coverage) is structural — always computed.
+  const e2 = safe(() => aiTools.analyze(db, session, difficulty.bucket));
+
+  // One consolidated LLM call → { scores, advice } (null if disabled/failed).
+  let llm = null;
+  try { llm = await analyzeSessionLLM(db, session, { force: opts.force === true }); }
+  catch (_) { llm = null; }
+  const cells = (llm && llm.scores) || {};
+
+  const h1 = safe(() => problemDef.analyze(db, session, difficulty.bucket, cells.H1));
+  const h2 = safe(() => judgement.analyze(db, session, difficulty.bucket, cells.H2));
+  const e1 = safe(() => aiKnowledge.analyze(db, session, difficulty.bucket, cells.E1));
+  const o1 = safe(() => outputQuality.analyze(db, session, difficulty.bucket, cells.O1));
+
+  const judgeSrc = dimensionSource([h1, h2, e1, o1].map((r) => r && r.judgeSource));
+  return assemble(difficulty, { h1, h2, e1, e2, o1 }, llm, judgeSrc);
+}
+
+/** Build the standard result object from the per-dimension scorer outputs. */
+function assemble(difficulty, dims, llm, judgeSource) {
+  const { h1, h2, e1, e2, o1 } = dims;
+  const pick = (r, f) => (r ? r[f] : null);
+
+  const subScores = { H1: pick(h1, 'subScores'), H2: pick(h2, 'subScores'), H3: null, E1: pick(e1, 'subScores'), E2: pick(e2, 'subScores'), O1: pick(o1, 'subScores') };
+  const subLevels = { H1: pick(h1, 'subLevels'), H2: pick(h2, 'subLevels'), H3: null, E1: pick(e1, 'subLevels'), E2: pick(e2, 'subLevels'), O1: pick(o1, 'subLevels') };
+  const subEvidence = { H1: pick(h1, 'subEvidence'), H2: pick(h2, 'subEvidence'), H3: null, E1: pick(e1, 'subEvidence'), E2: pick(e2, 'subEvidence'), O1: pick(o1, 'subEvidence') };
+
+  const scores = { H1: pick(h1, 'score'), H2: pick(h2, 'score'), H3: null, E1: pick(e1, 'score'), E2: pick(e2, 'score'), O1: pick(o1, 'score') };
+  const levels = { H1: scoreToLevel(scores.H1), H2: scoreToLevel(scores.H2), H3: null, E1: scoreToLevel(scores.E1), E2: scoreToLevel(scores.E2), O1: scoreToLevel(scores.O1) };
+
+  return {
+    difficulty, subScores, subLevels, subEvidence, scores, levels, judgeSource,
+    // Full analyzer payload (scores+advice) cached verbatim in llm_judge_v2.
+    llmJudge: llm || null,
+    // Raw advice + the meta the advice normaliser needs (job persists to llm_advice).
+    llmAdvice: llm && llm.advice ? llm.advice : null,
+    llmAdviceMeta: llm ? { msgCount: llm.msgCount, cli: llm.cli } : null,
+  };
+}
+
+function safe(fn) {
+  try { return fn(); }
+  catch (err) { console.warn('[scoring-v2] dimension error:', err.message); return null; }
+}
+
+module.exports = { analyzeSessionV2, rollupDimension };