novel-writer-cli 0.0.2 → 0.1.0

package/dist/init.js

@@ -0,0 +1,165 @@
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createDefaultCheckpoint } from "./checkpoint.js";
+import { NovelCliError } from "./errors.js";
+import { ensureDir, pathExists, readJsonFile, readTextFile, writeJsonFile, writeTextFile } from "./fs-utils.js";
+import { rejectPathTraversalInput } from "./safe-path.js";
+import { isPlainObject } from "./type-guards.js";
+export function resolveInitRootDir(args) {
+    const cwdAbs = resolve(args.cwd);
+    if (!args.projectOverride)
+        return cwdAbs;
+    rejectPathTraversalInput(args.projectOverride, "--project");
+    return resolve(cwdAbs, args.projectOverride);
+}
+export function normalizePlatformId(value) {
+    if (value === "qidian" || value === "tomato")
+        return value;
+    throw new NovelCliError(`Invalid --platform: ${String(value)} (expected qidian|tomato).`, 2);
+}
+function moduleRootDir() {
+    // src/init.ts → <repo_root>; dist/init.js → <package_root>
+    // NOTE: Not compatible with single-file bundlers (esbuild/rollup).
+    return resolve(fileURLToPath(new URL(".", import.meta.url)), "..");
+}
+const TEMPLATE_DIR = join(moduleRootDir(), "templates");
+async function ensureRootIsDirectory(absPath) {
+    try {
+        const s = await stat(absPath);
+        if (!s.isDirectory()) {
+            throw new NovelCliError(`Project root is not a directory: ${absPath}`, 2);
+        }
+    }
+    catch (err) {
+        if (err instanceof NovelCliError)
+            throw err;
+        // Path does not exist or is inaccessible — attempt to create it.
+        await ensureDir(absPath);
+    }
+}
+async function writeIfMissingOrForce(args) {
+    const abs = join(args.rootDir, args.relPath);
+    const exists = await pathExists(abs);
+    if (exists && !args.force) {
+        args.result.skipped.push(args.relPath);
+        return;
+    }
+    if (args.contents.kind === "text")
+        await writeTextFile(abs, args.contents.text);
+    else
+        await writeJsonFile(abs, args.contents.json);
+    if (exists)
+        args.result.overwritten.push(args.relPath);
+    else
+        args.result.created.push(args.relPath);
+}
+async function loadTemplateText(name) {
+    try {
+        return await readTextFile(join(TEMPLATE_DIR, name));
+    }
+    catch (err) {
+        if (err instanceof NovelCliError) {
+            throw new NovelCliError(`Built-in template missing or unreadable: templates/${name}. ${err.message}`, 2);
+        }
+        throw err;
+    }
+}
+async function loadTemplateJson(name) {
+    let raw;
+    try {
+        raw = await readJsonFile(join(TEMPLATE_DIR, name));
+    }
+    catch (err) {
+        if (err instanceof NovelCliError) {
+            throw new NovelCliError(`Built-in template missing or unreadable: templates/${name}. ${err.message}`, 2);
+        }
+        throw err;
+    }
+    if (!isPlainObject(raw)) {
+        throw new NovelCliError(`Built-in template templates/${name}: expected a JSON object, got ${typeof raw}.`, 2);
+    }
+    return raw;
+}
+async function loadPlatformProfileTemplate(platform) {
+    const raw = await loadTemplateJson("platform-profile.json");
+    const defaults = raw.defaults;
+    if (!isPlainObject(defaults)) {
+        throw new NovelCliError("Invalid templates/platform-profile.json: missing 'defaults' object.", 2);
+    }
+    const selected = defaults[platform];
+    if (!isPlainObject(selected)) {
+        throw new NovelCliError(`Invalid templates/platform-profile.json: missing defaults.${platform} object.`, 2);
+    }
+    return selected;
+}
+const DEFAULT_TEMPLATES = [
+    { relPath: "brief.md", templateName: "brief-template.md", kind: "text" },
+    { relPath: "style-profile.json", templateName: "style-profile-template.json", kind: "json" },
+    { relPath: "ai-blacklist.json", templateName: "ai-blacklist.json", kind: "json" },
+    { relPath: "web-novel-cliche-lint.json", templateName: "web-novel-cliche-lint.json", kind: "json" }
+];
+const STAGING_SUBDIRS = [
+    "staging/chapters",
+    "staging/summaries",
+    "staging/state",
+    "staging/evaluations",
+    "staging/logs",
+    "staging/storylines",
+    "staging/volumes",
+    "staging/foreshadowing",
+    "staging/manifests"
+];
+export async function initProject(args) {
+    const force = Boolean(args.force);
+    const minimal = Boolean(args.minimal);
+    const platform = args.platform ?? null;
+    const result = {
+        rootDir: args.rootDir,
+        ensuredDirs: [],
+        created: [],
+        overwritten: [],
+        skipped: []
+    };
+    await ensureRootIsDirectory(args.rootDir);
+    for (const relDir of STAGING_SUBDIRS) {
+        await ensureDir(join(args.rootDir, relDir));
+        result.ensuredDirs.push(relDir);
+    }
+    // Intentionally capture time once for transactional consistency.
+    const nowIso = new Date().toISOString();
+    await writeIfMissingOrForce({
+        rootDir: args.rootDir,
+        relPath: ".checkpoint.json",
+        contents: { kind: "json", json: createDefaultCheckpoint(nowIso) },
+        force,
+        result
+    });
+    if (!minimal) {
+        for (const tmpl of DEFAULT_TEMPLATES) {
+            const contents = tmpl.kind === "text"
+                ? { kind: "text", text: await loadTemplateText(tmpl.templateName) }
+                : { kind: "json", json: await loadTemplateJson(tmpl.templateName) };
+            await writeIfMissingOrForce({ rootDir: args.rootDir, relPath: tmpl.relPath, contents, force, result });
+        }
+    }
+    if (platform) {
+        const templateProfile = await loadPlatformProfileTemplate(platform);
+        await writeIfMissingOrForce({
+            rootDir: args.rootDir,
+            relPath: "platform-profile.json",
+            contents: { kind: "json", json: { ...templateProfile, created_at: nowIso } },
+            force,
+            result
+        });
+        // genre-weight-profiles.json is required when platform-profile.json.scoring is present.
+        await writeIfMissingOrForce({
+            rootDir: args.rootDir,
+            relPath: "genre-weight-profiles.json",
+            contents: { kind: "json", json: await loadTemplateJson("genre-weight-profiles.json") },
+            force,
+            result
+        });
+    }
+    return result;
+}

