braintrust-lite 0.1.7 → 0.1.8

package/src/reflector.js

@@ -0,0 +1,244 @@
+'use strict';
+
+/**
+ * Reflector — async background process (Phase 2)
+ *
+ * Invoked as a detached child: node reflector.js --run <ts>
+ *
+ * Verifier ≠ Executor principle:
+ *   Uses REFLECTOR_CMD (codex gpt-5.4-mini) which differs from the default
+ *   judge (claude). Avoids self-evaluation bias.
+ *
+ * One LLM call, three outputs:
+ *   1. lessons  — 1-3 reusable rules (≤30 chars each)
+ *   2. skills   — 0-2 reusable prompt templates (Voyager skill library)
+ *   3. judge_score — 1-5 quality rating for the judge report
+ */
+
+const { appendFileSync } = require('fs');
+const { spawn } = require('child_process');
+const { join } = require('path');
+
+const {
+  REFLECTOR_CMD,
+  REFLECTOR_ARGS_PREFIX,
+  REFLECTOR_LOG,
+  DB_PATH,
+  ECONOMY,
+} = require('./config.js');
+
+// ─── Logging ──────────────────────────────────────────────────────────────────
+
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  try { appendFileSync(REFLECTOR_LOG, line); } catch { /* ignore */ }
+}
+
+// ─── Process runner (no timeout — reflector runs offline) ─────────────────────
+
+function run(cmd, args) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '', stderr = '';
+    proc.stdout.on('data', d => { stdout += d; });
+    proc.stderr.on('data', d => { stderr += d; });
+    proc.on('close', code => resolve({ stdout, stderr, code }));
+    proc.on('error', err => resolve({ stdout: '', stderr: err.message, code: -1 }));
+  });
+}
+
+// ─── Extract text from codex JSONL ────────────────────────────────────────────
+
+function extractCodexText(stdout) {
+  const lines = stdout.trim().split('\n').reverse();
+  for (const l of lines) {
+    try {
+      const e = JSON.parse(l);
+      if (e.item?.text) return e.item.text;
+    } catch { /* skip */ }
+  }
+  return stdout.trim();
+}
+
+// ─── Build reflector prompt ───────────────────────────────────────────────────
+
+function buildReflectorPrompt(question, judgeReport) {
+  return `你是一个 AI 系统的元认知分析器。以下是一次 AI 智囊团的讨论结果，请完成 3 个任务：
+
+问题: ${question}
+
+Judge 融合报告:
+${judgeReport.slice(0, 3000)}
+
+---
+
+**任务 1** — 提炼 1-3 条可复用的 lesson（每条 ≤30字，可操作的规则，不是泛泛而谈）
+**任务 2** — 抽取 0-2 条 skill（命名 + 描述 + 可注入的 prompt 片段，参考示例格式）
+**任务 3** — 给 judge 报告质量评分 1-5 分（具体性 × 可行性 × 完整度）
+
+严格按以下 JSON 格式输出，不要有任何额外文字：
+{
+  "lessons": [
+    {"domain": "general", "lesson": "简短可操作规则，≤30字"}
+  ],
+  "skills": [
+    {
+      "name": "snake_case_name",
+      "description": "一句话描述用途",
+      "template": "可直接注入 prompt 的模板文本",
+      "domain": "general"
+    }
+  ],
+  "judge_score": 4,
+  "judge_weakness": "一句话说明 judge 报告最大的不足"
+}
+
+示例 skill:
+{
+  "name": "constraint_first_analysis",
+  "description": "架构决策前先列约束，避免方案偏离实际",
+  "template": "请先列出至少3个硬约束（性能/成本/团队能力），再给出候选方案。",
+  "domain": "architecture"
+}`;
+}
+
+// ─── Parse reflector JSON output ──────────────────────────────────────────────
+
+function parseReflectorOutput(text) {
+  // Find JSON object in the response
+  const start = text.indexOf('{');
+  const end = text.lastIndexOf('}');
+  if (start === -1 || end === -1) throw new Error('No JSON object found in reflector output');
+
+  const raw = JSON.parse(text.slice(start, end + 1));
+
+  return {
+    lessons: Array.isArray(raw.lessons) ? raw.lessons : [],
+    skills: Array.isArray(raw.skills) ? raw.skills : [],
+    judgeScore: typeof raw.judge_score === 'number' ? raw.judge_score : null,
+    judgeWeakness: raw.judge_weakness || null,
+  };
+}
+
+// ─── Persist to DB ────────────────────────────────────────────────────────────
+
+function persistReflections(ts, { lessons, skills, judgeScore }) {
+  let db;
+  try {
+    const Database = require('better-sqlite3');
+    db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+  } catch (err) {
+    log(`DB open failed: ${err.message}`);
+    return;
+  }
+
+  const now = Date.now();
+
+  // Insert lessons
+  const insertLesson = db.prepare(`
+    INSERT INTO lessons (from_run, domain, lesson, created_at)
+    VALUES (?, ?, ?, ?)
+  `);
+  for (const l of lessons) {
+    if (!l.lesson || l.lesson.length > 120) continue; // basic validation
+    insertLesson.run(ts, l.domain || 'general', l.lesson, now);
+  }
+
+  // Insert skills
+  const insertSkill = db.prepare(`
+    INSERT OR IGNORE INTO skills (name, description, template, domain, from_run, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  for (const s of skills) {
+    if (!s.name || !s.template) continue;
+    insertSkill.run(
+      s.name, s.description || '', s.template, s.domain || 'general', ts, now
+    );
+  }
+
+  // Update run state + judge_score
+  const updates = ['state = ?', 'reflected_at = ?'];
+  const vals = ['reflected', now];
+  if (judgeScore !== null) { updates.push('judge_score = ?'); vals.push(judgeScore); }
+  vals.push(ts);
+  db.prepare(`UPDATE runs SET ${updates.join(', ')} WHERE ts = ?`).run(...vals);
+
+  db.close();
+}
+
+// ─── Main reflect() ───────────────────────────────────────────────────────────
+
+async function reflect(ts) {
+  if (ECONOMY) {
+    log(`[${ts}] ECONOMY mode — reflector skipped`);
+    return;
+  }
+
+  log(`[${ts}] starting reflection`);
+
+  // Load run data from DB
+  let db;
+  try {
+    const Database = require('better-sqlite3');
+    db = new Database(DB_PATH);
+  } catch (err) {
+    log(`[${ts}] DB open failed: ${err.message}`);
+    return;
+  }
+
+  const run = db.prepare('SELECT question, judge_report FROM runs WHERE ts = ?').get(ts);
+  db.close();
+
+  if (!run) { log(`[${ts}] run not found in DB`); return; }
+  if (!run.judge_report) { log(`[${ts}] no judge_report — skipping (per design: only reflect judged runs)`); return; }
+
+  const prompt = buildReflectorPrompt(run.question, run.judge_report);
+
+  log(`[${ts}] calling ${REFLECTOR_CMD} with ${REFLECTOR_ARGS_PREFIX.join(' ')}`);
+  const raw = await run_reflector(prompt);
+
+  if (!raw.stdout) {
+    log(`[${ts}] empty output from reflector (code=${raw.code}): ${raw.stderr.slice(0, 200)}`);
+    return;
+  }
+
+  const text = extractCodexText(raw.stdout);
+
+  let parsed;
+  try {
+    parsed = parseReflectorOutput(text);
+  } catch (err) {
+    log(`[${ts}] JSON parse failed: ${err.message}\nRaw: ${text.slice(0, 300)}`);
+    return;
+  }
+
+  log(`[${ts}] lessons=${parsed.lessons.length} skills=${parsed.skills.length} score=${parsed.judgeScore}`);
+
+  persistReflections(ts, parsed);
+  log(`[${ts}] done`);
+}
+
+// We can't name the function run() due to conflict above — use alias
+async function run_reflector(prompt) {
+  return run(REFLECTOR_CMD, [...REFLECTOR_ARGS_PREFIX, prompt]);
+}
+
+// ─── CLI entry point ──────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const runIdx = args.indexOf('--run');
+  if (runIdx === -1 || !args[runIdx + 1]) {
+    process.stderr.write('Usage: node reflector.js --run <ts>\n');
+    process.exit(1);
+  }
+  const ts = args[runIdx + 1];
+  reflect(ts).catch(err => {
+    log(`[${ts}] uncaught error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { reflect };

package/src/save.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { writeFileSync, mkdirSync } = require('fs');
+const { join } = require('path');
+
+/**
+ * Save all run artifacts to disk.
+ * Creates: raw/*.txt, normalized.json, report.md, summary.md
+ *
+ * @param {string} runDir - Absolute path to the run directory
+ * @param {string} question - The user's question
+ * @param {object} raws - Map of provider name → raw process result
+ * @param {Array} results - Normalized provider results
+ * @param {string|null} judgeOutput - Judge fusion report markdown
+ */
+function saveArtifacts(runDir, question, raws, results, judgeOutput) {
+  mkdirSync(join(runDir, 'raw'), { recursive: true });
+
+  // Save raw provider outputs
+  for (const [name, raw] of Object.entries(raws)) {
+    writeFileSync(join(runDir, 'raw', `${name}.txt`), raw.stdout || '');
+  }
+
+  // Save normalized JSON
+  writeFileSync(join(runDir, 'normalized.json'), JSON.stringify(results, null, 2));
+
+  // Save full report (all provider outputs + judge)
+  writeFileSync(join(runDir, 'report.md'), buildReport(question, results, judgeOutput));
+
+  // Save summary (question + judge only, token-efficient for context loading)
+  writeFileSync(join(runDir, 'summary.md'), buildSummary(question, results, judgeOutput));
+}
+
+/**
+ * Build the full report markdown.
+ */
+function buildReport(question, results, judgeOutput) {
+  const lines = [
+    `**问题**: ${question}`,
+    `**时间**: ${new Date().toISOString()}`,
+    '',
+    '---',
+    '',
+  ];
+
+  for (const r of results) {
+    const timing = `${(r.duration_ms / 1000).toFixed(1)}s`;
+    const warn = r.error ? ` ⚠ ${r.error}` : '';
+    lines.push(`## ${r.provider} (${timing}${warn})`);
+    lines.push('');
+    lines.push(r.content || '[no content]');
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  }
+
+  if (judgeOutput) {
+    lines.push('# 🧠 BRAINTRUST — 智囊团融合报告');
+    lines.push('');
+    lines.push(judgeOutput);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Build the summary markdown (question + judge only, ~500-1000 chars).
+ * Used for token-efficient context loading via --context-dir.
+ */
+function buildSummary(question, results, judgeOutput) {
+  const lines = [
+    `**问题**: ${question}`,
+    `**时间**: ${new Date().toISOString()}`,
+    '',
+  ];
+
+  if (judgeOutput) {
+    lines.push(judgeOutput);
+  } else {
+    // No judge: include key_claims from each successful model
+    for (const r of results) {
+      if (!r.error && r.key_claims.length) {
+        lines.push(`## ${r.provider}`);
+        lines.push(r.key_claims.join('\n'));
+        lines.push('');
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { saveArtifacts };

package/src/server.js

@@ -1,60 +1,267 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { consult } from './consult.js';
-import { formatAsMarkdown } from './format.js';
+'use strict';
+
+/**
+ * MCP server for braintrust-lite.
+ *
+ * Exposes one tool: `consult`
+ * Runs Claude CLI, Codex CLI, and Gemini CLI in parallel, returns their
+ * responses as Model A / B / C (blind by default) for the calling agent to judge.
+ *
+ * Protocol: JSON-RPC 2.0 over stdio, line-delimited.
+ */
+
+const readline = require('readline');
+const { spawn } = require('child_process');
+const { resolve } = require('path');
+const { version: PKG_VERSION } = require('../package.json');
+
+const { DEFAULT_TIMEOUT_S } = require('./config.js');
+const { getActiveProviders } = require('./providers/index.js');
+const { normalize } = require('./normalize.js');
+const { buildGeneratorSystem } = require('./prompts/index.js');
+
+// ─── Process Runner ────────────────────────────────────────────────────────────
+
+function makeRunner(timeoutMs, workDir) {
+  return function runProcess(cmd, args, opts = {}) {
+    const ac = new AbortController();
+    const cwd = opts.cwd || workDir;
+    const proc = spawn(cmd, args, { signal: ac.signal, stdio: ['ignore', 'pipe', 'pipe'], cwd });
+    let stdout = '', stderr = '';
+    proc.stdout.on('data', d => { stdout += d; });
+    proc.stderr.on('data', d => { stderr += d; });
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    return new Promise(res => {
+      let resolved = false;
+      const done = (code, error_type = null) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timer);
+        res({ stdout, stderr, code, error_type });
+      };
+      proc.on('close', code => done(code, code !== 0 ? 'nonzero' : null));
+      proc.on('error', err => {
+        if (err.name === 'AbortError') done('timeout', 'timeout');
+        else if (err.code === 'ENOENT') done(-1, 'enoent');
+        else done(-1, 'spawn_error');
+      });
+    });
+  };
+}
+
+// ─── MCP Response Helpers ──────────────────────────────────────────────────────
+
+function respond(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+}
+
+function respondError(id, code, message) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
+}
+
+// ─── Tool Schema ───────────────────────────────────────────────────────────────
 
 const CONSULT_TOOL = {
   name: 'consult',
-  description: '并发调用 Codex、Gemini、Claude CLI，获取三个模型的独立视角。适合架构选型、方案设计、技术决策、复杂调研。调用方担任 Judge 盲评综合输出。不适合：typo 修复、单行改动、只读查询。',
+  description:
+    '并发调用 Claude CLI、Codex CLI、Gemini CLI，以 Model A/B/C 匿名形式返回三模型独立回答，' +
+    '供主 Claude 担任 Judge 进行盲评合并。',
   inputSchema: {
     type: 'object',
+    required: ['prompt'],
     properties: {
-      prompt:      { type: 'string',  description: '要问各模型的问题，建议精炼自包含。' },
-      only:        { type: 'string',  enum: ['codex', 'gemini', 'claude'], description: '只调用指定一个模型。' },
-      skip:        { type: 'array',   items: { type: 'string', enum: ['codex', 'gemini', 'claude'] }, description: '跳过指定模型。' },
-      timeout_sec: { type: 'number',  description: '每个模型超时秒数，默认 90。0 = 不限时。' },
-      blind:       { type: 'boolean', description: '匿名化 provider 名称（默认 true）。' },
-      cwd:         { type: 'string',  description: '子进程工作目录。' },
+      prompt: {
+        type: 'string',
+        description: '问题或任务描述（建议自包含，含必要上下文）',
+      },
+      skip: {
+        type: 'array',
+        items: { type: 'string', enum: ['claude', 'codex', 'gemini'] },
+        description: '跳过指定模型（可多选）',
+      },
+      only: {
+        type: 'string',
+        enum: ['claude', 'codex', 'gemini'],
+        description: '只调用一个模型',
+      },
+      timeout_sec: {
+        type: 'number',
+        description: '每个模型超时秒数（0 = 不限时等待；默认 90）',
+        default: 90,
+      },
+      blind: {
+        type: 'boolean',
+        description: '匿名化模型名称为 A/B/C，防止位置偏置（默认 true）',
+        default: true,
+      },
+      cwd: {
+        type: 'string',
+        description: '子进程工作目录（默认：当前进程 cwd）',
+      },
     },
-    required: ['prompt'],
   },
 };
 
-const server = new Server(
-  { name: 'braintrust-lite', version: '0.1.7' },
-  { capabilities: { tools: {} } }
-);
+// ─── Blind Label Assignment ────────────────────────────────────────────────────
+
+/**
+ * Assign Model A/B/C labels in a stable but non-alphabetical order
+ * (sorted by a cheap hash of the provider name to reduce position bias).
+ *
+ * @param {Array} results - Normalized provider results
+ * @returns {Array<{label: string, result: object}>}
+ */
+function assignBlindLabels(results) {
+  const hash = s => [...s].reduce((acc, c) => ((acc * 31) + c.charCodeAt(0)) | 0, 0);
+  const sorted = [...results].sort((a, b) => hash(a.provider) - hash(b.provider));
+  return sorted.map((r, i) => ({ label: String.fromCharCode(65 + i), result: r }));
+}
+
+// ─── Consult Handler ──────────────────────────────────────────────────────────
+
+async function handleConsult(args) {
+  const {
+    prompt,
+    skip = [],
+    only,
+    timeout_sec = DEFAULT_TIMEOUT_S,
+    blind = true,
+    cwd,
+  } = args;
+
+  if (!prompt || !prompt.trim()) {
+    throw new Error('prompt is required and must not be empty');
+  }
+
+  // No-timeout sentinel: use 10 min cap so the process eventually ends
+  const timeoutMs = timeout_sec === 0 ? 10 * 60 * 1000 : timeout_sec * 1000;
+  const workDir = cwd ? resolve(cwd) : process.cwd();
+  const runProcess = makeRunner(timeoutMs, workDir);
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [CONSULT_TOOL] }));
+  // Resolve active providers
+  const skipList = only
+    ? ['claude', 'codex', 'gemini'].filter(n => n !== only)
+    : [...skip];
+  const activeProviders = getActiveProviders(skipList);
 
-server.setRequestHandler(CallToolRequestSchema, async req => {
-  if (req.params.name !== 'consult') throw new Error(`Unknown tool: ${req.params.name}`);
+  if (activeProviders.length === 0) {
+    throw new Error('No providers selected — check skip/only parameters.');
+  }
 
-  const args = req.params.arguments ?? {};
-  const timeoutMs = args.timeout_sec != null
-    ? (Number(args.timeout_sec) === 0 ? 0 : Number(args.timeout_sec) * 1000)
-    : 90_000;
+  // Build generator prompt
+  const systemPrompt = buildGeneratorSystem('general');
+  const fullPrompt = `${systemPrompt}\n\n${prompt}`;
 
-  const { results, mapping, successCount, totalCount } = await consult({
-    prompt:    String(args.prompt ?? ''),
-    only:      args.only,
-    skip:      Array.isArray(args.skip) ? args.skip : [],
-    timeoutMs,
-    blind:     args.blind !== false,
-    cwd:       args.cwd,
+  // Run all providers in parallel
+  const startTimes = Object.fromEntries(activeProviders.map(p => [p.name, Date.now()]));
+  const settled = await Promise.allSettled(
+    activeProviders.map(p => runProcess(p.cmd, p.getArgs(fullPrompt)))
+  );
+
+  // Normalize results
+  const results = activeProviders.map((p, i) => {
+    const raw = settled[i].status === 'fulfilled'
+      ? settled[i].value
+      : { stdout: '', stderr: '', code: -1, error_type: 'spawn_error' };
+    const ms = Date.now() - startTimes[p.name];
+    return normalize(p.name, raw, p.adapt(raw), ms);
   });
 
-  if (results.every(r => r.error)) {
-    const detail = results.map(r => `${r.provider}=${r.error_type || r.error}`).join(', ');
-    throw new Error(`All providers failed: ${detail}`);
+  const successCount = results.filter(r => !r.error).length;
+
+  // Build labeled pairs
+  const labeled = blind
+    ? assignBlindLabels(results)
+    : results.map(r => ({ label: r.provider, result: r }));
+
+  // Compose text output
+  const parts = [];
+
+  for (const { label, result: r } of labeled) {
+    const header = blind ? `Model ${label}` : r.provider;
+    const timing = r.error
+      ? ` ⚠ ${r.error_type || r.error}`
+      : ` (${(r.duration_ms / 1000).toFixed(1)}s, parse_score=${r.parse_score.toFixed(2)})`;
+    parts.push(`## ${header}${timing}\n\n${r.content || '[no output]'}`);
+  }
+
+  if (successCount < activeProviders.length) {
+    parts.push(
+      `> ⚠ **DEGRADED**: Only ${successCount}/${activeProviders.length} models responded successfully.`
+    );
+  }
+
+  if (blind) {
+    const mapping = labeled.map(({ label, result: r }) => `Model ${label} = ${r.provider}`).join(' · ');
+    parts.push(`---\n**REVEAL** (read after judging): ${mapping}`);
   }
 
+  const text = parts.join('\n\n---\n\n');
+
   return {
-    content: [{ type: 'text', text: formatAsMarkdown(results, mapping, { successCount, totalCount }) }],
+    content: [{ type: 'text', text }],
   };
-});
+}
+
+// ─── Request Dispatcher ────────────────────────────────────────────────────────
+
+async function dispatch(req) {
+  const { id, method, params } = req;
+
+  switch (method) {
+    case 'initialize':
+      respond(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'braintrust-lite', version: PKG_VERSION },
+      });
+      return;
+
+    case 'notifications/initialized':
+      return; // no-op, no response needed
+
+    case 'tools/list':
+      respond(id, { tools: [CONSULT_TOOL] });
+      return;
+
+    case 'tools/call': {
+      const toolName = params && params.name;
+      if (toolName !== 'consult') {
+        respondError(id, -32601, `Unknown tool: ${toolName}`);
+        return;
+      }
+      try {
+        const result = await handleConsult(params.arguments || {});
+        respond(id, result);
+      } catch (err) {
+        respondError(id, -32603, err.message);
+      }
+      return;
+    }
+
+    default:
+      // Only send error for requests (have an id), not notifications
+      if (id !== undefined && id !== null) {
+        respondError(id, -32601, `Method not found: ${method}`);
+      }
+  }
+}
+
+// ─── Entry Point ──────────────────────────────────────────────────────────────
+
+function main() {
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+  rl.on('line', line => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let req;
+    try { req = JSON.parse(trimmed); } catch { return; }
+    dispatch(req).catch(err => process.stderr.write(`[server error] ${err.message}\n`));
+  });
+
+  rl.on('close', () => process.exit(0));
+}
 
-const transport = new StdioServerTransport();
-await server.connect(transport);
+main();

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 HongjieRen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.