dsh-novel-generator 0.1.27 → 0.1.29

package/README.md

@@ -31,8 +31,14 @@ dsh plugin --profile web add dsh-novel-generator
 
 - 时间线以「天」计（0 = 创建作品那天），你选的「快照间隔」（7 / 15 / 30 / 90 / 180 / 365 天，可手输）决定了一条**网格**：第 15、30、45… 天。
 - **手动**：把时间线拖到网格点上（第 N 天且 N 能被间隔整除），标题栏出现「生成世界快照 · 第 N 天」；该点已有快照时按钮变成「重新生成快照 · 第 N 天」，会替换旧的那份。两种情况都先弹确认。
-- **自动**：每次生成章节后检查两个条件，缺一不可：① 本章结束时间**正好落在网格点上**；② **上一格**（该点 − 一个间隔）已经有快照（第 0 天视为已覆盖）。满足才自动生成这一格的快照。
-- 这样改间隔不会把旧快照重排：网格随当前间隔移动，自动生成只沿着「上一格存在」的链条向前推进，断档的地方留给你手动补。
+- **自动**：只要故事时间被推进到新的网格点就会触发——**新建章节（含只有大纲的空章节）、自动推演、生成正文、手动保存正文**都算。判定是幂等的：已经存在的点不会被普通保存再次生成。
+- **每个点收录哪些章节**（`[上一份快照日, 本点)` 半开区间）：
+  - 只收录**结束时间严格早于本点**的章节——**结束在本点那一天的那一章不算**，它正是这次快照要"为之而拍"的那段，快照生成时它还没写出来；
+  - 也不收录上一份快照已经收录过的章节（`结束日 < 上一快照日` 的跳过），所以**每一章恰好被一份快照收录一次**。
+  - 例：间隔 30、章节各 10 天 → 第 30 天快照收录第 1、2 章；第 60 天快照收录第 3、4、5 章。
+- 这样改间隔不会把旧快照重排：网格随当前间隔移动，自动生成只沿着链条向前推进，断档的地方留给你手动补。
+- **空段落点不调用模型**：如果某个网格点没有可收录的章节（例如一章就占满整个间隔），插件直接把上一版快照抄过来、注明"这段时间没有已写章节"，既省一次模型调用，也避免模型凭空编出世界设定——那种编造会污染后续所有章节的提示。落点那一章不会因此丢失：写下一章时它照样出现在「已发生的章节梗概」里。
+- 同一部作品同一时间只跑一个快照任务，避免并发把同一个点重复生成。
 
 - **重置**：时间线右上角的「重置快照」会清空全部快照，再按当前间隔从第 1 格逐格重建到故事末端（确认框里写明要生成几份）。
 - **物品 / 事件**：快照里除了世界观、角色、势力、关系，还有物品（名称 + 下落/用途）和事件（故事天数 + 标题 + 一句话），事件按时间从新到旧排列。

package/index.js

@@ -1201,7 +1201,10 @@ function stretchBefore(project, chapter, snapshot) {
   return (project.chapters || [])
     .filter((entry) => entry.chapterId !== chapter.chapterId
       && entry.startDay < chapter.startDay
-      && chapterWindow(project, entry).end > base
+      // The snapshot at day `base` covers chapters ending strictly before it, so
+      // a chapter ending exactly on that day is still unwritten history for this
+      // stretch and must be handed to the writer (>= rather than >).
+      && chapterWindow(project, entry).end >= base
       && ((entry.outline && entry.outline.synopsis) || '').trim() !== '')
     .sort((a, b) => a.startDay - b.startDay);
 }
@@ -1496,7 +1499,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-27.11',
+    revision: '2026-10-27.17',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -2046,7 +2049,7 @@ function nextChapterIndex(project) {
   return max + 1;
 }
 
