novel-writer-cli 0.0.3 → 0.1.0

package/dist/__tests__/volume-review-pipeline.test.js

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { advanceCheckpointForStep } from "../advance.js";
+import { computeNextStep } from "../next-step.js";
+async function writeJson(absPath, payload) {
+    await mkdir(dirname(absPath), { recursive: true });
+    await writeFile(absPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+async function exists(absPath) {
+    try {
+        await stat(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+test("computeNextStep progresses through volume review phases based on artifacts", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-vol-review-phases-"));
+    // 1) no artifacts => collect
+    let next = await computeNextStep(rootDir, {
+        last_completed_chapter: 10,
+        current_volume: 1,
+        orchestrator_state: "VOL_REVIEW",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:collect");
+    // 2) quality summary exists => audit
+    await mkdir(join(rootDir, "staging/vol-review"), { recursive: true });
+    await writeJson(join(rootDir, "staging/vol-review/quality-summary.json"), { schema_version: 1, generated_at: new Date().toISOString() });
+    next = await computeNextStep(rootDir, {
+        last_completed_chapter: 10,
+        current_volume: 1,
+        orchestrator_state: "VOL_REVIEW",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:audit");
+    // 3) audit report exists => report
+    await writeJson(join(rootDir, "staging/vol-review/audit-report.json"), { schema_version: 1, generated_at: new Date().toISOString(), stats: {} });
+    next = await computeNextStep(rootDir, {
+        last_completed_chapter: 10,
+        current_volume: 1,
+        orchestrator_state: "VOL_REVIEW",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:report");
+    // 4) review report exists => cleanup
+    await writeFile(join(rootDir, "staging/vol-review/review-report.md"), "# report\n", "utf8");
+    next = await computeNextStep(rootDir, {
+        last_completed_chapter: 10,
+        current_volume: 1,
+        orchestrator_state: "VOL_REVIEW",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:cleanup");
+    // 5) foreshadow status exists => transition
+    await writeJson(join(rootDir, "staging/vol-review/foreshadow-status.json"), { schema_version: 1, generated_at: new Date().toISOString() });
+    next = await computeNextStep(rootDir, {
+        last_completed_chapter: 10,
+        current_volume: 1,
+        orchestrator_state: "VOL_REVIEW",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:transition");
+});
+test("advanceCheckpointForStep(review:transition) increments volume, returns to WRITING, and clears review artifacts", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-vol-review-transition-"));
+    await mkdir(join(rootDir, "staging/vol-review"), { recursive: true });
+    // checkpoint
+    await writeFile(join(rootDir, ".checkpoint.json"), `${JSON.stringify({ last_completed_chapter: 10, current_volume: 1, orchestrator_state: "VOL_REVIEW", pipeline_stage: "committed", inflight_chapter: null }, null, 2)}\n`, "utf8");
+    // required artifacts for transition validation
+    await writeJson(join(rootDir, "staging/vol-review/quality-summary.json"), { schema_version: 1, generated_at: new Date().toISOString() });
+    await writeJson(join(rootDir, "staging/vol-review/audit-report.json"), { schema_version: 1, generated_at: new Date().toISOString(), stats: {} });
+    await writeFile(join(rootDir, "staging/vol-review/review-report.md"), "# report\n", "utf8");
+    await writeJson(join(rootDir, "staging/vol-review/foreshadow-status.json"), { schema_version: 1, generated_at: new Date().toISOString() });
+    const updated = await advanceCheckpointForStep({ rootDir, step: { kind: "review", phase: "transition" } });
+    assert.equal(updated.current_volume, 2);
+    assert.equal(updated.orchestrator_state, "WRITING");
+    assert.equal(updated.pipeline_stage, "committed");
+    assert.equal(updated.inflight_chapter, null);
+    assert.equal(updated.revision_count, 0);
+    assert.equal(updated.hook_fix_count, 0);
+    assert.equal(updated.title_fix_count, 0);
+    assert.equal(await exists(join(rootDir, "staging/vol-review")), false);
+});
+test("advanceCheckpointForStep refuses to advance review steps from CHAPTER_REWRITE", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-vol-review-guard-"));
+    await writeFile(join(rootDir, ".checkpoint.json"), `${JSON.stringify({ last_completed_chapter: 10, current_volume: 1, orchestrator_state: "CHAPTER_REWRITE", pipeline_stage: "revising", inflight_chapter: 11 }, null, 2)}\n`, "utf8");
+    await assert.rejects(() => advanceCheckpointForStep({ rootDir, step: { kind: "review", phase: "collect" } }), /Refusing to advance review step from orchestrator_state=CHAPTER_REWRITE/);
+});
+test("computeNextStep enters volume review after committing volume-end chapter when outline range matches", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-vol-review-enter-"));
+    await mkdir(join(rootDir, "volumes/vol-01"), { recursive: true });
+    await writeFile(join(rootDir, "volumes/vol-01/outline.md"), "### 第 1 章\n\n### 第 2 章\n", "utf8");
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 2,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "committed",
+        inflight_chapter: null
+    });
+    assert.equal(next.step, "review:collect");
+    assert.equal(next.reason, "volume_end:vol_review:missing_quality_summary");
+});

package/dist/__tests__/volume-review-storyline-rhythm.test.js

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { computeStorylineRhythm } from "../volume-review.js";
+test("computeStorylineRhythm counts multiple storyline_id entries per chapter (unique per chapter)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-storyline-rhythm-"));
+    await mkdir(join(rootDir, "summaries"), { recursive: true });
+    await writeFile(join(rootDir, "summaries/chapter-001-summary.md"), `storyline_id: main\nstoryline_id: side\nstoryline_id: side\n`, "utf8");
+    await writeFile(join(rootDir, "summaries/chapter-002-summary.md"), `storyline_id: side\n`, "utf8");
+    const res = await computeStorylineRhythm({ rootDir, volume: 1, chapter_range: [1, 2] });
+    const obj = res;
+    assert.equal(obj.schema_version, 1);
+    assert.deepEqual(obj.appearances, { main: 1, side: 2 });
+    assert.deepEqual(obj.last_seen, { main: 1, side: 2 });
+    assert.ok(Array.isArray(obj.warnings));
+    assert.ok(obj.warnings.some((w) => w.includes("Missing optional file: volumes/vol-01/storyline-schedule.json")));
+});

package/dist/advance.js

@@ -3,11 +3,10 @@ import { readCheckpoint, writeCheckpoint } from "./checkpoint.js";
 import { NovelCliError } from "./errors.js";
 import { removePath } from "./fs-utils.js";
 import { withWriteLock } from "./lock.js";
-import { chapterRelPaths, titleFixSnapshotRel } from "./steps.js";
+import { chapterRelPaths, formatStepId, titleFixSnapshotRel } from "./steps.js";
 import { validateStep } from "./validate.js";
+import { VOL_REVIEW_RELS } from "./volume-review.js";
 function stageForStep(step) {
-    if (step.kind !== "chapter")
-        throw new NovelCliError(`Unsupported step kind: ${step.kind}`, 2);
     switch (step.stage) {
         case "draft":
             return "drafting";
@@ -21,55 +20,153 @@ function stageForStep(step) {
             return "refined";
         case "hook-fix":
             return "refined";
-        default:
-            throw new NovelCliError(`Unsupported step stage: ${step.stage}`, 2);
+        case "review":
+        case "commit":
+            throw new NovelCliError(`Unsupported step stage for advance: ${step.stage}`, 2);
+        default: {
+            const _exhaustive = step.stage;
+            throw new NovelCliError(`Unsupported step stage: ${_exhaustive}`, 2);
+        }
     }
 }
 export async function advanceCheckpointForStep(args) {
-    if (args.step.kind !== "chapter")
-        throw new NovelCliError(`Unsupported step kind: ${args.step.kind}`, 2);
-    if (args.step.stage === "commit")
-        throw new NovelCliError(`Use 'novel commit' for commit.`, 2);
-    if (args.step.stage === "review")
-        throw new NovelCliError(`Review is a manual step; do not advance it.`, 2);
-    return await withWriteLock(args.rootDir, { chapter: args.step.chapter }, async () => {
-        const checkpoint = await readCheckpoint(args.rootDir);
-        // Enforce validate-before-advance to keep deterministic semantics.
-        await validateStep({ rootDir: args.rootDir, checkpoint, step: args.step });
-        const updated = { ...checkpoint };
-        const nextStage = stageForStep(args.step);
-        updated.pipeline_stage = nextStage;
-        updated.inflight_chapter = args.step.chapter;
-        // Ensure revision counter is initialized when starting from draft (revision loops may preserve it).
-        if (args.step.stage === "draft") {
-            if (typeof updated.revision_count !== "number")
+    const step = args.step;
+    if (step.kind === "chapter") {
+        if (step.stage === "commit")
+            throw new NovelCliError(`Use 'novel commit' for commit.`, 2);
+        if (step.stage === "review")
+            throw new NovelCliError(`Review is a manual step; do not advance it.`, 2);
+        return await withWriteLock(args.rootDir, { chapter: step.chapter }, async () => {
+            const checkpoint = await readCheckpoint(args.rootDir);
+            // Enforce validate-before-advance to keep deterministic semantics.
+            await validateStep({ rootDir: args.rootDir, checkpoint, step });
+            const updated = { ...checkpoint };
+            const nextStage = stageForStep(step);
+            updated.pipeline_stage = nextStage;
+            updated.inflight_chapter = step.chapter;
+            updated.orchestrator_state =
+                checkpoint.orchestrator_state === "CHAPTER_REWRITE" || checkpoint.pipeline_stage === "revising" ? "CHAPTER_REWRITE" : "WRITING";
+            // Ensure revision counter is initialized when starting from draft (revision loops may preserve it).
+            if (step.stage === "draft") {
+                if (typeof updated.revision_count !== "number")
+                    updated.revision_count = 0;
+                updated.hook_fix_count = 0;
+                updated.title_fix_count = 0;
+                await removePath(join(args.rootDir, titleFixSnapshotRel(step.chapter)));
+                // If rewinding from a later stage, clear downstream staging artifacts to avoid skipping steps with stale data.
+                const prevStage = checkpoint.pipeline_stage ?? null;
+                const prevInflight = typeof checkpoint.inflight_chapter === "number" ? checkpoint.inflight_chapter : null;
+                if (prevInflight === step.chapter && prevStage && prevStage !== "drafting") {
+                    const rel = chapterRelPaths(step.chapter);
+                    await removePath(join(args.rootDir, rel.staging.summaryMd));
+                    await removePath(join(args.rootDir, rel.staging.deltaJson));
+                    await removePath(join(args.rootDir, rel.staging.crossrefJson));
+                    await removePath(join(args.rootDir, rel.staging.evalJson));
+                    await removePath(join(args.rootDir, rel.staging.styleRefinerChangesJson));
+                    // Revision loops are driven by gate decision after judge.
+                    if (prevStage === "judged") {
+                        const prev = typeof updated.revision_count === "number" ? updated.revision_count : 0;
+                        updated.revision_count = prev + 1;
+                        updated.orchestrator_state = "CHAPTER_REWRITE";
+                    }
+                }
+            }
+            // Title-fix counts as a bounded micro-revision and invalidates the current eval.
+            if (step.stage === "title-fix") {
+                const prev = typeof updated.title_fix_count === "number" ? updated.title_fix_count : 0;
+                if (prev >= 1) {
+                    throw new NovelCliError(`Title-fix already attempted for chapter ${step.chapter}; manual review required.`, 2);
+                }
+                updated.title_fix_count = prev + 1;
+                const rel = chapterRelPaths(step.chapter);
+                await removePath(join(args.rootDir, rel.staging.evalJson));
+            }
+            // Hook-fix counts as a bounded micro-revision and invalidates the current eval.
+            if (step.stage === "hook-fix") {
+                const prev = typeof updated.hook_fix_count === "number" ? updated.hook_fix_count : 0;
+                if (prev >= 1) {
+                    throw new NovelCliError(`Hook-fix already attempted for chapter ${step.chapter}; manual review required.`, 2);
+                }
+                updated.hook_fix_count = prev + 1;
+                const rel = chapterRelPaths(step.chapter);
+                await removePath(join(args.rootDir, rel.staging.evalJson));
+            }
+            // Refine rewrites the chapter draft; invalidate prior eval to force re-judge.
+            if (step.stage === "refine") {
+                const rel = chapterRelPaths(step.chapter);
+                await removePath(join(args.rootDir, rel.staging.evalJson));
+                // If we're polishing after a judged gate decision, count it as a revision loop.
+                const prevStage = checkpoint.pipeline_stage ?? null;
+                const prevInflight = typeof checkpoint.inflight_chapter === "number" ? checkpoint.inflight_chapter : null;
+                if (prevInflight === step.chapter && prevStage === "judged") {
+                    const prev = typeof updated.revision_count === "number" ? updated.revision_count : 0;
+                    updated.revision_count = prev + 1;
+                    updated.orchestrator_state = "CHAPTER_REWRITE";
+                }
+            }
+            updated.last_checkpoint_time = new Date().toISOString();
+            await writeCheckpoint(args.rootDir, updated);
+            return updated;
+        });
+    }
+    if (step.kind === "review") {
+        const reviewStep = step;
+        return await withWriteLock(args.rootDir, {}, async () => {
+            const checkpoint = await readCheckpoint(args.rootDir);
+            if (checkpoint.orchestrator_state !== "WRITING" && checkpoint.orchestrator_state !== "VOL_REVIEW") {
+                throw new NovelCliError(`Refusing to advance review step from orchestrator_state=${checkpoint.orchestrator_state}. Expected WRITING (volume_end) or VOL_REVIEW.`, 2);
+            }
+            // Enforce validate-before-advance to keep deterministic semantics.
+            await validateStep({ rootDir: args.rootDir, checkpoint, step: reviewStep });
+            const updated = { ...checkpoint };
+            updated.inflight_chapter = null;
+            if (reviewStep.phase === "transition") {
+                updated.current_volume = checkpoint.current_volume + 1;
+                updated.orchestrator_state = "WRITING";
+                updated.pipeline_stage = "committed";
                 updated.revision_count = 0;
-            updated.hook_fix_count = 0;
-            updated.title_fix_count = 0;
-            await removePath(join(args.rootDir, titleFixSnapshotRel(args.step.chapter)));
-        }
-        // Title-fix counts as a bounded micro-revision and invalidates the current eval.
-        if (args.step.stage === "title-fix") {
-            const prev = typeof updated.title_fix_count === "number" ? updated.title_fix_count : 0;
-            if (prev >= 1) {
-                throw new NovelCliError(`Title-fix already attempted for chapter ${args.step.chapter}; manual review required.`, 2);
+                updated.hook_fix_count = 0;
+                updated.title_fix_count = 0;
+                await removePath(join(args.rootDir, VOL_REVIEW_RELS.dir));
             }
-            updated.title_fix_count = prev + 1;
-            const rel = chapterRelPaths(args.step.chapter);
-            await removePath(join(args.rootDir, rel.staging.evalJson));
-        }
-        // Hook-fix counts as a bounded micro-revision and invalidates the current eval.
-        if (args.step.stage === "hook-fix") {
-            const prev = typeof updated.hook_fix_count === "number" ? updated.hook_fix_count : 0;
-            if (prev >= 1) {
-                throw new NovelCliError(`Hook-fix already attempted for chapter ${args.step.chapter}; manual review required.`, 2);
+            else {
+                updated.orchestrator_state = "VOL_REVIEW";
             }
-            updated.hook_fix_count = prev + 1;
-            const rel = chapterRelPaths(args.step.chapter);
-            await removePath(join(args.rootDir, rel.staging.evalJson));
-        }
-        updated.last_checkpoint_time = new Date().toISOString();
-        await writeCheckpoint(args.rootDir, updated);
-        return updated;
-    });
+            updated.last_checkpoint_time = new Date().toISOString();
+            await writeCheckpoint(args.rootDir, updated);
+            return updated;
+        });
+    }
+    if (step.kind === "volume") {
+        return await withWriteLock(args.rootDir, {}, async () => {
+            const checkpoint = await readCheckpoint(args.rootDir);
+            if (checkpoint.orchestrator_state !== "VOL_PLANNING") {
+                throw new NovelCliError(`Cannot advance ${formatStepId(step)} unless orchestrator_state=VOL_PLANNING.`, 2);
+            }
+            await validateStep({ rootDir: args.rootDir, checkpoint, step });
+            const updated = { ...checkpoint };
+            updated.orchestrator_state = "VOL_PLANNING";
+            updated.pipeline_stage = "committed";
+            updated.inflight_chapter = null;
+            const phase = step.phase;
+            switch (phase) {
+                case "outline":
+                    updated.volume_pipeline_stage = "validate";
+                    break;
+                case "validate":
+                    updated.volume_pipeline_stage = "commit";
+                    break;
+                case "commit":
+                    throw new NovelCliError(`Use 'novel commit --volume <n>' for volume commit.`, 2);
+                default: {
+                    const _exhaustive = phase;
+                    throw new NovelCliError(`Unsupported volume phase: ${String(_exhaustive)}`, 2);
+                }
+            }
+            updated.last_checkpoint_time = new Date().toISOString();
+            await writeCheckpoint(args.rootDir, updated);
+            return updated;
+        });
+    }
+    throw new NovelCliError(`Unsupported step kind: ${step.kind}`, 2);
 }

package/dist/checkpoint.js

@@ -1,13 +1,17 @@
 import { join } from "node:path";
 import { NovelCliError } from "./errors.js";
 import { readJsonFile, writeJsonFile } from "./fs-utils.js";
+import { ORCHESTRATOR_STATES, VOLUME_PHASES } from "./steps.js";
 import { isPlainObject } from "./type-guards.js";
 export const PIPELINE_STAGES = ["drafting", "drafted", "refined", "judged", "revising", "committed"];
 export function createDefaultCheckpoint(nowIso) {
     return {
         last_completed_chapter: 0,
         current_volume: 1,
+        // TODO(CS-O3): Default to INIT once the quickstart pipeline is implemented.
+        orchestrator_state: "WRITING",
         pipeline_stage: "committed",
+        volume_pipeline_stage: null,
         inflight_chapter: null,
         revision_count: 0,
         hook_fix_count: 0,
@@ -34,6 +38,23 @@ function asNullableInt(value) {
         return null;
     return asInt(value);
 }
+function isOrchestratorState(value) {
+    return ORCHESTRATOR_STATES.includes(value);
+}
+export function inferLegacyState(args) {
+    const stage = args.pipeline_stage ?? null;
+    const inflight = args.inflight_chapter ?? null;
+    // Inconsistent legacy checkpoint: inflight present but stage is idle.
+    if ((stage === null || stage === "committed") && inflight !== null)
+        return "ERROR_RETRY";
+    // Inconsistent legacy checkpoint: pipeline in-flight but missing chapter pointer.
+    if (stage !== null && stage !== "committed" && inflight === null)
+        return "ERROR_RETRY";
+    if (stage === "revising")
+        return "CHAPTER_REWRITE";
+    // Default to WRITING to preserve the legacy single-chapter pipeline behavior.
+    return "WRITING";
+}
 function parseCheckpoint(data) {
     if (!isPlainObject(data)) {
         throw new NovelCliError(".checkpoint.json must be a JSON object.", 2);
@@ -43,12 +64,8 @@ function parseCheckpoint(data) {
         throw new NovelCliError(".checkpoint.json.last_completed_chapter must be an int >= 0.", 2);
     }
     const currentVolume = asInt(data.current_volume);
-    if (currentVolume === null || currentVolume < 0) {
-        throw new NovelCliError(".checkpoint.json.current_volume must be an int >= 0.", 2);
-    }
-    const orchestratorState = data.orchestrator_state;
-    if (orchestratorState !== undefined && asString(orchestratorState) === null) {
-        throw new NovelCliError(".checkpoint.json.orchestrator_state must be a string when present.", 2);
+    if (currentVolume === null || currentVolume < 1) {
+        throw new NovelCliError(".checkpoint.json.current_volume must be an int >= 1.", 2);
     }
     const pipelineStageRaw = data.pipeline_stage;
     let pipelineStage;
@@ -72,10 +89,36 @@ function parseCheckpoint(data) {
     const inflightRaw = data.inflight_chapter;
     const inflight = asNullableInt(inflightRaw);
     if (inflightRaw !== undefined && inflight === null && inflightRaw !== null) {
-        throw new NovelCliError(".checkpoint.json.inflight_chapter must be an int >= 0 (or null).", 2);
+        throw new NovelCliError(".checkpoint.json.inflight_chapter must be an int >= 1 (or null).", 2);
+    }
+    if (inflight !== undefined && inflight !== null && inflight < 1) {
+        throw new NovelCliError(".checkpoint.json.inflight_chapter must be an int >= 1 (or null).", 2);
+    }
+    const volumeStageRaw = data.volume_pipeline_stage;
+    let volumeStage;
+    if (volumeStageRaw === undefined) {
+        volumeStage = undefined;
+    }
+    else if (volumeStageRaw === null) {
+        volumeStage = null;
+    }
+    else if (typeof volumeStageRaw === "string") {
+        if (VOLUME_PHASES.includes(volumeStageRaw)) {
+            volumeStage = volumeStageRaw;
+        }
+        else {
+            throw new NovelCliError(`.checkpoint.json.volume_pipeline_stage must be one of: ${VOLUME_PHASES.join(", ")} (or null)`, 2);
+        }
     }
-    if (inflight !== undefined && inflight !== null && inflight < 0) {
-        throw new NovelCliError(".checkpoint.json.inflight_chapter must be an int >= 0 (or null).", 2);
+    else {
+        throw new NovelCliError(`.checkpoint.json.volume_pipeline_stage must be a string (or null)`, 2);
+    }
+    const lastCommitted = data.last_committed_volume;
+    if (lastCommitted !== undefined) {
+        const lc = asInt(lastCommitted);
+        if (lc === null || lc < 0) {
+            throw new NovelCliError(".checkpoint.json.last_committed_volume must be an int >= 0 when present.", 2);
+        }
     }
     const revision = data.revision_count;
     if (revision !== undefined) {
@@ -106,15 +149,31 @@ function parseCheckpoint(data) {
     if (lastTime !== undefined && asString(lastTime) === null) {
         throw new NovelCliError(".checkpoint.json.last_checkpoint_time must be a string when present.", 2);
     }
+    const orchestratorStateRaw = data.orchestrator_state;
+    let orchestratorState;
+    if (orchestratorStateRaw === undefined) {
+        orchestratorState = inferLegacyState({ pipeline_stage: pipelineStage ?? null, inflight_chapter: inflight ?? null });
+    }
+    else {
+        const raw = asString(orchestratorStateRaw);
+        if (raw === null) {
+            throw new NovelCliError(".checkpoint.json.orchestrator_state must be a string when present.", 2);
+        }
+        if (!isOrchestratorState(raw)) {
+            throw new NovelCliError(`.checkpoint.json.orchestrator_state must be one of: ${ORCHESTRATOR_STATES.join(", ")} (or omit for legacy inference).`, 2);
+        }
+        orchestratorState = raw;
+    }
     const checkpoint = {
         ...data,
         last_completed_chapter: lastCompleted,
-        current_volume: currentVolume
+        current_volume: currentVolume,
+        orchestrator_state: orchestratorState
     };
-    if (orchestratorState !== undefined)
-        checkpoint.orchestrator_state = orchestratorState;
     if (pipelineStage !== undefined)
         checkpoint.pipeline_stage = pipelineStage;
+    if (volumeStage !== undefined)
+        checkpoint.volume_pipeline_stage = volumeStage;
     if (inflight !== undefined)
         checkpoint.inflight_chapter = inflight;
     return checkpoint;