@waterwx/dsh-novel-forge 1.3.1 → 1.3.2-alpha

package/src/client/api.ts

@@ -8,6 +8,13 @@ import {
   NOVEL_API,
   type AssetsPatch,
   type AssetsResponse,
+  type AddModelRequest,
+  type AddModelResponse,
+  type LlmModelsResponse,
+  type LlmProvidersResponse,
+  type LlmVendorsResponse,
+  type RemoveProviderRequest,
+  type RemoveProviderResponse,
   type BibleResponse,
   type ChapterResponse,
   type ConfigPatch,
@@ -16,9 +23,16 @@ import {
   type ForeshadowResponse,
   type JobFrame,
   type LoadOutlineResponse,
+  type AdaptExecuteRequest,
+  type AdaptRewriteFrame,
+  type AdaptMaterializeSaveRequest,
+  type AdaptMaterializeSaveResponse,
+  type PluginUpdateResponse,
+  type LlmTestResponse,
   type NovelConfig,
   type PlanResponse,
   type ReviewReport,
+  type RevisionPlanResponse,
   type StatusResponse,
   type StyleEngineRequest,
   type StyleAsset,
@@ -50,12 +64,37 @@ async function readJson<T>(response: Response): Promise<T> {
   return body as T
 }
 
-/** POST JSON, return parsed JSON. */
+/** 面板所绑定的当前书（打开时锁定；每次书级请求带上，避免被全局 active 串书）。 */
+let currentBookId: string | null = null
+export function setCurrentBook(id: string | null): void {
+  currentBookId = id
+}
+
+/** 给 GET 路径追加当前书 bookId（读接口也按书路由）。 */
+function withBookId(path: string): string {
+  if (currentBookId === null) return path
+  const sep = path.includes('?') ? '&' : '?'
+  return `${path}${sep}bookId=${encodeURIComponent(currentBookId)}`
+}
+
+/**
+ * 给 POST 请求体注入当前书 bookId（与 withBookId 对称）。
+ *
+ * 这是本模块的不变量：**每一个书级请求都必须显式带上 bookId**，否则宿主会退回
+ * 「全局 active 书」——切书与请求并发时就会串书。
+ */
+function withBookIdBody(payload: unknown): unknown {
+  if (currentBookId === null) return payload
+  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return payload
+  return { ...(payload as Record<string, unknown>), bookId: currentBookId }
+}
+
+/** POST JSON, return parsed JSON. 若已绑定当前书，自动把 bookId 注入请求体。 */
 async function postJson<T>(path: string, payload: unknown): Promise<T> {
   const response = await fetch(path, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(payload),
+    body: JSON.stringify(withBookIdBody(payload)),
   })
   return readJson<T>(response)
 }
@@ -63,7 +102,7 @@ async function postJson<T>(path: string, payload: unknown): Promise<T> {
 /** The browser half's only data entry point. */
 export class NovelApi {
   async status(): Promise<StatusResponse> {
-    const response = await fetch(NOVEL_API.status)
+    const response = await fetch(withBookId(NOVEL_API.status))
     return readJson<StatusResponse>(response)
   }
 
@@ -75,6 +114,11 @@ export class NovelApi {
     return postJson<{ ok: boolean; bookName: string }>(NOVEL_API.saveOutline, { text })
   }
 
+  /** 反推大纲：从已写章节正文反向生成全书总纲（NDJSON 流）。 */
+  async outlineReverse(onFrame: (frame: JobFrame) => void): Promise<void> {
+    await this.streamJob(NOVEL_API.outlineReverse, {}, onFrame)
+  }
+
   /** 开书想法 → AI 大纲：生成 count 个方案（换批时传 exclude 避开已暂留方向）。 */
   async outlineSuggest(idea: string, count?: number, exclude?: string[]): Promise<import('../protocol.ts').OutlineSuggestResponse> {
     return postJson<import('../protocol.ts').OutlineSuggestResponse>(NOVEL_API.outlineSuggest, { idea, count, exclude })
@@ -109,12 +153,12 @@ export class NovelApi {
     return postJson<ForeshadowResponse>(NOVEL_API.foreshadow, req)
   }
 
-  async exportBook(format: 'txt' | 'md'): Promise<ExportResponse> {
-    return postJson<ExportResponse>(NOVEL_API.exportBook, { format })
+  async exportBook(format: 'txt' | 'md' | 'json', scope: import('../protocol.ts').ExportScope = 'book'): Promise<ExportResponse> {
+    return postJson<ExportResponse>(NOVEL_API.exportBook, { format, scope })
   }
 
   async chapter(no: number): Promise<ChapterResponse> {
-    const response = await fetch(`${NOVEL_API.chapter}?no=${no}`)
+    const response = await fetch(withBookId(`${NOVEL_API.chapter}?no=${no}`))
     return readJson<ChapterResponse>(response)
   }
 
@@ -123,6 +167,14 @@ export class NovelApi {
     return postJson<{ report: ReviewReport }>(NOVEL_API.chapterCheck, { chapterNo: no, text, previousReport })
   }
 
+  /**
+   * 修订指令合并：把本章的审稿意见（勾选项）+ 时间线矛盾 + 张力偏差合成**一份**指令。
+   * 面板所有「按意见修订 / 一键按建议修订」入口都先走这里，保证同一章只改一轮。
+   */
+  async revisionPlan(no: number, reviewIssues?: ReviewReport['issues'], opts: { includeTimeline?: boolean; includeTension?: boolean } = {}): Promise<RevisionPlanResponse> {
+    return postJson<RevisionPlanResponse>(NOVEL_API.revisionPlan, { op: 'plan', chapterNo: no, reviewIssues, ...opts })
+  }
+
   /** 保存手动编辑的正文（自动备份 .bak；带报告则沿用落盘，否则保存后自动审稿）。 */
   async chapterSave(no: number, text: string, report?: ReviewReport): Promise<import('../protocol.ts').ChapterSaveResponse> {
     return postJson<import('../protocol.ts').ChapterSaveResponse>(NOVEL_API.chapterSave, { chapterNo: no, text, report })
@@ -132,10 +184,25 @@ export class NovelApi {
     return postJson<{ config: NovelConfig }>(NOVEL_API.config, patch)
   }
 
+  /** 输出目录迁移：dryRun=true 仅预览目录内容；确认时传 to 搬迁。 */
+  async moveOutputDir(to?: string, dryRun?: boolean): Promise<import('../protocol.ts').MoveOutputDirResponse> {
+    return postJson<import('../protocol.ts').MoveOutputDirResponse>(NOVEL_API.moveOutputDir, { to, dryRun })
+  }
+
+  /** 本书参数：不带 patch 读取；带 patch 合并保存（字段传 null = 回退全局）。 */
+  async bookSettings(patch?: Record<string, unknown>): Promise<import('../protocol.ts').BookSettingsResponse> {
+    return postJson<import('../protocol.ts').BookSettingsResponse>(NOVEL_API.bookSettings, patch === undefined ? {} : { patch })
+  }
+
   async openFolder(): Promise<void> {
     await fetch(NOVEL_API.openFolder, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' })
   }
 
+  /** 插件自更新：在 DSH profile 目录拉取最新 npm 版（需重启 DSH 生效）。 */
+  async pluginUpdate(): Promise<PluginUpdateResponse> {
+    return postJson<PluginUpdateResponse>(NOVEL_API.pluginUpdate, {})
+  }
+
   /** 书架快照。 */
   async bookshelf(): Promise<import('../protocol.ts').BookshelfSnapshot> {
     const response = await fetch(NOVEL_API.bookshelf)
@@ -157,6 +224,88 @@ export class NovelApi {
     return postJson<import('../protocol.ts').AuditResponse>(NOVEL_API.audit, {})
   }
 
+  /** 热门题材雷达：信号 + 生产底座。 */
+  async marketRadar(req: import('../protocol.ts').MarketRadarRequest): Promise<{ result: import('../protocol.ts').MarketRadarResult }> {
+    return postJson<{ result: import('../protocol.ts').MarketRadarResult }>(NOVEL_API.marketRadar, req)
+  }
+
+  /** 真实榜单扫榜：抓取公开榜单，返回分组候选。 */
+  async marketRadarScan(req: { platforms?: string[] }): Promise<{ result: { scannedAt: string; groups: any[] } }> {
+    return postJson<{ result: { scannedAt: string; groups: any[] } }>(NOVEL_API.marketRadarScan, req)
+  }
+
+  /** 把雷达生产底座里的新资产同步进全局资源库（跨书复用；已有名字跳过）。 */
+  async marketRadarSync(req: { foundation: import('../protocol.ts').ProductionFoundation }): Promise<{ ok: boolean; synced: { genre: boolean; primaryMode: boolean; secondaryMode: boolean } }> {
+    return postJson<{ ok: boolean; synced: { genre: boolean; primaryMode: boolean; secondaryMode: boolean } }>(NOVEL_API.marketRadarSync, req)
+  }
+
+  /** 书内知识库：读取。 */
+  async knowledgeList(): Promise<{ docs: import('../protocol.ts').KnowledgeDoc[] }> {
+    const response = await fetch(withBookId(NOVEL_API.knowledge))
+    return readJson<{ docs: import('../protocol.ts').KnowledgeDoc[] }>(response)
+  }
+
+  /** 书内知识库：新增。 */
+  async knowledgeAdd(doc: { title: string; content: string }): Promise<{ docs: import('../protocol.ts').KnowledgeDoc[] }> {
+    return postJson<{ docs: import('../protocol.ts').KnowledgeDoc[] }>(NOVEL_API.knowledge, { action: 'add', doc })
+  }
+
+  /** 书内知识库：删除。 */
+  async knowledgeRemove(id: string): Promise<{ docs: import('../protocol.ts').KnowledgeDoc[] }> {
+    return postJson<{ docs: import('../protocol.ts').KnowledgeDoc[] }>(NOVEL_API.knowledge, { action: 'remove', id })
+  }
+
+  /** 书分析/拆书。 */
+  async bookAnalysis(text: string): Promise<{ result: import('../protocol.ts').BookAnalysisResult }> {
+    return postJson<{ result: import('../protocol.ts').BookAnalysisResult }>(NOVEL_API.bookAnalysis, { text })
+  }
+
+  /** 创意灵感。 */
+  async ideaInspiration(idea: string, count = 5): Promise<{ result: import('../protocol.ts').IdeaInspirationResult }> {
+    return postJson<{ result: import('../protocol.ts').IdeaInspirationResult }>(NOVEL_API.ideaInspiration, { idea, count })
+  }
+
+  /** 雷达→灵感：基于市场信号/生产底座/创意简报生成开书灵感。 */
+  async marketIdeaInspiration(req: { signals?: import('../protocol.ts').MarketRadarSignal[]; foundation?: import('../protocol.ts').ProductionFoundation; brief?: import('../protocol.ts').MarketCreativeBrief; count?: number }): Promise<{ result: import('../protocol.ts').IdeaInspirationResult }> {
+    return postJson<{ result: import('../protocol.ts').IdeaInspirationResult }>(NOVEL_API.ideaInspirationMarket, req)
+  }
+
+  /** 自动编辑编排建议：基于全书上下文。 */
+  async director(focus?: string): Promise<{ result: import('../protocol.ts').DirectorAdvice }> {
+    return postJson<{ result: import('../protocol.ts').DirectorAdvice }>(NOVEL_API.director, { focus })
+  }
+
+  /** 自动编辑「采纳」出的书内待办：读取。 */
+  async directorTodosList(): Promise<{ todos: import('../protocol.ts').DirectorTodo[] }> {
+    const response = await fetch(withBookId(NOVEL_API.directorTodos))
+    return readJson<{ todos: import('../protocol.ts').DirectorTodo[] }>(response)
+  }
+
+  /** 待办：新增（来源 risk/fix）。 */
+  async directorTodosAdd(text: string, source: 'risk' | 'fix'): Promise<{ todos: import('../protocol.ts').DirectorTodo[] }> {
+    return postJson<{ todos: import('../protocol.ts').DirectorTodo[] }>(NOVEL_API.directorTodos, { op: 'add', text, source })
+  }
+
+  /** 待办：勾选/取消。 */
+  async directorTodosToggle(id: string): Promise<{ todos: import('../protocol.ts').DirectorTodo[] }> {
+    return postJson<{ todos: import('../protocol.ts').DirectorTodo[] }>(NOVEL_API.directorTodos, { op: 'toggle', id })
+  }
+
+  /** 待办：删除。 */
+  async directorTodosRemove(id: string): Promise<{ todos: import('../protocol.ts').DirectorTodo[] }> {
+    return postJson<{ todos: import('../protocol.ts').DirectorTodo[] }>(NOVEL_API.directorTodos, { op: 'remove', id })
+  }
+
+  /** 用选中的市场信号 + 影响模式生成开书创意简报。 */
+  async marketRadarBrief(req: import('../protocol.ts').MarketRadarBriefRequest): Promise<{ creativeBrief: import('../protocol.ts').MarketCreativeBrief }> {
+    return postJson<{ creativeBrief: import('../protocol.ts').MarketCreativeBrief }>(NOVEL_API.marketRadarBrief, req)
+  }
+
+  /** 把雷达生产底座一键应用到某本书（写入项目资产/开书定盘）。 */
+  async marketRadarApply(req: { bookId?: string; foundation: import('../protocol.ts').ProductionFoundation }): Promise<{ ok: boolean; bookName: string }> {
+    return postJson<{ ok: boolean; bookName: string }>(NOVEL_API.marketRadarApply, req)
+  }
+
   /** 角色卡刷新（基于事实库聚合）。 */
   async charactersRefresh(): Promise<{ cards: import('../protocol.ts').RoleStatusCard[] }> {
     return postJson<{ cards: import('../protocol.ts').RoleStatusCard[] }>(NOVEL_API.charactersRefresh, {})
@@ -167,7 +316,7 @@ export class NovelApi {
     return postJson<{ ok: boolean; filled: number }>(NOVEL_API.factsBackfill, {})
   }
 
-  /** 设定圣经局部修补。 */
+  /** 道藏局部修补。 */
   async biblePatch(patch: import('../protocol.ts').BiblePatchRequest): Promise<{ bible: import('../protocol.ts').StoryBible }> {
     return postJson<{ bible: import('../protocol.ts').StoryBible }>(NOVEL_API.biblePatch, patch)
   }
@@ -202,22 +351,44 @@ export class NovelApi {
     return postJson<{ ok: boolean; no: number }>(NOVEL_API.chapterApprove, { chapterNo: no })
   }
 
-  /** 角色库：AI 提炼 / 采纳 / 更新 / 删除。 */
-  async roles(req: import('../protocol.ts').RolesRequest): Promise<import('../protocol.ts').RolesResponse> {
-    return postJson<import('../protocol.ts').RolesResponse>(NOVEL_API.roles, req)
+  /** 对选中的提供商/模型发一次最小真实调用，验证连通性。 */
+  async llmTest(provider: string, model: string): Promise<LlmTestResponse> {
+    return postJson<LlmTestResponse>(NOVEL_API.llmTest, { provider, model })
+  }
+
+  /** 添加模型：厂商直填 key，或自定义 OpenAI 兼容路由（写 DSH 凭据 + 注册路由）。 */
+  async addModel(req: AddModelRequest): Promise<AddModelResponse> {
+    return postJson<AddModelResponse>(NOVEL_API.addModel, req)
   }
 
-  /** 场景库：AI 提炼 / 采纳 / 更新 / 删除 / 图集。 */
-  async scenes(req: import('../protocol.ts').ScenesRequest): Promise<import('../protocol.ts').ScenesResponse> {
-    return postJson<import('../protocol.ts').ScenesResponse>(NOVEL_API.scenes, req)
+  /** 运行时厂商目录（DSH pi-ai 可配置提供方 + 内置适配器）。 */
+  async llmVendors(): Promise<LlmVendorsResponse> {
+    const response = await fetch(NOVEL_API.llmVendors)
+    return readJson<LlmVendorsResponse>(response)
   }
 
-  /** 视觉世界观规则：提炼 / 保存。 */
-  async visualRules(req: import('../protocol.ts').VisualRulesRequest): Promise<import('../protocol.ts').VisualRulesResponse> {
-    return postJson<import('../protocol.ts').VisualRulesResponse>(NOVEL_API.visualRules, req)
+  /** 查询某个 provider 当前可用的模型（添加成功后可即时刷新）。 */
+  async llmModels(provider: string): Promise<LlmModelsResponse> {
+    const response = await fetch(NOVEL_API.llmModels + '?provider=' + encodeURIComponent(provider))
+    return readJson<LlmModelsResponse>(response)
   }
 
-  /** 小说简介：AI 生成/补全（partial 留空 = 全量），或手动保存。 */
+  /** 已注册的提供方路由列表（提供方管理卡片）。 */
+  async llmProviders(): Promise<LlmProvidersResponse> {
+    const response = await fetch(NOVEL_API.llmProviders)
+    return readJson<LlmProvidersResponse>(response)
+  }
+
+  /** 移除一个提供方（unset key + 移除 llm-pi-ai 路由）。 */
+  async removeProvider(req: RemoveProviderRequest): Promise<RemoveProviderResponse> {
+    return postJson<RemoveProviderResponse>(NOVEL_API.llmRemove, req)
+  }
+
+  async roles(req: import('../protocol.ts').RolesRequest): Promise<import('../protocol.ts').RolesResponse> {
+    return postJson<import('../protocol.ts').RolesResponse>(NOVEL_API.roles, req)
+  }
+
+  /** 小说简介：生成/补全（partial 留空 = 全量），或手动保存。 */
   async blurb(action: 'generate' | 'save', text?: string, partial?: string): Promise<{ blurb: string }> {
     return postJson<{ blurb: string }>(NOVEL_API.blurb, { action, text, partial })
   }
@@ -239,7 +410,7 @@ export class NovelApi {
     return postJson<{ bookName: string }>(NOVEL_API.rename, { bookName })
   }
 
-  /** 大世界：AI 提炼（generate）或手动保存（save）。 */
+  /** 大世界：提炼（generate）或手动保存（save）。 */
   async world(action: 'generate' | 'save', world?: import('../protocol.ts').WorldState): Promise<{ world: import('../protocol.ts').WorldState }> {
     return postJson<{ world: import('../protocol.ts').WorldState }>(NOVEL_API.world, { action, world })
   }
@@ -254,6 +425,26 @@ export class NovelApi {
     return postJson<import('../protocol.ts').BookshelfSnapshot>('/api/dsh-novel-forge/bookshelf/remove', { id })
   }
 
+  /** 导入已有项目目录（Mode A）：校验 novel-project.json，登记/激活书架。 */
+  async bookImportDir(outputDir: string): Promise<import('../protocol.ts').BookImportDirResponse> {
+    return postJson<import('../protocol.ts').BookImportDirResponse>(NOVEL_API.bookshelfImportDir, { outputDir })
+  }
+
+  /** 导入 txt/md 全本（Mode B）：服务器本地文件路径模式。 */
+  async bookImportText(filePath: string, outputDir?: string): Promise<import('../protocol.ts').BookImportTextResponse> {
+    return postJson<import('../protocol.ts').BookImportTextResponse>(NOVEL_API.bookshelfImportText, { filePath, outputDir })
+  }
+
+  /** 拆章预览（浏览器上传全文，不落盘）：返回识别到的章节与跳过清单。 */
+  async bookImportTextPreview(text: string, fileName?: string): Promise<import('../protocol.ts').BookImportTextPreviewResponse> {
+    return postJson<import('../protocol.ts').BookImportTextPreviewResponse>(NOVEL_API.bookshelfImportTextPreview, { text, fileName })
+  }
+
+  /** 导入 txt/md 全本（Mode B）：浏览器上传全文内容模式。 */
+  async bookImportTextContent(text: string, fileName: string, outputDir?: string): Promise<import('../protocol.ts').BookImportTextResponse> {
+    return postJson<import('../protocol.ts').BookImportTextResponse>(NOVEL_API.bookshelfImportText, { text, fileName, outputDir })
+  }
+
   /** 生产单：启动批量生产（区间或新增 N 章；计划不足自动补）。 */
   async runStart(req: import('../protocol.ts').RunStartRequest): Promise<import('../protocol.ts').RunState> {
     return postJson<import('../protocol.ts').RunState>(NOVEL_API.runStart, req)
@@ -279,7 +470,7 @@ export class NovelApi {
 
   /** Get project writing assets + built-in libraries. */
   async assets(): Promise<AssetsResponse> {
-    const response = await fetch(NOVEL_API.assets)
+    const response = await fetch(withBookId(NOVEL_API.assets))
     return readJson<AssetsResponse>(response)
   }
 
@@ -366,7 +557,8 @@ export class NovelApi {
     const response = await fetch(NOVEL_API.assistant, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ message }),
+      // 与其它书级请求一致：显式带 bookId，避免切书后被宿主的全局 active 串书。
+      body: JSON.stringify(withBookIdBody({ message })),
     })
     if (!response.ok) {
       await readJson<{ error?: string }>(response)
@@ -396,9 +588,83 @@ export class NovelApi {
     }
   }
 
+  /** 张力曲线：数据 + 规则核对。 */
+  async tension(): Promise<import('../protocol.ts').TensionResponse> {
+    const response = await fetch(withBookId(NOVEL_API.tension))
+    return readJson<import('../protocol.ts').TensionResponse>(response)
+  }
+
+  /** 设置张力曲线预设。 */
+  async tensionPreset(preset: import('../protocol.ts').TensionCurvePreset): Promise<void> {
+    await postJson(NOVEL_API.tension, { op: 'preset', preset })
+  }
+
+  /** 设置/清除某一章的目标张力。 */
+  async tensionSet(chapterNo: number, tension?: number): Promise<void> {
+    await postJson(NOVEL_API.tension, { op: 'set', chapterNo, tension })
+  }
+
+  /** 提示词槽位：列表。 */
+  async promptSlots(): Promise<import('../protocol.ts').PromptSlotsResponse> {
+    const response = await fetch(withBookId(NOVEL_API.promptSlots))
+    return readJson<import('../protocol.ts').PromptSlotsResponse>(response)
+  }
+
+  /** 写入一个提示词槽位（空串 = 清空）。 */
+  async promptSlotSet(id: import('../protocol.ts').PromptSlotId, value: string): Promise<void> {
+    await postJson(NOVEL_API.promptSlots, { id, value })
+  }
+
+  /** 故事时间线：列表（含规则初筛问题）。 */
+  async timeline(): Promise<import('../protocol.ts').TimelineResponse> {
+    const response = await fetch(withBookId(NOVEL_API.timeline))
+    return readJson<import('../protocol.ts').TimelineResponse>(response)
+  }
+
+  /** 抽取某一章的时间线事件。 */
+  async timelineExtract(chapterNo: number): Promise<{ events: import('../protocol.ts').TimelineEvent[] }> {
+    return postJson<{ events: import('../protocol.ts').TimelineEvent[] }>(NOVEL_API.timeline, { op: 'extract', chapterNo })
+  }
+
+  /** 检查时间线矛盾（规则初筛 + AI 复核）。 */
+  async timelineCheck(): Promise<import('../protocol.ts').TimelineResponse> {
+    return postJson<import('../protocol.ts').TimelineResponse>(NOVEL_API.timeline, { op: 'check' })
+  }
+
+  /** 手工修正一条时间线事件。 */
+  async timelineUpdate(event: import('../protocol.ts').TimelineEvent): Promise<void> {
+    await postJson(NOVEL_API.timeline, { op: 'update', event })
+  }
+
+  /** 删除一条时间线事件。 */
+  async timelineRemove(id: string): Promise<void> {
+    await postJson(NOVEL_API.timeline, { op: 'remove', id })
+  }
+
+  /** 章节历史版本列表。 */
+  async snapshots(): Promise<import('../protocol.ts').SnapshotResponse> {
+    const response = await fetch(withBookId(NOVEL_API.snapshot))
+    return readJson<import('../protocol.ts').SnapshotResponse>(response)
+  }
+
+  /** 回滚到某个历史版本。 */
+  async snapshotRestore(id: string): Promise<void> {
+    await postJson(NOVEL_API.snapshot, { op: 'restore', id })
+  }
+
+  /** 给某章手工存档。 */
+  async snapshotCreate(chapterNo: number): Promise<void> {
+    await postJson(NOVEL_API.snapshot, { op: 'create', chapterNo })
+  }
+
+  /** 删除一个历史版本。 */
+  async snapshotRemove(id: string): Promise<void> {
+    await postJson(NOVEL_API.snapshot, { op: 'remove', id })
+  }
+
   /** Load the persisted assistant conversation. */
   async assistantHistory(): Promise<import('../protocol.ts').AssistantMessage[]> {
-    const response = await fetch(NOVEL_API.assistantHistory)
+    const response = await fetch(withBookId(NOVEL_API.assistantHistory))
     const body = await readJson<{ messages: import('../protocol.ts').AssistantMessage[] }>(response)
     return body.messages
   }
@@ -407,4 +673,95 @@ export class NovelApi {
   async assistantClear(): Promise<{ ok: boolean }> {
     return postJson<{ ok: boolean }>(NOVEL_API.assistantClear, {})
   }
+
+  /** 作者资产库/总数据：读取跨书可复用资产。 */
+  async authorAssets(): Promise<import('../protocol.ts').AuthorAssetsResponse> {
+    const response = await fetch(NOVEL_API.authorAssets)
+    return readJson<import('../protocol.ts').AuthorAssetsResponse>(response)
+  }
+
+  /** 作者资产库：新增/更新一条资产（upsert by id）。 */
+  async authorAssetsUpsert(asset: import('../protocol.ts').AuthorStyleAsset): Promise<import('../protocol.ts').AuthorAssetsResponse> {
+    return postJson<import('../protocol.ts').AuthorAssetsResponse>(NOVEL_API.authorAssetsUpsert, { asset })
+  }
+
+  /** 作者资产库：删除一条资产。 */
+  async authorAssetsRemove(id: string): Promise<import('../protocol.ts').AuthorAssetsResponse> {
+    return postJson<import('../protocol.ts').AuthorAssetsResponse>(NOVEL_API.authorAssetsRemove, { id })
+  }
+
+  /** 作者资产库：导入默认（书架书的写作资产/角色 + 内置全局库）批量沉淀。 */
+  async authorAssetsImportDefault(): Promise<import('../protocol.ts').AuthorAssetsResponse> {
+    return postJson<import('../protocol.ts').AuthorAssetsResponse>(NOVEL_API.authorAssetsImportDefault, {})
+  }
+
+  /** 改编模式 P0：上传全文 → 原文设定卡片 / 可改范围矩阵。 */
+  async adaptAnalyze(text: string, filePath?: string): Promise<import('../protocol.ts').AdaptAnalyzeResponse> {
+    return postJson<import('../protocol.ts').AdaptAnalyzeResponse>(NOVEL_API.adaptAnalyze, { text, filePath })
+  }
+
+  /** 改编模式 P1：确认要改的维度 → 生成映射表/改编规则/联动影响清单。 */
+  async adaptPropose(req: import('../protocol.ts').AdaptProposeRequest): Promise<import('../protocol.ts').AdaptProposeResponse> {
+    return postJson<import('../protocol.ts').AdaptProposeResponse>(NOVEL_API.adaptPropose, req)
+  }
+
+  /** 改编模式 P2：执行术语替换（全局替换 + 命中统计 + 改编文本预览）。 */
+  async adaptExecute(req: import('../protocol.ts').AdaptExecuteRequest): Promise<import('../protocol.ts').AdaptExecuteResponse> {
+    return postJson<import('../protocol.ts').AdaptExecuteResponse>(NOVEL_API.adaptExecute, req)
+  }
+
+  /** 改编模式 P3：保存改编全文为新书（原书保留，登记书架）。 */
+  async adaptSave(req: import('../protocol.ts').AdaptSaveRequest): Promise<import('../protocol.ts').AdaptSaveResponse> {
+    return postJson<import('../protocol.ts').AdaptSaveResponse>(NOVEL_API.adaptSave, req)
+  }
+
+  /** 改编模式 P4：从源全文 + 编辑后方案提炼新书资料并保存为「待写新书」。 */
+  async adaptMaterialize(req: import('../protocol.ts').AdaptMaterializeRequest): Promise<import('../protocol.ts').AdaptMaterializeResponse> {
+    return postJson<import('../protocol.ts').AdaptMaterializeResponse>(NOVEL_API.adaptMaterialize, req)
+  }
+
+  /** 改编模式：保存预览/微调后的新书资料为新书（原书保留，登记书架）。 */
+  async adaptMaterializeSave(req: AdaptMaterializeSaveRequest): Promise<AdaptMaterializeSaveResponse> {
+    return postJson<AdaptMaterializeSaveResponse>(NOVEL_API.adaptMaterializeSave, req)
+  }
+
+  /** 改编模式：rewrite 逐章重写（NDJSON 流式进度，支持分段 startNo/endNo）。 */
+  async adaptRewriteStream(req: AdaptExecuteRequest, onFrame: (frame: AdaptRewriteFrame) => void): Promise<void> {
+    const response = await fetch(NOVEL_API.adaptRewriteStream, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(req),
+    })
+    if (!response.ok) {
+      await readJson<{ error?: string }>(response)
+      return
+    }
+    if (response.body === null) throw new NovelApiError('adapt rewrite: no response body')
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+      for (const line of lines) {
+        if (line.trim() === '') continue
+        let frame: AdaptRewriteFrame
+        try {
+          frame = JSON.parse(line) as AdaptRewriteFrame
+        } catch {
+          continue
+        }
+        onFrame(frame)
+        if (frame.type === 'error') throw new NovelApiError(frame.message)
+      }
+    }
+  }
+
+  /** 主题自定义背景：上传图片，服务端存盘并返回可访问 URL。 */
+  async themeBackgroundUpload(dataUrl: string): Promise<{ url: string }> {
+    return postJson<{ url: string }>(NOVEL_API.themeBackgroundUpload, { dataUrl })
+  }
 }

package/src/client/chip-prefs.ts

@@ -0,0 +1,121 @@
+/**
+ * 右上角「小说工坊生成状态」芯片的显示偏好（纯客户端、localStorage）。
+ *
+ * 为什么是 localStorage 而不是插件配置：这是纯界面 chrome，与显示模式 / 界面密度 /
+ * 编辑器字号 / 芯片自身的位置记忆同类；哪个浏览器想清屏就哪个浏览器清，不需要跨端同步。
+ * 将来若要跨端，把键名沿用成 config 字段 `showRunChip` 即可平滑升级。
+ *
+ * 三态：
+ *   off    关闭（同时停止 4 秒轮询，不白跑）
+ *   active 只在生产单**运行中或已暂停**时显示（不想错过生成，也不想留残影）
+ *   always 只要该目录有生产单状态就显示（默认，保持历史行为）
+ */
+
+import type { RunState } from '../protocol.ts'
+
+export type RunChipMode = 'off' | 'active' | 'always'
+
+/** localStorage 键（与芯片位置记忆同一命名空间）。 */
+export const RUN_CHIP_MODE_KEY = 'dsh-novel-forge.runChip.mode'
+
+/** 同页变更通知用的自定义事件名（跨标签页走原生 storage 事件）。 */
+export const RUN_CHIP_MODE_EVENT = 'dsh-novel-forge:runchip-mode'
+
+/** 默认值与历史行为一致：有生产单状态就显示。 */
+export const DEFAULT_RUN_CHIP_MODE: RunChipMode = 'always'
+
+/** 设置页下拉用的三态选项（顺序即用户看到的顺序）。 */
+export const RUN_CHIP_MODE_OPTIONS: ReadonlyArray<{ value: RunChipMode; label: string }> = [
+  { value: 'always', label: '总是显示' },
+  { value: 'active', label: '仅生成中 / 暂停时显示' },
+  { value: 'off', label: '关闭' },
+]
+
+const ALL_MODES: readonly RunChipMode[] = ['off', 'active', 'always']
+
+function isMode(value: unknown): value is RunChipMode {
+  return typeof value === 'string' && (ALL_MODES as readonly string[]).includes(value)
+}
+
+/** 安全拿 localStorage：隐私模式 / 非浏览器环境下为 undefined。 */
+function storage(): Storage | undefined {
+  try {
+    return typeof localStorage === 'undefined' ? undefined : localStorage
+  } catch {
+    return undefined
+  }
+}
+
+/** 读取偏好（缺失 / 非法 / 存储不可用 → 默认值）。 */
+export function readRunChipMode(): RunChipMode {
+  try {
+    const raw = storage()?.getItem(RUN_CHIP_MODE_KEY)
+    return isMode(raw) ? raw : DEFAULT_RUN_CHIP_MODE
+  } catch {
+    return DEFAULT_RUN_CHIP_MODE
+  }
+}
+
+/** 已注册的同页监听者（storage 事件只覆盖跨标签页，同页要靠这里）。 */
+const listeners = new Set<(mode: RunChipMode) => void>()
+
+/** 写入偏好并通知所有监听者；存储不可用时仍通知（本次会话内生效）。 */
+export function writeRunChipMode(mode: RunChipMode): void {
+  try {
+    storage()?.setItem(RUN_CHIP_MODE_KEY, mode)
+  } catch {
+    /* 存储不可用：本次会话内仍然生效 */
+  }
+  for (const listener of [...listeners]) {
+    try {
+      listener(mode)
+    } catch {
+      /* 单个监听者出错不影响其他人 */
+    }
+  }
+  try {
+    if (typeof window !== 'undefined' && typeof CustomEvent === 'function') {
+      window.dispatchEvent(new CustomEvent(RUN_CHIP_MODE_EVENT, { detail: mode }))
+    }
+  } catch {
+    /* 事件派发失败无关紧要 */
+  }
+}
+
+/** 订阅偏好变化（同页 + 跨标签页 storage）；返回退订函数。 */
+export function subscribeRunChipMode(listener: (mode: RunChipMode) => void): () => void {
+  listeners.add(listener)
+  const onStorage = (event: StorageEvent): void => {
+    if (event.key !== null && event.key !== RUN_CHIP_MODE_KEY) return
+    listener(readRunChipMode())
+  }
+  let attached = false
+  try {
+    if (typeof window !== 'undefined') {
+      window.addEventListener('storage', onStorage)
+      attached = true
+    }
+  } catch {
+    attached = false
+  }
+  return () => {
+    listeners.delete(listener)
+    if (!attached) return
+    try {
+      window.removeEventListener('storage', onStorage)
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * 给定偏好与当前生产单状态，判断芯片是否应可见。
+ * null（没有生产单状态）永远不显示——这是渲染层与测试共用的唯一判据。
+ */
+export function isRunChipVisible(mode: RunChipMode, state: RunState | null | undefined): boolean {
+  if (state === null || state === undefined) return false
+  if (mode === 'off') return false
+  if (mode === 'active') return state.status === 'running' || state.status === 'paused'
+  return true
+}