dsh-novel-generator 0.1.5 → 0.1.8

package/README.md

@@ -29,13 +29,18 @@ dsh plugin --profile web add dsh-novel-generator
 
 ## 世界快照怎么来
 
-- 时间线以「天」计（0 = 创建作品那天），整条线的右端永远等于最新快照的时间。
-- **每次生成章节后**都会检查：本章结束时间距离上一份快照是否已满一个时间线单位（30 / 90 / 365 天，由你选）。
-- 满了就取**上一份世界快照 + 这段时间内各章的梗概**，让作品会话产出新快照（世界观 / 角色 / 势力 / 关系），时间线随之向前多出一段到新快照时间。
-- 第一份快照同样按这个规则：故事时间走过一个单位后才写入。
+- 时间线以「天」计（0 = 创建作品那天），你选的「快照间隔」（7 / 15 / 30 / 90 / 180 / 365 天，可手输）决定了一条**网格**：第 15、30、45… 天。
+- **手动**：把时间线拖到网格点上（第 N 天且 N 能被间隔整除），标题栏出现「生成世界快照 · 第 N 天」；该点已有快照时按钮变成「重新生成快照 · 第 N 天」，会替换旧的那份。两种情况都先弹确认。
+- **自动**：每次生成章节后检查两个条件，缺一不可：① 本章结束时间**正好落在网格点上**；② **上一格**（该点 − 一个间隔）已经有快照（第 0 天视为已覆盖）。满足才自动生成这一格的快照。
+- 这样改间隔不会把旧快照重排：网格随当前间隔移动，自动生成只沿着「上一格存在」的链条向前推进，断档的地方留给你手动补。
+
+- **重置**：时间线右上角的「重置快照」会清空全部快照，再按当前间隔从第 1 格逐格重建到故事末端（确认框里写明要生成几份）。
+- **物品 / 事件**：快照里除了世界观、角色、势力、关系，还有物品（名称 + 下落/用途）和事件（故事天数 + 标题 + 一句话），事件按时间从新到旧排列。
+- **章节正文的依据**：生成正文时会带上「当前快照 + 该快照之后到本章之前的各章梗概」，不再只看上一章。
 
 ## 数据与接口
 
+
 - **索引文件**：`<DSH_HOME>/novel-studio/projects/<项目id>/project.json`（`DSH_HOME` 缺省为 `~/.dsh`，本机即 `C:\Users\Admin\.dsh\novel-studio`）。时间线、大纲、快照字段都记在这里；`dataDir` 配置可改这块的位置。
 - **正文、梗概、快照全部写到工作目录下、以作品名称命名的文件夹里**：
 

package/client.js

@@ -716,7 +716,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
     /* ------------------------------------------------------------ world page */
 
