@lingjingai/scriptctl 0.9.7 → 0.9.8

package/dist/usecases/direct.js

@@ -626,12 +626,6 @@ 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))
@@ -721,698 +715,577 @@ function validateInitOpts(opts) {
             nextSteps: ["Use a supported source file and rerun init."],
         });
     }
-    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);
+    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() },
+            });
             throw exc;
         }
-        if (result.kind === "halt")
-            return [result.report, result.exitCode];
-    }
-    // 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",
+        const e = exc;
+        const receivedError = `${source}: ${e?.name ?? "Error"}${e?.message ? `: ${e.message}` : ""}`;
+        updateRunState(workspace, {
+            status: "init_failed",
             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."],
+            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."],
+        });
+    }
+    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() },
             });
-        },
-    },
-    {
-        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",
+        }
+        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: "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."],
-            });
-        },
-    },
-    {
-        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 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);
-                }
-            }
-            const failures = [];
-            const outcomes = await pMapWithConcurrency(pending, ctx.concurrency, async (batch) => {
-                return await extractBatchWithRecovery(ctx.provider, ctx.sourceText, batch);
+                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."],
             });
-            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));
+        }
+        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);
                 }
+                const errorPath = batchErrorPath(batchResultsDir, cachedBatch);
+                if (exists(errorPath))
+                    deletePath(errorPath);
             }
-            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 };
+        }
+        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);
             }
-            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;
+        }
+        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")) {
                 try {
-                    names = fs.readdirSync(dir);
+                    deletePath(path.join(dir, name));
                 }
                 catch {
-                    continue;
-                }
-                for (const name of names) {
-                    if (name.endsWith(".error.json")) {
-                        try {
-                            deletePath(path.join(dir, name));
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
+                    // ignore
                 }
             }
-            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",
+        }
+    }
+    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,
                 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: ctx.checkpoint, batch_checkpoint: ctx.batchCheckpoint, episode_completed: ctx.results.length },
+                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 },
             });
-        },
-    },
-    {
-        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",
+        }
+        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",
-                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 },
+                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 },
             });
-        },
-    },
-    {
-        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 };
-        },
-    },
-];
+        }
+        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];
+}
 export function summarizeIssues(issues) {
     if (issues.length === 0)
         return [];