dsh-novel-generator 0.1.16 → 0.1.18

package/README.md

@@ -62,6 +62,12 @@ dsh plugin --profile web add dsh-novel-generator
 - 生成、推演、快照都是异步任务：`POST /generate`、`POST /compose`、`POST /deduce`、`POST /snapshot/refresh` 返回 `jobId`，再由 `GET /job?id=` 轮询。
 - `timeline.cursor` 现在以「天」为单位；旧数据（按格计数）在首次读取时自动换算一次并标记 `cursorUnit: "day"`。
 
+## 迁移、导入与会话
+
+- **改目录**：作品列表每行的「改目录」会把整个作品文件夹搬到新目录，作品的 `cwd` 随之更新；目标目录已有同名非空文件夹时拒绝。
+- **导入已有作品**：列表上方的「导入已有作品…」选中一个作品文件夹（含 `作品信息.md`），插件从文件重建条目——章节、大纲、梗概、字数、时间长度、世界快照都会读回来，并新建一个会话。这既是手动迁移入口，也是 `.dsh/novel-studio` 数据丢失后的恢复路径。
+- **会话**：作品与会话一对一。会话被删除时插件会自动重建；被**归档**时探测不到（DSH 无查询接口），用「重建会话」按钮手动换一个。会话的模型会在每次任务前与作品记录的模型对齐。
+
 ## 自检脚本（开发用，不随包发布）
 
 ```bash

package/client.js

@@ -187,6 +187,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 .dsn-input.dsn-readonly:focus{border-color:var(--dsw-alias-border-l1)}
 .dsn-input.dsn-input-invalid{border-color:var(--dsw-alias-state-warn-primary)}
 .dsn-path{display:flex;gap:6px}
+.dsn-import{display:flex;align-items:center;gap:10px;margin:2px 0 12px}
 .dsn-list{display:flex;flex-direction:column;gap:8px}
 .dsn-row{display:flex;align-items:center;gap:12px;padding:12px 14px;border-radius:12px;
   border:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-1);cursor:pointer}
@@ -515,6 +516,65 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
         }
       }, [onReload]);
 
+      /** Move a work's folder to another directory. */
+      const moveWork = useCallback(async (project) => {
+        const ui = typeof resolveWorkspace === 'function' ? resolveWorkspace() : null;
+        if (!ui || typeof ui.pickDirectory !== 'function') {
+          setError(t('目录选择器还没就绪，请稍后再试', 'The directory picker is not ready yet — try again in a moment.'));
+          return;
+        }
+        let picked = '';
+        try {
+          picked = (await ui.pickDirectory()) || '';
+        } catch (pickError) {
+          setError(messageOf(pickError));
+          return;
+        }
+        if (!picked) return;
+        if (!window.confirm(t('把「{title}」整个文件夹移到 {cwd} 吗？正文、梗概、快照会一起搬过去。', 'Move the whole “{title}” folder to {cwd}? Chapters, outlines and snapshots travel with it.', { title: project.title, cwd: picked }))) return;
+        try {
+          await api('/project/move', { projectId: project.projectId, cwd: picked });
+          await onReload();
+        } catch (moveError) {
+          setError(messageOf(moveError));
+        }
+      }, [resolveWorkspace, onReload]);
+
+      /** Adopt an existing work folder that the plugin does not know about. */
+      const importWork = useCallback(async () => {
+        const ui = typeof resolveWorkspace === 'function' ? resolveWorkspace() : null;
+        if (!ui || typeof ui.pickDirectory !== 'function') {
+          setError(t('目录选择器还没就绪，请稍后再试', 'The directory picker is not ready yet — try again in a moment.'));
+          return;
+        }
+        let picked = '';
+        try {
+          picked = (await ui.pickDirectory()) || '';
+        } catch (pickError) {
+          setError(messageOf(pickError));
+          return;
+        }
+        if (!picked) return;
+        const parts = picked.split(/[\\/]+/).filter(Boolean);
+        const folder = parts.pop() || '';
+        const parent = parts.join('\\');
+        if (!folder || !parent) {
+          setError(t('请选择作品文件夹本身，而不是磁盘根目录', 'Pick the work folder itself, not a drive root.'));
+          return;
+        }
+        try {
+          const result = await api('/project/import', { cwd: parent, folder });
+          await onReload();
+          setError(t('已导入「{title}」：{chapters} 章、{snapshots} 份快照', 'Imported “{title}”: {chapters} chapters, {snapshots} snapshots', {
+            title: result.project.title,
+            chapters: result.imported.chapters,
+            snapshots: result.imported.snapshots,
+          }));
+        } catch (importError) {
+          setError(messageOf(importError));
+        }
+      }, [resolveWorkspace, onReload]);
+
       return h('div', { className: 'dsn-projects' },
         h('div', { className: 'dsn-create' },
           h('label', { className: 'dsn-field' },
@@ -574,6 +634,15 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
               onClick: create,
             }, busy ? t('创建中…', "Creating…") : t('创建作品并开会话', "Create work and open its session")))),
 
+        h('div', { className: 'dsn-import' },
+          h('button', {
+            className: 'dsn-btn ghost',
+            type: 'button',
+            title: t('把别处已有的作品文件夹接进来（章节、梗概、快照会从文件读回）', 'Adopt an existing work folder: chapters, outlines and snapshots are read back from the files'),
+            onClick: importWork,
+          }, t('导入已有作品…', "Import a work…")),
+          h('span', { className: 'dsn-hint' }, t('选择那个作品文件夹本身（含「作品信息.md」的目录）', 'Pick the work folder itself — the one holding 作品信息.md'))),
+
         error ? h('div', { className: 'dsn-error', style: { margin: 0 } }, error) : null,
 
         h('div', { className: 'dsn-list' },
@@ -617,6 +686,15 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
                 }
               },
             }, t('重建会话', "New session")),
+            h('button', {
+              className: 'dsn-btn ghost',
+              type: 'button',
+              title: t('把这个作品的文件夹搬到别的工作目录', 'Move this work’s folder to another working directory'),
+              onClick: (event) => {
+                event.stopPropagation();
+                moveWork(project);
+              },
+            }, t('改目录', "Move")),
             h('button', {
               className: 'dsn-btn danger ghost',
               type: 'button',
@@ -1041,7 +1119,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
     /* ---------------------------------------------------------- outline page */
 
-    function OutlinePage({ detail, chapter, isFirstChapter, onBack, onSaved, notify, onRegisterGuard, requestConfirm }) {
+    function OutlinePage({ detail, chapter, isFirstChapter, onBack, onSaved, notify, onRegisterGuard, requestConfirm, onBusyChange }) {
       const buildForm = useCallback(() => ({
         title: chapter ? chapter.title || '' : '',
         durationDays: chapter && chapter.outline ? chapter.outline.durationDays : (detail.timeline.unitDays || 30),
@@ -1182,6 +1260,22 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
         });
       }, [requestConfirm, startJob]);
 
+      // Report the running job upward so the studio can lock itself and warn
+      // before the panel is closed mid-generation.
+      useEffect(() => {
+        if (typeof onBusyChange !== 'function') return;
+        const running = job && job.state === 'running';
+        if (!running) {
+          onBusyChange(null);
+          return undefined;
+        }
+        onBusyChange({
+          label: job.kind === 'compose' ? t('正在自动推演…', 'Deducing…') : t('正在生成章节故事…', 'Generating the chapter…'),
+          message: job.message || '',
+        });
+        return () => onBusyChange(null);
+      }, [job ? job.jobId : null, job ? job.state : null, job ? job.message : null, onBusyChange]);
+
       useEffect(() => {
         if (!job) return;
         if (job.kind === 'generate' && job.state === 'done') {
@@ -1312,7 +1406,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
      * The only place a chapter is created: word bounds and the story length are
      * required, and one button can deduce the synopsis and write the chapter.
      */
-    function NewChapterDialog({ detail, startDay, onCancel, onCreated, notify }) {
+    function NewChapterDialog({ detail, startDay, onCancel, onCreated, notify, onBusyChange }) {
       const [form, setForm] = useState({
         title: '',
         minWords: 1200,
@@ -1337,6 +1431,20 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
       const composing = Boolean(job && job.state === 'running' && job.kind === 'compose');
 
+      // A deducing dialog locks the studio behind it and warns before closing.
+      useEffect(() => {
+        if (typeof onBusyChange !== 'function') return undefined;
+        if (!composing) {
+          onBusyChange(null);
+          return undefined;
+        }
+        onBusyChange({
+          label: t('正在自动推演新章节…', 'Deducing a new chapter…'),
+          message: (job && job.message) || '',
+        });
+        return () => onBusyChange(null);
+      }, [composing, job ? job.message : null, onBusyChange]);
+
       const create = useCallback(async () => {
         setBusy(true);
         setError('');
@@ -1500,13 +1608,25 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
 
     /* ------------------------------------------------------------- workspace */
 
-    function ProjectWorkspace({ detail, onReload, notify, onRegisterLeaveGuard }) {
+    function ProjectWorkspace({ detail, onReload, notify, onRegisterLeaveGuard, onBusyChange }) {
       const [view, setView] = useState('world');
       const [chapterId, setChapterId] = useState(null);
       // 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;
+      // The same idea for the chapter jobs (自动推演 / 生成章节故事), reported up
+      // by the pages that own them.
+      const [childBusy, setChildBusy] = useState(null);
+      const busy = snapshotJob || childBusy;
+      const snapshotBusy = Boolean(snapshotJob);
+
+      // Tell the shell whether a long operation is in flight, so closing the
+      // panel can ask first.
+      useEffect(() => {
+        if (typeof onBusyChange !== 'function') return undefined;
+        onBusyChange(busy ? { label: busy.label, message: busy.message } : null);
+        return () => onBusyChange(null);
+      }, [busy ? busy.label : null, busy ? busy.message : null, onBusyChange]);
       const [dialogOpen, setDialogOpen] = useState(false);
       const [text, setText] = useState('');
       const [dirty, setDirty] = useState(false);
@@ -1706,14 +1826,14 @@ 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
+        // Any running job owns the work: nothing else may be edited while it
+        // rewrites the novel underneath.
+        busy
           ? 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.'))))
+              h('div', { className: 'dsn-lock-title' }, busy.label),
+              h('div', { className: 'dsn-lock-text' }, busy.message),
+              h('div', { className: 'dsn-lock-hint' }, t('生成期间界面不可操作，完成后会自动刷新', 'The studio is locked while this runs; it refreshes when done.'))))
           : null,
         h('div', { className: 'dsn-track', style: { transform: `translateX(-${trackIndex * 100}%)` } },
           h('section', { className: 'dsn-page' },
@@ -1756,6 +1876,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
               notify,
               onRegisterGuard: registerOutlineGuard,
               requestConfirm: setConfirmRequest,
+              onBusyChange: setChildBusy,
               isFirstChapter: Boolean(chapter && chapters.length > 0 && chapter.chapterId === chapters[0].chapterId),
             }))),
         confirmRequest
@@ -1804,6 +1925,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
             onCancel: () => setDialogOpen(false),
             onCreated: created,
             notify,
+            onBusyChange: setChildBusy,
           })
           : null);
     }
@@ -1818,6 +1940,8 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
       const [projectId, setProjectId] = useState(null);
       const [detail, setDetail] = useState(null);
       const [toast, setToast] = useToast();
+      // Set while a work runs a model job, so leaving the panel can warn first.
+      const [busyNow, setBusyNow] = useState(null);
       const [modelTarget, setModelTarget] = useState(null);
       const leaveGuard = useRef(null);
       const registerLeaveGuard = useCallback((guard) => {
@@ -1825,13 +1949,21 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
       }, []);
       /** Every way out of the studio asks the workspace first. */
       const requestLeave = useCallback((proceed) => {
+        // A running generation outranks the editor guard: say it is still going
+        // before anything closes.
+        if (busyNow) {
+          const label = busyNow.label || t('正在生成', 'Generation is running');
+          if (!window.confirm(t('{label}，现在离开吗？生成会在后台继续，回来时刷新即可看到结果。', '{label} — leave now? It keeps running in the background; reopen the panel later to see the result.', { label }))) return;
+          proceed();
+          return;
+        }
         const guard = leaveGuard.current;
         if (typeof guard === 'function') {
           guard(proceed);
           return;
         }
         proceed();
-      }, []);
+      }, [busyNow]);
       const close = useCallback(() => requestLeave(() => setOverlayOpen(false)), [requestLeave]);
 
       const loadBoot = useCallback(async () => {
@@ -1911,6 +2043,7 @@ body[data-ds-dark-theme] .dsn-shell{color-scheme:dark}
                   onReload: reloadDetail,
                   notify,
                   onRegisterLeaveGuard: registerLeaveGuard,
+                  onBusyChange: setBusyNow,
                 })),
         modelTarget
           ? h(ModelDialog, {

package/index.js

@@ -14,6 +14,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
+import path from 'node:path';
 
 export const name = 'dsh-novel-generator';
 export const inject = ['webServer'];
@@ -891,6 +892,9 @@ async function rebindSession(ctx, root, project) {
     draft.sessionId = sessionId;
   });
   try {
+    // The memo skips projects already grouped; a rebind starts a new session
+    // that has never been grouped, so the entry has to go.
+    ensuredWorkspaces.delete(project.projectId);
     await ensureWorkspace(ctx, root, project);
   } catch {
     // Grouping is cosmetic; the session works either way.
@@ -900,6 +904,27 @@ async function rebindSession(ctx, root, project) {
   return { controller, agent: result.agent };
 }
 
+/**
+ * Keep the work's Session on the work's model.
+ *
+ * A session remembers the model it was last given, so a rebuilt session — or a
+ * switch that quietly failed on an archived one — can leave it on a different
+ * model than the work records. The pairing is re-applied whenever they differ.
+ */
+const syncedSessionModels = new Map();
+
+async function syncSessionModel(controller, project) {
+  if (!project || !project.sessionId || !project.model || !project.model.provider || !project.model.model) return;
+  const key = `${project.model.provider}/${project.model.model}`;
+  if (syncedSessionModels.get(project.sessionId) === key) return;
+  try {
+    await controller.selectModel({ sessionId: project.sessionId, ...project.model });
+    syncedSessionModels.set(project.sessionId, key);
+  } catch {
+    // The work still records the model; the next job tries again.
+  }
+}
+
 /** Resolve (or resume) the ordinary Agent that owns one project's Session. */
 async function resolveAgent(ctx, root, project, onNote) {
   const controller = ctx.get('sessionController');
@@ -930,7 +955,10 @@ async function resolveAgent(ctx, root, project, onNote) {
   } catch {
     result = null;
   }
-  if (result && result.agent) return { controller, agent: result.agent };
+  if (result && result.agent) {
+    await syncSessionModel(controller, project);
+    return { controller, agent: result.agent };
+  }
   // The old session is gone: rebuild instead of failing every later call.
   const rebuilt = await rebindSession(ctx, root, project);
   if (onNote) onNote('原作品会话已不存在，已自动新建一个会话继续');
@@ -1361,7 +1389,7 @@ async function bootstrap(ctx, root) {
     }
   }
   return {
-    revision: '2026-10-20.44',
+    revision: '2026-10-21.2',
     projects,
     models: {
       default: modelCatalog.default || null,
@@ -1516,6 +1544,236 @@ async function updateModel(ctx, root, body) {
   return { project: projectSummary, warning };
 }
 
+/**
+ * Move one work's folder to another directory and repoint the work at it.
+ *
+ * The folder is the work: chapter text, outlines and snapshots travel with it.
+ * A destination that already holds someone else's files is refused, exactly as
+ * creation refuses it.
+ */
+async function moveProject(ctx, root, body) {
+  const projectId = asText(body.projectId);
+  if (projectId === '') throw httpError(400, '缺少 projectId');
+  const cwd = asText(body.cwd);
+  if (cwd === '') throw httpError(400, '请选择新的工作目录');
+  try {
+    const info = await stat(cwd);
+    if (!info.isDirectory()) throw new Error('not a directory');
+  } catch {
+    throw httpError(400, '新的工作目录不存在或不是文件夹');
+  }
+  const project = await readProject(root, projectId);
+  if (path.resolve(cwd) === path.resolve(project.cwd)) {
+    throw httpError(409, '新旧工作目录相同，无需移动');
+  }
+  const from = projectContentDir(project);
+  const to = join(cwd, safeSegment(project.title, '未命名作品'));
+  const claimed = await reserveWorkFolder({ projectId, title: project.title, cwd }, projectId);
+  if (path.resolve(claimed) !== path.resolve(to)) {
+    throw httpError(409, `目标目录下已经有名为「${basename(to)}」的文件夹，请先在那边清空或删掉`);
+  }
+  if (await pathExists(from)) {
+    await moveTree(from, to);
+  }
+  const moved = await mutateProject(root, projectId, (draft) => {
+    draft.cwd = cwd;
+    draft.updatedAt = Date.now();
+    return summarize(draft);
+  });
+  await persistProject(root, await readProject(root, projectId));
+  return { project: moved, from, to };
+}
+
+/** Copy-then-delete move that also works across drives. */
+async function moveTree(from, to) {
+  try {
+    await rename(from, to);
+    return;
+  } catch {
+    // Cross-device rename fails; fall through to a copy.
+  }
+  await mkdir(to, { recursive: true });
+  for (const entry of await readdir(from, { withFileTypes: true })) {
+    const source = join(from, entry.name);
+    const target = join(to, entry.name);
+    if (entry.isDirectory()) await moveTree(source, target);
+    else await rename(source, target).catch(async () => {
+      await writeFile(target, await readFile(source));
+      await unlink(source);
+    });
+  }
+  await rm(from, { recursive: true, force: true });
+}
+
+/**
+ * Adopt a work folder that lives outside the plugin's index — the manual
+ * migration path, and the way back from a lost `.dsh/novel-studio` data
+ * directory. Chapters, outlines and snapshots are read back from the files.
+ */
+async function importProject(ctx, root, body) {
+  const cwd = asText(body.cwd);
+  const folder = asText(body.folder);
+  if (cwd === '' || folder === '') throw httpError(400, '请填写工作目录与作品文件夹名');
+  const dir = join(cwd, folder);
+  let info;
+  try {
+    info = await stat(dir);
+    if (!info.isDirectory()) throw new Error('not a directory');
+  } catch {
+    throw httpError(400, `找不到作品文件夹：${dir}`);
+  }
+  const title = folder;
+  const titleIssue = titleProblem(title);
+  if (titleIssue !== null) throw httpError(400, titleIssue);
+
+  const existing = (await listProjects(root)).find((entry) => path.resolve(entry.cwd) === path.resolve(cwd) && entry.title === title);
+  if (existing) throw httpError(409, '这部作品已经导入过了');
+
+  const files = (await readdir(dir).catch(() => [])).filter((name) => name.endsWith('.md'));
+  let subtitle = '';
+  try {
+    const infoText = await readFile(join(dir, '作品信息.md'), 'utf8');
+    const match = infoText.match(/#\s*作品[：:]\s*(.+)/u);
+    if (match) subtitle = match[1].trim();
+  } catch {
+    // No 作品信息.md: the folder name is the title.
+  }
+
+  const chapters = [];
+  const outlineDir = join(dir, '章节大纲');
+  let outlineNames = [];
+  try {
+    outlineNames = (await readdir(outlineDir)).filter((name) => name.endsWith('.md'));
+  } catch {
+    outlineNames = [];
+  }
+  let runningStart = 0;
+  const sorted = outlineNames
+    .map((name) => ({ name, index: Number((name.match(/第(\d+)章/u) || [])[1] || 0) }))
+    .filter((entry) => entry.index > 0)
+    .sort((a, b) => a.index - b.index);
+  for (const entry of sorted) {
+    let text = '';
+    try {
+      text = await readFile(join(outlineDir, entry.name), 'utf8');
+    } catch {
+      continue;
+    }
+    const heading = (text.match(/^#\s*第\s*\d+\s*章\s*(.*)$/mu) || [])[1] || '';
+    const span = text.match(/故事时间：第\s*(\d+)\s*→\s*(\d+)\s*天/u);
+    const words = text.match(/字数要求：\s*(\d+)\s*[–-]\s*(\d+)/u);
+    const synopsisMin = text.match(/梗概最低字数：\s*(\d+)/u);
+    const synopsis = (text.split('## 故事梗概')[1] || '').trim();
+    const startDay = span ? Number(span[1]) : runningStart;
+    const endDay = span ? Number(span[2]) : startDay + 30;
+    runningStart = endDay;
+    const chapterTitle = heading.trim() || `第 ${entry.index} 章`;
+    let content = '';
+    const bodyName = files.find((name) => name.startsWith(`第${String(entry.index).padStart(2, '0')}章`));
+    if (bodyName) {
+      try {
+        content = await readFile(join(dir, bodyName), 'utf8');
+      } catch {
+        content = '';
+      }
+    }
+    chapters.push({
+      chapterId: randomUUID(),
+      index: entry.index - 1,
+      title: chapterTitle,
+      startDay,
+      durationDays: Math.max(1, endDay - startDay),
+      outline: {
+        synopsis,
+        synopsisMinChars: synopsisMin ? Number(synopsisMin[1]) : 100,
+        durationDays: Math.max(1, endDay - startDay),
+        minWords: words ? Number(words[1]) : 1200,
+        maxWords: words ? Number(words[2]) : 3500,
+        savedAt: Date.now(),
+      },
+      content,
+      wordCount: wordCount(content),
+      status: content.trim() === '' ? 'outlined' : 'generated',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      generatedAt: content.trim() === '' ? null : Date.now(),
+    });
+  }
+
+  const snapshots = [];
+  const snapshotDir = join(dir, '世界快照');
+  let snapshotNames = [];
+  try {
+    snapshotNames = (await readdir(snapshotDir)).filter((name) => name.endsWith('.json'));
+  } catch {
+    snapshotNames = [];
+  }
+  for (const name of snapshotNames.sort()) {
+    try {
+      const data = JSON.parse(await readFile(join(snapshotDir, name), 'utf8'));
+      const day = Number((name.match(/第(\d+)天/u) || [])[1] || 0);
+      const normalized = normalizeSnapshot(data);
+      snapshots.push({
+        snapshotId: randomUUID(),
+        day,
+        createdAt: Date.now(),
+        unitDays: Number(data.unitDays) || 30,
+        ...normalized,
+      });
+    } catch {
+      // A malformed sidecar is skipped, not fatal.
+    }
+  }
+  snapshots.sort((a, b) => a.day - b.day);
+
+  const unitDays = snapshots.length ? snapshots[snapshots.length - 1].unitDays : 30;
+  const project = {
+    projectId: randomUUID(),
+    title,
+    cwd,
+    agentPreset: null,
+    model: null,
+    sessionId: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    timeline: {
+      unitDays,
+      cursor: Math.max(lastChapterEnd({ chapters }), snapshots.length ? snapshots[snapshots.length - 1].day : 0),
+      origin: new Date().toISOString().slice(0, 10),
+      cursorUnit: 'day',
+    },
+    chapters,
+    snapshots,
+  };
+  await writeJson(projectFile(root, project.projectId), project);
+  await persistProject(root, project);
+  const created = await createSessionFor(ctx, root, project);
+  return {
+    project: summarize(await readProject(root, project.projectId)),
+    imported: { chapters: chapters.length, snapshots: snapshots.length, subtitle },
+    sessionId: created,
+  };
+}
+
+/** Give a freshly imported work its own session (best effort). */
+async function createSessionFor(ctx, root, project) {
+  const controller = ctx.get('sessionController');
+  if (!controller) return null;
+  try {
+    const created = await controller.create({ cwd: project.cwd });
+    const sessionId = created && created.sessionId ? created.sessionId : null;
+    if (!sessionId) return null;
+    project.sessionId = sessionId;
+    await mutateProject(root, project.projectId, (draft) => {
+      draft.sessionId = sessionId;
+    });
+    await ensureWorkspace(ctx, root, project);
+    return sessionId;
+  } catch {
+    return null;
+  }
+}
+
 async function updateTimeline(root, body) {
   const projectId = asText(body.projectId);
   const unitDays = Number(body.unitDays);
@@ -2184,6 +2442,10 @@ async function dispatch(ctx, root, registry, method, path, url, body) {
       return updateModel(ctx, root, body);
     case '/project/rebind':
       return rebindProject(ctx, root, body);
+    case '/project/move':
+      return moveProject(ctx, root, body);
+    case '/project/import':
+      return importProject(ctx, root, body);
     case '/outline/save':
       return saveOutline(root, body);
     case '/chapter/save':

package/package.json

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