elanous 0.2.37 → 0.2.40

package/scripts/release-loop/traffic-transition.ts

@@ -4,12 +4,17 @@ import { debug } from '../../src/debug/log.js';
 import type { GraphContext } from './node-verdict.js';
 import type { ReleaseLoopConfig } from './unattended-release.js';
 
-export type ReleaseTrafficEvent = 'gate-passed' | 'verify-complete';
+export type ReleaseTrafficEvent = 'cut-start' | 'gate-passed' | 'npm-published' | 'verify-complete' | 'failed';
+
+export interface TrafficBeforeCut {
+  global?: string;
+  perCycle: Record<string, unknown>;
+}
 
 export interface TrafficFile {
   global?: string;
   seats: Record<string, Record<string, unknown>>;
-  releaseLifecycle?: { runId: string; version: string; stage: 1 | 2; event: ReleaseTrafficEvent; startedAt?: string; updatedAt: string };
+  releaseLifecycle?: { runId: string; version: string; stage: 0 | 1 | 2 | 3; event: ReleaseTrafficEvent; startedAt?: string; updatedAt: string; beforeCut?: TrafficBeforeCut };
   [key: string]: unknown;
 }
 
@@ -18,7 +23,7 @@ type ReleaseTrafficConfig = ReleaseLoopConfig & {
 };
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
-const STAGE: Record<ReleaseTrafficEvent, 1 | 2> = { 'gate-passed': 1, 'verify-complete': 2 };
+const STAGE: Record<ReleaseTrafficEvent, 0 | 1 | 2 | 3> = { 'cut-start': 0, 'gate-passed': 1, 'npm-published': 2, 'verify-complete': 2, failed: 3 };
 const TRAFFIC_PER_CYCLE = { half: 3, full: 6 } as const;
 
 export interface TrafficTransitionOptions {
@@ -112,32 +117,65 @@ export async function applyReleaseTrafficEvent(
   const log = options.log ?? ((name, fields) => debug.log('release-loop.traffic', name, fields));
   const stage = STAGE[event];
   const stamp = (options.now ?? (() => new Date()))().toISOString();
-  const rate = event === 'gate-passed' ? TRAFFIC_PER_CYCLE.half : TRAFFIC_PER_CYCLE.full;
-  const releaseLifecycle = { runId, version, stage, event, ...(context.startedAt ? { startedAt: context.startedAt } : {}), updatedAt: stamp };
+  const rate = event === 'gate-passed' ? TRAFFIC_PER_CYCLE.half
+    : event === 'npm-published' || event === 'verify-complete' ? TRAFFIC_PER_CYCLE.full : undefined;
   const release = () => {
     const unlock = acquireTrafficLock(path, options.lockTimeoutMs);
     try {
       const before = readTrafficFile(path);
       const prior = before.releaseLifecycle;
+      if ((event === 'npm-published' || event === 'verify-complete') && context.outputs['npm-publish']?.outcome !== 'ok') {
+        return { file: before, applied: false, idempotent: false, reason: 'npm-publish-unconfirmed' };
+      }
       const sameRun = prior?.runId === runId;
       const newerVersion = !prior?.runId || compareReleaseVersions(version, prior.version) > 0;
       const sameVersionLaterRun = prior?.version === version && isLaterRun(context.startedAt, prior.startedAt);
-      if (sameRun && prior.stage >= stage) return { file: before, applied: true, idempotent: true };
-      const permitted = sameRun
-        ? prior.stage === stage - 1
-        : newerVersion || (event === 'gate-passed' && prior?.version === version && (prior.stage ?? 0) < 2 && sameVersionLaterRun)
-          || (event === 'verify-complete' && prior?.version === version && sameVersionLaterRun);
+      const resumedTrafficNode = sameRun && prior.stage === 3
+        && (event === 'cut-start' && context.nodeId === 'traffic-cut-start'
+          || event === 'gate-passed' && context.nodeId === 'traffic-gate-passed'
+          || event === 'npm-published' && context.nodeId === 'traffic-npm-published'
+          || event === 'verify-complete' && context.nodeId === 'traffic-verify-complete' && context.outputs['npm-publish']?.outcome === 'ok');
+      if (sameRun && prior.stage === 3 && event !== 'failed' && !resumedTrafficNode) {
+        return { file: before, applied: false, idempotent: false, reason: 'run-already-failed' };
+      }
+      if (sameRun && prior.stage >= stage && event !== 'failed' && !resumedTrafficNode) return { file: before, applied: true, idempotent: true };
+      if (event === 'failed' && (!sameRun || prior?.stage === 2 || prior?.stage === 3 || !prior?.beforeCut)) {
+        return { file: before, applied: false, idempotent: false,
+          reason: !sameRun ? prior?.runId ? 'different-run-is-current' : 'before-cut-unmeasured'
+            : prior?.stage === 2 ? 'published-keeps-full' : prior?.stage === 3 ? 'already-restored' : 'before-cut-unmeasured' };
+      }
+      const permitted = event === 'failed' ? sameRun
+        : sameRun ? resumedTrafficNode || (stage === 0 ? prior.stage === 0 : stage > prior.stage)
+        : newerVersion || (prior?.version === version && sameVersionLaterRun && (prior.stage < 2 || prior.stage === 3 || event === 'verify-complete'));
       if (!permitted) {
         return { file: before, applied: false, idempotent: false, reason: prior?.runId && prior.runId !== runId ? 'different-run-is-current' : 'event-out-of-order' };
       }
+      if (event === 'cut-start' && prior && prior.stage < 2 && !prior.beforeCut) {
+        return { file: before, applied: false, idempotent: false, reason: 'before-cut-unmeasured' };
+      }
+      const beforeCut = event === 'cut-start' ? {
+        ...(prior?.stage !== undefined && prior.stage < 2 && prior.beforeCut
+          ? prior.beforeCut
+          : { ...(before.global === undefined ? {} : { global: before.global }),
+            perCycle: Object.fromEntries(SEATS.map((seat) => [seat, before.seats[seat]?.perCycle])) }),
+      } : prior?.beforeCut;
+      const releaseLifecycle = { runId, version, stage, event, ...(context.startedAt ? { startedAt: context.startedAt } : {}),
+        updatedAt: stamp, ...(beforeCut ? { beforeCut } : {}) };
       const after: TrafficFile = {
         ...before,
-        ...(event === 'verify-complete' ? { global: 'green' } : {}),
+        ...(event === 'cut-start' ? { global: 'gate' }
+          : event === 'gate-passed' ? { global: 'yellow' }
+          : event === 'npm-published' || event === 'verify-complete' ? { global: 'green' }
+          : beforeCut?.global === undefined ? {} : { global: beforeCut.global }),
         seats: Object.fromEntries(Object.entries(before.seats).map(([seat, value]) => [
-          seat, SEATS.includes(seat as typeof SEATS[number]) ? { ...value, perCycle: rate } : value,
+          seat, SEATS.includes(seat as typeof SEATS[number])
+            ? { ...value, ...(event === 'failed' ? { perCycle: beforeCut?.perCycle[seat] } : rate === undefined ? {} : { perCycle: rate }) }
+            : value,
         ])),
         releaseLifecycle,
       };
+      if (event === 'failed' && beforeCut?.global === undefined) delete after.global;
+      if (event === 'failed') for (const seat of SEATS) if (beforeCut?.perCycle[seat] === undefined) delete after.seats[seat]?.perCycle;
       atomicWriteTrafficFile(path, after);
       return { file: after, applied: true, idempotent: false };
     } finally { unlock(); }
@@ -145,7 +183,9 @@ export async function applyReleaseTrafficEvent(
   const result = release();
   const reason = result.applied && result.idempotent ? 'already-applied' : result.reason;
   log(result.idempotent ? 'already-applied' : result.applied ? 'applied' : 'ignored', {
-    runId, version, event, stage, reason, perCycle: rate, ...(event === 'verify-complete' ? { global: 'green' } : {}),
+    runId, version, event, stage, reason, ...(rate === undefined ? {} : { perCycle: rate }),
+    ...(event === 'cut-start' ? { global: 'gate' } : event === 'gate-passed' ? { global: 'yellow' }
+      : event === 'npm-published' || event === 'verify-complete' ? { global: 'green' } : {}),
   });
   return { applied: result.applied, stage: result.file.releaseLifecycle?.stage ?? 0, ...(reason ? { reason } : {}) };
 }

package/scripts/release-loop/version-node.ts

@@ -8,6 +8,7 @@ import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
 import { landingFreezeMessage, readLandingFreeze, type LandingFreeze } from '../../src/release-loop/landing-freeze.js';
 import { baseVersion, isReleaseVersion, isStableVersion, prereleaseKind } from './release-version.js';
+import { cutReleaseBranch } from './cut-branch.js';
 
 type Kind = 'release' | 'dev-bump';
 type Output = { outcome: 'ok' | 'error'; kind: Kind | null; version: string | null; commit: string | null; pr: number | null; files?: string[]; worktree?: string; error?: string;
@@ -441,36 +442,65 @@ export function main(args: string[] = process.argv.slice(2), repo = process.cwd(
   let branchCut = false;
   let runId: string | undefined;
   try {
-    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] [--cut-commit <sha>] --json');
-    kind = args[0];
+    if (args[0] !== 'release' && args[0] !== 'dev-bump' && args[0] !== 'cut-branch')
+      throw new Error('usage: version-node.ts <release|dev-bump|cut-branch> [--version <v>] [--cut <sha>] [--cut-commit <sha>] [--pick <sha>] [--base <sha>] [--append] [--dry-run] --json');
+    kind = args[0] === 'cut-branch' ? 'release' : args[0];
+    const picks: string[] = [];
+    let base: string | undefined;
+    let append = false;
+    let dryRun = false;
+    let versionRelease: { commit?: unknown; base?: unknown; branch?: unknown } | undefined;
     for (let i = 1; i < args.length; i++) {
       if (args[i] === '--json') continue;
       if (args[i] === '--version' && args[i + 1]) { version = args[++i]!; continue; }
       if (args[i] === '--cut' && args[i + 1]) { cut = args[++i]!; continue; }
       if (args[i] === '--cut-commit' && args[i + 1]) { cutCommit = args[++i]!; continue; }
+      if (args[i] === '--pick' && args[i + 1]) { picks.push(args[++i]!); continue; }
+      if (args[i] === '--base' && args[i + 1]) { base = args[++i]!; continue; }
+      if (args[i] === '--append') { append = true; continue; }
+      if (args[i] === '--dry-run') { dryRun = true; continue; }
       throw new Error(`unknown or incomplete argument: ${args[i]}`);
     }
     if (process.env.ELANOUS_GRAPH_CONTEXT) {
       const location = process.env.ELANOUS_GRAPH_CONTEXT;
       const context = JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as {
-        runId?: unknown; input?: { version?: unknown; cutCommit?: unknown; forceFreeze?: unknown; branchCut?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+        runId?: unknown; input?: { version?: unknown; cutCommit?: unknown; forceFreeze?: unknown; branchCut?: unknown };
+        outputs?: Record<string, { outcome?: unknown; commit?: unknown; base?: unknown; branch?: unknown } | undefined> };
       if (context.runId !== undefined) {
         if (typeof context.runId !== 'string') throw new Error('runId must be a string');
         runId = context.runId;
       }
       if (!version && typeof context.input?.version === 'string') version = context.input.version;
       forceFreeze = context.input?.forceFreeze === true;
-      branchCut = context.input?.branchCut === true;
+      const releasedBranch = context.outputs?.['version-release']?.branch;
+      branchCut = context.input?.branchCut === true
+        || (kind === 'dev-bump'
+          && context.outputs?.['version-release']?.outcome === 'ok'
+          && typeof version === 'string'
+          && releasedBranch === `release/${version}`);
       if (kind === 'release' && cutCommit === undefined && context.input?.cutCommit !== undefined) {
         if (typeof context.input.cutCommit !== 'string') throw new Error('cutCommit must be a commit SHA');
         cutCommit = context.input.cutCommit;
       }
       // The cut = the commit version-release landed (what cutoff and the gate measured).
+      // RELEASE-APPEND-BASE-AUTO: cut-branch consumes that same record as its ledger seam
+      // (ledger: () => versionRelease), so it must not also see it injected as --cut.
       const releasedCommit = context.outputs?.['version-release']?.commit;
-      if (!cut && typeof releasedCommit === 'string' && releasedCommit) cut = releasedCommit;
+      if (args[0] !== 'cut-branch' && !cut && typeof releasedCommit === 'string' && releasedCommit) cut = releasedCommit;
+      // RELEASE-APPEND-BASE-AUTO: the version-release node's record is the ledger seam cut-branch consults.
+      versionRelease = context.outputs?.['version-release'];
     }
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
+    if (args[0] === 'cut-branch') {
+      if (cut !== undefined || cutCommit !== undefined) throw new Error('--cut/--cut-commit are not valid for cut-branch');
+      if (!picks.length) throw new Error('at least one --pick commit is required');
+      const result = cutReleaseBranch({
+        version, pick: picks, ...(base !== undefined ? { base } : {}), append, dryRun,
+        repoRoot: resolve(repo), ledger: () => versionRelease,
+      });
+      return { outcome: 'ok', kind: 'release', version, commit: result.commit, pr: null, branch: result.branch, ...(dryRun ? { skipped: 'dry-run' } : {}) };
+    }
     if (kind === 'dev-bump' && cutCommit !== undefined) throw new Error('--cut-commit is only valid for release');
     return landing(resolve(repo), kind, version, cut, cutCommit, forceFreeze, branchCut, undefined, runId);
   } catch (error) {

package/scripts/release-story/draft.ts

@@ -46,7 +46,7 @@ function userFacingLines(markdown: string): { lines: string[]; internalDropped:
       if (text) internalDropped++;
       return [];
     }
-    const publicText = text.replace(/\s+["'“]?Target:\s*next\.["'”]?\s*$/i, '')
+    const publicText = text.replace(/\s+["'“]?Target:\s*next\.["'”]?(?=\s*(?:\([^)]*\))?\s*$)/i, '')
       .replace(/\s+["'“]?Documentation:\s*.*\.["'”]?\s*$/i, '').trim()
       .replace(/^(?:feat|fix)\s*—\s*/i, '');
     return publicText ? [publicText] : [];

package/scripts/research-bench/README.md

@@ -0,0 +1,53 @@
+신설: scripts/research-bench/README.md
+# Research harness benchmark
+
+## SCQA
+
+**S** — The 10/31 positioning decision needs evidence about Elanous research quality and its Bloom-native research design.
+
+**C** — A product-default comparison mixes harness and model effects. Bloom stages and graph layouts also need isolated comparisons under one model and fixed questions.
+
+**Q** — How do we compare the products, measure Bloom's contribution, and test the recommended stage layout under either the default API cap or an explicitly approved uncapped run?
+
+**A** — Run the same ten questions across a controlled pair, Bloom ablation, product-default pair, and Elanous layout ablation. Start with three questions, review the measurement, then run all ten. Keep manifests, raw answers, scores, latency, and spend in private evidence.
+
+## Experiment matrix
+
+| Cell | Comparison | Bloom instruction | Layout | Harnesses |
+|---|---|---|---|---|
+| A0 | Controlled baseline and no-Bloom ablation | None | Baseline | Elanous + Claude Code, both Opus 5.5 |
+| A1 | Bloom ablation | Stages 1–3 | Baseline | Elanous + Claude Code, both Opus 5.5 |
+| A2 | Bloom ablation | Stages 1–5 | Baseline | Elanous + Claude Code, both Opus 5.5 |
+| A3 | Bloom ablation | Stages 1–6 | Baseline | Elanous + Claude Code, both Opus 5.5 |
+| B | Product comparison | None | Product defaults | Elanous installed default + Claude Code defaults |
+| P1 | Layout ablation | Stages 1–6 | Linear 1→6 | Elanous, Opus 5.5 |
+| P5 | Layout ablation | Stages 1–6 | Front 6 reverse design; parallel 1/3; 4/5 loop; final 6 | Elanous, Opus 5.5 |
+| P5-no-front6 | Layout ablation | Stages 1–6 | P5 without front 6 | Elanous, Opus 5.5 |
+
+A0 is also the no-Bloom ablation baseline. A1–A3 add cumulative Bloom scaffolding to the same question; the question text stays unchanged. The product cell uses Elanous's installed default configuration (gpt-6-luna) against Claude Code defaults; it is not a controlled model comparison. OP deferred role-routed Elanous best-config measurement to B2 after 0.2.40. Layout cells measure Elanous architecture only. The 10 questions cover finance, technology, and market; at least four require analysis/evaluation.
+
+## Run order and budget
+
+- Pilot: the first-listed question in each of the finance, technology, and market domains across all eight cells, 39 total invocations (24 Elanous API calls, 15 Claude subscription calls).
+- Execution-validation smoke: a configurable number of first-listed questions in A0 only, each as one matched Claude/Elanous pair. This checks runtime, timeout recovery, and cost collection; do not score it.
+- Full: 10 questions in all eight cells, 130 total invocations (80 Elanous API calls, 50 Claude subscription calls).
+- Default runs use the approved Elanous API cap of $200. After each Elanous call, read its `llm-usage` event, calculate token cost at official rates, and append to the private ledger. Do not start the next pair once cumulative Elanous API spend reaches $160 (80%). Finish the current matched pair. Claude Code subscription calls are recorded at $0 API spend and do not consume that cap. Use `--no-cost-cap` only when OP explicitly authorizes an uncapped run; manifests and ledgers mark both cap fields `null`.
+- Opus 5.5 rates are $4/MTok input, $20/MTok output, $5/MTok 5-minute cache writes, and $0.20/MTok cache reads. The official price table is [Anthropic prompt-cache pricing](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) and [Claude Opus pricing](https://www.anthropic.com/claude/opus). Other Elanous models use the price estimate in their `llm-usage` event; an unknown API price stops the run.
+- Pair order alternates for the controlled cells by question and cell. Every invocation starts a fresh session. Never pass one answer to another run.
+- Collect per-cell rubric scores, actual provider spend, elapsed time, source count/quality, resolution level, tool traces, and failure/unknown notes. Report paired deltas and uncertainty; ten questions do not support broad population claims.
+
+## Commands
+
+```bash
+bun scripts/research-bench/run.ts --dry-run
+bun scripts/research-bench/run.ts --live --smoke-pairs 3 --baseline-sha <main-commit-sha> --config <private-config.json> --no-cost-cap --approval-ref OP#42096 --out ~/elanous-hq/seat-state/OP/evidence/20261026/askop-model-vs-harness
+bun scripts/research-bench/run.ts --live --pilot --baseline-sha <main-commit-sha> --config <private-config.json> --max-total-cost-usd 200 --out ~/elanous-hq/seat-state/OP/evidence/20261026/askop-model-vs-harness
+bun scripts/research-bench/run.ts --live --pilot --baseline-sha <main-commit-sha> --config <private-config.json> --no-cost-cap --approval-ref OP#42096 --out ~/elanous-hq/seat-state/OP/evidence/20261026/askop-model-vs-harness
+bun scripts/research-bench/run.ts --live --full --baseline-sha <main-commit-sha> --config <private-config.json> --max-total-cost-usd 200 --out ~/elanous-hq/seat-state/OP/evidence/20261026/askop-model-vs-harness
+```
+
+The private config is version 2 and has adapters for A0, A1, A2, A3, B, P1, P5, and P5-no-front6, plus a baseline version probe. The probe must report the exact `--baseline-sha` requested before any live invocation starts. Smoke validation selects one question each from finance, technology, and market (one to three pairs), and its results are not scored. Adapter arguments are arrays, never shell strings; `{prompt}` is required and the other values may be interpolated when the adapter supports them. Each adapter declares model, tool-policy ID, turn limit, timeout, and a usage source. A0–A3 use Opus 5.5, eight tool turns, a 10-minute timeout, and a common research tool-policy ID; the Elanous config sets the Anthropic turn cap to eight, while Claude Code uses `--max-turns 8`. Elanous adapters query `eln logs --category llm.usage --event llm-usage --json --json-data --session {sessionId}` after each invocation; Claude Code adapters emit `stream-json` usage. Tool names differ slightly between CLI surfaces (Elanous `ListDir`, Claude Code `LS`); each call records the model reported by its usage source and token usage, using `unknown` when the source omits the model. Product defaults may differ by design.
+
+## Scoring and evidence
+
+Use `rubric.md` with blinded harness/model labels. Two raters score independently; a third resolves any two-point disagreement. Report per-question and per-dimension results, latency, and actual API spend. Outputs go only to private `seat-state/OP/evidence/`; never commit provider answers. Keep question and rubric versions fixed for regression comparisons.

package/scripts/research-bench/questions.json

@@ -0,0 +1,66 @@
+[
+  {
+    "id": "finance-01-kgb-10y",
+    "domain": "finance",
+    "bloom": ["remember", "understand", "analyze", "evaluate", "create"],
+    "requiresHigherOrder": true,
+    "prompt": "현재 기준으로 한국 국고채 10년물 금리의 최근 30일 변화를 조사하라. 공신력 있는 시계열 값과 날짜를 먼저 제시하고, 움직임을 설명하는 요인을 데이터로 분해하라. 가장 강한 대안 설명과 반대 근거를 포함하고, 향후 3개월의 조건부 시나리오를 제시하되 투자 권유는 하지 마라. 핵심 주장마다 원문 출처 URL과 기준 시각을 붙여라."
+  },
+  {
+    "id": "finance-02-usdkrw",
+    "domain": "finance",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate"],
+    "requiresHigherOrder": true,
+    "prompt": "현재 기준 최근 90일 원/달러 환율 변화를 조사하고, 달러지수·미 국채금리·한국 수출 및 자금 흐름이 각각 설명하는 부분을 구분하라. 인과관계와 동시 움직임을 혼동하지 말고, 각 설명을 지지하는 자료와 반대 사례를 대조하라. 근거가 부족한 요인은 미확인으로 남기고, 출처 URL·값·날짜를 제시하라."
+  },
+  {
+    "id": "finance-03-korean-memory-producers",
+    "domain": "finance",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate", "create"],
+    "requiresHigherOrder": true,
+    "prompt": "현재 공개된 최신 실적 기준으로 삼성전자와 SK하이닉스의 메모리 사업을 비교하라. 매출·수익성·제품 믹스·CAPEX 등 비교 가능한 수치를 같은 기간으로 정렬하고, 차이의 원인을 분해하라. 두 회사 각각에 유리한 반대 근거와 데이터 공백을 포함하고, 다음 두 분기에 관찰할 지표와 조건부 시나리오를 제안하라. 투자 권유는 하지 말고 원문 출처·기간·단위를 표시하라."
+  },
+  {
+    "id": "technology-01-hbm4",
+    "domain": "technology",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate", "create"],
+    "requiresHigherOrder": true,
+    "prompt": "HBM4의 현재 개발·양산·고객 인증 상태와 공급망 병목을 1차 자료 중심으로 조사하라. 발표·샘플·인증·양산을 서로 다른 상태로 구분하고, 메모리 업체·패키징·가속기 공급망의 인과 관계를 설명하라. 일정 지연 또는 채택 축소를 뒷받침하는 반대 근거도 찾고, 2027년까지 확인 가능한 관측 지표와 시나리오를 제시하라."
+  },
+  {
+    "id": "technology-02-coding-agent-adoption",
+    "domain": "technology",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate"],
+    "prompt": "2025년 이후 코딩 에이전트의 실제 조직 도입과 생산성 효과를 조사하라. 벤더 발표·설문·독립 실험을 출처 유형별로 분리하고, 표본·측정 정의·선택 편향을 비교하라. 생산성 향상 주장에 대한 반대 결과와 보안·검토 비용도 포함하고, 근거가 말할 수 있는 범위를 제안하라. 핵심 수치에는 모집단·기간·원문 URL을 붙여라."
+  },
+  {
+    "id": "technology-03-inference-economics",
+    "domain": "technology",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate", "create"],
+    "prompt": "최근 12개월의 frontier 및 open-weight 모델 추론 비용·성능 변화를 비교하라. 공개 가격표와 재현 가능한 독립 평가를 분리하고, 토큰 가격·지연·품질·하드웨어 이용률이 실제 총비용에 미치는 영향을 계산 가능한 단위로 제시하라. '더 싸다'는 주장에 대한 반례와 작업별 차이를 분석하고, 12개월의 조건부 시나리오를 제시하라."
+  },
+  {
+    "id": "market-01-enterprise-research-agents",
+    "domain": "market",
+    "bloom": ["remember", "understand", "analyze", "evaluate", "create"],
+    "prompt": "기업용 조사·리서치 에이전트 시장의 규모와 성장률 주장을 비교하라. 최소 세 출처의 정의·포함 제품·기준 연도·예측 기간을 대조하고, 같은 시장을 측정하는지 판단하라. 도입 사례와 실사용 효과의 독립 근거를 벤더 전망과 분리하고, 가장 큰 불확실성 및 반대 근거를 제시하라."
+  },
+  {
+    "id": "market-02-korean-enterprise-automation",
+    "domain": "market",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate", "create"],
+    "prompt": "한국 기업의 에이전트형 AI 업무 자동화에서 현재 가치가 검증된 부문을 조사하라. 금융·제조·고객지원 등 최소 세 부문에서 실제 배포, 실험, 계획 발표를 구분하고, 도입 전후의 비용·시간·오류 지표를 찾아라. 규제·데이터·통합 비용과 효과가 없었던 사례도 포함하고, 다음 12개월에 검증할 측정 설계를 제안하라."
+  },
+  {
+    "id": "market-03-ai-research-assistants",
+    "domain": "market",
+    "bloom": ["remember", "understand", "apply", "analyze", "evaluate"],
+    "prompt": "AI 조사 보조 제품군의 최근 경쟁 구도를 조사하라. 제품 기능 나열 대신 출처 발견·교차검증·기억·도구 실행·인용 정확도·가격을 축으로 비교하라. 독립 평가와 공식 문서를 구분하고, 강점 주장을 뒤집을 수 있는 반례 및 기능 미지원 증거를 찾으라. 사용 사례별로 승자를 달리 제시하고 근거 수준을 표시하라."
+  },
+  {
+    "id": "market-04-agentic-knowledge-work",
+    "domain": "market",
+    "bloom": ["understand", "apply", "analyze", "evaluate", "create"],
+    "prompt": "지식 노동에서 조사 에이전트가 검색·분석·보고 과정을 바꾸는 방식을 조사하라. 현장 도입 사례와 통제된 연구를 분리하고, 어떤 작업은 자동화되고 어떤 판단은 사람에게 남는지 사례로 분석하라. 생산성 이익과 함께 오류·근거 누락·데이터 유출·검토 비용의 반대 근거를 다루고, 측정 가능한 성공 기준과 실패 시 대안을 설계하라."
+  }
+]

package/scripts/research-bench/rubric.md

@@ -0,0 +1,33 @@
+# Blind scoring rubric
+
+## SCQA
+
+**S** — 조사 답변은 출처가 있어도 깊이·범위·원인 설명·반대 근거·지연이 서로 다를 수 있다.
+
+**C** — 단일 총점이나 인상 평가는 하니스 이름·문장 길이에 끌려 재현이 어렵다.
+
+**Q** — 10개 답변을 어떻게 비교해 회귀와 강점을 구분할까?
+
+**A** — 두 응답의 harness/model 표식을 지운 뒤 아래 품질 7개 축과 지연을 각각 0–3점으로 채점한다. 기준과 근거 위치를 기록하고, 두 명이 독립 채점한다. 불일치가 2점 이상이면 제3자 판정을 남긴다.
+
+## Dimensions (0–3 each)
+
+| Dimension | 0 | 1 | 2 | 3 |
+|---|---|---|---|---|
+| 근거의 양·검증성 | 출처가 없거나 핵심 주장을 지지하지 않음 | 단일 출처 위주, 일부 핵심 주장만 연결 | 핵심 주장 대부분이 직접 출처와 연결되고 2종 이상 출처 사용 | 핵심 주장 전부 추적 가능, 1차 자료와 독립 확인을 교차 대조하고 날짜·단위를 보존 |
+| 해상도 L0–L3 | 결론 한 줄조차 불명확 | L0 결론만 있음 | L1 자료 근거 또는 L2 원인 분해까지 도달 | L3 반대 근거·조건부 시나리오까지 근거와 함께 제시 |
+| 데이터 폭 | 단일 출처·측정치 | 한 유형 또는 한 기간만 사용 | 여러 출처 유형·기간을 비교하나 주요 공백 존재 | 정의·표본·기간이 다른 자료를 분리하고 폭과 대표성 한계를 명시 |
+| 원인 분해 | 결론만 말하거나 상관을 인과로 단정 | 요인을 나열 | 요인별 자료와 작동 경로를 나눔 | 대안 설명을 비교하고 어떤 자료가 원인을 가르는지 제시 |
+| 반대 근거 | 없음 | 형식적 한 문장 | 실재하는 반대 자료나 대안 가설 하나 이상 | 가장 강한 반증을 찾아 주장·확신을 그에 맞게 조정 |
+| 기억·맥락 활용 | 기준일·제공 맥락을 무시하거나 꾸밈 | 맥락 언급만 있고 답에 영향 없음 | 제공된 공통 맥락/과거 기준선을 정확히 사용 | 이전 결과와의 차이를 추적하고, 제공되지 않은 기억을 쓴 척하지 않음 |
+| 출력의 풍부함·사용성 | 읽거나 행동으로 옮기기 어려움 | 장문/목록이지만 구조·다음 단계 약함 | 요약·표·출처가 명료하고 공백을 드러냄 | 핵심 판단→근거→대안→관측 지표로 이어지며 목적에 맞는 구조를 사용 |
+| 지연(고정 timeout 대비) | timeout 또는 결과 없음 | 허용 시간의 75% 초과 | 25% 초과~75% 이하 | 25% 이하 |
+
+## Scoring controls
+
+- 각 점수에 답변 내 근거 인용(문단/문장)과 출처 URL을 기록한다. 근거 없는 점수는 무효다.
+- 인용 링크가 존재하는 것만으로 근거로 세지 않는다. 출처 본문이 실제 주장을 지지하는지 확인한다.
+- 모델 이름·harness 이름은 검수자가 모르게 바꾼다. 실행 순서는 질문마다 번갈아 균형화한다.
+- 불확실성·측정 불가를 정직하게 표시한 답은 그 이유만으로 감점하지 않는다.
+- 품질 7축은 문항당 7–21점이다. 지연 점수는 별도로 내고 품질 합계에 섞지 않는다. 총계보다 축별 중앙값·범위·문항별 짝차를 먼저 보고한다.
+- 적어도 2명 채점자의 가중치 없는 평균을 쓴다. 필요하면 차원별 Cohen's kappa를 함께 기록한다. 표본 10개를 모집단 일반화나 유의성 주장으로 부풀리지 않는다.