-    function WorldPage({ detail, onTimeline, onEnterStory, onRefreshSnapshot, snapshotBusy, requestConfirm }) {
+    function WorldPage({ detail, onTimeline, onEnterStory, onRefreshSnapshot, onResetSnapshots, snapshotBusy, requestConfirm }) {
       const snapshots = detail.snapshots || [];
       const facts = detail.timelineFacts || {};
       const latest = facts.latestSnapshotDay !== undefined
@@ -748,13 +748,16 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
       const snapshot = snapshotAt(detail, day);
       const chapters = detail.chapters || [];
-      // Two moments offer the button: the story has reached the next snapshot
-      // point (a new snapshot), or the slider sits on the newest snapshot
-      // (regenerate it after editing the chapters behind it).
-      const atLatestSnapshot = latest > 0 && day === latest;
+      // The button belongs on the interval grid: the cursor must sit exactly on
+      // a multiple of the current interval. There it either fills a missing
+      // snapshot or replaces the one already written for that day.
+      const onGridPoint = unitDays >= 1 && day > 0 && day % unitDays === 0;
+      const hasSnapshotHere = (detail.snapshots || []).some((entry) => entry.day === day);
       const canSnapshot = chapters.length > 0
-        && ((storyEnd >= nextDay && day >= nextDay) || atLatestSnapshot);
-      const snapshotLabel = atLatestSnapshot
+        && onGridPoint
+        && (hasSnapshotHere || day <= storyEnd);
+      const regenerating = hasSnapshotHere;
+      const snapshotLabel = regenerating
         ? t('重新生成快照 · 第 {day} 天', 'Regenerate snapshot · day {day}', { day })
         : t('生成世界快照 · 第 {day} 天', 'Generate snapshot · day {day}', { day });
       const nearest = useMemo(() => {
@@ -773,18 +776,18 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
       const askSnapshot = useCallback(() => {
         requestConfirm({
-          title: atLatestSnapshot
+          title: regenerating
             ? t('是否重新生成第 {day} 天的世界快照？', 'Regenerate the world snapshot for day {day}?', { day })
             : t('是否为当前时间生成世界快照？', "Generate a world snapshot for this point in time?"),
-          text: atLatestSnapshot
+          text: regenerating
             ? t('会以第 {day} 天之前那版快照和这段时间的章节梗概重写这一天，原有快照被替换。', 'It rewrites day {day} from the snapshot before it and the synopses of this stretch; the existing snapshot is replaced.', { day })
             : t('将为第 {day} 天生成一份世界快照：以上一份快照和这段时间的章节梗概为依据，时间线会延伸到这一天。', 'A world snapshot will be generated for day {day} from the previous snapshot and the synopses of this stretch; the timeline extends to that day.', { day }),
-          confirmLabel: atLatestSnapshot
+          confirmLabel: regenerating
             ? t('重新生成', 'Regenerate')
             : t('生成快照', "Generate snapshot"),
           action: () => onRefreshSnapshot(day),
         });
-      }, [requestConfirm, day, detail, onRefreshSnapshot, atLatestSnapshot]);
+      }, [requestConfirm, day, detail, onRefreshSnapshot, regenerating]);
 
       return h(React.Fragment, null,
         h('div', { className: 'dsn-pagehead' },
@@ -797,6 +800,13 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
             'aria-pressed': showChart,
             onClick: () => setShowChart((value) => !value),
           }, showChart ? t('隐藏统计图', "Hide chart") : t('显示统计图', "Show chart")),
+          h('button', {
+            className: 'dsn-btn ghost',
+            type: 'button',
+            disabled: snapshotBusy || chapters.length === 0,
+            title: t('清除全部世界快照，按当前间隔逐格重建', 'Clear every snapshot and rebuild them point by point at the current interval'),
+            onClick: onResetSnapshots,
+          }, t('重置快照', "Reset snapshots")),
           canSnapshot
             ? h('button', {
               className: 'dsn-btn',
@@ -837,6 +847,27 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
                 key: index,
                 className: 'dsn-entry',
               }, h('span', null, relation))))
+              : h('div', { className: 'dsn-muted' }, t('暂无', "None yet"))),
+          h('div', { className: 'dsn-card' },
+            h('h4', null, t('物品', "Items")),
+            snapshot && snapshot.items && snapshot.items.length
+              ? h('div', { className: 'dsn-entries' }, snapshot.items.map((item, index) => h('div', {
+                key: `${item.name}-${index}`,
+                className: 'dsn-entry',
+              }, h('b', null, item.name), h('span', null, item.desc))))
+              : h('div', { className: 'dsn-muted' }, t('暂无', "None yet"))),
+          h('div', { className: 'dsn-card', style: { gridColumn: 'span 2' } },
+            h('h4', null, t('事件', "Events")),
+            snapshot && snapshot.events && snapshot.events.length
+              ? h('div', { className: 'dsn-entries' }, snapshot.events
+                .slice()
+                .sort((a, b) => (b.day === null || b.day === undefined ? -1 : b.day) - (a.day === null || a.day === undefined ? -1 : a.day))
+                .map((event, index) => h('div', {
+                  key: `${event.title}-${index}`,
+                  className: 'dsn-entry',
+                },
+                h('b', null, event.day === null || event.day === undefined ? t('时间不详', 'Day unknown') : t('第 {day} 天', 'Day {day}', { day: event.day })),
+                h('span', null, `${event.title}${event.desc ? `：${event.desc}` : ''}`))))
               : h('div', { className: 'dsn-muted' }, t('暂无', "None yet")))),
         showChart ? h(ChapterChart, { detail }) : null);
     }