package/dist/instructions.js

@@ -1,7 +1,8 @@
+import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { NovelCliError } from "./errors.js";
 import { ensureDir, pathExists, readJsonFile, readTextFile, writeJsonFile, writeTextFileIfMissing } from "./fs-utils.js";
-import { loadContinuityLatestSummary } from "./consistency-auditor.js";
+import { loadContinuityLatestSummary, tryResolveVolumeChapterRange } from "./consistency-auditor.js";
 import { loadEngagementLatestSummary } from "./engagement.js";
 import { computeForeshadowVisibilityReport, loadForeshadowGlobalItems } from "./foreshadow-visibility.js";
 import { computeEffectiveScoringWeights, loadGenreWeightProfiles } from "./scoring-weights.js";
@@ -11,8 +12,10 @@ import { computePrejudgeGuardrailsReport, writePrejudgeGuardrailsReport } from "
 import { loadPromiseLedgerLatestSummary } from "./promise-ledger.js";
 import { resolveProjectRelativePath } from "./safe-path.js";
 import { computeTitlePolicyReport } from "./title-policy.js";
-import { chapterRelPaths, formatStepId, pad2, titleFixSnapshotRel } from "./steps.js";
+import { chapterRelPaths, formatStepId, pad2, pad3, titleFixSnapshotRel } from "./steps.js";
 import { isPlainObject } from "./type-guards.js";
+import { VOL_REVIEW_RELS } from "./volume-review.js";
+import { computeVolumeChapterRange, volumeFinalRelPaths, volumeStagingRelPaths } from "./volume-planning.js";
 function relIfExists(relPath, exists) {
     return exists ? relPath : null;
 }
@@ -23,14 +26,309 @@ function safeEmbedMode(mode) {
         return "brief";
     throw new NovelCliError(`Unsupported --embed mode: ${mode}. Supported: brief`, 2);
 }
