@jiy/quizme 0.1.0 → 0.1.1

package/README.md

@@ -39,10 +39,37 @@ quizme --repo .
 quizme "React rendering and caching"
 ```
 
+## 配置
+
+### 交互式设置（持久化）
+
+首次运行会引导选择语言与等级；运行中进入「设置」页可调整以下项，改动写入本地配置：
+
+| 项 | 说明 | 可选值 |
+| --- | --- | --- |
+| 语言 | 题目与解释语言 | 中文 / English |
+| 等级 | 题目难度定位 | Junior / Mid / Senior / Staff+ |
+| 每日目标 | 每日题目数 | 1–9 |
+| 音效 | 答题音效开关 | 开 / 关 |
+| 题目模型 | 生成题目时传给 `claude --model` 的别名 | Haiku（默认，快）/ Sonnet / Opus / 账号默认 |
+| 题目 Effort | 生成题目时传给 `claude --effort` 的等级 | Low（默认）/ Medium / High / xHigh / Max |
+
+> 默认 `Haiku` + `Low`：题目生成本质是结构化 JSON 输出，Haiku/low 足够且明显更快、更省。需要更高质量时可在设置页临时调高。
+
+### 环境变量
+
+| 变量 | 作用 |
+| --- | --- |
+| `QUIZME_CLAUDE_BIN` | 指定 `claude` 可执行文件的绝对路径（PATH 找不到时使用） |
+| `QUIZME_DATA_DIR` | 覆盖本地数据存储目录；不设时使用平台 app data 目录，受限环境 fallback 到 `./.quizme` |
+| `QUIZME_CLAUDE_WHY_MODEL` | `why` 模式（答错后深度讲解）使用的模型别名；不设则走账号默认模型 |
+| `QUIZME_CLAUDE_WHY_EFFORT` | `why` 模式的 effort 等级（`low`/`medium`/`high`/`xhigh`/`max`）；不设则走默认 |
+
+> `why` 模式刻意与题目生成分开配置：讲解对模型质量更敏感，默认保持账号模型；仅当想全局降级/提速时才设这两个变量。
+
 ## 说明
 
 - 默认模式会从 `~/.claude/projects` 读取当前仓库最近的 Claude Code transcript。统计、档案、设置、复习等功能通过交互式主界面进入。
 - 本地数据存储在平台 app data 目录中，并使用 `sqlite3`。
-- 在受限环境中，存储会 fallback 到 `./.quizme`。也可以通过 `QUIZME_DATA_DIR=/path/to/data` 覆盖数据目录。
 - 题目生成和 `why` 模式会调用本地 `claude` CLI 的 print mode（`--bare` + `--tools ""`，禁用 agent tool；上下文已写入 prompt）。
-- 离线 demo 可使用 `QUIZME_PROVIDER=local`。如果希望优先使用 Claude、失败后 fallback 到本地 provider，可使用 `QUIZME_PROVIDER_FALLBACK=local`。
+- 离线 provider（`QUIZME_PROVIDER=local`、`QUIZME_PROVIDER_FALLBACK=local`）为**暂未实现**的能力，当前不可用。

package/dist/cli/config.js

@@ -1,4 +1,16 @@
 import { runInkSetup } from "../ui/renderApp.js";
+const DEFAULT_CLAUDE_MODEL = "haiku";
+const DEFAULT_CLAUDE_EFFORT = "low";
+function normalizeEffort(value) {
+    if (value === "low" ||
+        value === "medium" ||
+        value === "high" ||
+        value === "xhigh" ||
+        value === "max") {
+        return value;
+    }
+    return undefined;
+}
 export async function ensureConfig(store) {
     const existing = store.getConfig("user");
     if (existing) {
@@ -12,12 +24,18 @@ export async function ensureConfig(store) {
     return normalizeConfig(config);
 }
 export function normalizeConfig(config = {}) {
+    const claudeModel = typeof config.claudeModel === "string" && config.claudeModel.trim()
+        ? config.claudeModel.trim()
+        : DEFAULT_CLAUDE_MODEL;
+    const claudeEffort = normalizeEffort(config.claudeEffort) ?? DEFAULT_CLAUDE_EFFORT;
     return {
         level: config.level || "mid",
         language: config.language || "en",
         dailyGoal: Number(config.dailyGoal || 5),
         soundEnabled: config.soundEnabled === true,
-        createdAt: config.createdAt || new Date().toISOString()
+        createdAt: config.createdAt || new Date().toISOString(),
+        claudeModel,
+        claudeEffort
     };
 }
 function pickLevel(value) {

package/dist/generation/prompts/quiz.js

@@ -0,0 +1,57 @@
+/**
+ * Static instructional text for quiz generation.
+ *
+ * This is the part you tune when iterating on quiz quality — keep it
+ * decoupled from the dynamic context (signals, recent questions, source)
+ * assembled by {@link buildQuizPrompt} below.
+ */
+export const QUIZ_PROMPT_INSTRUCTIONS = [
+    "You are QuizMe, a CLI technical interview quiz generator for developers.",
+    "Return strict JSON only, matching the provided schema.",
+    "Generate exactly 5 multiple-choice questions with exactly 4 choices (ids A, B, C, D) and exactly one best answer.",
+    "Across the 5 questions, aim for this mix: 2 contextual, 2 adjacent, 1 interview_style.",
+    "Every question MUST include a `whyWrong` object with a short reason for each non-answer choice id.",
+    "Lean toward questions a well-rounded engineer should genuinely know: underlying principles, technology selection and tradeoffs, comparative distinctions between similar tools or patterns, and debugging / code-review judgment.",
+    "Each question in the batch MUST probe a distinct concept — vary the topic, depth, and angle so no two questions read as restatements of each other.",
+    "Prefer questions with a spark of intrigue and a clear, transferable takeaway: the reader should learn something concrete, not merely be quizzed. Keep them broadly applicable across teams and codebases.",
+    "Avoid: vague or ambiguous premises; pure business-logic trivia tied to one app; overly niche implementation details; tedious questions; anything requiring scratch arithmetic or hand-tracing long code; and questions so hard they frustrate instead of teach.",
+    "Weight the batch toward the user's weak areas from profile signals below; keep a small share of strong-area questions for positive reinforcement."
+].join("\n");
+/**
+ * Render profile signals into a compact strengths/weaknesses summary for the
+ * prompt. Top 5 by score and bottom 5 with wrong answers are surfaced so the
+ * generator can both reinforce and challenge the user.
+ */
+function summarizeSignals(signals) {
+    if (!signals.length)
+        return "None yet.";
+    const strongest = [...signals].sort((a, b) => b.score - a.score).slice(0, 5);
+    const weakest = [...signals]
+        .filter((s) => s.wrongCount > 0)
+        .sort((a, b) => a.score - a.score || b.wrongCount - a.wrongCount)
+        .slice(0, 5);
+    const format = (s) => `${s.tag}(score=${s.score.toFixed(2)}, conf=${s.confidence.toFixed(2)}, +${s.correctCount}/-${s.wrongCount})`;
+    return [
+        `Strong: ${strongest.map(format).join(", ") || "none"}`,
+        `Weak: ${weakest.map(format).join(", ") || "none"}`
+    ].join("\n");
+}
+/**
+ * Assemble the full quiz-generation prompt: static instructions plus the
+ * dynamic per-call context (level, language, mode, profile signals, recent
+ * questions to avoid, and the source summary).
+ */
+export function buildQuizPrompt({ source, config, recentQuestions, mode, signals }) {
+    return [
+        QUIZ_PROMPT_INSTRUCTIONS,
+        `User level: ${config.level}`,
+        `Language for questions and explanations: ${config.language}`,
+        `Mode: ${mode}`,
+        "Profile signals:",
+        summarizeSignals(signals),
+        "Recent questions to avoid repeating (topic:question pairs):",
+        JSON.stringify(recentQuestions.slice(0, 20).map((q) => ({ topic: q.topic, question: q.question }))),
+        "Source context summary:",
+        source.summary
+    ].join("\n\n");
+}

package/dist/generation/prompts/why.js

@@ -0,0 +1,30 @@
+/**
+ * Static instructional text for why-mode (on-demand explanation).
+ *
+ * Tuned separately from quiz generation — why mode is a deep, single-question
+ * tutor drill-down, not a batch generator. Keep this decoupled from the
+ * dynamic question/answer context assembled by {@link buildWhyPrompt} below.
+ */
+export const WHY_PROMPT_INSTRUCTIONS = [
+    "You are QuizMe in why mode — an expert technical tutor.",
+    "Provide a concise, concrete explanation. Explain why the correct answer is right, why each wrong option is weaker, and connect the concept to practical engineering work.",
+    "Stay focused on this question — do not become a general tutor."
+].join("\n");
+/**
+ * Assemble the full why-mode prompt: static instructions plus the dynamic
+ * per-call context (question, choices, correct answer, user selection, the
+ * question's own explanation, and the user's follow-up).
+ */
+export function buildWhyPrompt({ question, config, asked, userAnswer }) {
+    return [
+        WHY_PROMPT_INSTRUCTIONS,
+        `Language: ${config.language}`,
+        `User level: ${config.level}`,
+        `Question: ${question.question}`,
+        `Choices: ${JSON.stringify(question.choices)}`,
+        `Correct answer: ${question.answer}`,
+        `User selected: ${userAnswer}`,
+        `Initial explanation: ${question.explanation}`,
+        `User follow-up question: ${asked}`
+    ].join("\n\n");
+}

package/dist/generation/schema.js

@@ -3,7 +3,7 @@ export const QUESTION_SCHEMA = {
     properties: {
         questions: {
             type: "array",
-            minItems: 3,
+            minItems: 5,
             maxItems: 5,
             items: {
                 type: "object",

package/dist/providers/claudeAgent.js

@@ -1,6 +1,11 @@
 import { spawn, spawnSync } from "node:child_process";
 import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { QUESTION_SCHEMA } from "../generation/schema.js";
+import { buildQuizPrompt } from "../generation/prompts/quiz.js";
+import { buildWhyPrompt } from "../generation/prompts/why.js";
 import { validateQuestions } from "../generation/validator.js";
 function isObject(value) {
     return value !== null && typeof value === "object";
@@ -24,73 +29,6 @@ function extractQuestionsPayload(value) {
     }
     return Array.isArray(value.questions) ? value : null;
 }
-function summarizeSignals(signals) {
-    if (!signals.length)
-        return "None yet.";
-    const strongest = [...signals].sort((a, b) => b.score - a.score).slice(0, 5);
-    const weakest = [...signals]
-        .filter((s) => s.wrongCount > 0)
-        .sort((a, b) => a.score - b.score || b.wrongCount - a.wrongCount)
-        .slice(0, 5);
-    const format = (s) => `${s.tag}(score=${s.score.toFixed(2)}, conf=${s.confidence.toFixed(2)}, +${s.correctCount}/-${s.wrongCount})`;
-    return [
-        `Strong: ${strongest.map(format).join(", ") || "none"}`,
-        `Weak: ${weakest.map(format).join(", ") || "none"}`
-    ].join("\n");
-}
-function summarizePreferences(prefs) {
-    if (!prefs.length)
-        return "None.";
-    const boost = prefs.filter((p) => p.kind === "boost").map((p) => p.tag);
-    const suppress = prefs.filter((p) => p.kind === "suppress").map((p) => p.tag);
-    const known = prefs.filter((p) => p.kind === "known").map((p) => p.tag);
-    const lines = [];
-    if (boost.length)
-        lines.push(`Boost (user wants more): ${boost.join(", ")}`);
-    if (suppress.length)
-        lines.push(`Suppress (user wants less): ${suppress.join(", ")}`);
-    if (known.length)
-        lines.push(`Already known (deprioritize as strong-area): ${known.join(", ")}`);
-    return lines.join("\n") || "None.";
-}
-function buildQuizPrompt({ source, config, recentQuestions, mode, signals, preferences }) {
-    return [
-        "You are QuizMe, a CLI technical interview quiz generator for developers.",
-        "Return strict JSON only, matching the provided schema.",
-        "Generate 3 to 5 multiple-choice questions with exactly 4 choices (ids A, B, C, D) and exactly one best answer.",
-        "Every question MUST include a `sourceMode` field, one of: contextual (about the session/repo), adjacent (related tools/frameworks/concepts), interview_style (evergreen interview knowledge).",
-        "Target mix across the batch: ~40% contextual, ~40% adjacent, ~20% interview_style.",
-        "Every question MUST include a `whyWrong` object with a short reason for each non-answer choice id.",
-        "Focus on engineering judgment, debugging, tradeoffs, and code review reasoning — not trivia.",
-        "Weight the batch toward the user's weak areas from profile signals below; keep a small share of strong-area questions for positive reinforcement.",
-        "Respect user preferences: boost tags should appear more often; suppress and 'known' tags should appear less often (do not fully drop them, just deprioritize).",
-        `User level: ${config.level}`,
-        `Language for questions and explanations: ${config.language}`,
-        `Mode: ${mode}`,
-        "Profile signals:",
-        summarizeSignals(signals),
-        "Profile preferences:",
-        summarizePreferences(preferences),
-        "Recent questions to avoid repeating (topic:question pairs):",
-        JSON.stringify(recentQuestions.slice(0, 20).map((q) => ({ topic: q.topic, question: q.question }))),
-        "Source context summary:",
-        source.summary
-    ].join("\n\n");
-}
-function buildWhyPrompt({ question, config, asked, userAnswer }) {
-    return [
-        "You are QuizMe in why mode — an expert technical tutor.",
-        `Language: ${config.language}`,
-        `User level: ${config.level}`,
-        `Question: ${question.question}`,
-        `Choices: ${JSON.stringify(question.choices)}`,
-        `Correct answer: ${question.answer}`,
-        `User selected: ${userAnswer}`,
-        `Initial explanation: ${question.explanation}`,
-        `User follow-up question: ${asked}`,
-        "Provide a concise, concrete explanation. Explain why the correct answer is right, why each wrong option is weaker, and connect the concept to practical engineering work. Stay focused on this question — do not become a general tutor."
-    ].join("\n\n");
-}
 /**
  * Print-mode hardening for scripted calls.
  * - `--bare`: skip hooks, MCP, CLAUDE.md auto-discovery, etc.
@@ -100,22 +38,135 @@ function buildWhyPrompt({ question, config, asked, userAnswer }) {
  */
 const CLAUDE_PRINT_SECURITY_ARGS = ["--bare", "--tools", ""];
 /**
- * Whether `claude` has already been verified on PATH this process. The check
+ * Effort levels accepted by `claude --effort`. Anything outside this set is
+ * ignored so a stray config value never produces an invalid CLI flag.
+ */
+const VALID_EFFORTS = new Set([
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+]);
+/**
+ * Build the `--model` / `--effort` flag pair for a `claude` print-mode call.
+ * Empty/unknown values are dropped so we never pass an invalid flag — the
+ * account default model/effort applies instead.
+ */
+function buildModelArgs(model, effort) {
+    const args = [];
+    const trimmedModel = typeof model === "string" ? model.trim() : "";
+    if (trimmedModel) {
+        args.push("--model", trimmedModel);
+    }
+    if (effort && VALID_EFFORTS.has(effort)) {
+        args.push("--effort", effort);
+    }
+    return args;
+}
+/**
+ * Resolve why-mode model/effort from the environment. Why mode is a deep,
+ * on-demand explanation — it's tuned separately from quiz generation so a
+ * faster/cheaper quiz default doesn't force the tutor down to the same tier.
+ */
+function buildWhyModelArgs() {
+    const model = process.env.QUIZME_CLAUDE_WHY_MODEL?.trim();
+    const effort = process.env.QUIZME_CLAUDE_WHY_EFFORT?.trim();
+    return buildModelArgs(model, effort);
+}
+/**
+ * Whether `claude` has already been verified this process. The check
  * is cheap but synchronous, so we avoid repeating it on every generation call.
  */
 let claudeAvailableVerified = false;
 /**
- * Pre-flight check: ensure the `claude` CLI is installed and on PATH before
- * we spawn a long-running print-mode call. Throws a clear, actionable error
- * instead of letting `spawn` fail later with a generic ENOENT.
+ * Resolved absolute path to the `claude` binary, cached after first lookup.
+ * `null` means "defer to PATH" (i.e. spawn `"claude"` and let the OS resolve).
+ * `undefined` means "not yet looked up".
  */
-function ensureClaudeAvailable() {
-    if (claudeAvailableVerified)
-        return;
-    const result = spawnSync("claude", ["--version"], {
+let claudeBinPath = undefined;
+/**
+ * Locations we probe for the `claude` CLI when it isn't on PATH. This covers
+ * the common install paths that GUI launchers / IDE integrated terminals often
+ * strip from PATH (notably `~/.local/bin`, where the native installer drops it).
+ */
+const CLAUDE_BIN_CANDIDATES = (() => {
+    const home = os.homedir();
+    const candidates = [
+        path.join(home, ".local/bin/claude"),
+        path.join(home, ".volta/bin/claude"),
+        path.join(home, ".bun/bin/claude"),
+        path.join(home, ".npm-global/bin/claude"),
+        "/usr/local/bin/claude",
+        "/opt/homebrew/bin/claude"
+    ];
+    // nvm: probe each installed node version's bin dir.
+    const nvmDir = process.env.NVM_DIR ?? path.join(home, ".nvm");
+    try {
+        const versions = existsSync(path.join(nvmDir, "versions/node"))
+            ? spawnSync("ls", [path.join(nvmDir, "versions/node")], { encoding: "utf8" }).stdout?.trim().split(/\s+/) ?? []
+            : [];
+        for (const v of versions) {
+            if (v)
+                candidates.push(path.join(nvmDir, "versions/node", v, "bin/claude"));
+        }
+    }
+    catch {
+        // ignore — nvm probe is best-effort
+    }
+    return candidates;
+})();
+/**
+ * Resolve the `claude` CLI binary path. Honors `QUIZME_CLAUDE_BIN` first, then
+ * PATH lookup, then a list of well-known install locations. Returns the
+ * absolute path if found, or `null` to fall back to a plain `claude` spawn.
+ */
+function resolveClaudeBin() {
+    if (claudeBinPath !== undefined)
+        return claudeBinPath;
+    // 1. Explicit override.
+    const override = process.env.QUIZME_CLAUDE_BIN;
+    if (override) {
+        claudeBinPath = override;
+        return claudeBinPath;
+    }
+    // 2. On PATH.
+    const pathCheck = spawnSync("claude", ["--version"], {
         stdio: "ignore",
         shell: process.platform === "win32"
     });
+    if (!pathCheck.error && pathCheck.status === 0) {
+        claudeBinPath = null; // let spawn resolve via PATH
+        return claudeBinPath;
+    }
+    // 3. Well-known install locations.
+    for (const candidate of CLAUDE_BIN_CANDIDATES) {
+        if (existsSync(candidate)) {
+            const verify = spawnSync(candidate, ["--version"], { stdio: "ignore" });
+            if (!verify.error && verify.status === 0) {
+                claudeBinPath = candidate;
+                return claudeBinPath;
+            }
+        }
+    }
+    claudeBinPath = null;
+    return claudeBinPath;
+}
+/**
+ * Pre-flight check: ensure the `claude` CLI is installed before we spawn a
+ * long-running print-mode call. Throws a clear, actionable error instead of
+ * letting `spawn` fail later with a generic ENOENT.
+ */
+function ensureClaudeAvailable() {
+    if (claudeAvailableVerified)
+        return;
+    const bin = resolveClaudeBin();
+    const result = bin
+        ? spawnSync(bin, ["--version"], { stdio: "ignore" })
+        : spawnSync("claude", ["--version"], {
+            stdio: "ignore",
+            shell: process.platform === "win32"
+        });
     if (result.error || result.status !== 0) {
         throw new Error([
             "Claude Code CLI (`claude`) was not found on your PATH.",
@@ -124,14 +175,20 @@ function ensureClaudeAvailable() {
             "Install it with:  npm install -g @anthropic-ai/claude-code",
             "Docs:             https://docs.anthropic.com/claude-code",
             "",
-            "Or run QuizMe offline with QUIZME_PROVIDER=local."
+            "If it is installed but not on this process's PATH, set",
+            "  QUIZME_CLAUDE_BIN=/absolute/path/to/claude",
+            "(also checked: " + CLAUDE_BIN_CANDIDATES.join(", ") + ")",
+            "",
+            "Note: an offline local provider (QUIZME_PROVIDER=local) is documented",
+            "but not yet implemented — the CLI still requires `claude`."
         ].join("\n"));
     }
     claudeAvailableVerified = true;
 }
 async function runClaude(args, { onEvent, timeout = 120000 } = {}) {
     return new Promise((resolve, reject) => {
-        const child = spawn("claude", [...CLAUDE_PRINT_SECURITY_ARGS, ...args], {
+        const bin = resolveClaudeBin() ?? "claude";
+        const child = spawn(bin, [...CLAUDE_PRINT_SECURITY_ARGS, ...args], {
             stdio: ["ignore", "pipe", "pipe"]
         });
         const chunks = [];
@@ -241,11 +298,12 @@ function extractTextFromEvents(events) {
     }
     return parts.join("");
 }
-export async function generateQuestions({ source, config, recentQuestions, mode = "mixed", signals = [], preferences = [], onProgress }) {
+export async function generateQuestions({ source, config, recentQuestions, mode = "mixed", signals = [], onProgress }) {
     ensureClaudeAvailable();
-    const prompt = buildQuizPrompt({ source, config, recentQuestions, mode, signals, preferences });
+    const prompt = buildQuizPrompt({ source, config, recentQuestions, mode, signals });
     const events = [];
     await runClaude([
+        ...buildModelArgs(config.claudeModel, config.claudeEffort),
         "-p",
         "--output-format", "stream-json",
         "--verbose",
@@ -275,7 +333,7 @@ export async function generateWhy({ question, config, asked, userAnswer, onProgr
     const prompt = buildWhyPrompt({ question, config, asked, userAnswer });
     const events = [];
     let streamedText = "";
-    await runClaude(["-p", "--output-format", "stream-json", "--verbose", prompt], {
+    await runClaude(["-p", ...buildWhyModelArgs(), "--output-format", "stream-json", "--verbose", prompt], {
         onEvent: (event) => {
             events.push(event);
             if (onProgress && isAssistantEvent(event)) {

package/dist/sources/claudeSession.js

@@ -1,6 +1,10 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import { getClaudeProjectsDir } from "../platform/paths.js";
+function getClaudeProjectsDir() {
+    return path.join(os.homedir(), ".claude", "projects");
+}
 function isObject(value) {
     return value !== null && typeof value === "object";
 }
@@ -51,12 +55,19 @@ function summarizeRows(rows) {
             .join("\n")
     };
 }
-function findMostRecentSessionGlobally() {
+/**
+ * Scan every `~/.claude/projects/<project>/*.jsonl` transcript globally and return them
+ * sorted by mtime (newest first). Scanning globally — rather than only the
+ * current project dir — is intentional: users fire QuizMe from any directory
+ * during Claude Code wait times and should get their latest session context
+ * regardless of where they launched it from.
+ */
+function listAllSessionFiles() {
     const projectsDir = getClaudeProjectsDir();
     if (!fs.existsSync(projectsDir)) {
-        return null;
+        return [];
     }
-    const allFiles = fs.readdirSync(projectsDir)
+    return fs.readdirSync(projectsDir)
         .flatMap((entry) => {
         const dir = path.join(projectsDir, entry);
         try {
@@ -69,15 +80,26 @@ function findMostRecentSessionGlobally() {
         }
     })
         .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    return allFiles.length ? allFiles[0] : null;
 }
-function findLatestSessionFile() {
-    const projectsDir = getClaudeProjectsDir();
-    const mostRecent = findMostRecentSessionGlobally();
-    if (!mostRecent) {
-        throw new Error(`No Claude project transcripts found in ${projectsDir}. Run Claude Code in this repo first, or use --repo / "topic".`);
+/**
+ * Pick `count` items from `items` uniformly at random without replacement
+ * (Fisher–Yates partial shuffle). Returns at most `min(count, items.length)`
+ * items, preserving the original (newest-first) order for readability.
+ */
+function pickRandom(items, count) {
+    if (items.length === 0 || count <= 0)
+        return [];
+    const k = Math.min(count, items.length);
+    const indices = items.map((_, i) => i);
+    for (let i = indices.length - 1; i > indices.length - k; i--) {
+        const j = i - Math.floor(crypto.randomInt(i + 1));
+        [indices[i], indices[j]] = [indices[j], indices[i]];
     }
-    return mostRecent;
+    // The last k indices are the picked ones; sort them to keep newest-first order.
+    return indices
+        .slice(indices.length - k)
+        .sort((a, b) => a - b)
+        .map((i) => items[i]);
 }
 export function getClaudeSummaryFromFile(filePath, cwd = process.cwd()) {
     const rows = parseJsonLines(filePath);
@@ -107,6 +129,52 @@ export function getClaudeSummaryFromFile(filePath, cwd = process.cwd()) {
         ].join("\n")
     };
 }
+/**
+ * How many of the most recent sessions to draw candidates from. Sampling a
+ * pool (not just the single newest) keeps the background context fresh across
+ * runs — the same question set isn't always anchored to whichever session
+ * happened to be touched last.
+ */
+const RECENT_SESSION_POOL = 10;
+/**
+ * How many sessions from the pool to actually feed into the prompt as
+ * background context. Three is enough breadth without bloating the prompt.
+ */
+const SELECTED_SESSION_COUNT = 3;
+/**
+ * Build a single {@link SourceSummary} from multiple session transcripts,
+ * each sectioned by its file name so the generator can tell them apart.
+ */
+function mergeSessionSummaries(summaries, cwd) {
+    if (summaries.length === 1) {
+        return summaries[0];
+    }
+    const sections = summaries.map((s, i) => `### Session ${i + 1}: ${s.title}\n${s.summary}`);
+    return {
+        sourceType: "claude_session",
+        title: `${summaries.length} recent sessions`,
+        summary: [
+            `Claude project path: ${cwd}`,
+            `Selected ${summaries.length} sessions (random sample from the ${RECENT_SESSION_POOL} most recent) as background context:`,
+            sections.join("\n\n")
+        ].join("\n")
+    };
+}
+/**
+ * Resolve the background context for a session-mode quiz: take the
+ * {@link RECENT_SESSION_POOL} most recent transcripts globally, randomly pick
+ * {@link SELECTED_SESSION_COUNT} of them, and merge their summaries.
+ *
+ * Falls back gracefully when fewer than the pool size exist — it samples from
+ * whatever is available and throws only when there are no transcripts at all.
+ */
 export function getLatestClaudeSummary(cwd = process.cwd()) {
-    return getClaudeSummaryFromFile(findLatestSessionFile(), cwd);
+    const pool = listAllSessionFiles().slice(0, RECENT_SESSION_POOL);
+    if (pool.length === 0) {
+        const projectsDir = getClaudeProjectsDir();
+        throw new Error(`No Claude project transcripts found in ${projectsDir}. Run Claude Code in this repo first, or use --repo / "topic".`);
+    }
+    const selected = pickRandom(pool, SELECTED_SESSION_COUNT);
+    const summaries = selected.map((file) => getClaudeSummaryFromFile(file, cwd));
+    return mergeSessionSummaries(summaries, cwd);
 }

package/dist/storage/index.js

@@ -1,7 +1,23 @@
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import { getAppDataDir } from "../platform/paths.js";
-import { SqliteStore } from "./sqlite.js";
-import { ensureDir } from "../platform/fs.js";
+import { JsonStore } from "./json.js";
+function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+export function getAppDataDir() {
+    if (process.env.QUIZME_DATA_DIR) {
+        return process.env.QUIZME_DATA_DIR;
+    }
+    const home = os.homedir();
+    if (process.platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "quizme");
+    }
+    if (process.platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "quizme");
+    }
+    return path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "quizme");
+}
 export function createStore() {
     let dataDir = getAppDataDir();
     try {
@@ -11,8 +27,7 @@ export function createStore() {
         dataDir = path.join(process.cwd(), ".quizme");
         ensureDir(dataDir);
     }
-    const dbPath = path.join(dataDir, "history.sqlite");
-    const store = new SqliteStore(dbPath);
+    const store = new JsonStore(path.join(dataDir, "quizme.json"));
     store.init();
     return store;
 }