@@ -1552,34 +1583,62 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
         }
       }, [detail.projectId, onReload, notify]);
 
+      /** Poll one snapshot job until it settles, then refresh the work. */
+      const waitSnapshotJob = useCallback((jobId, doneText) => {
+        const timer = setInterval(async () => {
+          try {
+            const job = await api(`/job?id=${encodeURIComponent(jobId)}`);
+            if (job.state === 'running') return;
+            clearInterval(timer);
+            setSnapshotBusy(false);
+            if (job.state === 'done') {
+              notify(doneText, 'success');
+              await onReload();
+            } else {
+              notify(job.error || t('世界快照更新失败', "World snapshot update failed"), 'error');
+            }
+          } catch (error) {
+            clearInterval(timer);
+            setSnapshotBusy(false);
+            notify(messageOf(error), 'error');
+          }
+        }, 2500);
+      }, [onReload, notify]);
+
       const refreshSnapshot = useCallback(async (day) => {
         setSnapshotBusy(true);
         try {
           const started = await api('/snapshot/refresh', { projectId: detail.projectId, day });
           notify(t('正在结算世界快照…', "Settling the world snapshot…"), 'success');
-          const timer = setInterval(async () => {
+          waitSnapshotJob(started.jobId, t('世界快照已更新，时间线向前延伸', "World snapshot updated; the timeline moved forward."));
+        } catch (error) {
+          setSnapshotBusy(false);
+          notify(messageOf(error), 'error');
+        }
+      }, [detail.projectId, notify, waitSnapshotJob]);
+
+      /** 重置快照：清空后按当前间隔从第 1 格重建到故事末端。 */
+      const resetSnapshots = useCallback(() => {
+        const facts = detail.timelineFacts || {};
+        const unit = Math.max(1, facts.unitDays || detail.timeline.unitDays || 30);
+        const end = Math.floor((facts.storyEnd || 0) / unit) * unit;
+        setConfirmRequest({
+          title: t('重置全部世界快照？', 'Reset every world snapshot?'),
+          text: t('将清除所有世界快照，并按当前间隔（每 {unit} 天）从第 {unit} 天起逐格重建到第 {end} 天，共 {count} 份。每份都要调用一次模型，耗时较长。', 'Every world snapshot is deleted and rebuilt point by point — {count} of them, from day {unit} to day {end} at the current {unit}-day interval. Each one calls the model, so this takes a while.', { unit, end, count: Math.max(0, Math.floor(end / unit)) }),
+          confirmLabel: t('清除并重建', 'Clear and rebuild'),
+          action: async () => {
+            setSnapshotBusy(true);
             try {
-              const job = await api(`/job?id=${encodeURIComponent(started.jobId)}`);
-              if (job.state === 'running') return;
-              clearInterval(timer);
-              setSnapshotBusy(false);
-              if (job.state === 'done') {
-                notify(t('世界快照已更新，时间线向前延伸', "World snapshot updated; the timeline moved forward."), 'success');
-                await onReload();
-              } else {
-                notify(job.error || t('世界快照更新失败', "World snapshot update failed"), 'error');
-              }
+              const started = await api('/snapshot/reset', { projectId: detail.projectId });
+              notify(t('正在重建世界快照…', 'Rebuilding world snapshots…'), 'success');
+              waitSnapshotJob(started.jobId, t('世界快照已全部重建', 'All world snapshots rebuilt'));
             } catch (error) {
-              clearInterval(timer);
               setSnapshotBusy(false);
               notify(messageOf(error), 'error');
             }
-          }, 2500);
-        } catch (error) {
-          setSnapshotBusy(false);
-          notify(messageOf(error), 'error');
-        }
-      }, [detail.projectId, onReload, notify]);
+          },
+        });
+      }, [detail, setConfirmRequest, notify, waitSnapshotJob]);
 
       const trackIndex = view === 'world' ? 0 : view === 'story' ? 1 : 2;
 
