dsh-novel-generator 0.1.8 → 0.1.11

package/README.md

@@ -36,7 +36,7 @@ dsh plugin --profile web add dsh-novel-generator
 
 - **重置**：时间线右上角的「重置快照」会清空全部快照，再按当前间隔从第 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)}
@@ -1465,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);
@@ -1583,36 +1591,57 @@ 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) => {
+      /**
+       * 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)}`);
-            if (job.state === 'running') return;
-            clearInterval(timer);
-            setSnapshotBusy(false);
-            if (job.state === 'done') {
-              notify(doneText, 'success');
+            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();
-            } else {
-              notify(job.error || t('世界快照更新失败', "World snapshot update failed"), 'error');
+              return;
             }
-          } catch (error) {
             clearInterval(timer);
-            setSnapshotBusy(false);
-            notify(messageOf(error), 'error');
+            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');
-          waitSnapshotJob(started.jobId, t('世界快照已更新，时间线向前延伸', "World snapshot updated; the timeline moved forward."));
+          waitSnapshotJob(
+            started.jobId,
+            t('正在生成第 {day} 天的世界快照…', 'Generating the world snapshot for day {day}…', { day }),
+            t('世界快照已更新，时间线向前延伸', "World snapshot updated; the timeline moved forward."),
+          );
         } catch (error) {
-          setSnapshotBusy(false);
           notify(messageOf(error), 'error');
         }
       }, [detail.projectId, notify, waitSnapshotJob]);
@@ -1627,13 +1656,14 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
           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 started = await api('/snapshot/reset', { projectId: detail.projectId });
-              notify(t('正在重建世界快照…', 'Rebuilding world snapshots…'), 'success');
-              waitSnapshotJob(started.jobId, t('世界快照已全部重建', 'All world snapshots rebuilt'));
+              waitSnapshotJob(
+                started.jobId,
+                t('正在重建世界快照…', 'Rebuilding world snapshots…'),
+                t('世界快照已全部重建', 'All world snapshots rebuilt'),
+              );
             } catch (error) {
-              setSnapshotBusy(false);
               notify(messageOf(error), 'error');
             }
           },
@@ -1643,6 +1673,15 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
       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, {

package/index.js

@@ -939,66 +939,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('');
@@ -1040,8 +1079,10 @@ function snapshotPrompt(project, previous, chapters, pointDay) {
   lines.push('');
   lines.push('要求：');
   lines.push('- 保留上一版中尚未被推翻的设定；角色、势力要包含新登场者；关系用「甲 乙 关系」三段式。');
-  lines.push('- items 记录这段时间出现或变化的关键物品（下落、归属、状态）；没有就给空数组。');
-  lines.push(`- events 记录这段时间发生的具体事件，day 用故事天数（整数，不超过 ${pointDay}），title 一行、desc 一两句，最近的排最前；没有就给空数组。`);
+  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');
 }
@@ -1146,7 +1187,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-20.20',
+    revision: '2026-10-20.32',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1505,22 +1546,25 @@ function chaptersForPoint(project, fromDay, point) {
  */
 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 = [];
-    let target = Math.max(1, Math.round(Number(targetDay) || 0));
-    for (;;) {
+    for (const point of points) {
       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 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} 份，目标第 ${target} 天）`;
+      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');
@@ -1528,6 +1572,25 @@ function registerSnapshot(ctx, root, registry, projectId, targetDay) {
       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,
@@ -1545,6 +1608,8 @@ function registerSnapshot(ctx, root, registry, projectId, targetDay) {
       await exportSnapshot(project, snapshot);
       made.push(point);
     }
+    await exportProjectInfo(await readProject(root, projectId));
+    return { made, target };
   });
 }
 
@@ -1580,14 +1645,22 @@ 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;
@@ -1620,8 +1693,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);
@@ -1660,6 +1750,7 @@ 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));
@@ -1737,9 +1828,19 @@ 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;

package/package.json

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