dsh-novel-generator 0.1.6 → 0.1.10

package/README.md

@@ -34,6 +34,10 @@ dsh plugin --profile web add dsh-novel-generator
 - **自动**：每次生成章节后检查两个条件，缺一不可：① 本章结束时间**正好落在网格点上**；② **上一格**（该点 − 一个间隔）已经有快照（第 0 天视为已覆盖）。满足才自动生成这一格的快照。
 - 这样改间隔不会把旧快照重排：网格随当前间隔移动，自动生成只沿着「上一格存在」的链条向前推进，断档的地方留给你手动补。
 
+- **重置**：时间线右上角的「重置快照」会清空全部快照，再按当前间隔从第 1 格逐格重建到故事末端（确认框里写明要生成几份）。
+- **物品 / 事件**：快照里除了世界观、角色、势力、关系，还有物品（名称 + 下落/用途）和事件（故事天数 + 标题 + 一句话），事件按时间从新到旧排列。
+- **章节正文的依据**：生成正文时会带上「当前快照 + 该快照之后到本章之前的各章梗概」，不再只看上一章。
+
 ## 数据与接口
 
 

package/client.js

@@ -197,6 +197,11 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
 /* workspace track */
 .dsn-stage{flex:1;position:relative;overflow:hidden;min-width:0}
+.dsn-lock{position:absolute;inset:0;z-index:40;display:flex;align-items:center;justify-content:center;background:color-mix(in srgb, var(--dsw-alias-bg-overlay) 88%, transparent);backdrop-filter:blur(2px);cursor:progress}
+.dsn-lock-box{max-width:420px;padding:20px 24px;border-radius:14px;border:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-3);box-shadow:0 18px 48px rgba(0,0,0,.28);text-align:center}
+.dsn-lock-title{font-size:15px;font-weight:600;color:var(--dsw-alias-label-primary)}
+.dsn-lock-text{margin-top:8px;font-size:13px;line-height:1.6;color:var(--dsw-alias-label-secondary);word-break:break-word}
+.dsn-lock-hint{margin-top:10px;font-size:12px;color:var(--dsw-alias-label-tertiary)}
 .dsn-track{display:flex;height:100%;transition:transform .28s ease}
 .dsn-page{width:100%;height:100%;flex:0 0 100%;display:flex;flex-direction:column;min-width:0}
 .dsn-pagehead{display:flex;align-items:center;gap:10px;padding:10px 16px;border-bottom:1px solid var(--dsw-alias-border-l1)}
@@ -716,7 +721,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
@@ -800,6 +805,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',
@@ -840,6 +852,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);
     }
@@ -1437,7 +1470,10 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
     function ProjectWorkspace({ detail, onReload, notify, onRegisterLeaveGuard }) {
       const [view, setView] = useState('world');
       const [chapterId, setChapterId] = useState(null);
-      const [snapshotBusy, setSnapshotBusy] = useState(false);
+      // A running snapshot job: { label, message }. Non-null locks the studio,
+      // because the job keeps rewriting this work's snapshots.
+      const [snapshotJob, setSnapshotJob] = useState(null);
+      const snapshotBusy = snapshotJob !== null;
       const [dialogOpen, setDialogOpen] = useState(false);
       const [text, setText] = useState('');
       const [dirty, setDirty] = useState(false);
@@ -1555,38 +1591,97 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
         }
       }, [detail.projectId, onReload, notify]);
 
