npm - @arcaneorion/dsh-teaching-board - Versions diffs - 0.4.1 → 0.5.1 - Mend

@arcaneorion/dsh-teaching-board 0.4.1 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/skills/stage-panel/submode/code/templates/lab.html ADDED Viewed

@@ -0,0 +1,561 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Code 展示</title>
+<style>
+  :root {
+    color-scheme: dark;
+    --bg: #0d1117;
+    --panel: #161b22;
+    --line: #30363d;
+    --text: #e6edf3;
+    --muted: #8b949e;
+    --accent: #3fb950;
+    --blue: #58a6ff;
+    --warn: #d29922;
+    --err: #f85149;
+    --kw: #ff7b72;
+    --str: #a5d6ff;
+    --com: #8b949e;
+    --num: #79c0ff;
+    --type: #ffa657;
+    --fn: #d2a8ff;
+    --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    --sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+  }
+  * { box-sizing: border-box; }
+  html, body {
+    margin: 0;
+    padding: 0;
+    background: var(--bg);
+    color: var(--text);
+    font-family: var(--sans);
+  }
+  button, textarea, pre { font: inherit; }
+  button { cursor: pointer; }
+  .wrap {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    max-width: 1080px;
+    margin: 0 auto;
+    padding: 16px;
+  }
+  .bar {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 10px;
+  }
+  .meta { min-width: 0; }
+  .lang {
+    display: inline-block;
+    font-family: var(--mono);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: .1em;
+    color: var(--accent);
+    border: 1px solid #238636;
+    border-radius: 999px;
+    padding: 1px 8px;
+    margin-bottom: 6px;
+  }
+  h1 {
+    margin: 0;
+    font-size: 20px;
+    line-height: 1.25;
+  }
+  .sub { margin: 4px 0 0; font-size: 13px; color: var(--muted); }
+  .btns { display: flex; gap: 8px; align-items: center; }
+  .btn {
+    border: 1px solid var(--line);
+    background: #21262d;
+    color: var(--text);
+    border-radius: 6px;
+    padding: 6px 12px;
+    font-size: 13px;
+    line-height: 1.2;
+  }
+  .btn.primary-soft {
+    background: #1f6feb33;
+    border-color: #1f6feb;
+    color: var(--blue);
+  }
+  .btn:hover { filter: brightness(1.12); }
+  .btn:disabled { opacity: .55; cursor: not-allowed; }
+  .tutor-row {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex-wrap: wrap;
+  }
+  .tutor-note {
+    flex: 1 1 240px;
+    background: #0f141a;
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    color: var(--text);
+    padding: 8px 10px;
+    font-size: 13px;
+  }
+  .tutor-note:focus { border-color: var(--blue); outline: none; }
+  .tutor-hint { font-size: 11px; color: var(--muted); }
+  .layout {
+    display: grid;
+    grid-template-columns: minmax(0, 1.5fr) minmax(240px, 1fr);
+    gap: 12px;
+    align-items: start;
+  }
+  .code-card {
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    background: var(--panel);
+    overflow: hidden;
+  }
+  .filebar {
+    display: flex;
+    justify-content: space-between;
+    gap: 8px;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--line);
+    font-family: var(--mono);
+    font-size: 12px;
+    color: var(--muted);
+    background: #0f141a;
+  }
+  .filebar b { color: var(--text); font-weight: 600; }
+  .code-stack {
+    position: relative;
+    background: #0b0f14;
+    max-height: 70vh;
+    overflow: auto;
+    margin: 0;
+    padding: 12px 14px;
+    white-space: pre;
+    tab-size: 4;
+    font-family: var(--mono);
+    font-size: 14px;
+    line-height: 1.55;
+    color: #dbe7f0;
+  }
+  .code-stack:empty::before { content: '(无代码)'; color: var(--muted); font-style: italic; }
+  .tok-kw { color: var(--kw); }
+  .tok-str { color: var(--str); }
+  .tok-com { color: var(--com); font-style: italic; }
+  .tok-num { color: var(--num); }
+  .tok-type { color: var(--type); }
+  .tok-fn { color: var(--fn); }
+  .tok-op { color: #ffA198; }
+  .side-card { padding: 12px; display: grid; gap: 12px; }
+  .block h2 {
+    margin: 0 0 6px;
+    font-size: 11px;
+    letter-spacing: .08em;
+    text-transform: uppercase;
+    color: var(--muted);
+  }
+  .block p, .block li {
+    margin: 0;
+    font-size: 13px;
+    line-height: 1.45;
+    color: #c9d1d9;
+  }
+  .block ul { margin: 0; padding-left: 1.1em; display: grid; gap: 6px; }
+  .ann { display: grid; gap: 6px; }
+  .ann div {
+    border-left: 3px solid var(--blue);
+    background: #0f141a;
+    padding: 6px 8px;
+    font-size: 12px;
+  }
+  .ann .error { border-left-color: var(--err); }
+  .ann .move, .ann .warn { border-left-color: var(--warn); }
+  .pipe {
+    font-family: var(--mono);
+    font-size: 11px;
+    color: var(--muted);
+  }
+  .hidden { display: none !important; }
+  @media (max-width: 860px) {
+    .layout { grid-template-columns: 1fr; }
+  }
+</style>
+</head>
+<body>
+  <div class="wrap">
+    <div class="bar">
+      <div class="meta">
+        <div class="lang" id="lang">python</div>
+        <h1 id="title">Code 展示</h1>
+        <p class="sub" id="subtitle"></p>
+      </div>
+      <div class="btns">
+        <button class="btn primary-soft" id="btn-send" type="button">发给导师讲解</button>
+      </div>
+    </div>
+    <div class="tutor-row">
+      <input id="tutor-note" class="tutor-note" type="text" maxlength="500" placeholder="发给导师时的可选问题（可不填，直接点按钮）" />
+      <span class="tutor-hint" id="tutor-hint">作为讲解素材呈现代码；点按钮附当前代码发给 AI 导师。</span>
+    </div>
+    <div class="layout">
+      <div class="code-card">
+        <div class="filebar">
+          <span><b id="filename">main.py</b></span>
+          <span>展示 · 讲解参考</span>
+        </div>
+        <pre class="code-stack" id="code"></pre>
+      </div>
+      <aside class="side-card">
+        <div class="block" id="summary-block">
+          <h2>本课</h2>
+          <p id="summary"></p>
+        </div>
+        <div class="block" id="objectives-block">
+          <h2>目标</h2>
+          <ul id="objectives"></ul>
+        </div>
+        <div class="block" id="ann-block">
+          <h2>行注</h2>
+          <div class="ann" id="annotations"></div>
+        </div>
+        <div class="block" id="exercise-block">
+          <h2>练习</h2>
+          <ul id="exercises"></ul>
+        </div>
+        <div class="block" id="hint-block">
+          <h2>提示</h2>
+          <ul id="hints"></ul>
+        </div>
+        <div class="pipe" id="pipe">就绪</div>
+      </aside>
+    </div>
+  </div>
+  <script>
+  const LESSON = __LOCALWEB_LESSON_DATA__;
+  const INPUT_ID = "__LOCALWEB_INPUT_ID__";
+  const PANEL_ID = "__LOCALWEB_PANEL_ID__";
+  const MENTOR = __LOCALWEB_MENTOR__;
+  const $ = (id) => document.getElementById(id);
+  const els = {
+    lang: $('lang'),
+    title: $('title'),
+    subtitle: $('subtitle'),
+    summary: $('summary'),
+    objectives: $('objectives'),
+    annotations: $('annotations'),
+    exercises: $('exercises'),
+    hints: $('hints'),
+    filename: $('filename'),
+    code: $('code'),
+    pipe: $('pipe'),
+    btnSend: $('btn-send'),
+    tutorNote: $('tutor-note'),
+    tutorHint: $('tutor-hint'),
+    summaryBlock: $('summary-block'),
+    objectivesBlock: $('objectives-block'),
+    annBlock: $('ann-block'),
+    exerciseBlock: $('exercise-block'),
+    hintBlock: $('hint-block'),
+  };
+  const lang = String((LESSON && LESSON.lang) || 'python').toLowerCase();
+  const KEYWORDS = {
+    python: new Set(['False','None','True','and','as','assert','async','await','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']),
+    rust: new Set(['as','async','await','break','const','continue','crate','dyn','else','enum','extern','false','fn','for','if','impl','in','let','loop','match','mod','move','mut','pub','ref','return','self','Self','static','struct','super','trait','true','type','unsafe','use','where','while']),
+    go: new Set(['break','case','chan','const','continue','default','defer','else','fallthrough','for','func','go','goto','if','import','interface','map','package','range','return','select','struct','switch','type','var']),
+  };
+  const BUILTINS = {
+    python: new Set(['print','len','range','str','int','float','list','dict','set','tuple','open','type','isinstance','enumerate','zip','map','filter','sum','min','max','abs','sorted','reversed','any','all']),
+    rust: new Set(['println','print','format','vec','String','Vec','Option','Result','Some','None','Ok','Err','Box','Rc','Arc']),
+    go: new Set(['fmt','make','len','cap','append','copy','delete','panic','recover','new','close','true','false','nil','string','int','int64','float64','bool','error','byte','rune']),
+  };
+  function defaultFilename(l) {
+    if (l === 'rust') return 'main.rs';
+    if (l === 'go') return 'main.go';
+    return 'main.py';
+  }
+  function primarySnippet() {
+    const snippets = Array.isArray(LESSON.snippets) ? LESSON.snippets.filter(Boolean) : [];
+    const runId = LESSON.run && LESSON.run.snippet_id;
+    const same = snippets.filter((s) => String(s.lang || lang).toLowerCase() === lang);
+    if (runId) {
+      const hit = same.find((s) => s.id === runId) || snippets.find((s) => s.id === runId);
+      if (hit) return hit;
+    }
+    return same.find((s) => (s.role || 'primary') === 'primary')
+      || same[0]
+      || {
+        id: 'main',
+        lang,
+        filename: (LESSON.starter && LESSON.starter.filename) || defaultFilename(lang),
+        code: (LESSON.starter && LESSON.starter.code) || '',
+        annotations: [],
+      };
+  }
+  const snippet = primarySnippet();
+  const displayCode = String(snippet.code || (LESSON.starter && LESSON.starter.code) || '');
+  let sendBusy = false;
+  function esc(v) {
+    return String(v ?? '').replace(/[&<>"']/g, (ch) => ({
+      '&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'
+    }[ch]));
+  }
+  function setPipe(msg) { els.pipe.textContent = msg; }
+  function tokenize(code, language) {
+    const kw = KEYWORDS[language] || KEYWORDS.python;
+    const builtins = BUILTINS[language] || new Set();
+    const lineComment = language === 'python' ? '#' : '//';
+    let i = 0;
+    let out = '';
+    const n = code.length;
+    function takeWhile(pred) {
+      const start = i;
+      while (i < n && pred(code[i])) i += 1;
+      return code.slice(start, i);
+    }
+    while (i < n) {
+      const ch = code[i];
+      const next = code[i + 1] || '';
+      if (language === 'python' && ch === '#') {
+        const text = takeWhile((c) => c !== '\n');
+        out += `<span class="tok-com">${esc(text)}</span>`;
+        continue;
+      }
+      if ((language === 'rust' || language === 'go') && ch === '/' && next === '/') {
+        const text = takeWhile((c) => c !== '\n');
+        out += `<span class="tok-com">${esc(text)}</span>`;
+        continue;
+      }
+      if ((language === 'rust' || language === 'go') && ch === '/' && next === '*') {
+        let text = '/*';
+        i += 2;
+        while (i < n && !(code[i] === '*' && code[i + 1] === '/')) {
+          text += code[i];
+          i += 1;
+        }
+        if (i < n) { text += '*/'; i += 2; }
+        out += `<span class="tok-com">${esc(text)}</span>`;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || (language === 'rust' && ch === 'r' && (next === '"' || next === '#'))) {
+        if (language === 'rust' && ch === 'r') {
+          let j = i + 1;
+          let hashes = '';
+          while (code[j] === '#') { hashes += '#'; j += 1; }
+          if (code[j] === '"') {
+            let text = code.slice(i, j + 1);
+            i = j + 1;
+            const end = '"' + hashes;
+            while (i < n && code.slice(i, i + end.length) !== end) {
+              text += code[i];
+              i += 1;
+            }
+            text += code.slice(i, i + end.length);
+            i += end.length;
+            out += `<span class="tok-str">${esc(text)}</span>`;
+            continue;
+          }
+        }
+        const quote = ch;
+        let text = quote;
+        i += 1;
+        while (i < n) {
+          const c = code[i];
+          text += c;
+          i += 1;
+          if (c === '\\' && i < n) { text += code[i]; i += 1; continue; }
+          if (c === quote) break;
+          if (c === '\n' && language === 'python' && quote !== "'''" ) break;
+        }
+        out += `<span class="tok-str">${esc(text)}</span>`;
+        continue;
+      }
+      if (language === 'go' && ch === '`') {
+        let text = '`';
+        i += 1;
+        while (i < n && code[i] !== '`') { text += code[i]; i += 1; }
+        if (i < n) { text += '`'; i += 1; }
+        out += `<span class="tok-str">${esc(text)}</span>`;
+        continue;
+      }
+      if (/[0-9]/.test(ch) || (ch === '.' && /[0-9]/.test(next))) {
+        const text = takeWhile((c) => /[0-9_.xXoObBa-fA-F]/.test(c));
+        out += `<span class="tok-num">${esc(text)}</span>`;
+        continue;
+      }
+      if (/[A-Za-z_]/.test(ch)) {
+        const text = takeWhile((c) => /[A-Za-z0-9_]/.test(c));
+        let k = i;
+        while (k < n && /\s/.test(code[k])) k += 1;
+        const isCall = code[k] === '(';
+        if (kw.has(text)) out += `<span class="tok-kw">${esc(text)}</span>`;
+        else if (builtins.has(text)) out += `<span class="tok-fn">${esc(text)}</span>`;
+        else if (/^[A-Z]/.test(text) && language !== 'python') out += `<span class="tok-type">${esc(text)}</span>`;
+        else if (isCall) out += `<span class="tok-fn">${esc(text)}</span>`;
+        else out += esc(text);
+        continue;
+      }
+      if ('=+-*/%<>!&|^~?:.'.includes(ch)) {
+        const text = takeWhile((c) => '=+-*/%<>!&|^~?:.'.includes(c));
+        out += `<span class="tok-op">${esc(text)}</span>`;
+        continue;
+      }
+      out += esc(ch);
+      i += 1;
+    }
+    return out || ' ';
+  }
+  function renderMeta() {
+    els.lang.textContent = lang;
+    els.title.textContent = (LESSON && LESSON.title) || 'Code 展示';
+    els.subtitle.textContent = (LESSON && (LESSON.subtitle || LESSON.stage)) || '';
+    const summary = (LESSON && LESSON.summary) || '';
+    els.summary.textContent = summary;
+    els.summaryBlock.classList.toggle('hidden', !summary);
+    const objectives = Array.isArray(LESSON.objectives) ? LESSON.objectives : [];
+    if (objectives.length) {
+      els.objectives.innerHTML = objectives.map((o) => `<li>${esc(o)}</li>`).join('');
+    } else {
+      els.objectivesBlock.classList.add('hidden');
+    }
+    const anns = Array.isArray(snippet.annotations) ? snippet.annotations : [];
+    if (anns.length) {
+      els.annotations.innerHTML = anns.map((a) =>
+        `<div class="${esc(a.kind || 'info')}"><strong>L${esc(a.line)}</strong> ${esc(a.text || '')}</div>`
+      ).join('');
+    } else {
+      els.annBlock.classList.add('hidden');
+    }
+    const exercises = Array.isArray(LESSON.exercises) ? LESSON.exercises : [];
+    if (exercises.length) {
+      els.exercises.innerHTML = exercises.map((ex) =>
+        `<li><strong>${esc(ex.type || 'task')}</strong> — ${esc(ex.prompt || '')}</li>`
+      ).join('');
+    } else {
+      els.exerciseBlock.classList.add('hidden');
+    }
+    const hints = Array.isArray(LESSON.hints) ? LESSON.hints : [];
+    if (hints.length) {
+      els.hints.innerHTML = hints.map((h) => `<li>${esc(h)}</li>`).join('');
+    } else {
+      els.hintBlock.classList.add('hidden');
+    }
+    els.filename.textContent = snippet.filename || defaultFilename(lang);
+  }
+  function buildTutorPackage(note) {
+    const lines = [
+      '## Code 展示 · 发给导师',
+      '',
+      `- lesson: ${(LESSON && (LESSON.id || LESSON.title)) || ''}`,
+      `- lang: ${lang}`,
+      `- file: ${els.filename.textContent || defaultFilename(lang)}`,
+      `- action: ask_tutor`,
+    ];
+    if (note) {
+      lines.push('', '### 用户说明', '', note);
+    }
+    lines.push('', '### 展示代码', '', '```' + lang, displayCode.replace(/\n$/, ''), '```');
+    lines.push('', '请结合代码讲解：思路、关键点、可能的问题或下一步。');
+    return lines.join('\n');
+  }
+  function sendToTutor() {
+    if (sendBusy) return;
+    if (!MENTOR || !INPUT_ID) {
+      setPipe('缺少导师通道：请用 code 命令（默认 wait）重新打开本课');
+      return;
+    }
+    const note = String((els.tutorNote && els.tutorNote.value) || '').trim();
+    const text = buildTutorPackage(note);
+    sendBusy = true;
+    els.btnSend.disabled = true;
+    els.btnSend.textContent = '发送中…';
+    setPipe('正在发给导师…');
+    window.parent.postMessage({
+      localweb: true,
+      type: 'panel_input',
+      input_id: INPUT_ID,
+      panel_id: PANEL_ID,
+      label: 'ask_tutor',
+      text,
+      meta: {
+        localweb_code: true,
+        action: 'ask_tutor',
+        lang,
+        lesson_id: (LESSON && LESSON.id) || '',
+        source: displayCode,
+        note,
+      },
+    }, '*');
+  }
+  function onTutorSendResult(ok, message) {
+    sendBusy = false;
+    els.btnSend.disabled = false;
+    els.btnSend.textContent = '发给导师讲解';
+    if (ok) {
+      setPipe(message || '已发送到导师通道');
+      if (els.tutorHint) els.tutorHint.textContent = '已发送 · 等待导师读取';
+    } else {
+      setPipe(message || '发送失败');
+      if (els.tutorHint) els.tutorHint.textContent = '发送失败，可再点一次';
+    }
+  }
+  window.addEventListener('message', (event) => {
+    const data = event.data;
+    if (!data || typeof data !== 'object' || data.localweb !== true) return;
+    if (data.type === 'panel_input_result') {
+      onTutorSendResult(Boolean(data.ok), data.message || (data.ok ? '已发送' : '发送失败'));
+    }
+  });
+  // Init: render code + meta. Pure display; no edits, no host run.
+  els.code.innerHTML = tokenize(displayCode.endsWith('\n') ? displayCode : displayCode + '\n', lang);
+  try { renderMeta(); } catch (err) { console.error(err); setPipe('meta render error, code still shown'); }
+  setPipe(MENTOR ? '展示 · 可发给导师讲解' : '展示模式');
+  els.btnSend.addEventListener('click', sendToTutor);
+  </script>
+</body>
+</html>

