dsh-lifecard 0.1.1 → 0.2.0

package/lib/index.js

@@ -25,7 +25,34 @@ import * as memory from './memory.js'
 import * as jobs from './jobs.js'
 import * as jobsStore from './jobs-store.js'
 import * as interview from './jobs-interview.js'
-import * as tavern from './tavern.js'
+// 这四个是「可以整个删掉」的功能模块：酒馆、写小说、预设、文字游戏。
+// 用「用到才加载」而不是文件顶上的静态 import —— 静态 import 一个不存在的
+// 文件会让整个插件起不来，那就不是「能删」而是「删了就全废」。
+// 删掉对应文件之后，只有那个功能报「这个功能没装」，别的照常。
+let tavern = null
+let novel = null
+let presets = null
+let game = null
+let career = null
+/** 哪个功能没装（给用户看的名字）。 */
+const FEATURE_NAMES = { tavern: '酒馆', novel: '写小说', presets: '预设', game: '文字小说游戏', career: '简历与规划' }
+/**
+ * 按需把四个模块加载进来。已经加载过的不会重复加载。
+ * @returns {Promise<Record<string, boolean>>} 每个模块现在在不在
+ */
+async function ensureModules() {
+  if (tavern === null) tavern = await import('./tavern.js').catch(() => null)
+  if (novel === null) novel = await import('./novel.js').catch(() => null)
+  if (presets === null) presets = await import('./presets.js').catch(() => null)
+  if (game === null) game = await import('./game.js').catch(() => null)
+  if (career === null) career = await import('./career.js').catch(() => null)
+  return { tavern: tavern !== null, novel: novel !== null, presets: presets !== null, game: game !== null, career: career !== null }
+}
+/** 这个功能没装的时候，统一回一句人话。 */
+function missingFeature(name) {
+  const label = FEATURE_NAMES[name] ?? name
+  return { ok: false, error: `「${label}」这个功能没装（对应的文件被删掉了）。别的功能不受影响。`, missingFeature: name }
+}
 export const name = 'dsh-lifecard'
 
 /** 需要宿主提供的服务。缺 webServer 就什么都不做（明确失败胜过静默半死）。 */