-async function saveOutline(root, body) {
+async function saveOutline(ctx, root, registry, body) {
   const projectId = asText(body.projectId);
   const chapterId = asText(body.chapterId);
   const outline = normalizeOutline(body.outline);
@@ -2100,10 +2103,21 @@ async function saveOutline(root, body) {
     await exportChapterOutline(savedProject, savedChapter);
     await exportProjectInfo(savedProject);
   }
-  return result;
+  // Creating (or re-timing) a chapter that brings the story onto an interval
+  // point is what earns the snapshot for that point: the chapter ending exactly
+  // there is still unwritten, so the snapshot is built from what came before it.
+  let snapshotJobId = null;
+  if (savedChapter) {
+    const fresh = await readProject(root, projectId);
+    const target = autoSnapshotTarget(fresh, chapterWindow(fresh, savedChapter).end);
+    if (target !== null) {
+      snapshotJobId = registerSnapshot(ctx, root, registry, projectId, target).jobId;
+    }
+  }
+  return snapshotJobId === null ? result : { ...result, snapshotJobId };
 }
 
-async function saveChapter(root, body) {
+async function saveChapter(ctx, root, registry, body) {
   const projectId = asText(body.projectId);
   const chapterId = asText(body.chapterId);
   const content = typeof body.content === 'string' ? body.content : '';
@@ -2123,7 +2137,16 @@ async function saveChapter(root, body) {
     return { chapter: { ...chapter, content: undefined }, project: summarize(project) };
   });
   await exportChapter(savedProject, savedChapter, content);
-  return result;
+  // Saving prose is the other way story time advances, so a point that is due
+  // gets its snapshot here too. The check is idempotent: an existing point is
+  // never re-created by an ordinary save.
+  let snapshotJobId = null;
+  if (savedChapter) {
+    const fresh = await readProject(root, projectId);
+    const target = autoSnapshotTarget(fresh, chapterWindow(fresh, savedChapter).end);
+    if (target !== null) snapshotJobId = registerSnapshot(ctx, root, registry, projectId, target).jobId;
+  }
+  return snapshotJobId === null ? result : { ...result, snapshotJobId };
 }
 
 /** Display name the plugin gives the sidebar workspace that holds its sessions. */
@@ -2256,15 +2279,21 @@ function previousChapter(project, chapter) {
 }
 
 /**
- * Chapters that belong to the stretch `(fromDay, point]`: fully written up to
- * the point, so a chapter that straddles it (the one still being written) is
- * left out. The chapter starting exactly at `fromDay` is included.
+ * Chapters that feed the snapshot at `point`: the stretch `[fromDay, point)`.
+ *
+ * A chapter belongs to the snapshot of the *next* point after it ends:
+ *
+ * - `end < point` — the chapter ending exactly on the point is the one this
+ *   snapshot is being taken for; it is still unwritten when the snapshot is
+ *   created, so counting it would pull unwritten plot into the world state.
+ * - `end >= fromDay` — every chapter is read by exactly one snapshot, and the
+ *   previous snapshot's last chapter is not read a second time.
  */
 function chaptersForPoint(project, fromDay, point) {
   return (project.chapters || [])
     .filter((chapter) => {
       const span = chapterWindow(project, chapter);
-      if (span.end > point || span.end <= fromDay) return false;
+      if (span.end >= point || span.end < fromDay) return false;
       return ((chapter.outline && chapter.outline.synopsis) || '').trim() !== ''
         || String(chapter.content || '').trim() !== '';
     })
@@ -2278,6 +2307,13 @@ function chaptersForPoint(project, fromDay, point) {
  * in order instead of skipping to the end.
  */
 function registerSnapshot(ctx, root, registry, projectId, targetDay) {
+  // One snapshot job per work at a time: two concurrent cascades would each read
+  // a half-written snapshot list and produce the same point twice.
+  for (const running of registry.jobs.values()) {
+    if (running.kind === 'snapshot' && running.projectId === projectId && running.state === 'running') {
+      return running;
+    }
+  }
   return startJob(registry, { kind: 'snapshot', projectId }, async (job) => {
     // The sequence is fixed from the state at the start of the job: recomputing
     // it every round would regenerate the last point forever once it exists.
@@ -2297,6 +2333,36 @@ function registerSnapshot(ctx, root, registry, projectId, targetDay) {
       const project = await readProject(root, projectId);
       const base = (project.snapshots || []).filter((snapshot) => snapshot.day < point).pop() || null;
       const chapters = chaptersForPoint(project, base ? base.day : 0, point);
+      // A point whose stretch holds no chapter is a blank update: carry the
+      // previous snapshot forward verbatim instead of asking the model to invent
+      // a world out of nothing — that invented text would then feed every later
+      // chapter. No material, no call.
+      if (chapters.length === 0) {
+        const carried = {
+          snapshotId: randomUUID(),
+          day: point,
+          createdAt: Date.now(),
+          unitDays: unit,
+          world: (base && base.world) || '',
+          characters: (base && base.characters) || [],
+          factions: (base && base.factions) || [],
+          relations: (base && base.relations) || [],
+          items: (base && base.items) || [],
+          events: (base && base.events) || [],
+          summary: base
+            ? `第 ${base.day} 天至第 ${point} 天之间没有已写章节，沿用上一版设定。`
+            : `第 ${point} 天之前还没有已写章节。`,
+        };
+        await mutateProject(root, projectId, (draft) => {
+          draft.snapshots = (draft.snapshots || []).filter((entry) => entry.day !== point);
+          draft.snapshots.push(carried);
+          draft.snapshots.sort((a, b) => a.day - b.day);
+          return carried;
+        });
+        await exportSnapshot(project, carried);
+        made.push(point);
+        continue;
+      }
       job.message = `正在生成第 ${point} 天的世界快照（第 ${made.length + 1}/${points.length} 份，目标第 ${target} 天）`;
       const reply = await askAgent(ctx, root, project, snapshotPrompt(project, base, chapters, point), (note) => {
         job.message = note;
@@ -2733,9 +2799,9 @@ async function dispatch(ctx, root, registry, method, path, url, body) {
     case '/project/import':
       return importProject(ctx, root, body);
     case '/outline/save':
-      return saveOutline(root, body);
+      return saveOutline(ctx, root, registry, body);
     case '/chapter/save':
-      return saveChapter(root, body);
+      return saveChapter(ctx, root, registry, body);
     case '/generate':
       return startGenerate(ctx, root, registry, body);
     case '/chapter/revise':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-novel-generator",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "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",