novel-writer-cli 0.0.2 → 0.1.0

package/README.md

@@ -46,7 +46,15 @@ node dist/cli.js --help
 
 ## 最小工作流：跑通一章
 
-在**小说项目根目录**（含 `.checkpoint.json`）运行：
+如果你是从零开始，在空目录先执行初始化（会创建 `.checkpoint.json` + `staging/**`，并写入若干可选模板文件）：
+
+```bash
+mkdir my-novel && cd my-novel
+novel init                      # --platform qidian|tomato 可选
+novel status
+```
+
+之后在**小说项目根目录**（含 `.checkpoint.json`）运行：
 
 ```bash
 # 1) 计算下一步

package/dist/__tests__/advance-refine-invalidates-eval.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { advanceCheckpointForStep } from "../advance.js";
+async function exists(absPath) {
+    try {
+        await stat(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+test("advanceCheckpointForStep(chapter:refine) invalidates eval and counts polish revisions after judge", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-advance-refine-"));
+    await writeFile(join(rootDir, ".checkpoint.json"), `${JSON.stringify({
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    }, null, 2)}\n`, "utf8");
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "draft text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeFile(join(rootDir, "staging/evaluations/chapter-001-eval.json"), `{"chapter":1,"overall":3.6,"recommendation":"polish"}\n`, "utf8");
+    assert.equal(await exists(join(rootDir, "staging/evaluations/chapter-001-eval.json")), true);
+    const updated = await advanceCheckpointForStep({ rootDir, step: { kind: "chapter", chapter: 1, stage: "refine" } });
+    assert.equal(updated.pipeline_stage, "refined");
+    assert.equal(updated.inflight_chapter, 1);
+    assert.equal(updated.revision_count, 1);
+    assert.equal(updated.orchestrator_state, "CHAPTER_REWRITE");
+    assert.equal(await exists(join(rootDir, "staging/evaluations/chapter-001-eval.json")), false);
+});

package/dist/__tests__/character-voice.test.js

@@ -407,7 +407,7 @@ test("buildInstructionPacket injects character voice drift directives into draft
         ]
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const draftOut = (await buildInstructionPacket({
         rootDir,
         checkpoint,

package/dist/__tests__/gate-decision.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { computeGateDecision, detectHighConfidenceViolation } from "../gate-decision.js";
+test("computeGateDecision maps score bands to decisions (no violations)", () => {
+    assert.equal(computeGateDecision({ overall_final: 4.0, revision_count: 0, has_high_confidence_violation: false }), "pass");
+    assert.equal(computeGateDecision({ overall_final: 3.9, revision_count: 0, has_high_confidence_violation: false }), "polish");
+    assert.equal(computeGateDecision({ overall_final: 3.5, revision_count: 0, has_high_confidence_violation: false }), "polish");
+    assert.equal(computeGateDecision({ overall_final: 3.4, revision_count: 0, has_high_confidence_violation: false }), "revise");
+    assert.equal(computeGateDecision({ overall_final: 3.0, revision_count: 0, has_high_confidence_violation: false }), "revise");
+    assert.equal(computeGateDecision({ overall_final: 2.9, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user");
+    assert.equal(computeGateDecision({ overall_final: 2.0, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user");
+    assert.equal(computeGateDecision({ overall_final: 1.99, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user_force_rewrite");
+});
+test("computeGateDecision forces revise on high-confidence violations", () => {
+    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 0, has_high_confidence_violation: true }), "revise");
+});
+test("computeGateDecision pauses for user when high-confidence violations persist beyond max_revisions", () => {
+    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 2, has_high_confidence_violation: true }), "pause_for_user");
+});
+test("computeGateDecision allows force_passed when revisions exhausted and score >= 3.0", () => {
+    assert.equal(computeGateDecision({ overall_final: 3.2, revision_count: 2, has_high_confidence_violation: false }), "force_passed");
+});
+test("computeGateDecision force-passes polish band when revisions exhausted", () => {
+    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 2, has_high_confidence_violation: false }), "force_passed");
+});
+test("computeGateDecision respects max_revisions override", () => {
+    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 1, has_high_confidence_violation: false, max_revisions: 1 }), "force_passed");
+});
+test("computeGateDecision supports manual force_pass override", () => {
+    assert.equal(computeGateDecision({ overall_final: 1.0, revision_count: 0, has_high_confidence_violation: true, force_pass: true }), "force_passed");
+});
+test("detectHighConfidenceViolation returns false when contract_verification is missing", () => {
+    assert.deepEqual(detectHighConfidenceViolation({ overall: 4.0, recommendation: "pass" }), {
+        has_high_confidence_violation: false,
+        high_confidence_violations: []
+    });
+});
+test("detectHighConfidenceViolation detects l1/l2/l3 high-confidence violations", () => {
+    const res = detectHighConfidenceViolation({
+        contract_verification: {
+            l1_checks: [{ status: "violation", confidence: "high", rule: "L1-001" }],
+            l2_checks: [],
+            l3_checks: []
+        }
+    });
+    assert.equal(res.has_high_confidence_violation, true);
+    assert.equal(res.high_confidence_violations.length, 1);
+});
+test("detectHighConfidenceViolation ignores ls_checks soft violations", () => {
+    const res = detectHighConfidenceViolation({
+        contract_verification: {
+            ls_checks: [{ status: "violation", confidence: "high", constraint_type: "soft" }]
+        }
+    });
+    assert.equal(res.has_high_confidence_violation, false);
+});
+test("detectHighConfidenceViolation marks inferred constraint_type for ls_checks when missing", () => {
+    const res = detectHighConfidenceViolation({
+        contract_verification: {
+            ls_checks: [{ status: "violation", confidence: "high" }]
+        }
+    });
+    assert.equal(res.has_high_confidence_violation, true);
+    assert.equal(res.high_confidence_violations.length, 1);
+    assert.equal(res.high_confidence_violations[0].constraint_type_inferred, true);
+});

package/dist/__tests__/init.test.js

@@ -0,0 +1,245 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { readCheckpoint } from "../checkpoint.js";
+import { NovelCliError } from "../errors.js";
+import { initProject, normalizePlatformId, resolveInitRootDir } from "../init.js";
+import { computeNextStep } from "../next-step.js";
+import { parsePlatformProfile } from "../platform-profile.js";
+// ── Helpers ──────────────────────────────────────────────────────────────
+async function assertDir(absPath) {
+    const s = await stat(absPath);
+    assert.ok(s.isDirectory(), `Expected directory: ${absPath}`);
+}
+async function assertFile(absPath) {
+    const s = await stat(absPath);
+    assert.ok(s.isFile(), `Expected file: ${absPath}`);
+}
+async function statExists(absPath) {
+    try {
+        await stat(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(absPath) {
+    return JSON.parse(await readFile(absPath, "utf8"));
+}
+// ── resolveInitRootDir ──────────────────────────────────────────────────
+test("resolveInitRootDir returns cwd when no projectOverride", () => {
+    const result = resolveInitRootDir({ cwd: "/tmp/foo" });
+    assert.equal(result, "/tmp/foo");
+});
+test("resolveInitRootDir resolves relative projectOverride against cwd", () => {
+    const result = resolveInitRootDir({ cwd: "/tmp", projectOverride: "my-novel" });
+    assert.equal(result, "/tmp/my-novel");
+});
+test("resolveInitRootDir rejects path traversal", () => {
+    assert.throws(() => resolveInitRootDir({ cwd: "/tmp", projectOverride: "../../etc" }), (err) => err instanceof NovelCliError && /path traversal/i.test(err.message));
+});
+// ── normalizePlatformId ─────────────────────────────────────────────────
+test("normalizePlatformId accepts valid values", () => {
+    assert.equal(normalizePlatformId("qidian"), "qidian");
+    assert.equal(normalizePlatformId("tomato"), "tomato");
+});
+test("normalizePlatformId rejects invalid values", () => {
+    assert.throws(() => normalizePlatformId("jjwxc"), (err) => err instanceof NovelCliError && /Invalid --platform.*jjwxc/i.test(err.message));
+    assert.throws(() => normalizePlatformId(42), (err) => err instanceof NovelCliError && /Invalid --platform/i.test(err.message));
+});
+// ── initProject: basic skeleton ─────────────────────────────────────────
+test("initProject creates a runnable skeleton with all checkpoint fields", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-basic-"));
+    try {
+        const result = await initProject({ rootDir });
+        assert.equal(result.rootDir, rootDir);
+        // Exact created set (non-minimal = checkpoint + 4 templates)
+        assert.deepEqual(result.created.sort(), [".checkpoint.json", "ai-blacklist.json", "brief.md", "style-profile.json", "web-novel-cliche-lint.json"].sort());
+        // All 9 staging dirs ensured
+        assert.equal(result.ensuredDirs.length, 9);
+        assert.ok(result.ensuredDirs.includes("staging/chapters"));
+        assert.ok(result.ensuredDirs.includes("staging/manifests"));
+        assert.ok(result.ensuredDirs.includes("staging/volumes"));
+        assert.ok(result.ensuredDirs.includes("staging/foreshadowing"));
+        // Verify ALL checkpoint fields
+        const checkpoint = await readCheckpoint(rootDir);
+        assert.equal(checkpoint.last_completed_chapter, 0);
+        assert.equal(checkpoint.current_volume, 1);
+        assert.equal(checkpoint.pipeline_stage, "committed");
+        assert.equal(checkpoint.volume_pipeline_stage, null);
+        assert.equal(checkpoint.inflight_chapter, null);
+        assert.equal(checkpoint.revision_count, 0);
+        assert.equal(checkpoint.hook_fix_count, 0);
+        assert.equal(checkpoint.title_fix_count, 0);
+        assert.ok(typeof checkpoint.last_checkpoint_time === "string" && checkpoint.last_checkpoint_time.length > 0);
+        // Integration: next step should be chapter:001:draft
+        const next = await computeNextStep(rootDir, checkpoint);
+        assert.equal(next.step, "chapter:001:draft");
+        // All staging dirs exist
+        for (const relDir of [
+            "staging/chapters",
+            "staging/summaries",
+            "staging/state",
+            "staging/evaluations",
+            "staging/logs",
+            "staging/storylines",
+            "staging/volumes",
+            "staging/foreshadowing",
+            "staging/manifests"
+        ]) {
+            await assertDir(join(rootDir, relDir));
+        }
+        // All template files exist
+        for (const relFile of ["brief.md", "style-profile.json", "ai-blacklist.json", "web-novel-cliche-lint.json"]) {
+            await assertFile(join(rootDir, relFile));
+        }
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Skip / Force: .checkpoint.json ──────────────────────────────────────
+test("initProject does not overwrite .checkpoint.json without --force", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-no-force-"));
+    try {
+        await writeFile(join(rootDir, ".checkpoint.json"), `${JSON.stringify({ last_completed_chapter: 5, current_volume: 1, pipeline_stage: "committed", inflight_chapter: null }, null, 2)}\n`, "utf8");
+        const result = await initProject({ rootDir, minimal: true });
+        assert.ok(result.skipped.includes(".checkpoint.json"));
+        assert.equal(result.overwritten.length, 0);
+        const checkpoint = await readCheckpoint(rootDir);
+        assert.equal(checkpoint.last_completed_chapter, 5);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("initProject overwrites .checkpoint.json with --force", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-force-"));
+    try {
+        await writeFile(join(rootDir, ".checkpoint.json"), `${JSON.stringify({ last_completed_chapter: 5, current_volume: 1, pipeline_stage: "committed", inflight_chapter: null }, null, 2)}\n`, "utf8");
+        const result = await initProject({ rootDir, minimal: true, force: true });
+        assert.ok(result.overwritten.includes(".checkpoint.json"));
+        const checkpoint = await readCheckpoint(rootDir);
+        assert.equal(checkpoint.last_completed_chapter, 0);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Skip / Force: template files ────────────────────────────────────────
+test("initProject skips existing template files without --force", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-skip-tpl-"));
+    try {
+        // Pre-create a template file
+        await writeFile(join(rootDir, "brief.md"), "custom brief", "utf8");
+        await writeFile(join(rootDir, "ai-blacklist.json"), "{}", "utf8");
+        const result = await initProject({ rootDir });
+        assert.ok(result.skipped.includes("brief.md"));
+        assert.ok(result.skipped.includes("ai-blacklist.json"));
+        assert.ok(result.created.includes("style-profile.json"));
+        assert.ok(result.created.includes("web-novel-cliche-lint.json"));
+        // Verify content was NOT overwritten
+        const content = await readFile(join(rootDir, "brief.md"), "utf8");
+        assert.equal(content, "custom brief");
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("initProject overwrites template files with --force", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-force-tpl-"));
+    try {
+        await writeFile(join(rootDir, "brief.md"), "custom brief", "utf8");
+        const result = await initProject({ rootDir, force: true });
+        assert.ok(result.overwritten.includes("brief.md"));
+        // Verify content was overwritten with template content
+        const content = await readFile(join(rootDir, "brief.md"), "utf8");
+        assert.notEqual(content, "custom brief");
+        assert.ok(content.length > 0);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Platform: tomato ────────────────────────────────────────────────────
+test("initProject writes platform-profile.json + genre-weight-profiles.json for --platform tomato", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-platform-tomato-"));
+    try {
+        const result = await initProject({ rootDir, minimal: true, platform: "tomato" });
+        assert.ok(result.created.includes("platform-profile.json"));
+        assert.ok(result.created.includes("genre-weight-profiles.json"));
+        const raw = await readJson(join(rootDir, "platform-profile.json"));
+        const profile = parsePlatformProfile(raw, "platform-profile.json");
+        assert.equal(profile.platform, "tomato");
+        assert.ok(typeof profile.created_at === "string" && profile.created_at.length > 0);
+        assert.ok(typeof profile.schema_version === "number");
+        // genre-weight-profiles.json should be a valid JSON object
+        const genreRaw = await readJson(join(rootDir, "genre-weight-profiles.json"));
+        assert.ok(typeof genreRaw === "object" && genreRaw !== null && !Array.isArray(genreRaw));
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Platform: qidian ────────────────────────────────────────────────────
+test("initProject writes platform-profile.json for --platform qidian", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-platform-qidian-"));
+    try {
+        const result = await initProject({ rootDir, minimal: true, platform: "qidian" });
+        assert.ok(result.created.includes("platform-profile.json"));
+        assert.ok(result.created.includes("genre-weight-profiles.json"));
+        const raw = await readJson(join(rootDir, "platform-profile.json"));
+        const profile = parsePlatformProfile(raw, "platform-profile.json");
+        assert.equal(profile.platform, "qidian");
+        assert.ok(typeof profile.created_at === "string" && profile.created_at.length > 0);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Minimal mode ────────────────────────────────────────────────────────
+test("initProject minimal mode skips templates", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-minimal-"));
+    try {
+        const result = await initProject({ rootDir, minimal: true });
+        assert.ok(result.created.includes(".checkpoint.json"));
+        assert.equal(result.created.length, 1);
+        await assertFile(join(rootDir, ".checkpoint.json"));
+        await assertDir(join(rootDir, "staging/chapters"));
+        assert.equal(await statExists(join(rootDir, "brief.md")), false);
+        assert.equal(await statExists(join(rootDir, "style-profile.json")), false);
+        assert.equal(await statExists(join(rootDir, "ai-blacklist.json")), false);
+        assert.equal(await statExists(join(rootDir, "web-novel-cliche-lint.json")), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+// ── Non-existent --project directory ────────────────────────────────────
+test("initProject can initialize a non-existent --project directory", async () => {
+    const parentDir = await mkdtemp(join(tmpdir(), "novel-init-project-"));
+    const rootDir = join(parentDir, "child-project");
+    try {
+        const result = await initProject({ rootDir, minimal: true });
+        assert.equal(result.rootDir, rootDir);
+        await assertFile(join(rootDir, ".checkpoint.json"));
+    }
+    finally {
+        await rm(parentDir, { recursive: true, force: true });
+    }
+});
+// ── Negative: rootDir is a file ─────────────────────────────────────────
+test("initProject throws when rootDir is a file", async () => {
+    const parentDir = await mkdtemp(join(tmpdir(), "novel-init-file-"));
+    const filePath = join(parentDir, "not-a-dir");
+    await writeFile(filePath, "hello", "utf8");
+    try {
+        await assert.rejects(() => initProject({ rootDir: filePath, minimal: true }), (err) => err instanceof NovelCliError && /not a directory/i.test(err.message));
+    }
+    finally {
+        await rm(parentDir, { recursive: true, force: true });
+    }
+});

package/dist/__tests__/narrative-health-injection.test.js

@@ -74,7 +74,7 @@ test("buildInstructionPacket injects compact narrative health summaries into dra
         has_blocking_issues: false
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const draftOut = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -126,7 +126,7 @@ test("buildInstructionPacket marks degraded when latest reports exist but are in
         has_blocking_issues: false
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -143,7 +143,7 @@ test("buildInstructionPacket marks degraded when latest reports exist but are in
 test("buildInstructionPacket does not inject narrative health when logs are missing (no summary, no degraded)", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-no-logs-"));
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 0, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 0, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -193,7 +193,7 @@ test("buildInstructionPacket does not inject narrative health summaries for stag
         has_blocking_issues: false
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const summarizeOut = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -239,7 +239,7 @@ test("buildInstructionPacket marks degraded on schema_version mismatch when late
         has_blocking_issues: false
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -279,7 +279,7 @@ test("buildInstructionPacket marks promise ledger degraded on schema_version mis
         issues: []
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -298,7 +298,7 @@ test("buildInstructionPacket marks both degraded when both latest files are inva
     await writeText(join(rootDir, "logs/engagement/latest.json"), "not-json");
     await writeText(join(rootDir, "logs/promises/latest.json"), "not-json");
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n（占位）\n");
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,
@@ -341,7 +341,7 @@ test("buildInstructionPacket treats oversized latest.json as degraded", async ()
         has_blocking_issues: false
     });
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n（占位）\n");
-    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1, orchestrator_state: "WRITING" };
     const out = (await buildInstructionPacket({
         rootDir,
         checkpoint,

package/dist/__tests__/next-step-gate-decision-routing.test.js

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+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");
+}
+test("computeNextStep routes judged+eval to commit on gate pass", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-pass-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 4.0, recommendation: "pass" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:commit");
+    assert.equal(next.reason, "judged:gate:pass");
+});
+test("computeNextStep routes judged+eval to refine on gate polish", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-polish-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 3.6, recommendation: "polish" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:refine");
+    assert.equal(next.reason, "judged:gate:polish");
+});
+test("computeNextStep routes judged+eval to draft on gate revise", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-revise-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 3.2, recommendation: "revise" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:draft");
+    assert.equal(next.reason, "judged:gate:revise");
+});
+test("computeNextStep routes judged+eval to commit on force_passed when revisions exhausted", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-force-passed-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 3.2, recommendation: "revise" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 2
+    });
+    assert.equal(next.step, "chapter:001:commit");
+    assert.equal(next.reason, "judged:gate:force_passed");
+});
+test("computeNextStep routes judged+eval to manual review on pause bands", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-pause-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 2.4, recommendation: "pause" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:review");
+    assert.equal(next.reason, "judged:gate:pause_for_user");
+});
+test("computeNextStep forces revise when eval has high-confidence violations", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-violation-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), {
+        chapter: 1,
+        overall: 4.8,
+        recommendation: "pass",
+        contract_verification: { l1_checks: [{ status: "violation", confidence: "high" }] }
+    });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:draft");
+    assert.equal(next.reason, "judged:gate:revise");
+});