+      /**
+       * Poll one snapshot job until it settles. While it runs the studio stays
+       * locked and the work is reloaded on every tick, so newly written
+       * snapshots appear on the timeline as they land.
+       */
+      const waitSnapshotJob = useCallback((jobId, label, doneText) => {
+        setSnapshotJob({ label, message: label });
+        let failures = 0;
+        const startedAt = Date.now();
+        const timer = setInterval(async () => {
+          try {
+            const job = await api(`/job?id=${encodeURIComponent(jobId)}`);
+            failures = 0;
+            if (job.state === 'running') {
+              if (Date.now() - startedAt > 45 * 60 * 1000) {
+                clearInterval(timer);
+                setSnapshotJob(null);
+                notify(t('快照任务超时，已解除锁定', 'The snapshot job timed out; the studio is unlocked.'), 'error');
+                return;
+              }
+              setSnapshotJob({ label, message: job.message || label });
+              await onReload();
+              return;
+            }
+            clearInterval(timer);
+            setSnapshotJob(null);
+            await onReload();
+            if (job.state === 'done') notify(doneText, 'success');
+            else notify(job.error || t('世界快照更新失败', "World snapshot update failed"), 'error');
+          } catch (error) {
+            failures += 1;
+            // Three failed polls in a row mean the studio cannot be held.
+            if (failures >= 3) {
+              clearInterval(timer);
+              setSnapshotJob(null);
+              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('正在生成第 {day} 天的世界快照…', 'Generating the world snapshot for day {day}…', { day }),
+            t('世界快照已更新，时间线向前延伸', "World snapshot updated; the timeline moved forward."),
+          );
+        } catch (error) {
+          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 () => {
             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 });
+              waitSnapshotJob(
+                started.jobId,
+                t('正在重建世界快照…', 'Rebuilding world snapshots…'),
+                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;
 
       return h('div', { className: 'dsn-stage' },
+        // A running snapshot job owns the work: nothing else may be edited
+        // while it rewrites snapshots underneath.
+        snapshotBusy
+          ? h('div', { className: 'dsn-lock' },
+            h('div', { className: 'dsn-lock-box' },
+              h('div', { className: 'dsn-lock-title' }, snapshotJob.label),
+              h('div', { className: 'dsn-lock-text' }, snapshotJob.message),
+              h('div', { className: 'dsn-lock-hint' }, t('快照生成期间界面不可操作，完成后会自动刷新', 'The studio is locked while snapshots are generated; it refreshes when done.'))))
+          : null,
         h('div', { className: 'dsn-track', style: { transform: `translateX(-${trackIndex * 100}%)` } },
           h('section', { className: 'dsn-page' },
             h(WorldPage, {
@@ -1594,6 +1689,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,14 @@ 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 必填：列出这段时间出现、易手或状态变化的关键物品（法宝、信物、丹药、线索等），每项 name + desc（下落/归属/用途）。');
+  lines.push(`- events 必填：这段时间每发生一件值得记录的事就写一条，day 为故事天数（整数，0~${pointDay}），title 一行，desc 一两句，按 day 从大到小排列。只要这段时间有章节内容，就至少写 1 条。`);
+  lines.push('- 只有这段时间确实没有任何可记录的物品或事件时，才给空数组。');
+  lines.push('注意：输出的 JSON 必须同时包含 items 与 events 两个键，缺任何一个都算不合格（没有内容就写 []）。');
   lines.push('不要调用任何工具，不要反问，只输出这个 JSON。');
   return lines.join('\n');
 }
@@ -1073,7 +1148,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-20.19',
+    revision: '2026-10-20.28',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1350,21 +1425,17 @@ async function ensureWorkspace(ctx, project) {
 }
 
 /**
- * Whether a chapter ending at `day` earns an automatic snapshot.
- *
- * The rule ignores how many snapshots exist and which interval produced them:
- * a point counts only when the chapter lands exactly on a multiple of the
- * *current* interval, and the point one interval earlier is already covered
- * (day 0 — the story's start — counts as covered). Changing the interval
- * therefore moves the grid, and generation only continues along an unbroken
- * chain rather than back-filling gaps by itself.
+ * 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 snapshotPointDue(project, day) {
+function autoSnapshotTarget(project, chapterEndDay) {
   const unit = Math.max(1, project.timeline.unitDays || 30);
-  if (day <= 0 || day % unit !== 0) return false;
-  const previous = day - unit;
-  if (previous <= 0) return true;
-  return (project.snapshots || []).some((snapshot) => snapshot.day === previous);
+  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. */
@@ -1412,44 +1483,126 @@ 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) => {
+    // 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.
+    const initial = await readProject(root, projectId);
+    const unit = Math.max(1, initial.timeline.unitDays || 30);
+    const target = Math.floor(Math.max(1, Math.round(Number(targetDay) || 0)) / unit) * unit;
+    if (target < unit) throw httpError(409, '目标时间还不到一个快照间隔，无法生成世界快照');
+    const startBase = (initial.snapshots || []).filter((snapshot) => snapshot.day < target).pop() || null;
+    let first = (startBase ? startBase.day : 0) + unit;
+    // Nothing new below the target means "redo the target point itself".
+    if (first > target) first = target;
+    const points = [];
+    for (let point = first; point <= target; point += unit) points.push(point);
+
+    const made = [];
+    for (const point of points) {
+      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);
+      job.message = `正在生成第 ${point} 天的世界快照（第 ${made.length + 1}/${points.length} 份，目标第 ${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, '模型返回的快照为空');
+      }
+      // A chapter boundary is a fact of the work itself, so it seeds the event
+      // list even when the model leaves `events` empty; model-written events win
+      // by title and anything else is added.
+      const seeded = chapters.map((chapter) => {
+        const span = chapterWindow(project, chapter);
+        return {
+          day: span.end,
+          title: chapter.title || `第 ${chapter.index + 1} 章`,
+          desc: ((chapter.outline && chapter.outline.synopsis) || '').slice(0, 120),
+        };
+      });
+      const known = new Set(normalized.events.map((event) => event.title));
+      for (const event of seeded) {
+        if (!known.has(event.title)) {
+          normalized.events.push(event);
+          known.add(event.title);
+        }
+      }
+      normalized.events.sort((a, b) => (b.day === null ? -1 : b.day) - (a.day === null ? -1 : a.day));
+      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);
+    }
+    await exportProjectInfo(await readProject(root, projectId));
+    return { made, target };
+  });
+}
+
+/** 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) || [] };
   });
 }
 
@@ -1479,9 +1632,9 @@ function startGenerate(ctx, root, registry, body) {
     await exportChapter(project, saved, content);
     const window = chapterWindow(project, chapter);
     let snapshotJobId = null;
-    if (snapshotPointDue(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 };
   });
@@ -1596,8 +1749,9 @@ function startCompose(ctx, root, registry, body) {
     if (written) await exportChapter(after, written, content);
     const window = chapterWindow(after, target);
     let snapshotJobId = null;
-    if (snapshotPointDue(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,
@@ -1713,6 +1867,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.6",
+  "version": "0.1.10",
   "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",