@lingjingai/scriptctl 0.9.5 → 0.9.7

package/dist/usecases/direct.js

@@ -626,6 +626,12 @@ async function pMapWithConcurrency(items, concurrency, worker) {
 // command_init
 // ---------------------------------------------------------------------------
 export async function commandInit(opts) {
+    const ctx = makeInitCtx(validateInitOpts(opts));
+    fs.mkdirSync(ctx.dd, { recursive: true });
+    ctx.previousState = readRunState(ctx.workspace);
+    return runInitPipeline(INIT_STEPS, ctx);
+}
+function validateInitOpts(opts) {
     const sourcePathArg = strOf(opts["source_path"]);
     const source = sourcePathArg.startsWith("~")
         ? path.join(process.env.HOME ?? "", sourcePathArg.slice(1))
@@ -715,577 +721,698 @@ export async function commandInit(opts) {
             nextSteps: ["Use a supported source file and rerun init."],
         });
     }
-    const dd = directDir(workspace);
-    fs.mkdirSync(dd, { recursive: true });
-    const previousStateBeforeInit = readRunState(workspace);
-    updateRunState(workspace, {
-        status: "init_running",
-        command: "direct init",
-        init_stage: "source_prepare",
-        provider: providerName,
-        model,
-        concurrency,
-        source_path: path.resolve(source),
-    });
-    let info;
-    try {
-        info = await prepareSource(source, workspace);
-    }
-    catch (exc) {
-        if (exc instanceof CliError) {
-            updateRunState(workspace, {
-                status: "init_failed",
-                init_stage: "source_prepare",
-                last_error: { title: exc.title, received: exc.received, failed_at: checkpointTimestamp() },
-            });
+    return { source, workspace, providerName, model, concurrency, batchMode, batchTargetLines, batchMaxChars, batchMinLines };
+}
+function makeInitCtx(inputs) {
+    return {
+        ...inputs,
+        dd: directDir(inputs.workspace),
+        previousState: {},
+        info: {},
+        sourceText: "",
+        manifest: {},
+        plan: {},
+        provider: undefined,
+        batchPlan: {},
+        checkpoint: {},
+        batchCheckpoint: {},
+        checkpointReused: false,
+        batchCheckpointReused: false,
+        episodeResultsDir: "",
+        batchResultsDir: "",
+        results: [],
+        skipped: [],
+        skippedEpisodeBatchCount: 0,
+        skippedBatches: [],
+        batchResults: [],
+        completedBatches: 0,
+        script: {},
+    };
+}
+async function runInitPipeline(steps, ctx) {
+    for (const step of steps) {
+        if (step.enter) {
+            const updates = step.enter(ctx);
+            if (updates)
+                updateRunState(ctx.workspace, updates);
+        }
+        let result;
+        try {
+            result = await step.run(ctx);
+        }
+        catch (exc) {
+            if (step.onError)
+                step.onError(ctx, exc);
             throw exc;
         }
-        const e = exc;
-        const receivedError = `${source}: ${e?.name ?? "Error"}${e?.message ? `: ${e.message}` : ""}`;
-        updateRunState(workspace, {
-            status: "init_failed",
-            init_stage: "source_prepare",
-            last_error: { title: "INIT BLOCKED: Source preparation failed", received: [receivedError], failed_at: checkpointTimestamp() },
-        });
-        throw new CliError("INIT BLOCKED: Source preparation failed", "Source preparation failed.", {
-            exitCode: EXIT_INPUT,
-            required: ["readable source file that can be converted to source.txt"],
-            received: [receivedError],
-            nextSteps: ["Fix or re-export the source file, then rerun init."],
-        });
+        if (result.kind === "halt")
+            return [result.report, result.exitCode];
     }
-    const sourceTextPath = strOf(info["sourceTextPath"]);
-    const sourceText = readText(sourceTextPath);
-    const manifest = makeSourceManifest(source, sourceTextPath, info);
-    updateRunState(workspace, { status: "init_running", init_stage: "episode_plan" });
-    let plan;
-    try {
-        plan = buildEpisodePlan(sourceText);
-    }
-    catch (exc) {
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Episode planning failed",
-            stage: "episode_plan",
-            required: ["source.txt that can be split into episodes"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Inspect workspace/source.txt, fix the source file, and rerun init."],
-        });
-    }
-    updateRunState(workspace, { status: "init_running", init_stage: "provider" });
-    let provider;
-    try {
-        provider = makeProvider(providerName, model);
-    }
-    catch (exc) {
-        if (exc instanceof CliError) {
-            updateRunState(workspace, {
-                status: "init_failed",
-                init_stage: "provider",
-                last_error: { title: exc.title, received: exc.received, failed_at: checkpointTimestamp() },
+    // The validate step always halts; reaching here means the step list is malformed.
+    throw new Error("init pipeline ended without halting");
+}
+function groupResultsByEpisode(batchResults) {
+    const byEpisode = new Map();
+    for (const result of batchResults) {
+        const ep = Number(result["episode"] ?? 0);
+        if (!byEpisode.has(ep))
+            byEpisode.set(ep, []);
+        byEpisode.get(ep).push(result);
+    }
+    return byEpisode;
+}
+// Merge one episode's batch results, validate, and persist its episode_results
+// file + index metadata. Shared by the success path (episode_merge) and the
+// failure path's partial merge so the two stay in lockstep.
+function mergeEpisodeAndPersist(sourceText, episodeResultsDir, episode, batchResultsForEpisode, providerName, model) {
+    const result = mergeBatchResultsForEpisode(episode, batchResultsForEpisode);
+    validateEpisodeExtractionQuality(sourceText, episode, result);
+    writeJson(episodeResultPath(episodeResultsDir, episode), compactEpisodeResult(result));
+    updateEpisodeResultMetadata(episodeResultsDir, episode, providerName, model);
+    return result;
+}
+const INIT_STEPS = [
+    {
+        stage: "source_prepare",
+        enter: (ctx) => ({
+            status: "init_running",
+            command: "direct init",
+            init_stage: "source_prepare",
+            provider: ctx.providerName,
+            model: ctx.model,
+            concurrency: ctx.concurrency,
+            source_path: path.resolve(ctx.source),
+        }),
+        // Handles errors inline: distinguishes CliError vs raw error and writes a
+        // bespoke last_error.received before failing, so it omits onError.
+        run: async (ctx) => {
+            let info;
+            try {
+                info = await prepareSource(ctx.source, ctx.workspace);
+            }
+            catch (exc) {
+                if (exc instanceof CliError) {
+                    updateRunState(ctx.workspace, {
+                        status: "init_failed",
+                        init_stage: "source_prepare",
+                        last_error: { title: exc.title, received: exc.received, failed_at: checkpointTimestamp() },
+                    });
+                    throw exc;
+                }
+                const e = exc;
+                const receivedError = `${ctx.source}: ${e?.name ?? "Error"}${e?.message ? `: ${e.message}` : ""}`;
+                updateRunState(ctx.workspace, {
+                    status: "init_failed",
+                    init_stage: "source_prepare",
+                    last_error: { title: "INIT BLOCKED: Source preparation failed", received: [receivedError], failed_at: checkpointTimestamp() },
+                });
+                throw new CliError("INIT BLOCKED: Source preparation failed", "Source preparation failed.", {
+                    exitCode: EXIT_INPUT,
+                    required: ["readable source file that can be converted to source.txt"],
+                    received: [receivedError],
+                    nextSteps: ["Fix or re-export the source file, then rerun init."],
+                });
+            }
+            ctx.info = info;
+            const sourceTextPath = strOf(info["sourceTextPath"]);
+            ctx.sourceText = readText(sourceTextPath);
+            ctx.manifest = makeSourceManifest(ctx.source, sourceTextPath, info);
+            return { kind: "continue" };
+        },
+    },
+    {
+        stage: "episode_plan",
+        enter: () => ({ status: "init_running", init_stage: "episode_plan" }),
+        run: (ctx) => {
+            ctx.plan = buildEpisodePlan(ctx.sourceText);
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Episode planning failed",
+                stage: "episode_plan",
+                required: ["source.txt that can be split into episodes"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Inspect workspace/source.txt, fix the source file, and rerun init."],
             });
-        }
-        throw exc;
-    }
-    updateRunState(workspace, { status: "init_running", init_stage: "episode_titles" });
-    try {
-        plan = await enrichEpisodePlanTitles(sourceText, plan, provider);
-    }
-    catch (exc) {
-        if (exc instanceof CliError) {
-            throw initFailedReport(workspace, {
-                title: exc.title,
+        },
+    },
+    {
+        stage: "provider",
+        enter: () => ({ status: "init_running", init_stage: "provider" }),
+        // Handles errors inline: writes init_failed run_state only for CliError,
+        // then rethrows the original error unchanged, so it omits onError.
+        run: (ctx) => {
+            try {
+                ctx.provider = makeProvider(ctx.providerName, ctx.model);
+            }
+            catch (exc) {
+                if (exc instanceof CliError) {
+                    updateRunState(ctx.workspace, {
+                        status: "init_failed",
+                        init_stage: "provider",
+                        last_error: { title: exc.title, received: exc.received, failed_at: checkpointTimestamp() },
+                    });
+                }
+                throw exc;
+            }
+            return { kind: "continue" };
+        },
+    },
+    {
+        stage: "episode_titles",
+        enter: () => ({ status: "init_running", init_stage: "episode_titles" }),
+        run: async (ctx) => {
+            ctx.plan = await enrichEpisodePlanTitles(ctx.sourceText, ctx.plan, ctx.provider);
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            if (exc instanceof CliError) {
+                throw initFailedReport(ctx.workspace, {
+                    title: exc.title,
+                    stage: "episode_titles",
+                    exitCode: exc.exitCode,
+                    required: exc.required.length > 0 ? exc.required : ["episode titles generated from source text"],
+                    received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
+                    nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init after checking source episode headers."],
+                });
+            }
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Episode title planning failed",
                 stage: "episode_titles",
-                exitCode: exc.exitCode,
-                required: exc.required.length > 0 ? exc.required : ["episode titles generated from source text"],
-                received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
-                nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init after checking source episode headers."],
+                required: ["episode titles generated from source text"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Inspect workspace/source.txt and episode_plan.json, then rerun init."],
             });
-        }
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Episode title planning failed",
-            stage: "episode_titles",
-            required: ["episode titles generated from source text"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Inspect workspace/source.txt and episode_plan.json, then rerun init."],
-        });
-    }
-    let batchPlan;
-    try {
-        batchPlan = buildBatchPlan(sourceText, plan, {
-            targetLines: batchTargetLines,
-            maxChars: batchMaxChars,
-            minLines: batchMinLines,
-            mode: batchMode,
-        });
-    }
-    catch (exc) {
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Batch planning failed",
-            stage: "batch_plan",
-            required: ["episode_plan.json that can be split into natural paragraph batches"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Inspect workspace/source.txt and episode_plan.json, then rerun init."],
-        });
-    }
-    const checkpoint = initCheckpoint(sourceText, plan);
-    const batchCheckpoint = initBatchCheckpoint(sourceText, batchPlan);
-    const previousState = previousStateBeforeInit;
-    const previousCheckpoint = isDict(previousState["checkpoint"]) ? previousState["checkpoint"] : {};
-    const previousBatchCheckpoint = isDict(previousState["batch_checkpoint"]) ? previousState["batch_checkpoint"] : {};
-    const checkpointReused = checkpointSourceMatches(previousCheckpoint, checkpoint);
-    const batchCheckpointReused = checkpointReused && batchCheckpointMatches(previousBatchCheckpoint, batchCheckpoint);
-    if (!checkpointReused)
-        resetInitOutputs(dd);
-    else if (!batchCheckpointReused)
-        resetBatchOutputs(dd);
-    writeJson(path.join(dd, "source_manifest.json"), manifest);
-    writeJson(path.join(dd, "episode_plan.json"), plan);
-    writeJson(path.join(dd, "batch_plan.json"), batchPlan);
-    const episodeResultsDir = path.join(dd, "episode_results");
-    const batchResultsDir = path.join(dd, "batch_results");
-    fs.mkdirSync(episodeResultsDir, { recursive: true });
-    fs.mkdirSync(batchResultsDir, { recursive: true });
-    updateRunState(workspace, {
-        status: "init_running",
-        init_stage: "batch_extract",
-        checkpoint,
-        batch_checkpoint: batchCheckpoint,
-        checkpoint_reused: checkpointReused,
-        batch_checkpoint_reused: batchCheckpointReused,
-        batch_mode: batchMode,
-        batch_target_lines: batchTargetLines,
-        batch_max_chars: batchMaxChars,
-        batch_min_lines: batchMinLines,
-        episode_total: asList(plan["episodes"]).length,
-        batch_total: asList(batchPlan["batches"]).length,
-    });
-    const results = [];
-    const skipped = [];
-    let skippedEpisodeBatchCount = 0;
-    const pendingBatches = [];
-    const batchesByEpisode = new Map();
-    for (const batch of asList(batchPlan["batches"])) {
-        const epNum = Number(batch["episode"]);
-        if (!batchesByEpisode.has(epNum))
-            batchesByEpisode.set(epNum, []);
-        batchesByEpisode.get(epNum).push(batch);
-    }
-    const previousProvider = strOf(previousState["provider"]).trim() || null;
-    for (const episode of asList(plan["episodes"])) {
-        const cached = checkpointReused
-            ? loadCheckpointedEpisode(sourceText, episodeResultsDir, episode, providerName, model, previousProvider)
-            : null;
-        if (cached !== null) {
-            results.push(cached);
-            skipped.push(Number(episode["episode"]));
-            const cachedBatches = batchesByEpisode.get(Number(episode["episode"])) ?? [];
-            skippedEpisodeBatchCount += cachedBatches.length;
-            for (const cachedBatch of cachedBatches) {
-                if (!exists(batchResultPath(batchResultsDir, cachedBatch))) {
-                    const backfilled = recoverBatchFromSource(sourceText, cachedBatch);
-                    persistBatchResult(batchResultsDir, cachedBatch, backfilled);
-                    updateBatchResultMetadata(batchResultsDir, cachedBatch, providerName, model);
+        },
+    },
+    {
+        stage: "batch_plan",
+        run: (ctx) => {
+            ctx.batchPlan = buildBatchPlan(ctx.sourceText, ctx.plan, {
+                targetLines: ctx.batchTargetLines,
+                maxChars: ctx.batchMaxChars,
+                minLines: ctx.batchMinLines,
+                mode: ctx.batchMode,
+            });
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Batch planning failed",
+                stage: "batch_plan",
+                required: ["episode_plan.json that can be split into natural paragraph batches"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Inspect workspace/source.txt and episode_plan.json, then rerun init."],
+            });
+        },
+    },
+    {
+        stage: "checkpoint_setup",
+        run: (ctx) => {
+            const checkpoint = initCheckpoint(ctx.sourceText, ctx.plan);
+            const batchCheckpoint = initBatchCheckpoint(ctx.sourceText, ctx.batchPlan);
+            const previousState = ctx.previousState;
+            const previousCheckpoint = isDict(previousState["checkpoint"]) ? previousState["checkpoint"] : {};
+            const previousBatchCheckpoint = isDict(previousState["batch_checkpoint"]) ? previousState["batch_checkpoint"] : {};
+            const checkpointReused = checkpointSourceMatches(previousCheckpoint, checkpoint);
+            const batchCheckpointReused = checkpointReused && batchCheckpointMatches(previousBatchCheckpoint, batchCheckpoint);
+            if (!checkpointReused)
+                resetInitOutputs(ctx.dd);
+            else if (!batchCheckpointReused)
+                resetBatchOutputs(ctx.dd);
+            writeJson(path.join(ctx.dd, "source_manifest.json"), ctx.manifest);
+            writeJson(path.join(ctx.dd, "episode_plan.json"), ctx.plan);
+            writeJson(path.join(ctx.dd, "batch_plan.json"), ctx.batchPlan);
+            const episodeResultsDir = path.join(ctx.dd, "episode_results");
+            const batchResultsDir = path.join(ctx.dd, "batch_results");
+            fs.mkdirSync(episodeResultsDir, { recursive: true });
+            fs.mkdirSync(batchResultsDir, { recursive: true });
+            ctx.checkpoint = checkpoint;
+            ctx.batchCheckpoint = batchCheckpoint;
+            ctx.checkpointReused = checkpointReused;
+            ctx.batchCheckpointReused = batchCheckpointReused;
+            ctx.episodeResultsDir = episodeResultsDir;
+            ctx.batchResultsDir = batchResultsDir;
+            updateRunState(ctx.workspace, {
+                status: "init_running",
+                init_stage: "batch_extract",
+                checkpoint,
+                batch_checkpoint: batchCheckpoint,
+                checkpoint_reused: checkpointReused,
+                batch_checkpoint_reused: batchCheckpointReused,
+                batch_mode: ctx.batchMode,
+                batch_target_lines: ctx.batchTargetLines,
+                batch_max_chars: ctx.batchMaxChars,
+                batch_min_lines: ctx.batchMinLines,
+                episode_total: asList(ctx.plan["episodes"]).length,
+                batch_total: asList(ctx.batchPlan["batches"]).length,
+            });
+            return { kind: "continue" };
+        },
+    },
+    {
+        stage: "extract_episodes",
+        run: async (ctx) => {
+            const pendingBatches = [];
+            const batchesByEpisode = new Map();
+            for (const batch of asList(ctx.batchPlan["batches"])) {
+                const epNum = Number(batch["episode"]);
+                if (!batchesByEpisode.has(epNum))
+                    batchesByEpisode.set(epNum, []);
+                batchesByEpisode.get(epNum).push(batch);
+            }
+            const previousProvider = strOf(ctx.previousState["provider"]).trim() || null;
+            for (const episode of asList(ctx.plan["episodes"])) {
+                const cached = ctx.checkpointReused
+                    ? loadCheckpointedEpisode(ctx.sourceText, ctx.episodeResultsDir, episode, ctx.providerName, ctx.model, previousProvider)
+                    : null;
+                if (cached !== null) {
+                    ctx.results.push(cached);
+                    ctx.skipped.push(Number(episode["episode"]));
+                    const cachedBatches = batchesByEpisode.get(Number(episode["episode"])) ?? [];
+                    ctx.skippedEpisodeBatchCount += cachedBatches.length;
+                    for (const cachedBatch of cachedBatches) {
+                        if (!exists(batchResultPath(ctx.batchResultsDir, cachedBatch))) {
+                            const backfilled = recoverBatchFromSource(ctx.sourceText, cachedBatch);
+                            persistBatchResult(ctx.batchResultsDir, cachedBatch, backfilled);
+                            updateBatchResultMetadata(ctx.batchResultsDir, cachedBatch, ctx.providerName, ctx.model);
+                        }
+                        const errorPath = batchErrorPath(ctx.batchResultsDir, cachedBatch);
+                        if (exists(errorPath))
+                            deletePath(errorPath);
+                    }
+                }
+                else {
+                    pendingBatches.push(...(batchesByEpisode.get(Number(episode["episode"])) ?? []));
                 }
-                const errorPath = batchErrorPath(batchResultsDir, cachedBatch);
-                if (exists(errorPath))
-                    deletePath(errorPath);
             }
-        }
-        else {
-            pendingBatches.push(...(batchesByEpisode.get(Number(episode["episode"])) ?? []));
-        }
-    }
-    const batchResults = [];
-    const skippedBatches = [];
-    const pending = [];
-    for (const batch of pendingBatches) {
-        const cachedBatch = batchCheckpointReused
-            ? loadCheckpointedBatch(sourceText, batchResultsDir, batch, providerName, model, previousProvider)
-            : null;
-        if (cachedBatch !== null) {
-            cachedBatch["_batch_id"] = batchResultKey(batch);
-            cachedBatch["_batch_part"] = Number(batch["part"]);
-            cachedBatch["_starts_inside_scene"] = Boolean(batch["starts_inside_scene"]);
-            batchResults.push(cachedBatch);
-            skippedBatches.push(batchResultKey(batch));
-        }
-        else {
-            pending.push(batch);
-        }
-    }
-    const failures = [];
-    const outcomes = await pMapWithConcurrency(pending, concurrency, async (batch) => {
-        return await extractBatchWithRecovery(provider, sourceText, batch);
-    });
-    for (let i = 0; i < outcomes.length; i++) {
-        const outcome = outcomes[i];
-        const batch = pending[i];
-        const errorPath = batchErrorPath(batchResultsDir, batch);
-        if (outcome.ok) {
-            const result = outcome.value;
-            result["_batch_id"] = batchResultKey(batch);
-            result["_batch_part"] = Number(batch["part"]);
-            result["_starts_inside_scene"] = Boolean(batch["starts_inside_scene"]);
-            batchResults.push(result);
-            persistBatchResult(batchResultsDir, batch, result);
-            updateBatchResultMetadata(batchResultsDir, batch, providerName, model);
-            if (exists(errorPath))
-                deletePath(errorPath);
-        }
-        else {
-            failures.push(writeBatchFailure(batchResultsDir, batch, outcome.error));
-        }
-    }
-    results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
-    batchResults.sort((a, b) => {
-        const ea = Number(a["episode"] ?? 0);
-        const eb = Number(b["episode"] ?? 0);
-        if (ea !== eb)
-            return ea - eb;
-        return Number(a["_batch_part"] ?? 0) - Number(b["_batch_part"] ?? 0);
-    });
-    failures.sort((a, b) => {
-        const ea = Number(a["episode"] ?? 0);
-        const eb = Number(b["episode"] ?? 0);
-        if (ea !== eb)
-            return ea - eb;
-        return Number(a["part"] ?? 0) - Number(b["part"] ?? 0);
-    });
-    const completedBatches = skippedEpisodeBatchCount + batchResults.length;
-    if (failures.length > 0) {
-        const failedEpisodes = [...new Set(failures.map((it) => Number(it["episode"])))].sort((a, b) => a - b);
-        const failedBatches = failures.map((it) => strOf(it["batch_id"]));
-        const currentFailureSignature = failureSignature(failedBatches);
-        const previousFailureSignature = failureSignature(previousState["failed_batches"]);
-        const sameFailuresRepeated = checkpointReused &&
-            batchCheckpointReused &&
-            currentFailureSignature.length > 0 &&
-            currentFailureSignature.length === previousFailureSignature.length &&
-            currentFailureSignature.every((v, idx) => v === previousFailureSignature[idx]) &&
-            ["init_incomplete", "init_stalled"].includes(strOf(previousState["status"]));
-        const previousFailureStreak = normalizeInt(previousState["failure_streak"], 0);
-        const failureStreak = sameFailuresRepeated ? previousFailureStreak + 1 : 1;
-        const failureTitle = sameFailuresRepeated
-            ? "INIT STALLED: Same batches keep failing"
-            : "INIT INCOMPLETE: Batch extraction failed";
-        const nextSteps = sameFailuresRepeated
-            ? [
-                "Run direct inspect --target issue to read failed batch details.",
-                "Do not rerun the same init command again until source, batch options, provider, or failed content has changed.",
-            ]
-            : [
-                "Run direct inspect --target issue to review failed batches.",
-                "Rerun the same init once if failures look transient; completed checkpoints will be reused.",
-            ];
-        const failedEpisodeSet = new Set(failedEpisodes);
-        const skippedSet = new Set(skipped);
-        const batchResultsByEpisode = new Map();
-        for (const result of batchResults) {
-            const ep = Number(result["episode"] ?? 0);
-            if (!batchResultsByEpisode.has(ep))
-                batchResultsByEpisode.set(ep, []);
-            batchResultsByEpisode.get(ep).push(result);
-        }
-        for (const episode of asList(plan["episodes"])) {
-            const episodeNum = Number(episode["episode"]);
-            if (skippedSet.has(episodeNum) || failedEpisodeSet.has(episodeNum))
-                continue;
-            const expectedBatches = (batchesByEpisode.get(episodeNum) ?? []).length;
-            if (expectedBatches && (batchResultsByEpisode.get(episodeNum) ?? []).length === expectedBatches) {
-                const result = mergeBatchResultsForEpisode(episode, batchResultsByEpisode.get(episodeNum) ?? []);
-                validateEpisodeExtractionQuality(sourceText, episode, result);
-                results.push(result);
-                writeJson(episodeResultPath(episodeResultsDir, episode), compactEpisodeResult(result));
-                updateEpisodeResultMetadata(episodeResultsDir, episode, providerName, model);
+            const pending = [];
+            for (const batch of pendingBatches) {
+                const cachedBatch = ctx.batchCheckpointReused
+                    ? loadCheckpointedBatch(ctx.sourceText, ctx.batchResultsDir, batch, ctx.providerName, ctx.model, previousProvider)
+                    : null;
+                if (cachedBatch !== null) {
+                    cachedBatch["_batch_id"] = batchResultKey(batch);
+                    cachedBatch["_batch_part"] = Number(batch["part"]);
+                    cachedBatch["_starts_inside_scene"] = Boolean(batch["starts_inside_scene"]);
+                    ctx.batchResults.push(cachedBatch);
+                    ctx.skippedBatches.push(batchResultKey(batch));
+                }
+                else {
+                    pending.push(batch);
+                }
             }
-        }
-        updateRunState(workspace, {
-            status: sameFailuresRepeated ? "init_stalled" : "init_incomplete",
-            init_stage: "batch_extract",
-            checkpoint,
-            batch_checkpoint: batchCheckpoint,
-            episode_total: asList(plan["episodes"]).length,
-            episode_completed: results.length,
-            episode_reused: skipped.length,
-            episode_failed: failedEpisodes.length,
-            failed_episodes: failedEpisodes,
-            batch_total: asList(batchPlan["batches"]).length,
-            batch_completed: completedBatches,
-            batch_reused: skippedEpisodeBatchCount + skippedBatches.length,
-            batch_failed: failures.length,
-            failed_batches: failedBatches,
-            failure_signature: currentFailureSignature,
-            failure_streak: failureStreak,
-            last_error: { title: failureTitle, failed_at: checkpointTimestamp() },
-            exportable: false,
-        });
-        const issues = failures.slice(0, 5).map((it) => `${it["batch_id"]} episode ${it["episode"]} part ${it["part"]}: ${it["error_type"]} - ${it["message"]}`);
-        const report = {
-            title: failureTitle,
-            result: [
-                `episodes total: ${asList(plan["episodes"]).length}`,
-                `completed: ${results.length}`,
-                `reused: ${skipped.length}`,
-                `failed episodes: ${failedEpisodes.length}`,
-                `batches: ${completedBatches}/${asList(batchPlan["batches"]).length} completed, ${failures.length} failed`,
-                `provider: ${providerName}`,
-            ],
-            artifacts: [
-                path.join(workspace, "source.txt"),
-                path.join(dd, "source_manifest.json"),
-                path.join(dd, "episode_plan.json"),
-                path.join(dd, "batch_plan.json"),
-                batchResultsDir,
-                episodeResultsDir,
-                path.join(dd, "run_state.json"),
-            ],
-            issues,
-            next: nextSteps,
-        };
-        return [report, EXIT_RUNTIME];
-    }
-    updateRunState(workspace, {
-        status: "init_running",
-        init_stage: "episode_merge",
-        checkpoint,
-        batch_checkpoint: batchCheckpoint,
-        episode_total: asList(plan["episodes"]).length,
-        episode_completed: results.length,
-        episode_reused: skipped.length,
-        episode_failed: 0,
-        failed_episodes: [],
-        batch_total: asList(batchPlan["batches"]).length,
-        batch_completed: completedBatches,
-        batch_reused: skippedEpisodeBatchCount + skippedBatches.length,
-        batch_failed: 0,
-        failed_batches: [],
-        failure_signature: [],
-        failure_streak: 0,
-        last_error: null,
-    });
-    for (const dir of [batchResultsDir, episodeResultsDir]) {
-        if (!exists(dir))
-            continue;
-        for (const name of fs.readdirSync(dir)) {
-            if (name.endsWith(".error.json")) {
+            const failures = [];
+            const outcomes = await pMapWithConcurrency(pending, ctx.concurrency, async (batch) => {
+                return await extractBatchWithRecovery(ctx.provider, ctx.sourceText, batch);
+            });
+            for (let i = 0; i < outcomes.length; i++) {
+                const outcome = outcomes[i];
+                const batch = pending[i];
+                const errorPath = batchErrorPath(ctx.batchResultsDir, batch);
+                if (outcome.ok) {
+                    const result = outcome.value;
+                    result["_batch_id"] = batchResultKey(batch);
+                    result["_batch_part"] = Number(batch["part"]);
+                    result["_starts_inside_scene"] = Boolean(batch["starts_inside_scene"]);
+                    ctx.batchResults.push(result);
+                    persistBatchResult(ctx.batchResultsDir, batch, result);
+                    updateBatchResultMetadata(ctx.batchResultsDir, batch, ctx.providerName, ctx.model);
+                    if (exists(errorPath))
+                        deletePath(errorPath);
+                }
+                else {
+                    failures.push(writeBatchFailure(ctx.batchResultsDir, batch, outcome.error));
+                }
+            }
+            ctx.results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
+            ctx.batchResults.sort((a, b) => {
+                const ea = Number(a["episode"] ?? 0);
+                const eb = Number(b["episode"] ?? 0);
+                if (ea !== eb)
+                    return ea - eb;
+                return Number(a["_batch_part"] ?? 0) - Number(b["_batch_part"] ?? 0);
+            });
+            failures.sort((a, b) => {
+                const ea = Number(a["episode"] ?? 0);
+                const eb = Number(b["episode"] ?? 0);
+                if (ea !== eb)
+                    return ea - eb;
+                return Number(a["part"] ?? 0) - Number(b["part"] ?? 0);
+            });
+            const completedBatches = ctx.skippedEpisodeBatchCount + ctx.batchResults.length;
+            ctx.completedBatches = completedBatches;
+            if (failures.length > 0) {
+                const failedEpisodes = [...new Set(failures.map((it) => Number(it["episode"])))].sort((a, b) => a - b);
+                const failedBatches = failures.map((it) => strOf(it["batch_id"]));
+                const currentFailureSignature = failureSignature(failedBatches);
+                const previousFailureSignature = failureSignature(ctx.previousState["failed_batches"]);
+                const sameFailuresRepeated = ctx.checkpointReused &&
+                    ctx.batchCheckpointReused &&
+                    currentFailureSignature.length > 0 &&
+                    currentFailureSignature.length === previousFailureSignature.length &&
+                    currentFailureSignature.every((v, idx) => v === previousFailureSignature[idx]) &&
+                    ["init_incomplete", "init_stalled"].includes(strOf(ctx.previousState["status"]));
+                const previousFailureStreak = normalizeInt(ctx.previousState["failure_streak"], 0);
+                const failureStreak = sameFailuresRepeated ? previousFailureStreak + 1 : 1;
+                const failureTitle = sameFailuresRepeated
+                    ? "INIT STALLED: Same batches keep failing"
+                    : "INIT INCOMPLETE: Batch extraction failed";
+                const nextSteps = sameFailuresRepeated
+                    ? [
+                        "Run direct inspect --target issue to read failed batch details.",
+                        "Do not rerun the same init command again until source, batch options, provider, or failed content has changed.",
+                    ]
+                    : [
+                        "Run direct inspect --target issue to review failed batches.",
+                        "Rerun the same init once if failures look transient; completed checkpoints will be reused.",
+                    ];
+                const failedEpisodeSet = new Set(failedEpisodes);
+                const skippedSet = new Set(ctx.skipped);
+                const batchResultsByEpisode = groupResultsByEpisode(ctx.batchResults);
+                for (const episode of asList(ctx.plan["episodes"])) {
+                    const episodeNum = Number(episode["episode"]);
+                    if (skippedSet.has(episodeNum) || failedEpisodeSet.has(episodeNum))
+                        continue;
+                    const expectedBatches = (batchesByEpisode.get(episodeNum) ?? []).length;
+                    if (expectedBatches && (batchResultsByEpisode.get(episodeNum) ?? []).length === expectedBatches) {
+                        ctx.results.push(mergeEpisodeAndPersist(ctx.sourceText, ctx.episodeResultsDir, episode, batchResultsByEpisode.get(episodeNum) ?? [], ctx.providerName, ctx.model));
+                    }
+                }
+                updateRunState(ctx.workspace, {
+                    status: sameFailuresRepeated ? "init_stalled" : "init_incomplete",
+                    init_stage: "batch_extract",
+                    checkpoint: ctx.checkpoint,
+                    batch_checkpoint: ctx.batchCheckpoint,
+                    episode_total: asList(ctx.plan["episodes"]).length,
+                    episode_completed: ctx.results.length,
+                    episode_reused: ctx.skipped.length,
+                    episode_failed: failedEpisodes.length,
+                    failed_episodes: failedEpisodes,
+                    batch_total: asList(ctx.batchPlan["batches"]).length,
+                    batch_completed: completedBatches,
+                    batch_reused: ctx.skippedEpisodeBatchCount + ctx.skippedBatches.length,
+                    batch_failed: failures.length,
+                    failed_batches: failedBatches,
+                    failure_signature: currentFailureSignature,
+                    failure_streak: failureStreak,
+                    last_error: { title: failureTitle, failed_at: checkpointTimestamp() },
+                    exportable: false,
+                });
+                const issues = failures.slice(0, 5).map((it) => `${it["batch_id"]} episode ${it["episode"]} part ${it["part"]}: ${it["error_type"]} - ${it["message"]}`);
+                const report = {
+                    title: failureTitle,
+                    result: [
+                        `episodes total: ${asList(ctx.plan["episodes"]).length}`,
+                        `completed: ${ctx.results.length}`,
+                        `reused: ${ctx.skipped.length}`,
+                        `failed episodes: ${failedEpisodes.length}`,
+                        `batches: ${completedBatches}/${asList(ctx.batchPlan["batches"]).length} completed, ${failures.length} failed`,
+                        `provider: ${ctx.providerName}`,
+                    ],
+                    artifacts: [
+                        path.join(ctx.workspace, "source.txt"),
+                        path.join(ctx.dd, "source_manifest.json"),
+                        path.join(ctx.dd, "episode_plan.json"),
+                        path.join(ctx.dd, "batch_plan.json"),
+                        ctx.batchResultsDir,
+                        ctx.episodeResultsDir,
+                        path.join(ctx.dd, "run_state.json"),
+                    ],
+                    issues,
+                    next: nextSteps,
+                };
+                return { kind: "halt", report, exitCode: EXIT_RUNTIME };
+            }
+            return { kind: "continue" };
+        },
+    },
+    {
+        stage: "episode_merge",
+        enter: (ctx) => ({
+            status: "init_running",
+            init_stage: "episode_merge",
+            checkpoint: ctx.checkpoint,
+            batch_checkpoint: ctx.batchCheckpoint,
+            episode_total: asList(ctx.plan["episodes"]).length,
+            episode_completed: ctx.results.length,
+            episode_reused: ctx.skipped.length,
+            episode_failed: 0,
+            failed_episodes: [],
+            batch_total: asList(ctx.batchPlan["batches"]).length,
+            batch_completed: ctx.completedBatches,
+            batch_reused: ctx.skippedEpisodeBatchCount + ctx.skippedBatches.length,
+            batch_failed: 0,
+            failed_batches: [],
+            failure_signature: [],
+            failure_streak: 0,
+            last_error: null,
+        }),
+        run: (ctx) => {
+            // Error-file cleanup is best-effort cosmetics: a readdir hiccup must never
+            // abort an otherwise-successful merge nor get misreported as a merge failure.
+            for (const dir of [ctx.batchResultsDir, ctx.episodeResultsDir]) {
+                if (!exists(dir))
+                    continue;
+                let names;
                 try {
-                    deletePath(path.join(dir, name));
+                    names = fs.readdirSync(dir);
                 }
                 catch {
-                    // ignore
+                    continue;
+                }
+                for (const name of names) {
+                    if (name.endsWith(".error.json")) {
+                        try {
+                            deletePath(path.join(dir, name));
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
                 }
             }
-        }
-    }
-    try {
-        const batchResultsByEpisode = new Map();
-        for (const result of batchResults) {
-            const ep = Number(result["episode"] ?? 0);
-            if (!batchResultsByEpisode.has(ep))
-                batchResultsByEpisode.set(ep, []);
-            batchResultsByEpisode.get(ep).push(result);
-        }
-        const skippedSet = new Set(skipped);
-        for (const episode of asList(plan["episodes"])) {
-            const episodeNum = Number(episode["episode"]);
-            if (skippedSet.has(episodeNum))
-                continue;
-            const result = mergeBatchResultsForEpisode(episode, batchResultsByEpisode.get(episodeNum) ?? []);
-            validateEpisodeExtractionQuality(sourceText, episode, result);
-            results.push(result);
-            writeJson(episodeResultPath(episodeResultsDir, episode), compactEpisodeResult(result));
-            updateEpisodeResultMetadata(episodeResultsDir, episode, providerName, model);
-            const errorPath = episodeErrorPath(episodeResultsDir, episode);
-            if (exists(errorPath))
-                deletePath(errorPath);
-        }
-    }
-    catch (exc) {
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Episode merge failed",
-            stage: "episode_merge",
-            required: ["complete batch_results/*.json that can merge into episode_results/*.json"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Rerun init; completed batch checkpoints will be reused and episode merge will retry."],
-            updates: { checkpoint, batch_checkpoint: batchCheckpoint, batch_completed: completedBatches },
-        });
-    }
-    results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
-    let script;
-    try {
-        updateRunState(workspace, { status: "init_running", init_stage: "script_merge", checkpoint, batch_checkpoint: batchCheckpoint });
-        script = mergeEpisodeResults(results, strOf(info["projectName"]) || path.basename(source, path.extname(source)));
-    }
-    catch (exc) {
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Merge failed",
-            stage: "script_merge",
-            required: ["complete episode_results/*.json"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Rerun init; completed episode extraction checkpoints will be reused and merge will retry."],
-            updates: { checkpoint, batch_checkpoint: batchCheckpoint, episode_completed: results.length },
-        });
-    }
-    try {
-        updateRunState(workspace, { status: "init_running", init_stage: "asset_curation", checkpoint, batch_checkpoint: batchCheckpoint });
-        const rawCuration = await providerExtractAssetCurationLocal(provider, sourceText, script);
-        const curation = curateScriptAssets(script, rawCuration);
-        writeJson(path.join(dd, "asset_curation.json"), curation);
-    }
-    catch (exc) {
-        if (exc instanceof CliError) {
-            throw initFailedReport(workspace, {
-                title: exc.title,
+            const batchResultsByEpisode = groupResultsByEpisode(ctx.batchResults);
+            const skippedSet = new Set(ctx.skipped);
+            for (const episode of asList(ctx.plan["episodes"])) {
+                const episodeNum = Number(episode["episode"]);
+                if (skippedSet.has(episodeNum))
+                    continue;
+                ctx.results.push(mergeEpisodeAndPersist(ctx.sourceText, ctx.episodeResultsDir, episode, batchResultsByEpisode.get(episodeNum) ?? [], ctx.providerName, ctx.model));
+                const errorPath = episodeErrorPath(ctx.episodeResultsDir, episode);
+                if (exists(errorPath))
+                    deletePath(errorPath);
+            }
+            ctx.results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Episode merge failed",
+                stage: "episode_merge",
+                required: ["complete batch_results/*.json that can merge into episode_results/*.json"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Rerun init; completed batch checkpoints will be reused and episode merge will retry."],
+                updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, batch_completed: ctx.completedBatches },
+            });
+        },
+    },
+    {
+        stage: "script_merge",
+        enter: (ctx) => ({ status: "init_running", init_stage: "script_merge", checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint }),
+        run: (ctx) => {
+            ctx.script = mergeEpisodeResults(ctx.results, strOf(ctx.info["projectName"]) || path.basename(ctx.source, path.extname(ctx.source)));
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Merge failed",
+                stage: "script_merge",
+                required: ["complete episode_results/*.json"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Rerun init; completed episode extraction checkpoints will be reused and merge will retry."],
+                updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
+            });
+        },
+    },
+    {
+        stage: "asset_curation",
+        enter: (ctx) => ({ status: "init_running", init_stage: "asset_curation", checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint }),
+        run: async (ctx) => {
+            const rawCuration = await providerExtractAssetCurationLocal(ctx.provider, ctx.sourceText, ctx.script);
+            const curation = curateScriptAssets(ctx.script, rawCuration);
+            writeJson(path.join(ctx.dd, "asset_curation.json"), curation);
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            if (exc instanceof CliError) {
+                throw initFailedReport(ctx.workspace, {
+                    title: exc.title,
+                    stage: "asset_curation",
+                    exitCode: exc.exitCode,
+                    required: exc.required.length > 0 ? exc.required : ["asset curation JSON matching final script contract"],
+                    received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
+                    nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
+                    updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
+                });
+            }
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Asset curation failed",
                 stage: "asset_curation",
-                exitCode: exc.exitCode,
-                required: exc.required.length > 0 ? exc.required : ["asset curation JSON matching final script contract"],
-                received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
-                nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
-                updates: { checkpoint, batch_checkpoint: batchCheckpoint, episode_completed: results.length },
+                required: ["provider location merge decisions and deterministic asset reuse curation"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
+                updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
             });
-        }
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Asset curation failed",
-            stage: "asset_curation",
-            required: ["provider location merge decisions and deterministic asset reuse curation"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
-            updates: { checkpoint, batch_checkpoint: batchCheckpoint, episode_completed: results.length },
-        });
-    }
-    try {
-        updateRunState(workspace, { status: "init_running", init_stage: "metadata_extract", checkpoint, batch_checkpoint: batchCheckpoint });
-        let metadata = provider.extractMetadata ? await provider.extractMetadata(sourceText, script) : {};
-        if (!isDict(metadata))
-            metadata = {};
-        writeJson(path.join(dd, "asset_metadata.json"), metadata);
-        applyMetadataToScript(script, metadata);
-    }
-    catch (exc) {
-        if (exc instanceof CliError) {
-            throw initFailedReport(workspace, {
-                title: exc.title,
+        },
+    },
+    {
+        stage: "metadata_extract",
+        enter: (ctx) => ({ status: "init_running", init_stage: "metadata_extract", checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint }),
+        run: async (ctx) => {
+            let metadata = ctx.provider.extractMetadata ? await ctx.provider.extractMetadata(ctx.sourceText, ctx.script) : {};
+            if (!isDict(metadata))
+                metadata = {};
+            writeJson(path.join(ctx.dd, "asset_metadata.json"), metadata);
+            applyMetadataToScript(ctx.script, metadata);
+            return { kind: "continue" };
+        },
+        onError: (ctx, exc) => {
+            if (exc instanceof CliError) {
+                throw initFailedReport(ctx.workspace, {
+                    title: exc.title,
+                    stage: "metadata_extract",
+                    exitCode: exc.exitCode,
+                    required: exc.required.length > 0 ? exc.required : ["metadata JSON matching final script contract"],
+                    received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
+                    nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
+                    updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
+                });
+            }
+            const e = exc;
+            throw initFailedReport(ctx.workspace, {
+                title: "INIT FAILED: Metadata extraction failed",
                 stage: "metadata_extract",
-                exitCode: exc.exitCode,
-                required: exc.required.length > 0 ? exc.required : ["metadata JSON matching final script contract"],
-                received: exc.received.length > 0 ? exc.received : [String(exc.message).slice(0, 160)],
-                nextSteps: exc.nextSteps.length > 0 ? exc.nextSteps : ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-                updates: { checkpoint, batch_checkpoint: batchCheckpoint, episode_completed: results.length },
+                required: ["provider metadata for worldview, role_type, and asset descriptions"],
+                received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
+                updates: { checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
             });
-        }
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Metadata extraction failed",
-            stage: "metadata_extract",
-            required: ["provider metadata for worldview, role_type, and asset descriptions"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-            updates: { checkpoint, batch_checkpoint: batchCheckpoint, episode_completed: results.length },
-        });
-    }
-    const scriptPath = path.join(dd, "script.initial.json");
-    writeJson(scriptPath, script);
-    updateRunState(workspace, { status: "init_running", init_stage: "validate", checkpoint, batch_checkpoint: batchCheckpoint });
-    let validation;
-    try {
-        validation = validateScript(workspace, scriptPath);
-    }
-    catch (exc) {
-        const e = exc;
-        throw initFailedReport(workspace, {
-            title: "INIT FAILED: Validation failed",
-            stage: "validate",
-            required: ["script.initial.json that can be validated"],
-            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
-            nextSteps: ["Rerun init to retry validation, or inspect script.initial.json if the failure persists."],
-            updates: { checkpoint, script_path: scriptPath },
-        });
-    }
-    const passed = Boolean(validation["passed"]);
-    const status = passed ? "ready_for_agent" : "needs_agent_repair";
-    updateRunState(workspace, {
-        status,
-        command: "direct init",
-        init_stage: "complete",
-        checkpoint,
-        batch_checkpoint: batchCheckpoint,
-        checkpoint_reused: checkpointReused,
-        batch_checkpoint_reused: batchCheckpointReused,
-        provider: providerName,
-        model,
-        concurrency,
-        batch_mode: batchMode,
-        batch_target_lines: batchTargetLines,
-        batch_max_chars: batchMaxChars,
-        batch_min_lines: batchMinLines,
-        source_path: path.resolve(source),
-        script_path: scriptPath,
-        validation_path: path.join(dd, "validation.json"),
-        episode_total: asList(plan["episodes"]).length,
-        episode_completed: results.length,
-        episode_reused: skipped.length,
-        episode_failed: 0,
-        failed_episodes: [],
-        batch_total: asList(batchPlan["batches"]).length,
-        batch_completed: completedBatches,
-        batch_reused: skippedEpisodeBatchCount + skippedBatches.length,
-        batch_failed: 0,
-        failed_batches: [],
-        failure_signature: [],
-        failure_streak: 0,
-        last_error: null,
-        review_status: "pending",
-        review_missing: [...REVIEW_TARGETS],
-        inspected_targets: [],
-        patch_count: 0,
-        exportable: providerName !== "mock",
-    });
-    const title = passed
-        ? "INIT COMPLETE: Initial script ready"
-        : "INIT NEEDS AGENT: Initial script written with repair issues";
-    const stats = validation["stats"] ?? {};
-    const report = {
-        title,
-        result: [
-            `episodes: ${stats["episodes"] ?? 0}`,
-            `scenes: ${stats["scenes"] ?? 0}`,
-            `actions: ${stats["actions"] ?? 0}`,
-            `validation: ${passed ? "passed" : "needs repair"}`,
-            `provider: ${providerName}`,
-            `episode checkpoint reused: ${skipped.length}`,
-            `batches: ${completedBatches}/${asList(batchPlan["batches"]).length} completed`,
-            `batch checkpoint reused: ${skippedEpisodeBatchCount + skippedBatches.length}`,
-            "agent_review: pending",
-        ],
-        artifacts: [
-            path.join(workspace, "source.txt"),
-            path.join(dd, "source_manifest.json"),
-            path.join(dd, "episode_plan.json"),
-            path.join(dd, "batch_plan.json"),
-            batchResultsDir,
-            episodeResultsDir,
-            path.join(dd, "asset_curation.json"),
-            path.join(dd, "asset_metadata.json"),
-            scriptPath,
-            path.join(dd, "validation.json"),
-            path.join(dd, "run_state.json"),
-        ],
-        issues: summarizeIssues(asList(validation["issues"])),
-        next: providerName === "mock"
-            ? [
-                "Run inspect for issue, episode, and asset; apply patches if needed; then validate/export.",
-                "Do not export mock-provider results for delivery.",
-            ]
-            : ["Run inspect for issue, episode, and asset; apply patches if needed; then validate/export."],
-    };
-    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
-}
+        },
+    },
+    {
+        stage: "validate",
+        // Handles errors inline: script.initial.json must be written and the
+        // validate run_state written before validateScript runs, so a uniform
+        // onError mapping cannot reproduce the ordering.
+        run: (ctx) => {
+            const { workspace, providerName, model, concurrency, source } = ctx;
+            const scriptPath = path.join(ctx.dd, "script.initial.json");
+            writeJson(scriptPath, ctx.script);
+            updateRunState(workspace, { status: "init_running", init_stage: "validate", checkpoint: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint });
+            let validation;
+            try {
+                validation = validateScript(workspace, scriptPath);
+            }
+            catch (exc) {
+                const e = exc;
+                throw initFailedReport(workspace, {
+                    title: "INIT FAILED: Validation failed",
+                    stage: "validate",
+                    required: ["script.initial.json that can be validated"],
+                    received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+                    nextSteps: ["Rerun init to retry validation, or inspect script.initial.json if the failure persists."],
+                    updates: { checkpoint: ctx.checkpoint, script_path: scriptPath },
+                });
+            }
+            const passed = Boolean(validation["passed"]);
+            const status = passed ? "ready_for_agent" : "needs_agent_repair";
+            updateRunState(workspace, {
+                status,
+                command: "direct init",
+                init_stage: "complete",
+                checkpoint: ctx.checkpoint,
+                batch_checkpoint: ctx.batchCheckpoint,
+                checkpoint_reused: ctx.checkpointReused,
+                batch_checkpoint_reused: ctx.batchCheckpointReused,
+                provider: providerName,
+                model,
+                concurrency,
+                batch_mode: ctx.batchMode,
+                batch_target_lines: ctx.batchTargetLines,
+                batch_max_chars: ctx.batchMaxChars,
+                batch_min_lines: ctx.batchMinLines,
+                source_path: path.resolve(source),
+                script_path: scriptPath,
+                validation_path: path.join(ctx.dd, "validation.json"),
+                episode_total: asList(ctx.plan["episodes"]).length,
+                episode_completed: ctx.results.length,
+                episode_reused: ctx.skipped.length,
+                episode_failed: 0,
+                failed_episodes: [],
+                batch_total: asList(ctx.batchPlan["batches"]).length,
+                batch_completed: ctx.completedBatches,
+                batch_reused: ctx.skippedEpisodeBatchCount + ctx.skippedBatches.length,
+                batch_failed: 0,
+                failed_batches: [],
+                failure_signature: [],
+                failure_streak: 0,
+                last_error: null,
+                review_status: "pending",
+                review_missing: [...REVIEW_TARGETS],
+                inspected_targets: [],
+                patch_count: 0,
+                exportable: providerName !== "mock",
+            });
+            const title = passed
+                ? "INIT COMPLETE: Initial script ready"
+                : "INIT NEEDS AGENT: Initial script written with repair issues";
+            const stats = validation["stats"] ?? {};
+            const report = {
+                title,
+                result: [
+                    `episodes: ${stats["episodes"] ?? 0}`,
+                    `scenes: ${stats["scenes"] ?? 0}`,
+                    `actions: ${stats["actions"] ?? 0}`,
+                    `validation: ${passed ? "passed" : "needs repair"}`,
+                    `provider: ${providerName}`,
+                    `episode checkpoint reused: ${ctx.skipped.length}`,
+                    `batches: ${ctx.completedBatches}/${asList(ctx.batchPlan["batches"]).length} completed`,
+                    `batch checkpoint reused: ${ctx.skippedEpisodeBatchCount + ctx.skippedBatches.length}`,
+                    "agent_review: pending",
+                ],
+                artifacts: [
+                    path.join(workspace, "source.txt"),
+                    path.join(ctx.dd, "source_manifest.json"),
+                    path.join(ctx.dd, "episode_plan.json"),
+                    path.join(ctx.dd, "batch_plan.json"),
+                    ctx.batchResultsDir,
+                    ctx.episodeResultsDir,
+                    path.join(ctx.dd, "asset_curation.json"),
+                    path.join(ctx.dd, "asset_metadata.json"),
+                    scriptPath,
+                    path.join(ctx.dd, "validation.json"),
+                    path.join(ctx.dd, "run_state.json"),
+                ],
+                issues: summarizeIssues(asList(validation["issues"])),
+                next: providerName === "mock"
+                    ? [
+                        "Run inspect for issue, episode, and asset; apply patches if needed; then validate/export.",
+                        "Do not export mock-provider results for delivery.",
+                    ]
+                    : ["Run inspect for issue, episode, and asset; apply patches if needed; then validate/export."],
+            };
+            return { kind: "halt", report, exitCode: passed ? EXIT_OK : EXIT_NEEDS_AGENT };
+        },
+    },
+];
 export function summarizeIssues(issues) {
     if (issues.length === 0)
         return [];