package/skills/stage-panel/submode/game-study/SKILL.md ADDED Viewed

@@ -0,0 +1,16 @@
+# game-study —— 自适应学习（面板交互模式·DSH 版）
+题目结构遵循 `schemas/quest.schema.json`（逐题主动回忆：题干/选项/答案/知识点/错因）；
+题库示例：`examples/hft-microstructure.json`、`examples/securities-law.json`；
+答题模板 `templates/quiz.html`。
+## 投递（DSH 原生）
+1. 逐题渲染 → `stage_panel`；答题选项用 `stage_choice`（回答 = 用户消息，无 wait）；
+2. 一轮完成后用面板给掌握度小结，并 `stage_choice` 出「下一轮 / 复习错题 / 结束」。
+## 说明（诚实标注）
+原实现的**跨会话掌握度 / 错题本 / FSRS 调度持久化**属于独立服务层（`.localweb/study/`），
+本模式暂不引入私有持久化——会话本身是真相。跨会话进度是后续可议的 feature（会话工具输出累积或独立存储服务），
+本轮先承接题目内容、答题模板与出题规范。

package/skills/stage-panel/submode/game-study/examples/hft-microstructure.json ADDED Viewed

@@ -0,0 +1,60 @@
+{
+  "schema_version": 2,
+  "id": "hft-microstructure",
+  "title": "高频交易微观结构",
+  "subtitle": "以限价订单簿为中心，漫步订单流/延迟/做市/风险四个展开面",
+  "domain": "HFT 微观结构",
+  "summary": "自适应学习：以限价订单簿为中心，逐题主动回忆。答错进错题本、掌握度累积、费曼题回传 CLI 判定。HP 不再是娱乐涂层，掌握度才是真正的训练预算。",
+  "cells": [
+    {"id":"lob","label":"限价订单簿","brief":"实时记录所有未成交限价单的数据结构——每个价位的买卖挂单量。微观结构的底座。","example":"Level-2：买一 100.00 挂 3000 股，卖一 100.02 挂 1500 股——簿的不对称就是信号。","difficulty":2,"tags":["core"]},
+    {"id":"orderflow","label":"订单流","brief":"按时间序贯到达的订单事件(新增/撤单/成交)序列。把市场看作由订单流驱动的时间动态系统。","example":"一笔 5000 股市价买单吃穿簿三层卖单才成交完——一次订单流事件对簿的冲击。","difficulty":3,"tags":["flow"],"prereq":["lob"]},
+    {"id":"latency","label":"延迟","brief":"从行情到达、到决策、到下单的端到端时间。微秒级 HFT 里，延迟直接等于机会。","example":"新行情后你下单差 50 微秒——这 50μs 决定你能否吃到那档价差。","difficulty":3,"tags":["latency"],"prereq":["lob"]},
+    {"id":"mm","label":"做市","brief":"同时在买价卖价双边挂限价单赚 bid-ask 价差，撮合时主动管理库存。HFT 占比最大的策略。","example":"bid=99.99 挂买、ask=100.01 挂卖各 100 股——两边成交赚 2 分×100=2 美元，不赌方向。","difficulty":3,"tags":["models"],"prereq":["lob"]},
+    {"id":"spread","label":"买卖价差","brief":"最优卖价(ask)与最优买价(bid)之差，即时流动性的价格。越窄越流动。","example":"bid=100.00、ask=100.02，价差 0.02——市价单一买一卖付 2 分钱流动性税。","difficulty":2,"tags":["book"],"prereq":["lob"]},
+    {"id":"depth","label":"订单簿深度","brief":"不同价位累积挂单量，衡量簿能吸收多大冲击而不剧烈移价。流动性的纵深。","example":"买盘 100.00 挂 3000 股、99.99 挂 8000 股——深度告诉你 5000 股市价单会把价砸到哪。","difficulty":3,"tags":["book"],"prereq":["lob"]},
+    {"id":"midprice","label":"中间价","brief":"(bid+ask)/2，订单簿瞬时公允估值。无交易成本的价格参考，多数策略的计价基准。","example":"bid=100.00、ask=100.02 → mid=100.01——做市盈亏常以 mid 为公允计价。","difficulty":2,"tags":["book"],"prereq":["spread"]},
+    {"id":"imbalance","label":"买卖单失衡","brief":"簿上买盘量与卖盘量的不对称。短期价格漂移最强预测因子之一：买压更强则中间价倾向上移。","example":"买盘 10000 股 vs 卖盘 4000 股，失衡比 +0.43——历史上正失衡后 1 秒收益偏正。","difficulty":4,"tags":["flow"],"prereq":["orderflow","depth"]},
+    {"id":"passive","label":"被动单与主动单","brief":"被动限价单挂簿等待成交(提供流动性)，主动市价单吃簿立即成交(消费流动性)。谁被动谁主动决定谁赚价差谁付价差。","example":"你挂 100.00 买单等成交是被动单；对手市价卖单砸进来吃掉你的挂单是主动单——你赚了价差。","difficulty":3,"tags":["flow"],"prereq":["orderflow"]},
+    {"id":"colo","label":"同地部署","brief":"把交易服务器物理放进交易所机房，把网络往返延迟压到最低。HFT 降延迟最直接的硬件手段。","example":"从芝加哥搬到纳斯达克 NJ 机房，往返 15ms→50μs，提速约 300 倍。","difficulty":3,"tags":["latency"],"prereq":["latency"]},
+    {"id":"latarb","label":"延迟套利","brief":"利用速度优势，在慢市场未更新报价前于快市场已更新价差中撮合。常被指为抢跑。","example":"ES 期货在 CME 已出新价，ETF 还挂旧价——抢在 ETF 更新前买入，几乎无风险赚价差。","difficulty":4,"tags":["latency"],"prereq":["colo"]},
+    {"id":"inventory","label":"库存风险","brief":"净头寸的方向性敞口。做市商一边成交多一边没成交就积累库存，被价格反向变动打亏。","example":"买单成交卖单没成交，净持多 100 股——价格跌 1 元库存亏 100 元，吃掉全天价差收入。","difficulty":3,"tags":["models"],"prereq":["mm"]},
+    {"id":"adverse","label":"逆相选择","brief":"做市商致命风险：挂单被知情交易者(有信息优势方)吃掉——成交在不利价格，跟着对手方向亏。","example":"知情者知道要发利好，猛砸市价买单吃光你的卖单——你卖在低价，眼看价格飞走。","difficulty":4,"tags":["models"],"prereq":["mm"]}
+  ],
+  "relations": [
+    {"from":"orderflow","to":"lob","label":"更新","kind":"implements"},
+    {"from":"lob","to":"spread","label":"涌现为","kind":"emerges"},
+    {"from":"lob","to":"depth","label":"具现","kind":"implements"},
+    {"from":"spread","to":"midprice","label":"计算","kind":"depends"},
+    {"from":"orderflow","to":"imbalance","label":"涌现为","kind":"emerges"},
+    {"from":"orderflow","to":"passive","label":"分类","kind":"unfolds"},
+    {"from":"passive","to":"imbalance","label":"累积","kind":"depends"},
+    {"from":"mm","to":"lob","label":"挂单于","kind":"implements"},
+    {"from":"mm","to":"spread","label":"赚取","kind":"implements"},
+    {"from":"mm","to":"inventory","label":"承担","kind":"constrains"},
+    {"from":"mm","to":"adverse","label":"面临","kind":"constrains"},
+    {"from":"latency","to":"colo","label":"通过","kind":"implements"},
+    {"from":"colo","to":"latarb","label":"武器化","kind":"implements"},
+    {"from":"latarb","to":"adverse","label":"加剧","kind":"emerges"},
+    {"from":"imbalance","to":"midprice","label":"推动","kind":"emerges"},
+    {"from":"inventory","to":"spread","label":"加宽","kind":"constrains"}
+  ],
+  "questions": [
+    {"id":"q1","cell":"lob","type":"choice","prompt":"限价订单簿(LOB)记录的是什么？","options":[{"label":"所有已成交的历史交易","correct":false},{"label":"所有未成交的限价挂单(按价位排列的买卖量)","correct":true},{"label":"交易所收取的手续费表","correct":false}],"answer":"所有未成交的限价挂单(按价位排列的买卖量)","explain":"LOB 是实时挂单簿，记录的是待成交的供需，不是历史成交。它是微观结构的底座。","difficulty":1},
+    {"id":"q2","cell":"spread","type":"choice","prompt":"买卖价差(bid-ask spread)衡量什么？","options":[{"label":"即时流动性的价格，越窄越流动","correct":true},{"label":"一天内最大涨跌幅","correct":false},{"label":"交易所的成交量","correct":false}],"answer":"即时流动性的价格，越窄越流动","explain":"价差=最优卖价-最优买价，是立即买入再卖出的流动性成本。窄价差=高流动性。","difficulty":1},
+    {"id":"q3","cell":"mm","type":"choice","prompt":"做市商的主要盈利来源是什么？","options":[{"label":"准确预测涨跌方向做单边交易","correct":false},{"label":"双边挂单赚 bid-ask 价差，不赌方向","correct":true},{"label":"收取其他交易者的佣金","correct":false}],"answer":"双边挂单赚 bid-ask 价差，不赌方向","explain":"做市靠在买卖双边挂限价单，撮合成交赚价差，靠成交量而非方向盈利。","difficulty":2},
+    {"id":"q4","cell":"adverse","type":"choice","prompt":"做市商最致命的风险「逆相选择」指的是？","options":[{"label":"交易所系统故障导致撤单","correct":false},{"label":"挂单被知情交易者吃掉，成交在不利价格","correct":true},{"label":"自己的网络延迟过高","correct":false}],"answer":"挂单被知情交易者吃掉，成交在不利价格","explain":"知情者有信息优势，专挑做市商挂单吃，做市商被动成交在错误方向，是结构性亏钱。","difficulty":3},
+    {"id":"q5","cell":["lob","spread"],"type":"connect","prompt":"「限价订单簿」与「买卖价差」是什么关系？","options":[{"label":"展开为","is":"unfolds","correct":false},{"label":"涌现为(簿的状态涌现出价差)","is":"emerges","correct":true},{"label":"互不相关","is":"","correct":false}],"answer":"emerges","explain":"价差是订单簿最优买卖档直接涌现的结果，簿的不对称就是价差信号。","difficulty":2},
+    {"id":"q6","cell":["mm","adverse"],"type":"connect","prompt":"「做市」与「逆相选择」是什么关系？","options":[{"label":"约束/面临(做市天然面临逆相风险)","is":"constrains","correct":true},{"label":"实现","is":"implements","correct":false},{"label":"同型","is":"mirrors","correct":false}],"answer":"constrains","explain":"做市必须在市场挂单等待，这天然暴露给知情者——逆相选择是做市的结构性约束。","difficulty":3},
+    {"id":"q7","cell":["latency","colo"],"type":"connect","prompt":"「延迟」与「同地部署」是什么关系？","options":[{"label":"实现(同地部署是实现低延迟的手段)","is":"implements","correct":true},{"label":"约束","is":"constrains","correct":false},{"label":"互不相关","is":"","correct":false}],"answer":"implements","explain":"同地部署把服务器搬进交易所机房，是实现端到端低延迟最直接的硬件手段。","difficulty":2},
+    {"id":"q8","cell":"orderflow","type":"multi","prompt":"订单流(order flow)包含哪些事件？(多选，全对才得分)","options":[{"label":"新增限价单","correct":true},{"label":"撤单","correct":true},{"label":"成交","correct":true},{"label":"收盘结算价","correct":false}],"answer":"新增限价单 / 撤单 / 成交","explain":"订单流是逐笔到达的订单事件序列：新挂、撤单、成交。结算价不属于逐笔订单事件。","difficulty":2},
+    {"id":"q9","cell":"imbalance","type":"choice","prompt":"买卖单失衡(imbalance)对短期中间价的预测信号是？","options":[{"label":"失衡越大，短期中间价越可能反向漂移","correct":false},{"label":"买压强于卖压，中间价倾向上移","correct":true},{"label":"失衡与价格无关","correct":false}],"answer":"买压强于卖压，中间价倾向上移","explain":"失衡是微观结构最强的短期方向因子：买盘堆积=买压，推动中间价上移。","difficulty":4},
+    {"id":"q10","cell":["lob","spread","midprice"],"type":"feynman","prompt":"用自己的话解释：限价订单簿是如何同时「产生」买卖价差和中间价的？它们之间是什么关系？","answer":"LOB 最优买价 bid 与最优卖价 ask 直接构成价差(ask-bid)；中间价=(bid+ask)/2 是无成本公允估值。价差是流动性成本，中间价是估值锚。","feynman_points":["bid 和 ask 都来自簿的最优档","价差=ask-bid(流动性成本)","中间价=(bid+ask)/2(公允估值)","价差越窄流动性越高，中间价越可信"],"explain":"考查对簿-价差-中间价三位一体的结构理解。","difficulty":4}
+  ],
+  "session": {"length": 8, "shuffle": true, "review_mode": false},
+  "next": [
+    {"id":"orderflow-deep","label":"深入订单流预测","description":"失衡、撤单流、微观价格漂移的动量信号。"},
+    {"id":"mm-deep","label":"深入做市机制","description":"库存动态管理、价差随风险调宽、与知情者博弈。"},
+    {"id":"latency-deep","label":"深入延迟竞赛","description":"FPGA、内核旁路、同地部署与延迟套利边界。"},
+    {"id":"book-deep","label":"深入订单簿动力学","description":"簿重建、隐藏冰山订单、不对称性作为信号。"}
+  ]
+}