@@ -1591,6 +1650,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
               onTimeline: saveTimeline,
               onEnterStory: enterStory,
               onRefreshSnapshot: refreshSnapshot,
+              onResetSnapshots: resetSnapshots,
               snapshotBusy,
               requestConfirm: setConfirmRequest,
             })),

package/index.js

@@ -386,6 +386,18 @@ async function exportSnapshot(project, snapshot) {
     lines.push('');
     for (const relation of snapshot.relations || []) lines.push(`- ${relation}`);
     lines.push('');
+    lines.push('## 物品');
+    lines.push('');
+    for (const item of snapshot.items || []) {
+      lines.push(`- ${item.name}${item.desc ? `：${item.desc}` : ''}`);
+    }
+    lines.push('');
+    lines.push('## 事件');
+    lines.push('');
+    for (const event of snapshot.events || []) {
+      lines.push(`- ${event.day === null || event.day === undefined ? '时间不详' : `第 ${event.day} 天`} ${event.title}${event.desc ? `：${event.desc}` : ''}`);
+    }
+    lines.push('');
     if (snapshot.summary) {
       lines.push('## 这段时间的变化');
       lines.push('');
@@ -401,6 +413,8 @@ async function exportSnapshot(project, snapshot) {
       characters: snapshot.characters || [],
       factions: snapshot.factions || [],
       relations: snapshot.relations || [],
+      items: snapshot.items || [],
+      events: snapshot.events || [],
       summary: snapshot.summary || '',
     }, null, 2), 'utf8');
     // Same one-time move for the snapshot folder the earlier build created
@@ -784,11 +798,37 @@ function normalizeSnapshot(raw) {
       return [from, to, type].filter((part) => part !== '').join(' ');
     })
     .filter((entry) => entry !== '');
+  const items = list(firstOf(source, ['items', '物品', '道具', '物品列表']))
+    .map((entry) => {
+      if (typeof entry === 'string') return { name: entry.trim(), desc: '' };
+      return {
+        name: asText(firstOf(entry, ['name', '名称', '名字', '物品'])),
+        desc: asText(firstOf(entry, ['desc', 'description', '描述', '简介', '用途'])),
+      };
+    })
+    .filter((entry) => entry.name !== '');
+  const events = list(firstOf(source, ['events', '事件', '事件列表']))
+    .map((entry) => {
+      if (typeof entry === 'string') return { day: null, title: entry.trim(), desc: '' };
+      const rawDay = firstOf(entry, ['day', 'time', '时间', '天数', 'at'], null);
+      const parsed = Number.isFinite(Number(rawDay)) ? Math.round(Number(rawDay)) : null;
+      const fallback = typeof rawDay === 'string' ? (rawDay.match(/\d+/g) || []).map(Number).pop() : undefined;
+      return {
+        day: parsed === null ? (Number.isFinite(fallback) ? fallback : null) : parsed,
+        title: asText(firstOf(entry, ['title', 'name', '事件', '标题', '名称'])),
+        desc: asText(firstOf(entry, ['desc', 'description', '描述', '内容', '简介'])),
+      };
+    })
+    .filter((entry) => entry.title !== '')
+    // Newest first: the list reads like the story's own clock.
+    .sort((a, b) => (b.day === null ? -1 : b.day) - (a.day === null ? -1 : a.day));
   return {
     world,
     characters,
     factions,
     relations,
+    items,
+    events,
     summary: asText(firstOf(source, ['summary', '梗概', '概述'])),
   };
 }
