dsh-novel-generator 0.1.10 → 0.1.12

package/README.md

@@ -36,7 +36,7 @@ dsh plugin --profile web add dsh-novel-generator
 
 - **重置**：时间线右上角的「重置快照」会清空全部快照，再按当前间隔从第 1 格逐格重建到故事末端（确认框里写明要生成几份）。
 - **物品 / 事件**：快照里除了世界观、角色、势力、关系，还有物品（名称 + 下落/用途）和事件（故事天数 + 标题 + 一句话），事件按时间从新到旧排列。
-- **章节正文的依据**：生成正文时会带上「当前快照 + 该快照之后到本章之前的各章梗概」，不再只看上一章。
+- **生成依据（统一规则）**：先找本章之前最近的那份世界快照。若「本章起始日 − 快照落点 > 当前间隔」，判定快照过旧，直接拒绝并提示先去时间长河更新快照；否则自动推演用「最近快照 + 快照落点之后、本章之前各章梗概」，写正文在此基础上再加一段「待生成的本章梗概」，并在提示里区分已发生与待生成两部分。
 
 ## 数据与接口
 

package/index.js

@@ -835,22 +835,59 @@ function normalizeSnapshot(raw) {
 
 /* ------------------------------------------------------------ agent work */
 
+/**
+ * Bind a fresh session to a work whose old one disappeared (deleted in the
+ * sidebar, or gone from the session store). The work's memory — snapshots,
+ * chapters, outlines — lives in files, so a new session loses only chat
+ * history, not the novel itself.
+ */
+async function rebindSession(ctx, root, project) {
+  const controller = ctx.get('sessionController');
+  if (controller === undefined) throw httpError(503, '当前部署缺少 sessionController 服务，无法为作品重建会话');
+  const created = await controller.create(project.agentPreset ? { cwd: project.cwd, agentPreset: project.agentPreset } : { cwd: project.cwd });
+  const sessionId = created && created.sessionId ? created.sessionId : null;
+  if (!sessionId) throw httpError(502, '没能为作品重建会话');
+  if (project.model) {
+    try {
+      await controller.selectModel({ sessionId, ...project.model });
+    } catch {
+      // The rebuilt session still works with the profile's default model.
+    }
+  }
+  project.sessionId = sessionId;
+  await mutateProject(root, project.projectId, (draft) => {
+    draft.sessionId = sessionId;
+  });
+  try {
+    await ensureWorkspace(ctx, project);
+  } catch {
+    // Grouping is cosmetic; the session works either way.
+  }
+  const result = await controller.resolveAgent(sessionId);
+  if (!result || !result.agent) throw httpError(502, '重建的会话无法启动');
+  return { controller, agent: result.agent };
+}
+
 /** Resolve (or resume) the ordinary Agent that owns one project's Session. */
-async function resolveAgent(ctx, project) {
+async function resolveAgent(ctx, root, project, onNote) {
   const controller = ctx.get('sessionController');
   if (controller === undefined) throw httpError(503, '当前部署缺少 sessionController 服务，无法驱动创作会话');
-  if (!project.sessionId) throw httpError(409, '这个作品还没有绑定会话');
-  let result;
+  if (!project.sessionId) {
+    const rebuilt = await rebindSession(ctx, root, project);
+    if (onNote) onNote('作品没有绑定会话，已新建一个会话');
+    return rebuilt;
+  }
+  let result = null;
   try {
     result = await controller.resolveAgent(project.sessionId);
-  } catch (error) {
-    throw httpError(502, `无法恢复作品会话：${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!result || !result.agent) {
-    const code = result && result.error && result.error.code ? result.error.code : 'unknown';
-    throw httpError(502, `无法恢复作品会话（${code}）`);
+  } catch {
+    result = null;
   }
-  return { controller, agent: result.agent };
+  if (result && result.agent) return { controller, agent: result.agent };
+  // The old session is gone: rebuild instead of failing every later call.
+  const rebuilt = await rebindSession(ctx, root, project);
+  if (onNote) onNote('原作品会话已不存在，已自动新建一个会话继续');
+  return rebuilt;
 }
 
 function withTimeout(promise, ms, onTimeout) {
@@ -868,32 +905,47 @@ function withTimeout(promise, ms, onTimeout) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
-/** Send one prompt into the project's own Session and return the reply text. */
-async function askAgent(ctx, project, prompt) {
-  const { controller, agent } = await resolveAgent(ctx, project);
-  const admission = new AbortController();
-  await withTimeout(controller.prompt({
-    sessionId: project.sessionId,
-    requestId: `novel-${randomUUID()}`,
-    mode: 'queue',
-    content: [{ type: 'text', text: prompt }],
-    clientTimeZone: 'Asia/Shanghai',
-  }, admission.signal), 60 * 1000, () => admission.abort());
-  await withTimeout(agent.whenIdle(), AGENT_TIMEOUT_MS, () => {
-    try {
-      agent.cancel({ kind: 'hook', reason: 'novel-studio generation timeout' });
-    } catch {
-      // Cancellation is best effort on the failure path.
+/**
+ * Send one prompt into the project's own Session and return the reply text.
+ * A freshly rebuilt session occasionally answers nothing on its first turn, so
+ * one silent reply earns a single retry before the job fails.
+ */
+async function askAgent(ctx, root, project, prompt, onNote) {
+  let rebuilt = false;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const before = project.sessionId;
+    const { controller, agent } = await resolveAgent(ctx, root, project, attempt === 0 ? onNote : undefined);
+    if (project.sessionId !== before) rebuilt = true;
+    const admission = new AbortController();
+    await withTimeout(controller.prompt({
+      sessionId: project.sessionId,
+      requestId: `novel-${randomUUID()}`,
+      mode: 'queue',
+      content: [{ type: 'text', text: prompt }],
+      clientTimeZone: 'Asia/Shanghai',
+    }, admission.signal), 60 * 1000, () => admission.abort());
+    await withTimeout(agent.whenIdle(), AGENT_TIMEOUT_MS, () => {
+      try {
+        agent.cancel({ kind: 'hook', reason: 'novel-studio generation timeout' });
+      } catch {
+        // Cancellation is best effort on the failure path.
+      }
+    });
+    const messages = agent.session.deriveMessages();
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const message = messages[index];
+      if (!message || message.role !== 'assistant') continue;
+      const text = textOfMessage(message);
+      if (text !== '') return text;
+    }
+    if (attempt === 0) {
+      if (onNote) onNote('模型这一轮没有回复，重试一次');
+      await new Promise((resolve) => setTimeout(resolve, 1500));
     }
-  });
-  const messages = agent.session.deriveMessages();
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (!message || message.role !== 'assistant') continue;
-    const text = textOfMessage(message);
-    if (text !== '') return text;
   }
-  throw httpError(502, '模型没有返回任何正文');
+  throw rebuilt
+    ? httpError(502, '作品的旧会话已不存在，已为它新建一个会话，但模型没有回复；请在侧栏打开这部作品的会话（「小说工坊」分组里）后再试一次')
+    : httpError(502, '模型没有返回任何正文');
 }
 
 function snapshotBlock(snapshot) {
@@ -939,66 +991,105 @@ function snapshotAt(project, day) {
   return snapshots[snapshots.length - 1];
 }
 
+/**
+ * How far the nearest snapshot sits behind a chapter's start.
+ *
+ * The rule both prompts share: the nearest snapshot node at or before the
+ * chapter wins. If the chapter starts more than one interval after that node,
+ * the snapshot is too stale to write from and the Client is told to update it
+ * first — the same rule for 自动推演 and for writing the chapter body.
+ */
+function snapshotDistance(project, chapter) {
+  const span = chapterWindow(project, chapter);
+  const unit = Math.max(1, project.timeline.unitDays || 30);
+  const snapshot = snapshotAt(project, span.start) || null;
+  const base = snapshot ? snapshot.day : 0;
+  const gap = Math.max(0, span.start - base);
+  return { snapshot, unit, base, gap, tooFar: gap > unit, startDay: span.start };
+}
+
+/** Chapters from the snapshot node up to (not including) the target chapter. */
+function stretchBefore(project, chapter, snapshot) {
+  const base = snapshot ? snapshot.day : 0;
+  return (project.chapters || [])
+    .filter((entry) => entry.chapterId !== chapter.chapterId
+      && entry.startDay < chapter.startDay
+      && chapterWindow(project, entry).end > base
+      && ((entry.outline && entry.outline.synopsis) || '').trim() !== '')
+    .sort((a, b) => a.startDay - b.startDay);
+}
+
+/**
+ * Refuse to write from a snapshot that has drifted more than one interval
+ * behind the chapter, and say what the user has to do about it.
+ */
+function assertSnapshotFresh(project, chapter) {
+  const distance = snapshotDistance(project, chapter);
+  if (!distance.tooFar) return distance;
+  const from = distance.base > 0 ? `第 ${distance.base} 天` : '故事开篇（还没有任何快照）';
+  throw httpError(409, `最近的世界快照停在${from}，本章从第 ${distance.startDay} 天开始，间隔 ${distance.gap} 天已超过当前快照间隔（${distance.unit} 天）；请先在时间长河点「更新世界快照」再来生成`);
+}
+
+function stretchLines(project, chapter, snapshot) {
+  const lines = [];
+  const stretch = stretchBefore(project, chapter, snapshot);
+  if (stretch.length === 0) return lines;
+  lines.push(snapshot
+    ? `【已发生的章节梗概 · 第 ${snapshot.day} 天之后到上一章】`
+    : '【已发生的章节梗概 · 开篇到上一章】');
+  for (const entry of stretch) {
+    lines.push(`- 第 ${entry.index + 1} 章 ${entry.title || ''}（第 ${entry.startDay}→${entry.startDay + entry.durationDays} 天）：${entry.outline.synopsis}`);
+  }
+  lines.push('');
+  return lines;
+}
+
 function chapterPrompt(project, chapter, previous) {
   const window = chapterWindow(project, chapter);
   const outline = chapter.outline || {};
-  const snapshot = snapshotAt(project, window.start);
-  // Everything written since that snapshot: the chapter is the continuation of
-  // this stretch, not just of the chapter right before it.
-  const recent = (project.chapters || [])
-    .filter((entry) => entry.chapterId !== chapter.chapterId
-      && entry.startDay < window.start
-      && (!snapshot || chapterWindow(project, entry).end > snapshot.day)
-      && (((entry.outline && entry.outline.synopsis) || '').trim() !== ''))
-    .sort((a, b) => a.startDay - b.startDay);
+  const { snapshot } = snapshotDistance(project, chapter);
   const lines = [];
   lines.push('你现在是这部小说的执笔作者。只输出本章正文，不要解释、不要标题、不要分点提纲。');
   lines.push('');
-  lines.push(`【章节】第 ${chapter.index + 1} 章 ${chapter.title || ''}（${dateForDay(project, window.start)} 起，跨度 ${chapter.durationDays} 天）`);
+  lines.push(`【本章】第 ${chapter.index + 1} 章 ${chapter.title || ''}（第 ${window.start}→${window.end} 天，跨度 ${chapter.durationDays} 天）`);
   lines.push('');
-  lines.push('【当前世界快照】');
+  lines.push('【最近的世界快照】');
   lines.push(snapshotBlock(snapshot));
   lines.push('');
-  if (recent.length) {
-    lines.push(snapshot ? `【第 ${snapshot.day} 天之后各章梗概】` : '【此前各章梗概】');
-    for (const entry of recent) {
-      lines.push(`- 第 ${entry.index + 1} 章 ${entry.title || ''}：${entry.outline.synopsis}`);
-    }
-    lines.push('');
+  const stretch = stretchLines(project, chapter, snapshot);
+  if (stretch.length) {
+    lines.push(...stretch);
   } else if (previous) {
     lines.push('【上一章梗概】');
     lines.push(`${previous.title || ''}：${(previous.outline && previous.outline.synopsis) || '（无）'}`);
     lines.push('');
   }
-  lines.push('【本章梗概】');
+  lines.push('【本章梗概 · 待生成的部分】');
   lines.push(outline.synopsis || '（无）');
   lines.push('');
   lines.push('【要求】');
+  lines.push('- 以上"已发生的章节梗概"是既定事实，不得改写；本章正文要接着它往下写。');
+  lines.push('- 按"本章梗概"把这一章的内容写出来，情节推进、场景与对话要完整。');
   lines.push('- 不要调用任何工具，不要反问，不要输出计划或步骤说明，直接给出最终正文。');
   lines.push(`- 字数控制在 ${outline.minWords || 800} 到 ${outline.maxWords || 3000} 字之间。`);
   lines.push('- 与世界观、角色、势力、物品、事件和人物关系保持一致，不要引入与快照冲突的设定。');
-  lines.push('- 有完整的情节推进、场景描写和对话，直接成文。');
   return lines.join('\n');
 }
 
 function deducePrompt(project, chapter) {
-  const day = chapter ? chapterWindow(project, chapter).start : (Number(project.timeline.cursor) || 0);
-  const snapshot = snapshotAt(project, day);
-  const chapters = project.chapters || [];
-  const previous = chapters.length ? chapters[chapters.length - 1] : null;
+  const target = chapter
+    ? chapter
+    : { chapterId: '', startDay: Number(project.timeline.cursor) || 0, durationDays: 0, index: (project.chapters || []).length };
+  const { snapshot } = snapshotDistance(project, target);
   const lines = [];
-  lines.push('你是这部小说的剧情推演器。请依据最新世界快照和最近一章，推演下一章的大纲。');
+  lines.push('你是这部小说的剧情推演器。请依据最近的世界快照，以及从该快照之后已经写过的各章梗概，推演下一章的大纲。');
   lines.push('只输出一个 JSON 对象，不要任何额外文字。');
   lines.push('');
-  lines.push('【最新世界快照】');
+  lines.push('【最近的世界快照】');
   lines.push(snapshotBlock(snapshot));
   lines.push('');
-  if (previous) {
-    lines.push('【最近一章】');
-    lines.push(`${previous.title || ''}（第 ${previous.startDay} 天起，跨度 ${previous.durationDays} 天）`);
-    lines.push(`梗概：${(previous.outline && previous.outline.synopsis) || '（无）'}`);
-    lines.push('');
-  }
+  const stretch = stretchLines(project, target, snapshot);
+  if (stretch.length) lines.push(...stretch);
   lines.push('【输出 JSON 结构】');
   lines.push('{"synopsis": "本章梗概，300 字以内，包含起因、经过、转折", "durationDays": 30, "minWords": 1200, "maxWords": 3500, "title": "本章标题"}');
   lines.push('');
@@ -1148,7 +1239,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-20.28',
+    revision: '2026-10-20.35',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1526,7 +1617,9 @@ function registerSnapshot(ctx, root, registry, projectId, targetDay) {
       const base = (project.snapshots || []).filter((snapshot) => snapshot.day < point).pop() || null;
       const chapters = chaptersForPoint(project, base ? base.day : 0, point);
       job.message = `正在生成第 ${point} 天的世界快照（第 ${made.length + 1}/${points.length} 份，目标第 ${target} 天）`;
-      const reply = await askAgent(ctx, project, snapshotPrompt(project, base, chapters, point));
+      const reply = await askAgent(ctx, root, project, snapshotPrompt(project, base, chapters, point), (note) => {
+        job.message = note;
+      });
       const parsed = parseJsonReply(reply);
       if (!parsed) throw httpError(502, '模型没有返回可解析的快照 JSON');
       const normalized = normalizeSnapshot(parsed);
@@ -1606,19 +1699,29 @@ function startSnapshotReset(ctx, root, registry, body) {
   });
 }
 
-function startGenerate(ctx, root, registry, body) {
+async function startGenerate(ctx, root, registry, body) {
   const projectId = asText(body.projectId);
   const chapterId = asText(body.chapterId);
+  // Refuse before the job is queued, so the Client sees a plain 409 instead of
+  // a job that fails a second later.
+  const preview = await readProject(root, projectId);
+  const claimed = preview.chapters.find((entry) => entry.chapterId === chapterId);
+  if (!claimed) throw httpError(404, `章节不存在: ${chapterId}`);
+  if (!claimed.outline) throw httpError(409, '请先在章节大纲里保存设定，再生成正文');
+  assertSnapshotFresh(preview, claimed);
   return startJob(registry, { kind: 'generate', projectId, chapterId }, async (job) => {
     const project = await readProject(root, projectId);
     const chapter = project.chapters.find((entry) => entry.chapterId === chapterId);
     if (!chapter) throw httpError(404, `章节不存在: ${chapterId}`);
     if (!chapter.outline) throw httpError(409, '请先在章节大纲里保存设定，再生成正文');
+    assertSnapshotFresh(project, chapter);
     const previous = project.chapters
       .filter((entry) => entry.chapterId !== chapter.chapterId && entry.startDay <= chapter.startDay)
       .sort((a, b) => b.startDay - a.startDay)[0] || null;
     job.message = '正在生成章节正文';
-    const content = await askAgent(ctx, project, chapterPrompt(project, chapter, previous));
+    const content = await askAgent(ctx, root, project, chapterPrompt(project, chapter, previous), (note) => {
+      job.message = note;
+    });
     const saved = await mutateProject(root, projectId, (draft) => {
       const target = draft.chapters.find((entry) => entry.chapterId === chapterId);
       if (!target) throw httpError(404, `章节不存在: ${chapterId}`);
@@ -1646,8 +1749,25 @@ function startGenerate(ctx, root, registry, body) {
  * chapter in place (the outline page's 自动推演, which overwrites everything);
  * without it the job appends a new one (the new-chapter dialog).
  */
-function startCompose(ctx, root, registry, body) {
+async function startCompose(ctx, root, registry, body) {
   const projectId = asText(body.projectId);
+  // Same early refusal as writing: a stale snapshot stops the job from being
+  // queued at all.
+  const preview = await readProject(root, projectId);
+  const claimedId = asText(body.chapterId);
+  const claimed = claimedId === ''
+    ? null
+    : (preview.chapters || []).find((entry) => entry.chapterId === claimedId) || null;
+  if (claimedId !== '' && !claimed) throw httpError(404, `章节不存在: ${claimedId}`);
+  const claimedStart = claimed
+    ? claimed.startDay
+    : (Number.isFinite(Number(body.startDay)) ? Math.max(0, Math.round(Number(body.startDay))) : lastChapterEnd(preview));
+  assertSnapshotFresh(preview, claimed || {
+    chapterId: '',
+    startDay: claimedStart,
+    durationDays: Math.round(Number(body.durationDays) || 0) || 1,
+    index: (preview.chapters || []).length,
+  });
   return startJob(registry, { kind: 'compose', projectId }, async (job) => {
     const minWords = Math.round(Number(body.minWords) || 0);
     const maxWords = Math.round(Number(body.maxWords) || 0);
@@ -1686,9 +1806,12 @@ function startCompose(ctx, root, registry, body) {
       outline: null,
     };
     const previous = previousChapter(project, draft);
+    assertSnapshotFresh(project, draft);
 
     job.message = '正在推演本章梗概与名称';
-    const deduceReply = await askAgent(ctx, project, deducePrompt(project, draft));
+    const deduceReply = await askAgent(ctx, root, project, deducePrompt(project, draft), (note) => {
+      job.message = note;
+    });
     const deduced = parseJsonReply(deduceReply) || {};
     const synopsis = asText(firstOf(deduced, ['synopsis', '梗概', 'summary']));
     if (synopsis === '') throw httpError(502, '模型没有给出章节梗概');
@@ -1732,7 +1855,9 @@ function startCompose(ctx, root, registry, body) {
     const fresh = await readProject(root, projectId);
     const target = fresh.chapters.find((entry) => entry.chapterId === chapterId);
     if (!target) throw httpError(500, '章节写入失败');
-    const content = await askAgent(ctx, fresh, chapterPrompt(fresh, target, previous));
+    const content = await askAgent(ctx, root, fresh, chapterPrompt(fresh, target, previous), (note) => {
+      job.message = note;
+    });
 
     await mutateProject(root, projectId, (current) => {
       const entry = current.chapters.find((item) => item.chapterId === chapterId);
@@ -1763,14 +1888,26 @@ function startCompose(ctx, root, registry, body) {
   });
 }
 
-function startDeduce(ctx, root, registry, body) {
+async function startDeduce(ctx, root, registry, body) {
   const projectId = asText(body.projectId);
   const chapterId = asText(body.chapterId);
+  // The outline page's 自动推演 follows the same freshness rule as writing, and
+  // refuses before queuing as well.
+  const preview = await readProject(root, projectId);
+  const claimed = chapterId === '' ? null : preview.chapters.find((entry) => entry.chapterId === chapterId) || null;
+  assertSnapshotFresh(preview, claimed || {
+    chapterId: '',
+    startDay: Number(preview.timeline.cursor) || lastChapterEnd(preview),
+    durationDays: 0,
+    index: (preview.chapters || []).length,
+  });
   return startJob(registry, { kind: 'deduce', projectId, chapterId }, async (job) => {
     const project = await readProject(root, projectId);
     const chapter = chapterId === '' ? null : project.chapters.find((entry) => entry.chapterId === chapterId) || null;
     job.message = '正在推演下一章大纲';
-    const reply = await askAgent(ctx, project, deducePrompt(project, chapter));
+    const reply = await askAgent(ctx, root, project, deducePrompt(project, chapter), (note) => {
+      job.message = note;
+    });
     const parsed = parseJsonReply(reply);
     if (!parsed) throw httpError(502, '模型没有返回可解析的大纲 JSON');
     const synopsis = asText(firstOf(parsed, ['synopsis', '梗概', 'summary']));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-novel-generator",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "description": "Novel studio for DeepSeek Harness: a draggable story timeline, world snapshots, chapter outlines, and chapters written by the work's own agent.",
   "license": "MIT",