+async function buildReviewInstructionPacket(args) {
+    const stepId = formatStepId(args.step);
+    if (args.step.kind !== "review")
+        throw new NovelCliError(`Unsupported review step: ${stepId}`, 2);
+    const step = args.step;
+    const volume = args.checkpoint.current_volume;
+    const embedMode = safeEmbedMode(args.embedMode);
+    const embed = {};
+    if (embedMode === "brief") {
+        const briefAbs = join(args.rootDir, "brief.md");
+        if (await pathExists(briefAbs)) {
+            const content = await readTextFile(briefAbs);
+            embed.brief_preview = content.slice(0, 2000);
+        }
+        else {
+            embed.brief_preview = null;
+        }
+    }
+    const commonPaths = {};
+    const maybeAddPath = async (target, key, relPath) => {
+        const absPath = join(args.rootDir, relPath);
+        if (await pathExists(absPath))
+            target[key] = relPath;
+    };
+    await maybeAddPath(commonPaths, "project_brief", "brief.md");
+    await maybeAddPath(commonPaths, "style_profile", "style-profile.json");
+    await maybeAddPath(commonPaths, "platform_profile", "platform-profile.json");
+    await maybeAddPath(commonPaths, "quality_rubric", "skills/novel-writing/references/quality-rubric.md");
+    await maybeAddPath(commonPaths, "foreshadowing_global", "foreshadowing/global.json");
+    await maybeAddPath(commonPaths, "storylines", "storylines/storylines.json");
+    const volumeOutlineRel = `volumes/vol-${pad2(volume)}/outline.md`;
+    if (await pathExists(join(args.rootDir, volumeOutlineRel)))
+        commonPaths.volume_outline = volumeOutlineRel;
+    // Resolve chapter range: prefer volume contracts/outline, fallback to last 10 chapters.
+    const endChapter = args.checkpoint.last_completed_chapter;
+    const resolvedRange = (await tryResolveVolumeChapterRange({ rootDir: args.rootDir, volume })) ??
+        (Number.isInteger(endChapter) && endChapter >= 1 ? { start: Math.max(1, endChapter - 9), end: endChapter } : null);
+    if (!resolvedRange) {
+        throw new NovelCliError(`Cannot resolve volume review chapter_range (last_completed_chapter=${String(endChapter)}).`, 2);
+    }
+    const inline = { volume, chapter_range: [resolvedRange.start, resolvedRange.end] };
+    const paths = { ...commonPaths };
+    const expected_outputs = [];
+    const next_actions = [];
+    let agent;
+    if (step.phase === "collect") {
+        agent = { kind: "cli", name: "volume-review" };
+        paths.quality_summary = VOL_REVIEW_RELS.qualitySummary;
+        expected_outputs.push({ path: VOL_REVIEW_RELS.qualitySummary, required: true });
+        next_actions.push({ kind: "command", command: `novel volume-review collect` });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (step.phase === "audit") {
+        agent = { kind: "subagent", name: "consistency-auditor" };
+        inline.scope = "volume_end";
+        inline.stride = 5;
+        inline.window = 10;
+        // Attach inputs expected by the ConsistencyAuditor agent.
+        const chapterPaths = [];
+        const contractPaths = [];
+        for (let chapter = resolvedRange.start; chapter <= resolvedRange.end; chapter++) {
+            const chapterRel = `chapters/chapter-${pad3(chapter)}.md`;
+            if (await pathExists(join(args.rootDir, chapterRel)))
+                chapterPaths.push(chapterRel);
+            const contractRel = `volumes/vol-${pad2(volume)}/chapter-contracts/chapter-${pad3(chapter)}.json`;
+            if (await pathExists(join(args.rootDir, contractRel)))
+                contractPaths.push(contractRel);
+        }
+        paths.chapters = chapterPaths;
+        if (contractPaths.length > 0)
+            paths.chapter_contracts = contractPaths;
+        await maybeAddPath(paths, "storyline_spec", "storylines/storyline-spec.json");
+        await maybeAddPath(paths, "storyline_schedule", `volumes/vol-${pad2(volume)}/storyline-schedule.json`);
+        await maybeAddPath(paths, "state_current", "state/current-state.json");
+        await maybeAddPath(paths, "state_changelog", "state/changelog.jsonl");
+        // Best-effort: include active character contracts.
+        const charsDirRel = "characters/active";
+        const charsDirAbs = join(args.rootDir, charsDirRel);
+        if (await pathExists(charsDirAbs)) {
+            try {
+                const entries = await readdir(charsDirAbs, { withFileTypes: true });
+                const rels = entries
+                    .filter((e) => e.isFile() && e.name.endsWith(".json"))
+                    .map((e) => `${charsDirRel}/${e.name}`)
+                    .sort();
+                if (rels.length > 0)
+                    paths.characters_active = rels;
+            }
+            catch {
+                inline.characters_active_degraded = true;
+            }
+        }
+        // Optional: pass quality summary to auditor.
+        if (await pathExists(join(args.rootDir, VOL_REVIEW_RELS.qualitySummary))) {
+            paths.quality_summary = VOL_REVIEW_RELS.qualitySummary;
+        }
+        expected_outputs.push({
+            path: VOL_REVIEW_RELS.auditReport,
+            required: true,
+            note: "ConsistencyAuditor returns JSON; the executor should write it to this path."
+        });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (step.phase === "report") {
+        agent = { kind: "cli", name: "volume-review" };
+        paths.quality_summary = VOL_REVIEW_RELS.qualitySummary;
+        paths.audit_report = VOL_REVIEW_RELS.auditReport;
+        expected_outputs.push({ path: VOL_REVIEW_RELS.reviewReport, required: true });
+        next_actions.push({ kind: "command", command: `novel volume-review report` });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (step.phase === "cleanup") {
+        agent = { kind: "cli", name: "volume-review" };
+        expected_outputs.push({ path: VOL_REVIEW_RELS.foreshadowStatus, required: true });
+        next_actions.push({ kind: "command", command: `novel volume-review cleanup` });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (step.phase === "transition") {
+        agent = { kind: "cli", name: "novel" };
+        expected_outputs.push({
+            path: "(checkpoint)",
+            required: true,
+            note: "Advance updates .checkpoint.json: current_volume++, orchestrator_state=WRITING, and clears staging/vol-review/."
+        });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else {
+        const _exhaustive = step.phase;
+        throw new NovelCliError(`Unsupported review phase: ${String(_exhaustive)}`, 2);
+    }
+    const packet = {
+        version: 1,
+        step: stepId,
+        agent,
+        manifest: {
+            mode: embedMode === "off" ? "paths" : "paths+embed",
+            inline,
+            paths,
+            ...(embedMode === "off" ? {} : { embed })
+        },
+        expected_outputs,
+        next_actions
+    };
+    let writtenPath = null;
+    if (args.writeManifest) {
+        const manifestsDir = join(args.rootDir, "staging/manifests");
+        await ensureDir(manifestsDir);
+        const fileName = `${stepId.replaceAll(":", "-")}.packet.json`;
+        writtenPath = `staging/manifests/${fileName}`;
+        await writeJsonFile(join(args.rootDir, writtenPath), packet);
+    }
+    return {
+        packet,
+        ...(writtenPath ? { written_manifest_path: writtenPath } : {})
+    };
+}
 export async function buildInstructionPacket(args) {
     const stepId = formatStepId(args.step);
+    if (args.step.kind === "review")
+        return await buildReviewInstructionPacket(args);
+    if (args.step.kind === "volume") {
+        const step = args.step;
+        const volume = args.checkpoint.current_volume;
+        const range = computeVolumeChapterRange({ current_volume: volume, last_completed_chapter: args.checkpoint.last_completed_chapter });
+        const embedMode = safeEmbedMode(args.embedMode);
+        const embed = {};
+        if (embedMode === "brief") {
+            const briefAbs = join(args.rootDir, "brief.md");
+            if (await pathExists(briefAbs)) {
+                const content = await readTextFile(briefAbs);
+                embed.brief_preview = content.slice(0, 2000);
+            }
+            else {
+                embed.brief_preview = null;
+            }
+        }
+        const inline = {
+            volume,
+            volume_plan: { volume, chapter_range: [range.start, range.end] }
+        };
+        const paths = {};
+        const maybeAddPath = async (key, relPath) => {
+            const absPath = join(args.rootDir, relPath);
+            if (await pathExists(absPath))
+                paths[key] = relPath;
+        };
+        await maybeAddPath("project_brief", "brief.md");
+        await maybeAddPath("style_profile", "style-profile.json");
+        await maybeAddPath("platform_profile", "platform-profile.json");
+        await maybeAddPath("genre_weight_profiles", "genre-weight-profiles.json");
+        await maybeAddPath("style_guide", "skills/novel-writing/references/style-guide.md");
+        await maybeAddPath("quality_rubric", "skills/novel-writing/references/quality-rubric.md");
+        await maybeAddPath("storylines", "storylines/storylines.json");
+        await maybeAddPath("world_rules", "world/rules.json");
+        await maybeAddPath("global_foreshadowing", "foreshadowing/global.json");
+        if (volume > 1) {
+            await maybeAddPath("prev_volume_review", `volumes/vol-${pad2(volume - 1)}/review.md`);
+        }
+        const worldDirAbs = join(args.rootDir, "world");
+        if (await pathExists(worldDirAbs))
+            paths.world_docs = "world/*.md";
+        const charsDirAbs = join(args.rootDir, "characters/active");
+        if (await pathExists(charsDirAbs)) {
+            paths.characters_md = "characters/active/*.md";
+            paths.characters_contracts = "characters/active/*.json";
+        }
+        let agent;
+        const expected_outputs = [];
+        const next_actions = [];
+        const staging = volumeStagingRelPaths(volume);
+        const final = volumeFinalRelPaths(volume);
+        const addPlanningOutputs = (base) => {
+            expected_outputs.push({ path: base.outlineMd, required: true });
+            expected_outputs.push({ path: base.storylineScheduleJson, required: true });
+            expected_outputs.push({ path: base.foreshadowingJson, required: true });
+            expected_outputs.push({ path: base.newCharactersJson, required: true });
+            for (let ch = range.start; ch <= range.end; ch++) {
+                expected_outputs.push({ path: base.chapterContractJson(ch), required: true });
+            }
+        };
+        if (step.phase === "outline") {
+            agent = { kind: "subagent", name: "plot-architect" };
+            inline.expected_outputs_base_dir = staging.dir;
+            addPlanningOutputs(staging);
+            next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+            next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+            next_actions.push({ kind: "command", command: `novel instructions volume:validate --json`, note: "After advance, proceed to validate/approve." });
+        }
+        else if (step.phase === "validate") {
+            agent = { kind: "cli", name: "manual-review" };
+            inline.review_targets = {
+                outline: staging.outlineMd,
+                storyline_schedule: staging.storylineScheduleJson,
+                foreshadowing: staging.foreshadowingJson,
+                new_characters: staging.newCharactersJson,
+                chapter_contracts_dir: staging.chapterContractsDir
+            };
+            addPlanningOutputs(staging);
+            next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+            next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+            next_actions.push({ kind: "command", command: `novel instructions volume:commit --json`, note: "After approval, proceed to commit." });
+        }
+        else if (step.phase === "commit") {
+            agent = { kind: "cli", name: "novel" };
+            inline.commit_from = staging.dir;
+            inline.commit_to = final.dir;
+            addPlanningOutputs(final);
+            next_actions.push({ kind: "command", command: `novel commit --volume ${volume}` });
+            next_actions.push({ kind: "command", command: `novel next`, note: "After commit, resume the writing pipeline." });
+        }
+        else {
+            const _exhaustive = step.phase;
+            throw new NovelCliError(`Unsupported volume phase: ${_exhaustive}`, 2);
+        }
+        const gate = args.novelAskGate ?? null;
+        const gateSpec = gate ? parseNovelAskQuestionSpec(gate.novel_ask) : null;
+        if (gate) {
+            resolveProjectRelativePath(args.rootDir, gate.answer_path, "novelAskGate.answer_path");
+            expected_outputs.unshift({
+                path: gate.answer_path,
+                required: true,
+                note: "AnswerSpec JSON record for the NOVEL_ASK gate (written before main step execution)."
+            });
+        }
+        const packet = {
+            version: 1,
+            step: stepId,
+            agent,
+            ...(gate ? { novel_ask: gateSpec, answer_path: gate.answer_path } : {}),
+            manifest: {
+                mode: embedMode === "off" ? "paths" : "paths+embed",
+                inline,
+                paths,
+                ...(embedMode === "off" ? {} : { embed })
+            },
+            expected_outputs,
+            next_actions
+        };
+        let writtenPath = null;
+        if (args.writeManifest) {
+            const manifestsDir = join(args.rootDir, "staging/manifests");
+            await ensureDir(manifestsDir);
+            const fileName = `${stepId.replaceAll(":", "-")}.packet.json`;
+            writtenPath = `staging/manifests/${fileName}`;
+            await writeJsonFile(join(args.rootDir, writtenPath), packet);
+        }
+        return {
+            packet,
+            ...(writtenPath ? { written_manifest_path: writtenPath } : {})
+        };
+    }
     if (args.step.kind !== "chapter")
         throw new NovelCliError(`Unsupported step: ${stepId}`, 2);
+    const step = args.step;
     const volume = args.checkpoint.current_volume;
     const volumeOutlineRel = `volumes/vol-${pad2(volume)}/outline.md`;
-    const chapterContractRel = `volumes/vol-${pad2(volume)}/chapter-contracts/chapter-${String(args.step.chapter).padStart(3, "0")}.json`;
-    const rel = chapterRelPaths(args.step.chapter);
+    const chapterContractRel = `volumes/vol-${pad2(volume)}/chapter-contracts/chapter-${String(step.chapter).padStart(3, "0")}.json`;
+    const rel = chapterRelPaths(step.chapter);
     const commonPaths = {};
     const maybeAddPath = async (target, key, relPath) => {
         const absPath = join(args.rootDir, relPath);
@@ -67,7 +365,7 @@ export async function buildInstructionPacket(args) {
         }
     }
     let agent;
-    const inline = { chapter: args.step.chapter, volume };
+    const inline = { chapter: step.chapter, volume };
     const paths = { ...commonPaths };
     const expected_outputs = [];
     const next_actions = [];
@@ -138,7 +436,7 @@ export async function buildInstructionPacket(args) {
                 inline.promise_ledger_report_summary_degraded = true;
         }
     };
-    if (args.step.stage === "draft") {
+    if (step.stage === "draft") {
         agent = { kind: "subagent", name: "chapter-writer" };
         // Optional: inject character voice drift directives (best-effort).
         await maybeAttachCharacterVoiceDirectives();
@@ -163,7 +461,7 @@ export async function buildInstructionPacket(args) {
             const items = await loadForeshadowGlobalItems(args.rootDir);
             const report = computeForeshadowVisibilityReport({
                 items,
-                asOfChapter: args.step.chapter,
+                asOfChapter: step.chapter,
                 volume,
                 platform,
                 genreDriveType
@@ -186,11 +484,11 @@ export async function buildInstructionPacket(args) {
         next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
         next_actions.push({
             kind: "command",
-            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:summarize --json`,
+            command: `novel instructions chapter:${String(step.chapter).padStart(3, "0")}:summarize --json`,
             note: "After advance, proceed to summarize."
         });
     }
-    else if (args.step.stage === "summarize") {
+    else if (step.stage === "summarize") {
         agent = { kind: "subagent", name: "summarizer" };
         paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
         expected_outputs.push({ path: rel.staging.summaryMd, required: true });
@@ -200,7 +498,7 @@ export async function buildInstructionPacket(args) {
         next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
         next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
     }
-    else if (args.step.stage === "refine") {
+    else if (step.stage === "refine") {
         agent = { kind: "subagent", name: "style-refiner" };
         // Optional: inject character voice drift directives (best-effort).
         await maybeAttachCharacterVoiceDirectives();
@@ -223,7 +521,7 @@ export async function buildInstructionPacket(args) {
         next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
         next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
     }
-    else if (args.step.stage === "judge") {
+    else if (step.stage === "judge") {
         agent = { kind: "subagent", name: "quality-judge" };
         const chapterDraftRel = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
         paths.chapter_draft = chapterDraftRel;
@@ -252,12 +550,12 @@ export async function buildInstructionPacket(args) {
             try {
                 const report = await computePrejudgeGuardrailsReport({
                     rootDir: args.rootDir,
-                    chapter: args.step.chapter,
+                    chapter: step.chapter,
                     chapterAbsPath: join(args.rootDir, chapterDraftRel),
                     platformProfileRelPath: loadedPlatform.relPath,
                     platformProfile: loadedPlatform.profile
                 });
-                const { relPath } = await writePrejudgeGuardrailsReport({ rootDir: args.rootDir, chapter: args.step.chapter, report });
+                const { relPath } = await writePrejudgeGuardrailsReport({ rootDir: args.rootDir, chapter: step.chapter, report });
                 paths.prejudge_guardrails = relPath;
                 inline.prejudge_guardrails = {
                     status: report.status,
@@ -283,7 +581,7 @@ export async function buildInstructionPacket(args) {
             note: "After advance, compute the next deterministic step (may be title-fix/hook-fix/review/commit)."
         });
     }
-    else if (args.step.stage === "title-fix") {
+    else if (step.stage === "title-fix") {
         agent = { kind: "subagent", name: "chapter-writer" };
         paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
         inline.fix_mode = "title-fix";
@@ -297,10 +595,10 @@ export async function buildInstructionPacket(args) {
         // Snapshot the chapter before title-fix so validate can ensure body is byte-identical.
         const beforeAbs = join(args.rootDir, rel.staging.chapterMd);
         const before = await readTextFile(beforeAbs);
-        const snapshotRel = titleFixSnapshotRel(args.step.chapter);
+        const snapshotRel = titleFixSnapshotRel(step.chapter);
         await writeTextFileIfMissing(join(args.rootDir, snapshotRel), before);
         paths.title_fix_before = snapshotRel;
-        const report = computeTitlePolicyReport({ chapter: args.step.chapter, chapterText: before, platformProfile: loadedPlatform.profile });
+        const report = computeTitlePolicyReport({ chapter: step.chapter, chapterText: before, platformProfile: loadedPlatform.profile });
         inline.title_policy = {
             enabled: titlePolicy.enabled,
             min_chars: titlePolicy.min_chars,
@@ -328,7 +626,7 @@ export async function buildInstructionPacket(args) {
             note: "After title-fix, compute the next deterministic step (typically judge)."
         });
     }
-    else if (args.step.stage === "hook-fix") {
+    else if (step.stage === "hook-fix") {
         agent = { kind: "subagent", name: "chapter-writer" };
         paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
         paths.chapter_eval = relIfExists(rel.staging.evalJson, await pathExists(join(args.rootDir, rel.staging.evalJson)));
@@ -344,28 +642,28 @@ export async function buildInstructionPacket(args) {
         next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
         next_actions.push({
             kind: "command",
-            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:judge --json`,
+            command: `novel instructions chapter:${String(step.chapter).padStart(3, "0")}:judge --json`,
             note: "After hook-fix, re-run QualityJudge to refresh eval."
         });
     }
-    else if (args.step.stage === "review") {
+    else if (step.stage === "review") {
         agent = { kind: "cli", name: "manual-review" };
         paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
         paths.chapter_eval = relIfExists(rel.staging.evalJson, await pathExists(join(args.rootDir, rel.staging.evalJson)));
         expected_outputs.push({ path: "(manual)", required: false, note: "Review required: guardrails still failing after bounded auto-fix." });
         next_actions.push({
             kind: "command",
-            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:judge --json`,
+            command: `novel instructions chapter:${String(step.chapter).padStart(3, "0")}:judge --json`,
             note: "After manually fixing the chapter (title/hook/etc), re-run QualityJudge."
         });
     }
-    else if (args.step.stage === "commit") {
+    else if (step.stage === "commit") {
         agent = { kind: "cli", name: "novel" };
-        expected_outputs.push({ path: `chapters/chapter-${String(args.step.chapter).padStart(3, "0")}.md`, required: true });
-        next_actions.push({ kind: "command", command: `novel commit --chapter ${args.step.chapter}` });
+        expected_outputs.push({ path: `chapters/chapter-${String(step.chapter).padStart(3, "0")}.md`, required: true });
+        next_actions.push({ kind: "command", command: `novel commit --chapter ${step.chapter}` });
     }
     else {
-        throw new NovelCliError(`Unsupported step stage: ${args.step.stage}`, 2);
+        throw new NovelCliError(`Unsupported step stage: ${step.stage}`, 2);
     }
     const gate = args.novelAskGate ?? null;
     const gateSpec = gate ? parseNovelAskQuestionSpec(gate.novel_ask) : null;