@@ -877,6 +917,18 @@ function snapshotBlock(snapshot) {
     lines.push('【关系】');
     for (const relation of snapshot.relations) lines.push(`- ${relation}`);
   }
+  if (snapshot.items && snapshot.items.length) {
+    lines.push('【物品】');
+    for (const item of snapshot.items) {
+      lines.push(`- ${item.name}${item.desc ? `：${item.desc}` : ''}`);
+    }
+  }
+  if (snapshot.events && snapshot.events.length) {
+    lines.push('【事件】');
+    for (const event of snapshot.events) {
+      lines.push(`- ${event.day === null || event.day === undefined ? '时间不详' : `第 ${event.day} 天`} ${event.title}${event.desc ? `：${event.desc}` : ''}`);
+    }
+  }
   return lines.join('\n');
 }
 
@@ -891,6 +943,14 @@ 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 lines = [];
   lines.push('你现在是这部小说的执笔作者。只输出本章正文，不要解释、不要标题、不要分点提纲。');
   lines.push('');
@@ -899,7 +959,13 @@ function chapterPrompt(project, chapter, previous) {
   lines.push('【当前世界快照】');
   lines.push(snapshotBlock(snapshot));
   lines.push('');
-  if (previous) {
+  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('');
+  } else if (previous) {
     lines.push('【上一章梗概】');
     lines.push(`${previous.title || ''}：${(previous.outline && previous.outline.synopsis) || '（无）'}`);
     lines.push('');
@@ -910,7 +976,7 @@ function chapterPrompt(project, chapter, previous) {
   lines.push('【要求】');
   lines.push('- 不要调用任何工具，不要反问，不要输出计划或步骤说明，直接给出最终正文。');
   lines.push(`- 字数控制在 ${outline.minWords || 800} 到 ${outline.maxWords || 3000} 字之间。`);
-  lines.push('- 与世界观、角色、势力和人物关系保持一致，不要引入与快照冲突的设定。');
+  lines.push('- 与世界观、角色、势力、物品、事件和人物关系保持一致，不要引入与快照冲突的设定。');
   lines.push('- 有完整的情节推进、场景描写和对话，直接成文。');
   return lines.join('\n');
 }
@@ -941,10 +1007,10 @@ function deducePrompt(project, chapter) {
   return lines.join('\n');
 }
 
-function snapshotPrompt(project, previous, chapters) {
+function snapshotPrompt(project, previous, chapters, pointDay) {
   const lines = [];
-  lines.push('你是这部小说的世界观维护者。请阅读以下章节梗概，输出更新后的世界快照。');
-  lines.push('只输出一个 JSON 对象，不要任何额外文字。');
+  lines.push(`你是这部小说的世界观维护者。当前要产出第 ${pointDay} 天的世界快照。`);
+  lines.push('请阅读以下章节梗概，输出更新后的世界快照。只输出一个 JSON 对象，不要任何额外文字。');
   lines.push('');
   if (previous) {
     lines.push('【上一版世界快照】');
@@ -952,6 +1018,10 @@ function snapshotPrompt(project, previous, chapters) {
     lines.push('');
   }
   lines.push('【这段时间的新章节】');
+  if (chapters.length === 0) {
+    lines.push('（这段时间没有已完成的章节：沿用上一版设定，只按时间推进做必要的细微更新。）');
+    lines.push('');
+  }
   for (const chapter of chapters) {
     const window = chapterWindow(project, chapter);
     lines.push(`--- 第 ${chapter.index + 1} 章 ${chapter.title || ''}（第 ${window.start} → ${window.end} 天，${dateForDay(project, window.start)} 至 ${dateForDay(project, window.end)}）---`);
@@ -966,9 +1036,12 @@ function snapshotPrompt(project, previous, chapters) {
     lines.push('');
   }
   lines.push('【输出 JSON 结构】');
-  lines.push('{"world":"世界观，按时间推进更新，500 字以内","characters":[{"name":"","desc":""}],"factions":[{"name":"","desc":""}],"relations":["A B 敌对"],"summary":"这段时期发生的关键变化"}');
+  lines.push('{"world":"世界观，按时间推进更新，500 字以内","characters":[{"name":"","desc":""}],"factions":[{"name":"","desc":""}],"relations":["A B 敌对"],"items":[{"name":"","desc":""}],"events":[{"day":30,"title":"","desc":""}],"summary":"这段时期发生的关键变化"}');
   lines.push('');
-  lines.push('要求：保留上一版中尚未被推翻的设定；角色、势力要包含新登场者；关系用「甲 乙 关系」三段式。');
+  lines.push('要求：');
+  lines.push('- 保留上一版中尚未被推翻的设定；角色、势力要包含新登场者；关系用「甲 乙 关系」三段式。');
+  lines.push('- items 记录这段时间出现或变化的关键物品（下落、归属、状态）；没有就给空数组。');
+  lines.push(`- events 记录这段时间发生的具体事件，day 用故事天数（整数，不超过 ${pointDay}），title 一行、desc 一两句，最近的排最前；没有就给空数组。`);
   lines.push('不要调用任何工具，不要反问，只输出这个 JSON。');
   return lines.join('\n');
 }
@@ -1073,7 +1146,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-20.18',
+    revision: '2026-10-20.20',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1349,15 +1422,18 @@ async function ensureWorkspace(ctx, project) {
   return workspace;
 }
 
-/** One snapshot per elapsed timeline threshold, derived from that period's chapters. */
-function snapshotDue(project, day) {
-  const snapshots = project.snapshots || [];
-  const last = snapshots[snapshots.length - 1];
+/**
+ * The grid point a new chapter brings the story to, or null when nothing new is
+ * due. A chapter spanning several points targets the last point it covers; the
+ * cascade then fills each point in between from the previous snapshot, so the
+ * unfinished chapter that straddles them never becomes its own material.
+ */
+function autoSnapshotTarget(project, chapterEndDay) {
   const unit = Math.max(1, project.timeline.unitDays || 30);
-  // Story time starts at day 0, so the first snapshot is due once the story has
-  // advanced one full unit from the origin rather than on the first chapter.
-  const since = last ? last.day : 0;
-  return day - since >= unit;
+  const point = Math.floor(Math.max(0, chapterEndDay) / unit) * unit;
+  if (point < unit) return null;
+  const latest = (project.snapshots || []).reduce((max, snapshot) => Math.max(max, snapshot.day), 0);
+  return point > latest ? point : null;
 }
 
 /** Story day where the next chapter continues: the end of the last chapter. */
@@ -1385,8 +1461,15 @@ function withTimelineFacts(project) {
       unitDays,
       latestSnapshotDay,
       storyEnd: lastChapterEnd(project),
-      nextSnapshotDay: latestSnapshotDay + unitDays,
+      // The next point on the *current* interval's grid, not "last + unit":
+      // after an interval change the grid moves under the existing snapshots.
+      nextSnapshotDay: Math.floor(latestSnapshotDay / unitDays) * unitDays + unitDays,
       snapshotDays: snapshots.map((snapshot) => snapshot.day),
+      // Every grid point up to the story's end, so the Client can mark them.
+      gridDays: Array.from(
+        { length: Math.max(0, Math.floor(lastChapterEnd(project) / unitDays)) },
+        (_, index) => (index + 1) * unitDays,
+      ),
     },
   };
 }
@@ -1398,44 +1481,102 @@ function previousChapter(project, chapter) {
     .sort((a, b) => b.startDay - a.startDay)[0] || null;
 }
 
-function registerSnapshot(ctx, root, registry, projectId, day) {
+/**
+ * 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.
+ */
+function chaptersForPoint(project, fromDay, point) {
+  return (project.chapters || [])
+    .filter((chapter) => {
+      const span = chapterWindow(project, chapter);
+      if (span.end > point || span.end <= fromDay) return false;
+      return ((chapter.outline && chapter.outline.synopsis) || '').trim() !== ''
+        || String(chapter.content || '').trim() !== '';
+    })
+    .sort((a, b) => a.startDay - b.startDay);
+}
+
+/**
+ * Fill every interval point from the newest existing snapshot up to `targetDay`,
+ * one snapshot per point, each built from the snapshot before it plus the
+ * chapters of that stretch. Long gaps (a jump of several points) therefore fill
+ * in order instead of skipping to the end.
+ */
+function registerSnapshot(ctx, root, registry, projectId, targetDay) {
   return startJob(registry, { kind: 'snapshot', projectId }, async (job) => {
+    const made = [];
+    let target = Math.max(1, Math.round(Number(targetDay) || 0));
+    for (;;) {
+      const project = await readProject(root, projectId);
+      const unit = Math.max(1, project.timeline.unitDays || 30);
+      target = Math.floor(target / unit) * unit;
+      if (target < unit) throw httpError(409, '目标时间还不到一个快照间隔，无法生成世界快照');
+      const snapshots = project.snapshots || [];
+      const base = snapshots.filter((snapshot) => snapshot.day < target).pop() || null;
+      const point = (base ? base.day : 0) + unit;
+      if (point > target) {
+        await exportProjectInfo(await readProject(root, projectId));
+        return { made, target };
+      }
+      const chapters = chaptersForPoint(project, base ? base.day : 0, point);
+      job.message = `正在生成第 ${point} 天的世界快照（第 ${made.length + 1} 份，目标第 ${target} 天）`;
+      const reply = await askAgent(ctx, project, snapshotPrompt(project, base, chapters, point));
+      const parsed = parseJsonReply(reply);
+      if (!parsed) throw httpError(502, '模型没有返回可解析的快照 JSON');
+      const normalized = normalizeSnapshot(parsed);
+      if (normalized.world === '' && normalized.characters.length === 0 && normalized.factions.length === 0) {
+        throw httpError(502, '模型返回的快照为空');
+      }
+      const snapshot = {
+        snapshotId: randomUUID(),
+        day: point,
+        createdAt: Date.now(),
+        unitDays: unit,
+        ...normalized,
+      };
+      await mutateProject(root, projectId, (draft) => {
+        // One snapshot per day: regenerating replaces the one already there.
+        draft.snapshots = (draft.snapshots || []).filter((entry) => entry.day !== point);
+        draft.snapshots.push(snapshot);
+        draft.snapshots.sort((a, b) => a.day - b.day);
+        return snapshot;
+      });
+      await exportSnapshot(project, snapshot);
+      made.push(point);
+    }
+  });
+}
+
+/** Wipe every snapshot (and its files) so the work can be rebuilt from day 1. */
+function startSnapshotReset(ctx, root, registry, body) {
+  const projectId = asText(body.projectId);
+  return startJob(registry, { kind: 'snapshot-reset', projectId }, async (job) => {
     const project = await readProject(root, projectId);
-    const snapshots = project.snapshots || [];
-    // Regenerating an existing day replaces it: the basis is the snapshot
-    // before that day, not the one being replaced.
-    const base = snapshots.filter((snapshot) => snapshot.day < day).pop() || null;
-    const since = base ? base.day : 0;
-    const chapters = (project.chapters || [])
-      .filter((chapter) => chapterWindow(project, chapter).end > since
-        && (((chapter.outline && chapter.outline.synopsis) || '').trim() !== '' || String(chapter.content || '').trim() !== ''))
-      .sort((a, b) => a.startDay - b.startDay);
-    if (chapters.length === 0) throw httpError(409, `第 ${day} 天之前还没有可依据的章节，无法生成世界快照`);
-    job.message = `正在阅读 ${chapters.length} 章的梗概并更新世界快照`;
-    const reply = await askAgent(ctx, project, snapshotPrompt(project, base, chapters));
-    const parsed = parseJsonReply(reply);
-    if (!parsed) throw httpError(502, '模型没有返回可解析的快照 JSON');
-    const normalized = normalizeSnapshot(parsed);
-    if (normalized.world === '' && normalized.characters.length === 0 && normalized.factions.length === 0) {
-      throw httpError(502, '模型返回的快照为空');
+    const unit = Math.max(1, project.timeline.unitDays || 30);
+    const storyEnd = lastChapterEnd(project);
+    const target = Math.floor(storyEnd / unit) * unit;
+    if (target < unit) throw httpError(409, '故事还不到一个快照间隔，没有可重建的快照');
+    if (target / unit > 120) {
+      throw httpError(409, `当前间隔只有 ${unit} 天，重建到第 ${target} 天需要 ${Math.floor(target / unit)} 次模型调用；请先把快照间隔调大一些再重置`);
     }
-    const snapshot = {
-      snapshotId: randomUUID(),
-      day,
-      createdAt: Date.now(),
-      unitDays: project.timeline.unitDays,
-      ...normalized,
-    };
+    job.message = '正在清除全部世界快照';
     await mutateProject(root, projectId, (draft) => {
-      // One snapshot per day: regenerating replaces the one already there.
-      draft.snapshots = (draft.snapshots || []).filter((entry) => entry.day !== day);
-      draft.snapshots.push(snapshot);
-      draft.snapshots.sort((a, b) => a.day - b.day);
-      return snapshot;
+      draft.snapshots = [];
     });
-    await exportSnapshot(project, snapshot);
-    await exportProjectInfo(await readProject(root, projectId));
-    return { snapshot };
+    try {
+      await rm(join(projectContentDir(project), '世界快照'), { recursive: true, force: true });
+    } catch {
+      // Nothing to remove.
+    }
+    // Run the rebuild inside this same job so the Client polls one thing.
+    const cascade = registerSnapshot(ctx, root, registry, projectId, target);
+    while (cascade.state === 'running') {
+      job.message = cascade.message || '正在重建世界快照';
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+    if (cascade.state === 'error') throw httpError(502, cascade.error || '重建世界快照失败');
+    return { target, made: (cascade.result && cascade.result.made) || [] };
   });
 }
 
@@ -1465,9 +1606,9 @@ function startGenerate(ctx, root, registry, body) {
     await exportChapter(project, saved, content);
     const window = chapterWindow(project, chapter);
     let snapshotJobId = null;
-    if (snapshotDue(project, window.end)) {
-      const snapshotJob = registerSnapshot(ctx, root, registry, projectId, window.end);
-      snapshotJobId = snapshotJob.jobId;
+    const autoTarget = autoSnapshotTarget(project, window.end);
+    if (autoTarget !== null) {
+      snapshotJobId = registerSnapshot(ctx, root, registry, projectId, autoTarget).jobId;
     }
     return { chapter: saved, wordCount: wordCount(content), snapshotJobId };
   });
@@ -1582,8 +1723,9 @@ function startCompose(ctx, root, registry, body) {
     if (written) await exportChapter(after, written, content);
     const window = chapterWindow(after, target);
     let snapshotJobId = null;
-    if (snapshotDue(after, window.end)) {
-      snapshotJobId = registerSnapshot(ctx, root, registry, projectId, window.end).jobId;
+    const autoTarget = autoSnapshotTarget(after, window.end);
+    if (autoTarget !== null) {
+      snapshotJobId = registerSnapshot(ctx, root, registry, projectId, autoTarget).jobId;
     }
     return {
       chapterId,
@@ -1699,6 +1841,8 @@ async function dispatch(ctx, root, registry, method, path, url, body) {
         : lastChapterEnd(project);
       return registerSnapshot(ctx, root, registry, projectId, day);
     }
+    case '/snapshot/reset':
+      return startSnapshotReset(ctx, root, registry, body);
     default:
       throw httpError(404, `未知接口: ${path}`);
   }

package/package.json

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