@@ -484,6 +511,13 @@ async function collectStream(handle) {
   const eat = (chunk) => {
     if (chunk === null || chunk === undefined) return
     if (typeof chunk === 'string') { text += chunk; return }
+    // 模型「想」的那一段走的是另一条事件（实测：{ type: 'reasoning-delta', text }）。
+    // 它不是回答，也**不能**当成回答拼进来：拼进去之后 JSON 前面多出几千字
+    // 「Thinking Process: …」，解析必失败——「整理进卡里」于是等五十秒、
+    // 试两次、报「AI 这次没给出能用的结果」，用户看到的是一直转圈。
+    // 下面那些「只要是 .text 就收」的兜底分支会让它漏进来，所以必须先在
+    // 这里按类型挡掉。
+    if (typeof chunk.type === 'string' && /reasoning|thinking|analysis/i.test(chunk.type)) return
     // 真实的流事件形状（实测）：{ type: 'text-delta', index, text }
     // block-start / block-end / text-start / text-end / finish 都不带正文
     if (chunk.type === 'text-delta' && typeof chunk.text === 'string') { text += chunk.text; return }
@@ -844,8 +878,13 @@ function buildApi(ctx, workspace, config, options) {
       const ws = await root(body)
       const data = body?.data
       if (data === null || typeof data !== 'object') return { ok: false, error: '没收到卡片内容，重新试一次。' }
+      // 判空必须在 safeId **之前**：`core.safeId('')` 返回 `'unnamed'`，
+      // 于是下面那句 `if (id === '')` 永远不成立——没起名字的新卡会悄悄
+      // 变成一张叫「unnamed」的卡，之后所有空名字的卡还会互相覆盖。
+      if (String(data.id ?? data.name ?? '').trim() === '') {
+        return { ok: false, error: '这张卡还没有名字，先给它起一个。' }
+      }
       const id = core.safeId(data.id ?? data.name ?? '')
-      if (id === '') return { ok: false, error: '这张卡还没有名字，先给它起一个。' }
       data.id = id
       data.lifecard = core.DATA_VERSION
       let rel
@@ -1197,7 +1236,9 @@ function buildApi(ctx, workspace, config, options) {
       const name = String(body?.name ?? about ?? 'material')
       const block = body?.meta === undefined ? content : `${content}\n\n\`\`\`\n${body.meta}\n\`\`\``
       const saved = await store.appendMaterial(ws, name, block)
-      return { ok: true, ...saved }
+      // 以前这里无条件 `ok:true` 再展开 saved，把 `ok:false` 盖掉了：
+      // 存失败时界面照样说「已保存」。别的路由都是先判 saved.ok 再往下走。
+      if (saved?.ok !== true) return { ok: false, error: saved?.error ?? '这段材料没存进去。', ...saved }
     },
 
     /** 材料列表 + 全文（分析用）。 */
@@ -1878,7 +1919,7 @@ function buildApi(ctx, workspace, config, options) {
         ? all.filter((p) => body.people.includes(keyOf(p)))
         : all
       if (wanted.length === 0) return { ok: false, error: '勾选的人一个都没对上。' }
-      const at = new Date().toISOString().slice(0, 10)
+      const at = store.localDate()
       const files = []
       for (const p of wanted) {
         const label = p.name !== '' ? p.name : p.kin
@@ -1922,7 +1963,7 @@ function buildApi(ctx, workspace, config, options) {
         ? all.filter((p) => body.people.includes(p.name !== '' ? `${p.kin}:${p.name}` : p.kin))
         : all
       if (wanted.length === 0) return { ok: false, error: '勾选的人一个都没对上。' }
-      const md = memory.renderMemoryMaterial(wanted, { read_at: new Date().toISOString().slice(0, 10) })
+      const md = memory.renderMemoryMaterial(wanted, { read_at: store.localDate() })
       const saved = await store.appendMaterial(ws, `记忆里认出来的人`, md)
       if (saved.ok !== true) return saved
       // 记下「这些人还缺什么」。等他们变成卡之后，卡上那个红色感叹号
@@ -2251,6 +2292,7 @@ function buildApi(ctx, workspace, config, options) {
 
     /** 酒馆：说过的这几场。 */
     'tavern.list': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
       const ws = await root(body)
       return await tavern.listChats(ws)
     },
@@ -2262,6 +2304,7 @@ function buildApi(ctx, workspace, config, options) {
      * 而不是对着一个空框想「我该说什么」。
      */
     'tavern.start': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
       const ws = await root(body)
       const want = String(body?.card ?? '').trim()
       if (want === '') return { ok: false, error: '得先挑一个人，才能开始。' }
@@ -2303,6 +2346,7 @@ function buildApi(ctx, workspace, config, options) {
 
     /** 酒馆：读这一场。 */
     'tavern.get': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
       const ws = await root(body)
       const id = String(body?.id ?? '').trim()
       if (id === '') return { ok: false, error: '这一场找不到了' }
@@ -2330,6 +2374,8 @@ function buildApi(ctx, workspace, config, options) {
      * 断网一次就全没了。
      */
     'tavern.say': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
+      if ((await ensureModules()).presets !== true) return missingFeature('presets')
       const id = String(body?.id ?? '').trim()
       if (id === '') return { ok: false, error: '这一场找不到了' }
       // 同一场会话一次只处理一句：读-改-写之间夹着一次模型调用，
@@ -2373,7 +2419,11 @@ function buildApi(ctx, workspace, config, options) {
         const memoryNote = (Array.isArray(got.notes) ? got.notes : [])
           .find((n) => String(n?.title ?? '').trim() === tavern.MEMORY_TITLE)
         const memory = memoryNote === undefined ? '' : String(memoryNote.body ?? '')
-        const system = tavern.buildRoleplaySystem({ cardName, persona: persona.text, worldNotes, memory })
+        // 演法预设：选了就把它那套要求拼在最后。找不到预设（用户删了）就不拼，
+        // 不能因为这一条让整场对话报错。
+        const roleplayPreset = await presets.resolve(ws, body?.preset)
+        const presetNote = roleplayPreset.ok === true && roleplayPreset.preset !== null ? String(roleplayPreset.preset.prompt ?? '') : ''
+        const system = tavern.buildRoleplaySystem({ cardName, persona: persona.text, worldNotes, memory, preset: presetNote })
         const user = tavern.buildRoleplayUser({ cardName, turns })
         const called = await callModel(ctx, { system, user, model: body?.model })
         const now = tavernStamp()
@@ -2406,9 +2456,13 @@ function buildApi(ctx, workspace, config, options) {
      * 让它别把之前发生过的事记错。
      */
     'tavern.summarize': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
       const ws = await root(body)
       const id = String(body?.id ?? '').trim()
       if (id === '') return { ok: false, error: '这一场找不到了' }
+      // 收尾也是一次「读 → 调模型（十几二十秒）→ 整文件写回」，跟 tavern.say 同一个形状。
+      // 不收进来排队的话，这段时间里说的任何一句都会被回写成收尾前那一版 —— 而且不留痕迹。
+      return oneAtATime(id, async () => {
       const got = await tavern.readChat(ws, id)
       if (got.ok !== true) return got
       const turns = Array.isArray(got.turns) ? got.turns.slice() : []
@@ -2428,16 +2482,771 @@ function buildApi(ctx, workspace, config, options) {
       const saved = await tavern.writeChat(ws, id, { ...got.data, notes, turns: turns.length, updated_at: tavernStamp() }, turns)
       if (saved.ok !== true) return { ok: false, error: `收好了，但没存下来：${saved.error}`, summary, turns }
       return { ok: true, id, summary, notes, turns }
+      })
+    },
+
+    /**
+     * 把这一场里最能代表 TA 的几句，写进那张卡的「对话示例」。
+     *
+     * 「对话示例」是下次演 TA 时最管用的材料：比「性格：沉默寡言」具体得多，
+     * 因为它就是那个人真的说过的话。演着演着发现 TA 说话的样子比卡上写的准，
+     * 这里就能把它固化下来。
+     */
+    'tavern.toExample': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '这一场找不到了' }
+      return oneAtATime(id, async () => {
+        const got = await tavern.readChat(ws, id)
+        if (got.ok !== true) return got
+        const turns = Array.isArray(got.turns) ? got.turns : []
+        if (turns.filter((t) => String(t?.who ?? '').trim() !== '我').length === 0) {
+          return { ok: false, error: 'TA 还没说过话，挑不出例句。' }
+        }
+        const cardName = String(got.data?.card_name ?? '').trim()
+        const prompt = tavern.buildExamplePrompt({ cardName, turns })
+        const called = await callModel(ctx, { system: prompt.system, user: prompt.user, model: body?.model })
+        if (called.ok !== true) return { ok: false, error: `没挑出来：${called.error ?? '过一会儿再试一次'}` }
+        const picked = tavern.cleanExamples(called.text)
+        if (picked.length === 0) return { ok: false, error: '这一次没挑出能用的句子，过一会儿再试一次。' }
+
+        const want = String(got.data?.card ?? '').trim()
+        if (want === '') return { ok: false, error: '这一场不知道是跟哪张卡演的，存不回去。' }
+        const card = await store.findCardByRelOrId(ws, want)
+        if (card === null) return { ok: false, error: '那张卡找不到了，它可能被删掉了。' }
+        const read = await store.readCard(ws, card)
+        if (read.ok !== true) return read
+        const sections = Array.isArray(read.sections) ? read.sections.map((x) => ({ ...x })) : []
+        const title = '对话示例'
+        const at = sections.findIndex((x) => String(x.title ?? '').trim() === title)
+        const block = picked.map((line) => `- ${line}`).join('\n')
+        if (at === -1) sections.push({ title, body: block })
+        else {
+          const oldBody = String(sections[at].body ?? '').trim()
+          const merged = oldBody === '' || oldBody === '_（还没写）_' ? block : `${oldBody}\n${block}`
+          // 例句越攒越多会把这个小节撑爆，之后每演一句都把这些全塞进提示词。
+          // 只留最后 24 行——它们是最靠近「现在这个人」的样子。
+          const lines = merged.split(/\r?\n/).filter((x) => x.trim() !== '')
+          sections[at] = { ...sections[at], body: lines.slice(-24).join('\n') }
+        }
+        const written = await store.writeCard(ws, card, read.data, sections)
+        if (written.ok !== true) return written
+        return { ok: true, path: written.path, picked }
+      })
     },
 
     /** 酒馆：这一场不要了。 */
-    'tavern.delete': async (body) => {
+        /**
+     * 把酒馆里聊出来的一场，变成某本小说的一章。
+     *
+     * 这是「三扇门其实是一件事」的那一步：先在酒馆里把人立起来、把话演一遍，
+     * 演得满意的那一场直接变成小说的正文，而不是再从头写一遍。
+     */
+    'tavern.toChapter': async (body) => {
+      const ws = await root(body)
+      const mods = await ensureModules()
+      if (mods.tavern !== true) return missingFeature('tavern')
+      if (mods.novel !== true) return missingFeature('novel')
+
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '得先挑一场聊过的。' }
+      const book = String(body?.book ?? '').trim()
+      if (book === '') return { ok: false, error: '得先挑一本书。没有书的话，先回「写小说」那扇门建一本。' }
+
+      const chat = await tavern.readChat(ws, id)
+      if (chat.ok !== true) return chat
+      const turns = chat.turns ?? []
+      if (turns.length === 0) return { ok: false, error: '这一场还什么都没说。先在酒馆里聊几句，再变。' }
+
+      const target = await novel.readBook(ws, book)
+      if (target.ok !== true) return target
+      if (target.book === null) return { ok: false, error: '找不到这本书。它可能被删了。' }
+
+      const built = novel.buildChatToChapterPrompt({
+        cardName: chat.data?.card_name ?? '',
+        bookTitle: target.book?.title ?? '',
+        turns,
+        note: String(body?.note ?? ''),
+      })
+      const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `这次没改出来：${called.error ?? '过一会儿再试一次'}` }
+
+      const text = String(called.text ?? '').trim()
+      if (text === '') return { ok: false, error: '它这次什么都没写出来，再试一次。' }
+
+      // 章号接着最后一章往后排。用「最后一章的号 + 1」而不是「章数 + 1」：
+      // 中间删过章的话（第 2 章被删），章数是 2、最后一章是第 3 章，
+      // 用章数算出来的 3 会覆盖掉现成的第 3 章。
+      const list = Array.isArray(target.chapters) ? target.chapters : []
+      const last = list.length === 0 ? 0 : Number(list[list.length - 1]?.index ?? 0)
+      const next = (Number.isFinite(last) ? last : 0) + 1
+      const written = await novel.writeChapter(ws, book, next, text)
+      if (written.ok !== true) return written
+      return { ok: true, book, chapter: written.index ?? next, text, turns: turns.length }
+    },
+
+'tavern.delete': async (body) => {
+      if ((await ensureModules()).tavern !== true) return missingFeature('tavern')
       const ws = await root(body)
       const id = String(body?.id ?? '').trim()
       if (id === '') return { ok: false, error: '这一场找不到了' }
       return await tavern.deleteChat(ws, id)
     },
+
+    // ── 写小说：一本书、一章一章 ─────────────────────────────────
+
+    /** 书架：所有书。 */
+    'novel.books': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      return await novel.listBooks(ws)
+    },
+
+    /** 新开一本。 */
+    'novel.create': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      return await novel.createBook(ws, {
+        title: body?.title,
+        genre: body?.genre,
+        idea: body?.idea,
+      })
+    },
+
+    /** 打开一本书（含章节清单）。 */
+    'novel.get': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.readBook(ws, id)
+    },
+
+    /** 改书的元信息（书名 / 题材 / 一句话）。 */
+    'novel.update': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.updateBook(ws, id, {
+        title: body?.title,
+        genre: body?.genre,
+        idea: body?.idea,
+      })
+    },
+
+    /** 这一章不要了。 */
+    'novel.chapter.delete': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.deleteChapter(ws, id, body?.index)
+    },
+
+    /** 整本书不要了。 */
+    'novel.delete': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.deleteBook(ws, id)
+    },
+
+    // ── 写小说的三段：规划 → 写章 → 审稿 ──────────────────────
+
+    /** 读大纲。 */
+    'novel.outline.get': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.readOutline(ws, id)
+    },
+
+    /** 自己写 / 改大纲（人也在这里改）。 */
+    'novel.outline.save': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.writeOutline(ws, id, String(body?.text ?? ''))
+    },
+
+    /**
+     * 让 AI 先把整本书的骨架搭出来（第一段：规划）。
+     *
+     * 只写进 outline.md，不动正文：这一步是「先想清楚」，用户看完能改，
+     * 改完再一章一章让它写。不落盘的话刷新一下就没了，白等一次模型。
+     */
+    'novel.outline.draft': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      if ((await ensureModules()).presets !== true) return missingFeature('presets')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      const book = await novel.readBook(ws, id)
+      if (book.ok !== true) return book
+      const worldNotes = []
+      const worldRel = typeof body?.world === 'string' ? body.world.trim() : ''
+      if (worldRel !== '') {
+        const world = await store.readCard(ws, worldRel)
+        if (world.ok === true) {
+          for (const entry of core.parseWorldEntries(world.sections)) {
+            const content = String(entry?.content ?? '').trim()
+            if (content !== '') worldNotes.push(content)
+          }
+        }
+      }
+      const cast = await gatherCast(ws, body?.cast)
+      const users = novel.buildOutlinePrompt({
+        title: String(book.data?.title ?? id),
+        genre: String(book.data?.genre ?? ''),
+        idea: String(book.idea ?? ''),
+        cast,
+        worldEntries: worldNotes,
+        chapters: Number(body?.chapters) || 12,
+        ask: body?.ask,
+      })
+      const outlinePreset = await presets.resolve(ws, body?.preset)
+      const outlineNote = outlinePreset.ok === true && outlinePreset.preset !== null ? String(outlinePreset.preset.prompt ?? '') : ''
+      const called = await callModel(ctx, {
+        system: [
+          '你是一个会写长篇小说的人。你先想清楚整本书怎么走，再动手写。',
+          outlineNote === '' ? '' : `\n【这本书怎么写】\n${outlineNote}`,
+        ].filter((x) => x !== '').join('\n'),
+        user: users,
+        model: body?.model,
+      })
+      if (called.ok !== true) return { ok: false, error: `这次没想出来：${called.error ?? '过一会儿再试一次'}` }
+      const text = String(called.text ?? '').trim()
+      if (text === '') return { ok: false, error: 'AI 这次没给出东西，再点一次试试。' }
+      const saved = await novel.writeOutline(ws, id, text)
+      if (saved.ok !== true) return saved
+      // 以前这里把 parseOutline 的结果展开在 ok:true 后面，而它自带一个
+      // ok（=「扒到几章」是否大于 0）。AI 写得散、一行「第 N 章：」都没有时，
+      // 文件其实已经写进去了，却返回 ok:false，界面报「这次没想出一个字」。
+      const parsed = novel.parseOutline(text)
+      return {
+        ok: true,
+        text,
+        path: saved.path,
+        theme: parsed.theme,
+        ending: parsed.ending,
+        chapters: parsed.chapters,
+        ...(parsed.chapters.length > 0 ? {} : { warning: '这一版大纲里没认出「第 N 章：」这样的行，文件已经存下了，你可以自己补上章号。' }),
+      }
+    },
+
+    /**
+     * 整本导出成一整篇文字。
+     *
+     * 用户电脑上只有这个插件，不会去翻 books/ 底下那一堆 001.md。
+     * 写完一本书要能一口气复制走，而不是一章一章点开来复制。
+     */
+    'novel.export': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      const got = await novel.readBook(ws, id)
+      if (got.ok !== true) return got
+
+      const lines = []
+      const title = String(got.data?.title ?? id).trim()
+      lines.push(`# ${title === '' ? '未命名' : title}`)
+      lines.push('')
+      if (String(got.idea ?? '').trim() !== '') {
+        lines.push(`> ${String(got.idea).trim()}`)
+        lines.push('')
+      }
+      let total = 0
+      for (const chapter of got.chapters) {
+        const one = await novel.readChapter(ws, id, chapter.index)
+        if (one.ok !== true) continue
+        lines.push(`## 第 ${chapter.index} 章`)
+        lines.push('')
+        lines.push(String(one.body ?? '').trim())
+        lines.push('')
+        total += 1
+      }
+      if (total === 0) return { ok: false, error: '这本书还一章都没有。先写一章，再导出。' }
+      return { ok: true, title, chapters: total, text: lines.join('\n').trim() + '\n' }
+    },
+
+    /**
+     * 审一章（第三段：审稿）。
+     *
+     * 只挑**具体能指出的问题**：哪里跳了、哪里人物不像、哪里在替读者总结。
+     * 不要它夸——「写得很好」这种话对写东西的人毫无用处。
+     */
+    'novel.chapter.review': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      const index = Number(body?.index) || 0
+      const got = await novel.readChapter(ws, id, index)
+      if (got.ok !== true) return got
+      const bodyText = String(got.body ?? '').trim()
+      if (bodyText === '') return { ok: false, error: '这一章还是空的，没什么可审的。' }
+      if (bodyText.length > 20000) {
+        return { ok: false, error: '这一章太长（超过两万字），一次读不完。先分成两章再挑毛病。' }
+      }
+
+      // 盲审：只给正文，不给书名、不给大纲、不给「这一章本来想写什么」。
+      //
+      // 为什么不给：写的人心里有一套意图，看的时候会不自觉地按意图去读，
+      // 于是「我本来想写这个」会替「我实际写出来的是什么」作证。
+      // 换成一个什么都不知道的读者，才是这本书真正的处境。
+      const user = [
+        '下面是一段小说正文。你之前没看过这本书，也不知道作者想写什么。',
+        '你就是一个第一次读到这里的读者。',
+        '',
+        '【正文】',
+        bodyText,
+        '',
+        '【读完告诉我这些】',
+        '1. 你读到哪儿卡住了（那句话说不上来、那段跳了、回头看了两遍才懂）',
+        '2. 你读到哪儿不信（这个人不会这么做、这件事不会这么发生）',
+        '3. 你读到哪儿想跳过（哪几段你在心里划过去了）',
+        '4. 哪句话是空话，删掉不影响（直接引原句）',
+        '',
+        '【怎么答】',
+        '- 每条一行，先写「哪里：」再写「为什么：」。要引原句。',
+        '- 最多 8 条，按你读的时候的不舒服程度排。',
+        '- 不夸。一句夸奖都不要。',
+        '- 不给改写版本——你只是读者，不是代笔。',
+        '- 没看出问题就直接说「没卡住的地方」，不要凑条数。',
+      ].join('\n')
+      const called = await callModel(ctx, {
+        // 换了一张纸：这段系统提示只要求它当读者，不要求它当编辑，
+        // 免得它从「怎么写更好」的角度出发，跑回写作者的位置上。
+        system: [
+          '你是一个普通读者，刚读完一段小说。',
+          '你没有写过这段，也不知道作者是谁、想写什么。',
+          '你只会说读的时候哪里不顺、哪里不信、哪里想跳过。',
+          '你不会改稿，也不会替作者想句子。',
+          body?.model === undefined || String(body.model).trim() === '' ? '' : '',
+        ].filter((x) => x !== '').join('\n'),
+        user,
+        model: body?.model,
+      })
+      if (called.ok !== true) return { ok: false, error: `这次没审成：${called.error ?? '过一会儿再试一次'}` }
+      const review = String(called.text ?? '').trim()
+      if (review === '') return { ok: false, error: 'AI 这次没给出意见，再点一次试试。' }
+      return { ok: true, index, review, chars: bodyText.length, blind: true, model: String(body?.model ?? '') }
+    },
+
+    /** 读一章。 */
+    // ── 简历与规划：写简历、看差距、规划怎么走 ─────────────────
+
+    /** 读简历和规划（还没写过也正常，返回 null）。 */
+    'career.get': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const profile = await career.readProfile(ws)
+      if (profile.ok !== true) return profile
+      const plan = await career.readPlan(ws)
+      if (plan.ok !== true) return plan
+      return {
+        ok: true,
+        profile: profile.data,
+        profileSections: profile.sections,
+        plan: plan.data,
+        planSections: plan.sections,
+      }
+    },
+
+    /** 存简历。 */
+    'career.profile.save': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const saved = await career.writeProfile(ws, body?.profile ?? {})
+      if (saved.ok !== true) return saved
+      return { ok: true, path: career.PROFILE_REL }
+    },
+
+    /** 存规划。 */
+    'career.plan.save': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const saved = await career.writePlan(ws, body?.plan ?? {})
+      if (saved.ok !== true) return saved
+      return { ok: true, path: career.PURPOSE_REL }
+    },
+
+    /** 让 AI 照简历写一份投这个岗位/学校的简历。 */
+    'career.resume': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const profile = await career.readProfile(ws)
+      if (profile.ok !== true) return profile
+      if (profile.data === null) return { ok: false, error: '还没有简历。先填一下基本情况、学过什么、做过什么。' }
+      const target = String(body?.target ?? '').trim()
+      if (target === '') return { ok: false, error: '先写清楚要投哪儿——公司加岗位，或者学校加专业。' }
+      const built = career.buildResumePrompt({ profile: profile.sections, target })
+      const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `这次没写出来：${called.error ?? '过一会儿再试一次'}` }
+      return { ok: true, target, text: String(called.text ?? '').trim() }
+    },
+
+    /** 看差距：目标要求的 vs 你现在有的。 */
+    'career.gap': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const profile = await career.readProfile(ws)
+      if (profile.ok !== true) return profile
+      if (profile.data === null) return { ok: false, error: '还没有简历。先填一下基本情况、学过什么、做过什么。' }
+      const target = String(body?.target ?? '').trim()
+      if (target === '') return { ok: false, error: '先写清楚要够到哪儿——公司加岗位，或者学校加专业。' }
+      const built = career.buildGapPrompt({ profile: profile.sections, target })
+      const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `这次没算出来：${called.error ?? '过一会儿再试一次'}` }
+      return { ok: true, target, text: String(called.text ?? '').trim() }
+    },
+
+    /** 规划怎么走。 */
+    'career.path': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
+      const profile = await career.readProfile(ws)
+      if (profile.ok !== true) return profile
+      if (profile.data === null) return { ok: false, error: '还没有简历。先填一下基本情况、学过什么、做过什么。' }
+      const goal = String(body?.goal ?? '').trim()
+      if (goal === '') return { ok: false, error: '先写一句「想到哪儿去」——具体的岗位、学校或状态。' }
+      const horizon = String(body?.horizon ?? '1年').trim()
+      const built = career.buildPathPrompt({ profile: profile.sections, goal, horizon })
+      const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `这次没规划出来：${called.error ?? '过一会儿再试一次'}` }
+      const text = String(called.text ?? '').trim()
+      return { ok: true, goal, horizon, text, steps: career.parseSteps(text) }
+    },
+
+    // ── 文字小说游戏：进到情节里，你来选，它来推 ────────────────
+
+    /** 一本书能开哪几局。 */
+    'game.list': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      const id = String(body?.book ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await game.listPlays(ws, id)
+    },
+
+    /** 读一局（回到上次那个地方）。 */
+    'game.get': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      const book = String(body?.book ?? '').trim()
+      const id = String(body?.id ?? '').trim()
+      if (book === '' || id === '') return { ok: false, error: '这一局找不到了' }
+      const got = await game.readPlay(ws, book, id)
+      if (got.ok !== true) return got
+      const last = [...got.turns].reverse().find((t) => t.kind === 'narrate')
+      return {
+        ok: true, id, book, path: got.path,
+        chapter: Number(got.data?.chapter) || 0,
+        preset: String(got.data?.preset ?? ''),
+        scene: got.scene,
+        holding: got.holding,
+        turns: got.turns,
+        choices: game.parseChoices(String(last?.text ?? '')).choices,
+      }
+    },
+
+    /** 开一局：从某一章接着演。 */
+    'game.start': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      if (mods.novel !== true) return missingFeature('novel')
+      const bookId = String(body?.book ?? '').trim()
+      if (bookId === '') return { ok: false, error: '没有说是哪本书' }
+      const book = await novel.readBook(ws, bookId)
+      if (book.ok !== true) return book
+      const chapter = Number(body?.chapter) || (book.chapters.length === 0 ? 0 : book.chapters[0].index)
+      // 开局那一段：优先用这一章的正文；没有就让 AI 自己起头。
+      let fromChapter = ''
+      if (chapter > 0) {
+        const got = await novel.readChapter(ws, bookId, chapter)
+        if (got.ok === true) fromChapter = novel.tailOf(got.body, 1600)
+      }
+      const picked = mods.presets === true ? await presets.resolve(ws, body?.preset) : { ok: true, preset: null }
+      const presetNote = picked.ok === true && picked.preset !== null ? String(picked.preset.prompt ?? '') : ''
+      const system = game.buildGmSystem({ bookTitle: String(book.data?.title ?? bookId), scene: '', holding: [], preset: presetNote })
+      const user = game.buildGmUser({ turns: [], move: '', fromChapter })
+      const called = await callModel(ctx, { system, user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `这一局开不起来：${called.error ?? '过一会儿再试一次'}` }
+      const parsed = game.parseChoices(called.text)
+      const id = game.newPlayId()
+      const now = new Date()
+      const turns = [{ kind: 'narrate', text: parsed.body }]
+      const data = {
+        id, book: bookId, chapter, preset: String(body?.preset ?? ''),
+        created_at: now.toISOString(), updated_at: now.toISOString(), turn: 0, scene: '', holding: [],
+      }
+      const saved = await game.writePlay(ws, bookId, id, data, turns)
+      if (saved.ok !== true) return saved
+      return { ok: true, id, book: bookId, chapter, path: saved.path, text: parsed.body, choices: parsed.choices, turns }
+    },
+
+    /** 走一步。 */
+    'game.say': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      const bookId = String(body?.book ?? '').trim()
+      const id = String(body?.id ?? '').trim()
+      if (bookId === '' || id === '') return { ok: false, error: '这一局找不到了' }
+      // 同一局的两步必须排队：这里也是「读 → 调模型（几十秒）→ 整文件写回」。
+      // 键要带 bookId —— 两本书里各自有一局 `play-1` 是很正常的。
+      return oneAtATime(`game:${bookId}/${id}`, async () => {
+      const got = await game.readPlay(ws, bookId, id)
+      if (got.ok !== true) return got
+      const turns = Array.isArray(got.turns) ? got.turns : []
+      const moves = turns.filter((t) => t.kind === 'choose' || t.kind === 'say').length
+      if (moves >= game.MAX_TURNS) {
+        return { ok: false, error: `这一局已经走了 ${moves} 步，太长了记不住前面。在这里收个尾，或者另开一局。`, turns }
+      }
+      const move = String(body?.move ?? '').trim()
+      if (move === '') return { ok: false, error: '先选一个方向，或者自己写一句' }
+      const book = mods.novel === true ? await novel.readBook(ws, bookId) : { ok: true, data: { title: bookId } }
+      if (book.ok !== true) return book
+      const picked = mods.presets === true ? await presets.resolve(ws, String(got.data?.preset ?? '')) : { ok: true, preset: null }
+      const presetNote = picked.ok === true && picked.preset !== null ? String(picked.preset.prompt ?? '') : ''
+      const system = game.buildGmSystem({ bookTitle: String(book.data?.title ?? bookId), scene: got.scene, holding: got.holding, preset: presetNote })
+      const user = game.buildGmUser({ turns, move })
+      const called = await callModel(ctx, { system, user, model: body?.model })
+      // 模型没接上也要把你这一步记下来：不然你选过什么，下一轮它完全不知道。
+      const parsed = game.parseChoices(called.ok === true ? called.text : '')
+      const nextTurns = [...turns, { kind: 'choose', text: move, result: called.ok === true ? parsed.body : '' }]
+      const now = new Date()
+      const data = { ...got.data, updated_at: now.toISOString(), turn: moves + 1 }
+      const saved = await game.writePlay(ws, bookId, id, data, nextTurns)
+      if (saved.ok !== true) return saved
+      if (called.ok !== true) {
+        return { ok: false, error: `这一步记下了，但它没接上话：${called.error ?? '过一会儿再试一次'}`, turns: nextTurns, kept: true }
+      }
+      return { ok: true, id, text: parsed.body, choices: parsed.choices, turns: nextTurns }
+      })
+    },
+
+    /**
+     * 把这一局演出来的东西，写成这本书的一章。
+     *
+     * 和酒馆那条是一个意思：演着演着发现这一段真好，就把它定下来变成正文，
+     * 而不是让人自己回去照着复述一遍。
+     */
+    'game.toChapter': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      if (mods.novel !== true) return missingFeature('novel')
+      const bookId = String(body?.book ?? '').trim()
+      const id = String(body?.id ?? '').trim()
+      if (bookId === '' || id === '') return { ok: false, error: '这一局找不到了' }
+      const got = await game.readPlay(ws, bookId, id)
+      if (got.ok !== true) return got
+      const turns = Array.isArray(got.turns) ? got.turns : []
+      if (turns.length === 0) return { ok: false, error: '这一局还什么都没发生，先走一步再变成一章。' }
+      const book = await novel.readBook(ws, bookId)
+      if (book.ok !== true) return book
+      const prompt = game.buildPlayToChapterPrompt({
+        bookTitle: String(book.data?.title ?? bookId),
+        turns,
+        note: body?.note,
+      })
+      const called = await callModel(ctx, { system: prompt.system, user: prompt.user, model: body?.model })
+      if (called.ok !== true) return { ok: false, error: `没写成：${called.error ?? '过一会儿再试一次'}`, kept: true }
+      const text = String(called.text ?? '').trim()
+      if (text === '') return { ok: false, error: '这次什么都没写出来，过一会儿再试一次。' }
+      const list = Array.isArray(book.chapters) ? book.chapters : []
+      const last = list.length === 0 ? 0 : Number(list[list.length - 1]?.index ?? 0)
+      const next = (Number.isFinite(last) ? last : 0) + 1
+      const saved = await novel.writeChapter(ws, bookId, next, text)
+      if (saved.ok !== true) return saved
+      return { ok: true, chapter: next, text, warning: saved.warning }
+    },
+
+    /** 这一局不要了。 */
+    'game.delete': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.game !== true) return missingFeature('game')
+      const book = String(body?.book ?? '').trim()
+      const id = String(body?.id ?? '').trim()
+      if (book === '' || id === '') return { ok: false, error: '这一局找不到了' }
+      return await game.deletePlay(ws, book, id)
+    },
+
+    // ── 预设：三种玩法各自的演法/写法 ─────────────────────────
+
+    /** 哪些功能装了、哪些没装。界面按这个决定显示什么。 */
+    'features.list': async (body) => {
+      const mods = await ensureModules()
+      return {
+        ok: true,
+        features: {
+          real: true,
+          jobs: true,
+          tavern: mods.tavern === true,
+          novel: mods.novel === true,
+          presets: mods.presets === true,
+          game: mods.game === true && mods.novel === true,
+          career: mods.career === true,
+        },
+      }
+    },
+
+    /** 列预设（内置 + 自己的）。 */
+    'preset.list': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.presets !== true) return missingFeature('presets')
+      return await presets.listAll(ws)
+    },
+
+    /** 把一份内置的复制成自己的，之后能随便改。 */
+    'preset.copy': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.presets !== true) return missingFeature('presets')
+      return await presets.copyBuiltin(ws, body?.id, body?.as)
+    },
+
+    /** 存一份自己的预设（新建或改）。 */
+    'preset.save': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.presets !== true) return missingFeature('presets')
+      return await presets.saveCustom(ws, { id: body?.id, mode: body?.mode, name: body?.name, desc: body?.desc, prompt: body?.prompt })
+    },
+
+    /** 删一份自己的预设。 */
+    'preset.delete': async (body) => {
+      const ws = await root(body); const mods = await ensureModules(); if (mods.presets !== true) return missingFeature('presets')
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪一份' }
+      return await presets.deleteCustom(ws, id)
+    },
+
+    'novel.chapter.get': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.readChapter(ws, id, body?.index)
+    },
+
+    /** 自己写（或改）一章，直接在编辑器里手写。 */
+    'novel.chapter.save': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      return await novel.writeChapter(ws, id, body?.index, String(body?.body ?? ''))
+    },
+
+    /**
+     * 让 AI 接着写。
+     *
+     * 三样东西一起给它：这本书的设定、上一章的结尾、这一章已经写到哪。
+     * 少给一样它就会开始自己编——只给设定它不知道刚才发生了什么，
+     * 只给上一章它不知道这本书要往哪走。
+     */
+    'novel.chapter.draft': async (body) => {
+      if ((await ensureModules()).novel !== true) return missingFeature('novel')
+      const ws = await root(body)
+      const id = String(body?.id ?? '').trim()
+      if (id === '') return { ok: false, error: '没有说是哪本书' }
+      const book = await novel.readBook(ws, id)
+      if (book.ok !== true) return book
+      const index = Number(body?.index) || (book.chapters.length === 0 ? 1 : book.chapters[book.chapters.length - 1].index)
+
+      // 这一章已经写成什么样（没有就是空的）
+      let currentBody = ''
+      const got = await novel.readChapter(ws, id, index)
+      if (got.ok === true) currentBody = String(got.body ?? '')
+
+      // 上一章的结尾
+      let previousTail = ''
+      const chapters = book.chapters.filter((c) => c.index < index)
+      if (chapters.length > 0) {
+        const prev = await novel.readChapter(ws, id, chapters[chapters.length - 1].index)
+        if (prev.ok === true) previousTail = novel.tailOf(prev.body)
+      }
+
+      // 世界设定（写小说时全量给，不像酒馆那样按关键词挑——写作需要知道全貌）
+      const worldNotes = []
+      const worldRel = typeof body?.world === 'string' && body.world.trim() !== '' ? body.world.trim() : ''
+      if (worldRel !== '') {
+        const world = await store.readCard(ws, worldRel)
+        if (world.ok === true) {
+          const entries = core.parseWorldEntries(world.sections)
+          for (const entry of entries) {
+            const content = String(entry?.content ?? '').trim()
+            if (content !== '') worldNotes.push(content)
+          }
+        }
+      }
+
+      // 出场的人（这本书挂的角色卡）
+      const cast = await gatherCast(ws, body?.cast)
+
+      // 大纲：写第几章要对着计划写，不然一章一章会拖成流水账
+      const outline = await novel.readOutline(ws, id)
+      const outlineText = outline.ok === true && outline.text !== '' ? outline.text : ''
+      const planItem = outline.ok === true ? (outline.chapters ?? []).find((c) => c.index === index) : undefined
+      const writePreset = await presets.resolve(ws, body?.preset)
+      const presetNote = writePreset.ok === true && writePreset.preset !== null ? String(writePreset.preset.prompt ?? '') : ''
+      const system = [
+        '你是一个写小说的人。你的任务是把故事写下去，不是解释、不是评论、不是总结。',
+        presetNote === '' ? '' : `\n【这一段怎么写】\n${presetNote}`,
+      ].filter((x) => x !== '').join('\n')
+      const user = novel.buildChapterPrompt({
+        title: String(book.data?.title ?? id),
+        idea: String(book.idea ?? ''),
+        genre: String(book.data?.genre ?? ''),
+        previousTail,
+        currentBody: String(currentBody ?? '').slice(-2000),
+        ask: body?.ask,
+        worldEntries: worldNotes,
+        cast,
+        outline: outlineText,
+        chapterPlan: planItem === undefined ? '' : planItem.plan,
+      })
+      const called = await callModel(ctx, { system, user, model: body?.model })
+      if (called.ok !== true) {
+        return { ok: false, error: `这次没写出来：${called.error ?? '过一会儿再试一次'}`, index }
+      }
+      const draft = String(called.text ?? '').trim()
+      if (draft === '') return { ok: false, error: 'AI 这次没写出东西来，再点一次试试。', index }
+      return {
+        ok: true,
+        index,
+        draft,
+        // 不直接落盘：写字的人要能先看、能改、能只取一半。落盘由 chapter.save 做。
+        hasCurrent: String(currentBody).trim() !== '',
+        usedWorld: worldNotes.length,
+        usedCast: cast.length,
+      }
+    },
+  }
+}
+
+/**
+ * 把「这本书挂的几张角色卡」收成几段人设。
+ *
+ * 一本书可以挂好几张卡（主角、对手、配角）。写某一章的时候把它们一起给模型，
+ * 它才不会把「说话很冲的那个人」写成温和的——那是长篇最容易崩的地方。
+ * 每张卡只取前 500 字：卡可能写得很长，全贴会把大纲和上一章挤掉。
+ */
+async function gatherCast(ws, wants) {
+  const out = []
+  const list = Array.isArray(wants) ? wants.slice(0, 8) : []
+  for (const want of list) {
+    const rel = String(want ?? '').trim()
+    if (rel === '') continue
+    const card = await store.readCard(ws, rel)
+    if (card.ok !== true) continue
+    // 酒馆模块被删掉时，这里自己拼一份最小的人设——
+    // 「写小说」不该因为「酒馆」没了就用不了。
+    let name = String(card.data?.name ?? '').trim()
+    let text = ''
+    if (tavern !== null) {
+      const persona = tavern.personaFromCard(card.data, card.sections)
+      name = persona.name
+      text = persona.text
+    } else {
+      const parts = ['自述', '性格', '口癖', '外貌']
+        .map((title) => core.sectionBody(card.sections, title).trim())
+        .filter((x) => x !== '')
+      text = parts.join('\n')
+    }
+    if (text === '') continue
+    out.push(`【${name === '' ? '这个人' : name}】${text.slice(0, 500)}`)
   }
+  return out
 }
 
 /** 酒馆的时间戳：`2026-10-24 16:11`。本地时间，字典序就是时间序。 */