dsh-novel-generator 0.1.26 → 0.1.28

package/README.md

@@ -31,8 +31,13 @@ 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 格逐格重建到故事末端（确认框里写明要生成几份）。
 - **物品 / 事件**：快照里除了世界观、角色、势力、关系，还有物品（名称 + 下落/用途）和事件（故事天数 + 标题 + 一句话），事件按时间从新到旧排列。
@@ -81,6 +86,15 @@ dsh plugin --profile web add dsh-novel-generator
 - 正文为空时按钮不可点，接口也会拒绝（400）；修改意见为空同样拒绝。
 - **重写结果只放进编辑区、不自动保存**，状态变成「未保存」，你确认后再点「保存」——避免 AI 的改动直接覆盖原稿。
 
+## 附属子插件：小说工坊 · 作者预设
+
+另有一个**独立包** `dsh-novel-author-preset`，只负责往 DSH 注册一个 Agent 预设「小说工坊 · 作者」：
+
+- 装上它（`dsh plugin --profile web add dsh-novel-author-preset`），作品列表的「预设」与「设置 → 预设」里就多出这一项，**新建作品默认用它**；
+- 卸掉它，预设立刻消失；已绑定的作品不会因此损坏——重建会话时检测到预设已不在，会自动退回 profile 的默认预设。
+
+预设内容刻意做得很薄：三句人设（你是小说写作者／只输出正文／文风视角篇幅以用户要求为准）+ 关闭运行时上下文 + **不挂任何工具** + 只保留上下文压缩。所有文学倾向都交给作品级「前置提示词」。
+
 ## 迁移、导入与会话
 
 - **改预设**：作品列表每行的「预设」改的是「下次建会话时用哪个预设」。会话在创建时就固定了预设，所以保存后会提示「重建会话后生效」——要立刻换，点同一行的「重建会话」。

package/index.js

@@ -922,6 +922,20 @@ function normalizeSnapshot(raw) {
 
 /* ------------------------------------------------------------ agent work */
 
+/** The preset a work records, but only when the deployment still offers it. */
+async function usablePreset(ctx, presetId) {
+  if (!presetId) return false;
+  const presets = ctx.get('agentPresets');
+  if (!presets || typeof presets.list !== 'function') return true;
+  try {
+    const list = await presets.list();
+    if (!Array.isArray(list) || list.length === 0) return true;
+    return list.some((entry) => entry.id === presetId);
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Bind a fresh session to a work whose old one disappeared (deleted in the
  * sidebar, or gone from the session store). The work's memory — snapshots,
@@ -931,7 +945,12 @@ function normalizeSnapshot(raw) {
 async function rebindSession(ctx, root, project) {
   const controller = ctx.get('sessionController');
   if (controller === undefined) throw httpError(503, '当前部署缺少 sessionController 服务，无法为作品重建会话');
-  const created = await controller.create(project.agentPreset ? { cwd: project.cwd, agentPreset: project.agentPreset } : { cwd: project.cwd });
+  // A preset can disappear when its plugin is uninstalled; falling back to the
+  // profile default keeps the work usable instead of failing every rebuild.
+  const presetOk = await usablePreset(ctx, project.agentPreset);
+  const created = await controller.create(presetOk && project.agentPreset
+    ? { cwd: project.cwd, agentPreset: project.agentPreset }
+    : { cwd: project.cwd });
   const sessionId = created && created.sessionId ? created.sessionId : null;
   if (!sessionId) throw httpError(502, '没能为作品重建会话');
   if (project.model) {
@@ -1182,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);
 }
@@ -1477,7 +1499,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-27.10',
+    revision: '2026-10-27.16',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1511,6 +1533,11 @@ async function createProject(ctx, root, body) {
   const cwd = asText(body.cwd);
   if (cwd === '') throw httpError(400, '请先选择作品的工作目录');
   const agentPreset = asText(body.agentPreset) || undefined;
+  // New works prefer the bundled author preset when its plugin is installed, and
+  // otherwise fall back to the profile default instead of failing.
+  const chosenPreset = agentPreset !== undefined && await usablePreset(ctx, agentPreset)
+    ? agentPreset
+    : (await usablePreset(ctx, AUTHOR_PRESET_ID) ? AUTHOR_PRESET_ID : undefined);
   const model = body.model && asText(body.model.provider) && asText(body.model.model)
     ? {
       provider: asText(body.model.provider),
@@ -1529,7 +1556,7 @@ async function createProject(ctx, root, body) {
     throw httpError(400, `无法在工作目录下创建作品文件夹：${error instanceof Error ? error.message : String(error)}`);
   }
 
-  const created = await controller.create(agentPreset === undefined ? { cwd } : { cwd, agentPreset });
+  const created = await controller.create(chosenPreset === undefined ? { cwd } : { cwd, agentPreset: chosenPreset });
   const sessionId = created && created.sessionId ? created.sessionId : null;
   let warning = null;
   if (sessionId && model) {
@@ -1546,7 +1573,7 @@ async function createProject(ctx, root, body) {
     projectId,
     title,
     cwd,
-    agentPreset: agentPreset || created.agentPreset || null,
+    agentPreset: chosenPreset || created.agentPreset || null,
     model,
     // Every new work starts with the default narrative preface; the author can
     // edit or clear it from the work list.
@@ -1914,6 +1941,9 @@ const PRELUDE_PRESETS = [
 /** The preface a fresh work starts with. */
 const DEFAULT_PRELUDE_MODE = 'thirdOmniscient';
 
+/** Preset id contributed by the optional `dsh-novel-author-preset` sub-plugin. */
+const AUTHOR_PRESET_ID = 'novel-studio-author';
+
 function defaultPrelude() {
   const preset = PRELUDE_PRESETS.find((entry) => entry.id === DEFAULT_PRELUDE_MODE);
   return preset ? { mode: preset.id, text: preset.text, updatedAt: Date.now() } : null;
@@ -2019,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);
@@ -2073,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 : '';
@@ -2096,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. */
@@ -2229,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() !== '';
     })
@@ -2251,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.
@@ -2706,9 +2769,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.26",
+  "version": "0.1.28",
   "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",