@lingjingai/scriptctl 0.11.4 → 0.12.0

package/dist/usecases/direct.js

@@ -1,10 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_CONCURRENCY, DEFAULT_MODEL, DEFAULT_PROVIDER, DIRECT_CONTRACT_VERSION, EXIT_INPUT, EXIT_NEEDS_AGENT, EXIT_OK, EXIT_RUNTIME, EXIT_USAGE, PARSE_MD_SPEC, REVIEW_TARGETS, SUPPORTED_EXTS, deletePath, deleteTree, directDir, exists, fmtId, readJson, readText, sha256Text, writeJson, } from "../common.js";
-import { compactBatchResult, compactEpisodeResult, buildBatchPlan, buildEpisodePlan, enrichEpisodePlanTitles, extractBatchWithRecovery, mergeEpisodeResults, normalizeEpisodeResult, normalizeInt, parseAssetDoc, parseMarkdownBatch, recoverBatchFromSource, uniqueAdd, validateBatchExtractionQuality, validateEpisodeExtractionQuality, _md_push_asset, curateScriptAssets, applyMetadataToScript, } from "../domain/direct-core.js";
+import { CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_CONCURRENCY, DEFAULT_MODEL, DEFAULT_PROVIDER, EXIT_INPUT, EXIT_NEEDS_AGENT, EXIT_OK, EXIT_RUNTIME, EXIT_USAGE, REVIEW_TARGETS, SUPPORTED_EXTS, deletePath, directDir, exists, fmtId, readJson, readText, writeJson, } from "../common.js";
+import { compactBatchResult, compactEpisodeResult, buildBatchPlan, buildEpisodePlan, enrichEpisodePlanTitles, extractBatchWithRecovery, mergeEpisodeResults, normalizeEpisodeResult, normalizeInt, uniqueAdd, validateEpisodeExtractionQuality, _md_push_asset, curateScriptAssets, applyMetadataToScript, } from "../domain/direct-core.js";
 import { validateScript } from "../domain/script-core.js";
-import { ScriptOutputApiError } from "../infra/script-output-store.js";
-import { apiErrorToCli, currentRevisionOrZero, scriptOutputClient, sortDeep } from "./script.js";
 import { makeProvider } from "../infra/providers.js";
 import { makeSourceManifest, prepareSource, } from "../infra/converters.js";
 function strOf(v) {
@@ -25,6 +23,12 @@ function checkpointTimestamp() {
     const now = new Date();
     return now.toISOString().replace(/\.\d+Z$/, "Z");
 }
+function parseIntList(v) {
+    return strOf(v).split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !Number.isNaN(n));
+}
+function parseStrList(v) {
+    return strOf(v).split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
 // ---------------------------------------------------------------------------
 // run_state.json
 // ---------------------------------------------------------------------------
@@ -56,18 +60,6 @@ export function readRunState(workspace) {
         return {};
     }
 }
-function failureSignature(items) {
-    if (!isList(items))
-        return [];
-    const out = [];
-    for (const item of items) {
-        const s = strOf(item).trim();
-        if (s)
-            out.push(s);
-    }
-    out.sort();
-    return out;
-}
 export function addInspectedTarget(workspace, target) {
     const state = readRunState(workspace);
     const targets = [];
@@ -149,9 +141,6 @@ function episodeErrorPath(dir, ep) {
 function episodeResultKey(ep) {
     return `ep_${pad3(Number(ep["episode"]))}`;
 }
-function episodeResultsIndexPath(dir) {
-    return path.join(dir, "index.json");
-}
 function batchResultKey(batch) {
     const bid = strOf(batch["batch_id"]).trim();
     if (bid)
@@ -167,9 +156,6 @@ function batchMarkdownPath(dir, batch) {
 function batchErrorPath(dir, batch) {
     return path.join(dir, `${batchResultKey(batch)}.error.json`);
 }
-function batchResultsIndexPath(dir) {
-    return path.join(dir, "index.json");
-}
 function persistBatchResult(dir, batch, result) {
     const rawMd = result["_raw_markdown"];
     delete result["_raw_markdown"];
@@ -183,263 +169,55 @@ function persistBatchResult(dir, batch, result) {
         deletePath(mdPath);
     }
 }
-function readBatchResultsIndex(dir) {
-    const p = batchResultsIndexPath(dir);
-    if (!exists(p))
-        return { version: 1, batches: {} };
-    let data;
-    try {
-        data = readJson(p);
-    }
-    catch {
-        return { version: 1, batches: {} };
-    }
-    if (!isDict(data))
-        return { version: 1, batches: {} };
-    if (!isDict(data["batches"]))
-        data["batches"] = {};
-    if (!("version" in data))
-        data["version"] = 1;
-    return data;
-}
-function writeBatchResultsIndex(dir, index) {
-    writeJson(batchResultsIndexPath(dir), index);
-}
-function updateBatchResultMetadata(dir, batch, providerName, model) {
-    const index = readBatchResultsIndex(dir);
-    const batches = index["batches"] ?? {};
-    batches[batchResultKey(batch)] = {
-        episode: Number(batch["episode"]),
-        part: Number(batch["part"]),
-        provider: providerName,
-        model,
-        extracted_at: checkpointTimestamp(),
-    };
-    index["batches"] = batches;
-    writeBatchResultsIndex(dir, index);
-}
-function removeBatchResultMetadata(dir, batch) {
-    const index = readBatchResultsIndex(dir);
-    const batches = index["batches"] ?? {};
-    const key = batchResultKey(batch);
-    if (key in batches) {
-        delete batches[key];
-        index["batches"] = batches;
-        writeBatchResultsIndex(dir, index);
-    }
-}
-function readEpisodeResultsIndex(dir) {
-    const p = episodeResultsIndexPath(dir);
-    if (!exists(p))
-        return { version: 1, episodes: {} };
-    let data;
-    try {
-        data = readJson(p);
-    }
-    catch {
-        return { version: 1, episodes: {} };
-    }
-    if (!isDict(data))
-        return { version: 1, episodes: {} };
-    if (!isDict(data["episodes"]))
-        data["episodes"] = {};
-    if (!("version" in data))
-        data["version"] = 1;
-    return data;
-}
-function writeEpisodeResultsIndex(dir, index) {
-    writeJson(episodeResultsIndexPath(dir), index);
-}
-function updateEpisodeResultMetadata(dir, ep, providerName, model) {
-    const index = readEpisodeResultsIndex(dir);
-    const episodes = index["episodes"] ?? {};
-    episodes[episodeResultKey(ep)] = {
-        provider: providerName,
-        model,
-        extracted_at: checkpointTimestamp(),
-    };
-    index["episodes"] = episodes;
-    writeEpisodeResultsIndex(dir, index);
-}
-function removeEpisodeResultMetadata(dir, ep) {
-    const index = readEpisodeResultsIndex(dir);
-    const episodes = index["episodes"] ?? {};
-    const key = episodeResultKey(ep);
-    if (key in episodes) {
-        delete episodes[key];
-        index["episodes"] = episodes;
-        writeEpisodeResultsIndex(dir, index);
-    }
-}
-function compactResultHasMultiRefs(data) {
-    for (const scene of asList(data["sc"])) {
-        if (!isDict(scene))
-            continue;
-        for (const action of asList(scene["a"])) {
-            if (!isDict(action))
-                continue;
-            const refs = action["r"];
-            if (isList(refs) && refs.length > 1)
-                return true;
-        }
-    }
-    return false;
-}
-export function initCheckpoint(sourceText, plan) {
-    const planText = JSON.stringify(plan, checkpointReplacer());
-    return {
-        contract_version: DIRECT_CONTRACT_VERSION,
-        source_sha256: sha256Text(sourceText),
-        episode_plan_sha256: sha256Text(planText),
-        total_episodes: Number(plan["total_episodes"] ?? asList(plan["episodes"]).length),
-    };
-}
-export function initBatchCheckpoint(sourceText, batchPlan) {
-    const planText = JSON.stringify(batchPlan, checkpointReplacer());
-    return {
-        contract_version: DIRECT_CONTRACT_VERSION,
-        source_sha256: sha256Text(sourceText),
-        batch_plan_sha256: sha256Text(planText),
-        total_batches: Number(batchPlan["total_batches"] ?? asList(batchPlan["batches"]).length),
-    };
-}
-// Title fields are LLM-mutated downstream by enrichEpisodePlanTitles, so they
-// must be excluded from checkpoint hashes — otherwise every rerun gets a fresh
-// SHA, the previous checkpoint never matches, and the whole batch pipeline
-// re-extracts from scratch.
-const CHECKPOINT_UNSTABLE_KEYS = new Set(["title", "generated_title", "title_status", "title_source"]);
-function checkpointReplacer() {
-    // Python's json.dumps(sort_keys=True) sorts keys recursively. Replicate by walking and sorting.
-    return function (key, value) {
-        if (CHECKPOINT_UNSTABLE_KEYS.has(key))
-            return undefined;
-        if (isDict(value)) {
-            const sorted = {};
-            for (const k of Object.keys(value).sort()) {
-                if (CHECKPOINT_UNSTABLE_KEYS.has(k))
-                    continue;
-                sorted[k] = value[k];
-            }
-            return sorted;
-        }
-        return value;
-    };
-}
-function checkpointSourceMatches(previous, current) {
-    if (!previous || Object.keys(previous).length === 0)
-        return false;
-    const keys = ["contract_version", "source_sha256", "episode_plan_sha256", "total_episodes"];
-    return keys.every((k) => previous[k] === current[k]);
-}
-function batchCheckpointMatches(previous, current) {
-    if (!previous || Object.keys(previous).length === 0)
-        return false;
-    const keys = ["contract_version", "source_sha256", "batch_plan_sha256", "total_batches"];
-    return keys.every((k) => previous[k] === current[k]);
-}
-function resetInitOutputs(dd) {
-    for (const dirname of ["episode_results", "batch_results"]) {
-        const target = path.join(dd, dirname);
-        if (exists(target))
-            deleteTree(target);
-    }
-    for (const name of ["script.initial.json", "validation.json", "batch_plan.json", "asset_curation.json", "asset_metadata.json"]) {
-        const p = path.join(dd, name);
-        if (exists(p))
-            deletePath(p);
-    }
-}
-function resetBatchOutputs(dd) {
-    const batchResultsDir = path.join(dd, "batch_results");
-    if (exists(batchResultsDir))
-        deleteTree(batchResultsDir);
-}
-function loadCheckpointedEpisode(sourceText, episodeResultsDir, ep, providerName, model, previousProvider) {
-    const p = episodeResultPath(episodeResultsDir, ep);
+// ---------------------------------------------------------------------------
+// Per-batch result files ARE the state. A batch with `<key>.json` is done; with
+// `<key>.error.json` it failed; with neither it is pending. Reuse = file
+// presence — the agent drives what to (re)run via `direct status` + --episodes/
+// --batches selection. No content hashes, no global checkpoint, no destructive
+// reset: re-running a unit only ever touches that unit's own files, so the other
+// episodes can never be lost.
+// ---------------------------------------------------------------------------
+// Read a persisted batch result (reused or freshly written) for assembly.
+// Returns null if absent or unreadable, in which case the batch counts as
+// not-done and will be (re)run.
+function readBatchResult(dir, batch) {
+    const p = batchResultPath(dir, batch);
     if (!exists(p))
         return null;
-    let result;
     try {
-        const data = readJson(p);
-        const metadata = isDict(data["_scriptctl"]) ? data["_scriptctl"] : {};
-        const index = readEpisodeResultsIndex(episodeResultsDir);
-        let indexEntry = {};
-        const eps = index["episodes"];
-        if (isDict(eps)) {
-            const entry = eps[episodeResultKey(ep)];
-            if (isDict(entry))
-                indexEntry = entry;
-        }
-        const resultProvider = strOf(metadata["provider"] || indexEntry["provider"] || previousProvider).trim();
-        if (providerName && resultProvider && resultProvider !== providerName) {
-            throw new Error(`checkpoint provider mismatch: ${resultProvider} != ${providerName}`);
-        }
-        result = normalizeEpisodeResult(data, ep);
-        validateEpisodeExtractionQuality(sourceText, ep, result);
-        if (!("sc" in data) || ["episode", "title", "source_span", "_scriptctl"].some((k) => k in data)) {
-            writeJson(p, compactEpisodeResult(result));
-            if (providerName && model)
-                updateEpisodeResultMetadata(episodeResultsDir, ep, providerName, model);
-        }
+        const result = normalizeEpisodeResult(readJson(p), batch);
+        result["_batch_id"] = batchResultKey(batch);
+        result["_batch_part"] = Number(batch["part"]);
+        result["_starts_inside_scene"] = Boolean(batch["starts_inside_scene"]);
+        return result;
     }
     catch {
-        try {
-            deletePath(p);
-        }
-        catch {
-            // ignore
-        }
-        removeEpisodeResultMetadata(episodeResultsDir, ep);
         return null;
     }
-    if (Number(result["episode"] ?? 0) !== Number(ep["episode"]))
-        return null;
-    if (JSON.stringify(result["source_span"]) !== JSON.stringify(ep["source_span"]))
-        return null;
-    return result;
 }
-function loadCheckpointedBatch(sourceText, batchResultsDir, batch, providerName, model, previousProvider) {
-    const p = batchResultPath(batchResultsDir, batch);
-    if (!exists(p))
-        return null;
-    let result;
-    try {
-        const data = readJson(p);
-        const index = readBatchResultsIndex(batchResultsDir);
-        let indexEntry = {};
-        const batches = index["batches"];
-        if (isDict(batches)) {
-            const entry = batches[batchResultKey(batch)];
-            if (isDict(entry))
-                indexEntry = entry;
-        }
-        const resultProvider = strOf(indexEntry["provider"] || previousProvider).trim();
-        if (providerName && resultProvider && resultProvider !== providerName) {
-            throw new Error(`checkpoint provider mismatch: ${resultProvider} != ${providerName}`);
-        }
-        result = normalizeEpisodeResult(data, batch);
-        validateBatchExtractionQuality(sourceText, batch, result);
-        if (!("sc" in data) || compactResultHasMultiRefs(data) || ["episode", "title", "source_span", "_scriptctl"].some((k) => k in data)) {
-            persistBatchResult(batchResultsDir, batch, result);
-            if (providerName && model)
-                updateBatchResultMetadata(batchResultsDir, batch, providerName, model);
-        }
-    }
-    catch {
-        try {
-            deletePath(p);
+// Delete result/meta/error/markdown files whose unit key is no longer in the
+// current plan (e.g. the source shed an episode). Pure function of the plan —
+// it never inspects hashes, content, or run_state, so it can only remove units
+// the plan no longer references. Also retires the legacy v3 `index.json`.
+function gcOrphanUnits(dir, liveKeys) {
+    if (!exists(dir))
+        return [];
+    const removed = [];
+    for (const name of fs.readdirSync(dir)) {
+        if (name === "index.json") {
+            deletePath(path.join(dir, name));
+            removed.push(name);
+            continue;
         }
-        catch {
-            // ignore
+        const key = name.replace(/\.(meta\.json|error\.json|json|md)$/, "");
+        if (key === name)
+            continue; // not a recognized unit artifact
+        if (!liveKeys.has(key)) {
+            deletePath(path.join(dir, name));
+            removed.push(name);
         }
-        removeBatchResultMetadata(batchResultsDir, batch);
-        return null;
     }
-    if (Number(result["episode"] ?? 0) !== Number(batch["episode"]))
-        return null;
-    if (JSON.stringify(result["source_span"]) !== JSON.stringify(batch["source_span"]))
-        return null;
-    return result;
+    return removed;
 }
 function mergeScene(target, source) {
     if ((target["location_name"] === "" || target["location_name"] === "未知场景" || target["location_name"] === null || target["location_name"] === undefined) &&
@@ -532,31 +310,10 @@ async function providerExtractAssetCurationLocal(provider, sourceText, script) {
     }
     return {};
 }
-function writeEpisodeFailure(dir, ep, exc) {
-    const err = exc;
-    const error = {
-        episode: Number(ep["episode"]),
-        title: ep["title"],
-        source_span: ep["source_span"],
-        error_type: err?.name || "Error",
-        message: (err?.message || err?.name || "Error").slice(0, 500),
-        failed_at: checkpointTimestamp(),
-    };
-    if (exc instanceof CliError) {
-        if (exc.required.length > 0)
-            error["required"] = exc.required;
-        if (exc.received.length > 0)
-            error["received"] = exc.received;
-        if (exc.nextSteps.length > 0)
-            error["next"] = exc.nextSteps;
-    }
-    const resultPath = episodeResultPath(dir, ep);
-    if (exists(resultPath))
-        deletePath(resultPath);
-    removeEpisodeResultMetadata(dir, ep);
-    writeJson(episodeErrorPath(dir, ep), error);
-    return error;
-}
+// Record a batch failure: write `<key>.error.json` (which marks the batch as
+// "tried and failed" → sticky on plain resume) and drop any stale result file.
+// The error_code (e.g. PROVIDER_CONTENT_FILTERED) is surfaced so the agent can
+// see WHY in `direct status` / `direct inspect` and decide whether to re-run.
 function writeBatchFailure(dir, batch, exc) {
     const err = exc;
     const error = {
@@ -570,6 +327,8 @@ function writeBatchFailure(dir, batch, exc) {
         failed_at: checkpointTimestamp(),
     };
     if (exc instanceof CliError) {
+        if (exc.errorCode)
+            error["error_code"] = exc.errorCode;
         if (exc.required.length > 0)
             error["required"] = exc.required;
         if (exc.received.length > 0)
@@ -580,7 +339,6 @@ function writeBatchFailure(dir, batch, exc) {
     const resultPath = batchResultPath(dir, batch);
     if (exists(resultPath))
         deletePath(resultPath);
-    removeBatchResultMetadata(dir, batch);
     writeJson(batchErrorPath(dir, batch), error);
     return error;
 }
@@ -635,6 +393,14 @@ export async function commandInit(opts) {
     const workspace = strOf(opts["workspace_path"] || "workspace");
     const providerName = strOf(opts["provider"] || DEFAULT_PROVIDER);
     const model = strOf(opts["model"] || process.env.SCRIPTCTL_ANTHROPIC_MODEL || DEFAULT_MODEL);
+    // Explicit selection: the agent decides what to (re)run. Default is "resume"
+    // — only batches never attempted run. --episodes / --batches force-rerun the
+    // named units, --retry-errors force-reruns everything currently errored, --all
+    // reruns everything. Forced units have their stale result/error deleted first.
+    const selEpisodes = new Set(parseIntList(opts["episodes"]));
+    const selBatches = new Set(parseStrList(opts["batches"]));
+    const retryErrors = Boolean(opts["retry_errors"]);
+    const runAll = Boolean(opts["all"]);
     let concurrency;
     try {
         concurrency = parseInt(strOf(opts["concurrency"] || DEFAULT_CONCURRENCY), 10);
@@ -719,7 +485,6 @@ export async function commandInit(opts) {
     }
     const dd = directDir(workspace);
     fs.mkdirSync(dd, { recursive: true });
-    const previousStateBeforeInit = readRunState(workspace);
     updateRunState(workspace, {
         status: "init_running",
         command: "direct init",
@@ -832,17 +597,6 @@ export async function commandInit(opts) {
             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);
@@ -850,24 +604,12 @@ export async function commandInit(opts) {
     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 = [];
+    // Non-destructive GC: drop result/meta/error/md files for units the current
+    // plan no longer references (e.g. the source shed an episode). Pure function
+    // of the plan — it never touches a unit the plan still references, and retires
+    // the legacy v3 index.json. There is no whole-directory reset any more.
+    gcOrphanUnits(episodeResultsDir, new Set(asList(plan["episodes"]).map((ep) => episodeResultKey(ep))));
+    gcOrphanUnits(batchResultsDir, new Set(asList(batchPlan["batches"]).map((b) => batchResultKey(b))));
     const batchesByEpisode = new Map();
     for (const batch of asList(batchPlan["batches"])) {
         const epNum = Number(batch["episode"]);
@@ -875,65 +617,55 @@ export async function commandInit(opts) {
             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);
-            }
+    const totalEpisodes = asList(plan["episodes"]).length;
+    const totalBatches = asList(batchPlan["batches"]).length;
+    // Decide which batches to run. Reuse = a result file is present; an error file
+    // makes a batch "sticky" (skipped on a plain rerun so a content filter can't
+    // loop). The agent overrides this with explicit selection.
+    const pending = [];
+    let reusedBatchCount = 0;
+    let stickyErrorCount = 0;
+    for (const batch of asList(batchPlan["batches"])) {
+        const epNum = Number(batch["episode"]);
+        const key = batchResultKey(batch);
+        const resultPath = batchResultPath(batchResultsDir, batch);
+        const errorPath = batchErrorPath(batchResultsDir, batch);
+        const forced = runAll || selEpisodes.has(epNum) || selBatches.has(key) || (retryErrors && exists(errorPath));
+        if (forced) {
+            if (exists(resultPath))
+                deletePath(resultPath);
+            if (exists(errorPath))
+                deletePath(errorPath);
+            pending.push(batch);
         }
-        else {
-            pendingBatches.push(...(batchesByEpisode.get(Number(episode["episode"])) ?? []));
+        else if (exists(resultPath)) {
+            reusedBatchCount++;
         }
-    }
-    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 if (exists(errorPath)) {
+            stickyErrorCount++; // tried and failed; left alone until explicitly re-run
         }
         else {
-            pending.push(batch);
+            pending.push(batch); // never attempted
         }
     }
-    const failures = [];
-    const outcomes = await pMapWithConcurrency(pending, concurrency, async (batch) => {
-        return await extractBatchWithRecovery(provider, sourceText, batch);
+    updateRunState(workspace, {
+        status: "init_running",
+        init_stage: "batch_extract",
+        batch_mode: batchMode,
+        batch_target_lines: batchTargetLines,
+        batch_max_chars: batchMaxChars,
+        batch_min_lines: batchMinLines,
+        episode_total: totalEpisodes,
+        batch_total: totalBatches,
     });
+    const failures = [];
+    const outcomes = await pMapWithConcurrency(pending, concurrency, async (batch) => 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);
+            persistBatchResult(batchResultsDir, batch, outcome.value);
+            const errorPath = batchErrorPath(batchResultsDir, batch);
             if (exists(errorPath))
                 deletePath(errorPath);
         }
@@ -941,185 +673,93 @@ export async function commandInit(opts) {
             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);
-        }
+    const doneBatches = reusedBatchCount + outcomes.filter((o) => o.ok).length;
+    const erroredBatches = stickyErrorCount + failures.length;
+    // Assemble every episode whose batches are all present on disk (reused +
+    // freshly extracted, read uniformly from disk). Incomplete episodes are
+    // reported; assembling them is left to an explicit re-run.
+    const results = [];
+    const incompleteEpisodes = [];
+    try {
         for (const episode of asList(plan["episodes"])) {
             const episodeNum = Number(episode["episode"]);
-            if (skippedSet.has(episodeNum) || failedEpisodeSet.has(episodeNum))
+            const epBatches = batchesByEpisode.get(episodeNum) ?? [];
+            const batchResults = epBatches.map((b) => readBatchResult(batchResultsDir, b)).filter((r) => r !== null);
+            if (epBatches.length === 0 || batchResults.length !== epBatches.length) {
+                incompleteEpisodes.push(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 merged = mergeBatchResultsForEpisode(episode, batchResults);
+            validateEpisodeExtractionQuality(sourceText, episode, merged);
+            results.push(merged);
+            writeJson(episodeResultPath(episodeResultsDir, episode), compactEpisodeResult(merged));
+            const errPath = episodeErrorPath(episodeResultsDir, episode);
+            if (exists(errPath))
+                deletePath(errPath);
         }
+    }
+    catch (exc) {
+        const e = exc;
+        throw initFailedReport(workspace, {
+            title: "INIT FAILED: Episode merge failed",
+            stage: "episode_merge",
+            required: ["batch_results/*.json that can merge into episode_results/*.json"],
+            received: [`${e?.name ?? "Error"}: ${(e?.message ?? "").slice(0, 160)}`],
+            nextSteps: ["Rerun init; completed batches are reused and episode merge will retry."],
+        });
+    }
+    results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
+    incompleteEpisodes.sort((a, b) => a - b);
+    if (incompleteEpisodes.length > 0) {
         updateRunState(workspace, {
-            status: sameFailuresRepeated ? "init_stalled" : "init_incomplete",
+            status: "init_incomplete",
             init_stage: "batch_extract",
-            checkpoint,
-            batch_checkpoint: batchCheckpoint,
-            episode_total: asList(plan["episodes"]).length,
+            episode_total: totalEpisodes,
             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,
+            incomplete_episodes: incompleteEpisodes,
+            batch_total: totalBatches,
+            batch_completed: doneBatches,
+            batch_failed: erroredBatches,
+            last_error: { title: "INIT INCOMPLETE: Some episodes have unextracted batches", failed_at: checkpointTimestamp() },
         });
-        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,
+            title: "INIT INCOMPLETE: Some episodes have unextracted batches",
             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`,
+                `episodes: ${results.length}/${totalEpisodes} complete`,
+                `incomplete episodes: ${incompleteEpisodes.join(", ")}`,
+                `batches: ${doneBatches}/${totalBatches} done, ${erroredBatches} error`,
                 `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,
+            next: [
+                "Run `direct status` to see per-episode batch state.",
+                "Re-run one episode with `direct init --episodes <n>`, one batch with `--batches <key>`, or all errors with `--retry-errors`.",
+                "Errored batches are left untouched on a plain rerun; select them to retry.",
+            ],
         };
         return [report, EXIT_RUNTIME];
     }
     updateRunState(workspace, {
         status: "init_running",
         init_stage: "episode_merge",
-        checkpoint,
-        batch_checkpoint: batchCheckpoint,
-        episode_total: asList(plan["episodes"]).length,
+        episode_total: totalEpisodes,
         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,
+        incomplete_episodes: [],
+        batch_total: totalBatches,
+        batch_completed: doneBatches,
+        batch_failed: erroredBatches,
         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 {
-                    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 });
+        updateRunState(workspace, { status: "init_running", init_stage: "script_merge" });
         script = mergeEpisodeResults(results, strOf(info["projectName"]) || path.basename(source, path.extname(source)));
     }
     catch (exc) {
@@ -1130,11 +770,11 @@ export async function commandInit(opts) {
             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 },
+            updates: { episode_completed: results.length },
         });
     }
     try {
-        updateRunState(workspace, { status: "init_running", init_stage: "asset_curation", checkpoint, batch_checkpoint: batchCheckpoint });
+        updateRunState(workspace, { status: "init_running", init_stage: "asset_curation" });
         const rawCuration = await providerExtractAssetCurationLocal(provider, sourceText, script);
         const curation = curateScriptAssets(script, rawCuration);
         writeJson(path.join(dd, "asset_curation.json"), curation);
@@ -1148,7 +788,7 @@ export async function commandInit(opts) {
                 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 },
+                updates: { episode_completed: results.length },
             });
         }
         const e = exc;
@@ -1158,11 +798,11 @@ export async function commandInit(opts) {
             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 },
+            updates: { episode_completed: results.length },
         });
     }
     try {
-        updateRunState(workspace, { status: "init_running", init_stage: "metadata_extract", checkpoint, batch_checkpoint: batchCheckpoint });
+        updateRunState(workspace, { status: "init_running", init_stage: "metadata_extract" });
         let metadata = provider.extractMetadata ? await provider.extractMetadata(sourceText, script) : {};
         if (!isDict(metadata))
             metadata = {};
@@ -1178,7 +818,7 @@ export async function commandInit(opts) {
                 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 },
+                updates: { episode_completed: results.length },
             });
         }
         const e = exc;
@@ -1188,12 +828,12 @@ export async function commandInit(opts) {
             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 },
+            updates: { 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 });
+    updateRunState(workspace, { status: "init_running", init_stage: "validate" });
     let validation;
     try {
         validation = validateScript(workspace, scriptPath);
@@ -1206,7 +846,7 @@ export async function commandInit(opts) {
             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 },
+            updates: { script_path: scriptPath },
         });
     }
     const passed = Boolean(validation["passed"]);
@@ -1215,10 +855,6 @@ export async function commandInit(opts) {
         status,
         command: "direct init",
         init_stage: "complete",
-        checkpoint,
-        batch_checkpoint: batchCheckpoint,
-        checkpoint_reused: checkpointReused,
-        batch_checkpoint_reused: batchCheckpointReused,
         provider: providerName,
         model,
         concurrency,
@@ -1229,24 +865,18 @@ export async function commandInit(opts) {
         source_path: path.resolve(source),
         script_path: scriptPath,
         validation_path: path.join(dd, "validation.json"),
-        episode_total: asList(plan["episodes"]).length,
+        episode_total: totalEpisodes,
         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,
+        incomplete_episodes: [],
+        batch_total: totalBatches,
+        batch_completed: doneBatches,
+        batch_reused: reusedBatchCount,
+        batch_failed: erroredBatches,
         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"
@@ -1260,9 +890,8 @@ export async function commandInit(opts) {
             `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}`,
+            `episodes: ${results.length}/${totalEpisodes} complete`,
+            `batches: ${doneBatches}/${totalBatches} done (reused ${reusedBatchCount})`,
             "agent_review: pending",
         ],
         artifacts: [
@@ -1288,277 +917,102 @@ export async function commandInit(opts) {
     };
     return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
 }
-export function summarizeIssues(issues) {
-    if (issues.length === 0)
-        return [];
-    const counts = {};
-    for (const item of issues) {
-        const sev = strOf(item["severity"]);
-        counts[sev] = (counts[sev] ?? 0) + 1;
-    }
-    const parts = Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)).map(([sev, c]) => `${sev}: ${c}`);
-    const first = issues[0];
-    return [parts.join("; "), `first: ${first["code"]} - ${first["summary"]}`];
-}
 // ---------------------------------------------------------------------------
-// command_parse — subagent-authored md workspace → script.initial.json
-//
-// Deterministic, no-LLM counterpart of `direct init`, but a DISTINCT layout from
-// write/direct: the 正文 md carries only the screenplay (no asset registration at
-// all), and each asset KIND is registered in its own file —
-// 人物.md / 场景.md / 道具.md / 发声源.md (+ optional 梗概.md for the whole-script
-// synopsis). It assembles the same script.initial.json and hands off to the
-// existing direct inspect/validate/export downstream (zero changes there).
+// command_status — the agent-facing state table, derived entirely from disk: a
+// batch with `<key>.json` is done, with `<key>.error.json` it failed, with
+// neither it is pending. run_state is just a denormalized cache of this, so the
+// agent can read state, then pick exactly which episodes/batches to (re)run.
 // ---------------------------------------------------------------------------
-const _EP_FILE_RE = /^ep[_-]?0*(\d+)\.(?:md|markdown)$/i;
-const ASSET_DOC_SPECS = [
-    { kind: "actors", names: ["人物.md", "角色.md", "characters.md", "actors.md"] },
-    { kind: "locations", names: ["场景.md", "地点.md", "locations.md"] },
-    { kind: "props", names: ["道具.md", "props.md"] },
-    { kind: "speakers", names: ["发声源.md", "speakers.md"] },
-];
-const SYNOPSIS_DOC_NAMES = ["梗概.md", "全文梗概.md", "synopsis.md"];
-const META_DOC_NAMES = ["元信息.md", "meta.md"];
-// Parse whole-script metadata from 元信息.md. Lines like `worldview: 现代` /
-// `世界观：现代` / `- style: 都市甜宠` / `主角: 陈墨, 苏晴`.
-function parseMetaDoc(text) {
-    const out = {};
-    for (const line of text.split(/\r?\n/)) {
-        const m = /^\s*[-*]?\s*(title|worldview|style|protagonists|标题|世界观|风格|主角|主角列表)\s*[:：]\s*(.+?)\s*$/i.exec(line);
-        if (!m)
-            continue;
-        const key = m[1].toLowerCase();
-        const val = m[2].trim();
-        if (!val)
-            continue;
-        if (key === "title" || key === "标题")
-            out.title = val;
-        else if (key === "worldview" || key === "世界观")
-            out.worldview = val;
-        else if (key === "style" || key === "风格")
-            out.style = val;
-        else if (key === "protagonists" || key === "主角" || key === "主角列表") {
-            out.protagonists = val.split(/[,，、]/).map((s) => s.trim()).filter(Boolean);
-        }
-    }
-    return out;
-}
-function firstExisting(dir, names) {
-    for (const n of names) {
-        const p = path.join(dir, n);
-        if (exists(p) && fs.statSync(p).isFile())
-            return p;
-    }
-    return null;
-}
-function collectEpisodeMdFiles(dir) {
-    if (!exists(dir) || !fs.statSync(dir).isDirectory())
-        return [];
-    const out = [];
-    for (const name of fs.readdirSync(dir)) {
-        const m = _EP_FILE_RE.exec(name);
-        if (!m)
-            continue;
-        const full = path.join(dir, name);
-        if (!fs.statSync(full).isFile())
-            continue;
-        out.push({ path: full, episode: parseInt(m[1], 10) });
-    }
-    out.sort((a, b) => a.episode - b.episode);
-    return out;
-}
-export async function commandParse(opts) {
-    if (opts["spec"]) {
-        return [{ title: "PARSE SPEC: md 工作区写法", body: PARSE_MD_SPEC }, EXIT_OK];
-    }
+export function commandStatus(opts) {
     const workspace = strOf(opts["workspace_path"] || "workspace");
-    const args = asList(opts["_args"]);
-    const mdDir = strOf(opts["md_dir"] || args[0] || path.join(workspace, "parse"));
-    if (!exists(mdDir) || !fs.statSync(mdDir).isDirectory()) {
-        throw new CliError("PARSE BLOCKED: md workspace not found", "md workspace not found.", {
-            exitCode: EXIT_INPUT,
-            required: ["a directory with per-episode 正文 md + 人物/场景/道具/发声源 md"],
-            received: [mdDir],
-            nextSteps: ["Pass the md workspace dir: scriptctl parse <dir>. Run `scriptctl parse --spec` for the format."],
-        });
-    }
-    let episodesDir = strOf(opts["episodes_dir"]).trim();
-    if (!episodesDir) {
-        const sub = path.join(mdDir, "episodes");
-        episodesDir = exists(sub) && fs.statSync(sub).isDirectory() ? sub : mdDir;
-    }
-    const bodyFiles = collectEpisodeMdFiles(episodesDir);
-    if (bodyFiles.length === 0) {
-        throw new CliError("PARSE BLOCKED: no episode md found", "no episode md found.", {
+    const dd = directDir(workspace);
+    const episodePlanPath = path.join(dd, "episode_plan.json");
+    const batchPlanPath = path.join(dd, "batch_plan.json");
+    if (!exists(episodePlanPath) || !exists(batchPlanPath)) {
+        throw new CliError("STATUS BLOCKED: Plan not found", "Plan not found.", {
             exitCode: EXIT_INPUT,
-            required: ["per-episode body md named like ep_001.md"],
-            received: [episodesDir],
-            nextSteps: ["Add per-episode 正文 md (ep_001.md, ep_002.md, ...). Run `scriptctl parse --spec` for the format."],
+            required: ["episode_plan.json and batch_plan.json"],
+            received: [exists(episodePlanPath) ? "episode_plan.json ok" : "episode_plan.json missing"],
+            nextSteps: ["Run scriptctl direct init first."],
         });
     }
-    // Each asset KIND is registered in its own file; the 正文 md carries none.
-    // Fold them all into one bible fragment (per-kind arrays).
-    const bible = { actors: [], locations: [], props: [], speakers: [], state_definitions: [] };
-    const assetDocsFound = [];
-    for (const spec of ASSET_DOC_SPECS) {
-        const p = firstExisting(mdDir, spec.names);
-        if (!p)
+    const episodes = asList(readJson(episodePlanPath)["episodes"]);
+    const batches = asList(readJson(batchPlanPath)["batches"]);
+    const batchResultsDir = path.join(dd, "batch_results");
+    const byEp = new Map();
+    let doneTotal = 0;
+    let errorTotal = 0;
+    for (const batch of batches) {
+        const epNum = Number(batch["episode"]);
+        if (!byEp.has(epNum))
+            byEp.set(epNum, { total: 0, done: 0, error: 0, errorKeys: [], reasons: new Set() });
+        const st = byEp.get(epNum);
+        st.total++;
+        if (exists(batchResultPath(batchResultsDir, batch))) {
+            st.done++;
+            doneTotal++;
             continue;
-        assetDocsFound.push(path.basename(p));
-        const parsed = parseAssetDoc(readText(p), spec.kind);
-        for (const key of ["actors", "locations", "props", "speakers", "state_definitions"]) {
-            bible[key].push(...asList(parsed[key]));
-        }
-    }
-    // Optional whole-script synopsis (梗概.md); strip a leading `# 梗概` header line.
-    let globalSynopsis = "";
-    const synPath = firstExisting(mdDir, SYNOPSIS_DOC_NAMES);
-    if (synPath)
-        globalSynopsis = readText(synPath).replace(/^\s*#\s+\S[^\n]*\n/, "").trim();
-    // Optional whole-script metadata (元信息.md): worldview / style / title.
-    const metaPath = firstExisting(mdDir, META_DOC_NAMES);
-    const meta = metaPath ? parseMetaDoc(readText(metaPath)) : {};
-    const results = [];
-    const sourceChunks = [];
-    for (const file of bodyFiles) {
-        const bodyText = readText(file.path);
-        sourceChunks.push(`# ep_${pad3(file.episode)}\n${bodyText.trim()}`);
-        try {
-            results.push(parseMarkdownBatch(bodyText, { episode: file.episode, part: 1 }, { fragmentMode: true }));
-        }
-        catch (exc) {
-            const e = exc;
-            throw new CliError("PARSE BLOCKED: episode md invalid", "episode md invalid.", {
-                exitCode: EXIT_INPUT,
-                required: ["per-episode 正文 md following `scriptctl parse --spec`"],
-                received: [`${path.basename(file.path)}: ${(e?.message ?? "").slice(0, 200)}`],
-                nextSteps: ["Fix the episode md and re-run parse."],
-            });
-        }
-    }
-    results.sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
-    // Fold the registered assets into the first episode result so their
-    // descriptions / states flow into the merge. Names are deduplicated globally
-    // by mergeEpisodeResults, so registering them first gives the canonical
-    // (registry) descriptions priority over anything implied by scene references.
-    if (results.length > 0) {
-        const first = results[0];
-        for (const key of ["actors", "locations", "props", "speakers", "state_definitions"]) {
-            first[key] = [...asList(bible[key]), ...asList(first[key])];
         }
-    }
-    const title = (meta.title || strOf(opts["title"]).trim() || path.basename(path.resolve(mdDir)));
-    const script = mergeEpisodeResults(results, title);
-    if (globalSynopsis)
-        script["synopsis"] = globalSynopsis;
-    if (meta.worldview) {
-        script["worldview"] = meta.worldview;
-        script["worldview_raw"] = meta.worldview;
-    }
-    if (meta.style)
-        script["style"] = meta.style;
-    // role_type (主角/配角) is md-driven via 元信息.md `主角:`, not a json patch.
-    if (meta.protagonists && meta.protagonists.length > 0) {
-        const leads = new Set(meta.protagonists);
-        for (const actor of asList(script["actors"])) {
-            actor["role_type"] = leads.has(strOf(actor["actor_name"])) ? "主角" : "配角";
+        const errPath = batchErrorPath(batchResultsDir, batch);
+        if (exists(errPath)) {
+            st.error++;
+            errorTotal++;
+            st.errorKeys.push(batchResultKey(batch));
+            try {
+                const err = readJson(errPath);
+                st.reasons.add(strOf(err["error_code"] || err["error_type"] || "Error"));
+            }
+            catch {
+                st.reasons.add("Error");
+            }
         }
     }
-    const dd = directDir(workspace);
-    fs.mkdirSync(dd, { recursive: true });
-    // Write source.txt so the existing direct validate/export downstream (which
-    // gates on source.txt existing) works unchanged. For a parse-origin script the
-    // authored md *is* the source, so we persist the concatenated bodies.
-    fs.mkdirSync(workspace, { recursive: true });
-    fs.writeFileSync(path.join(workspace, "source.txt"), sourceChunks.join("\n\n") + "\n", "utf-8");
-    const scriptPath = path.join(dd, "script.initial.json");
-    writeJson(scriptPath, script);
-    const validation = validateScript(workspace, scriptPath, { requireSource: false });
-    const passed = Boolean(validation["passed"]);
-    updateRunState(workspace, {
-        status: passed ? "ready_for_agent" : "needs_agent_repair",
-        command: "parse",
-        init_stage: "complete",
-        provider: "parse",
-        source_path: path.resolve(mdDir),
-        script_path: scriptPath,
-        validation_path: path.join(dd, "validation.json"),
-        episode_total: results.length,
-        episode_completed: results.length,
-        review_status: "pending",
-        review_missing: [...REVIEW_TARGETS],
-        inspected_targets: [],
-        patch_count: 0,
-        exportable: true,
-        last_error: null,
-    });
-    const stats = validation["stats"] ?? {};
-    const blockingOrError = Boolean(validation["has_blocking"]) ||
-        asList(validation["issues"]).some((it) => isDict(it) && (it["severity"] === "blocking" || it["severity"] === "error"));
-    // --publish: md → 校验 → 直接入库（不经 direct 的 inspect/review/export 门禁）。
-    // md 是唯一真相源：校验不过就报问题、不发布，让 agent 直接改 md 后重跑 parse --publish。
-    if (opts["publish"]) {
-        if (blockingOrError) {
-            return [{
-                    title: "PARSE PUBLISH BLOCKED: 校验未过，改 md 后重跑",
-                    result: [
-                        `asset docs: ${assetDocsFound.join(" / ") || "(none)"}`,
-                        `validation: needs repair`,
-                    ],
-                    artifacts: [scriptPath, path.join(dd, "validation.json")],
-                    issues: summarizeIssues(asList(validation["issues"])),
-                    next: ["按 issue 直接改对应的 ep_*.md / 人物·场景·道具·发声源.md / 元信息.md，再重跑 `scriptctl parse <dir> --publish`。"],
-                }, EXIT_NEEDS_AGENT];
-        }
-        const client = scriptOutputClient(opts);
-        const baseRevision = await currentRevisionOrZero(client);
-        const scriptHash = sha256Text(JSON.stringify(sortDeep(script)));
-        const requestId = strOf(opts["request_id"]).trim() || `scriptctl-parse:${scriptHash}`;
-        let replaceRes;
-        try {
-            replaceRes = await client.replaceScript({ requestId, baseRevision, script, source: "ctl" });
+    const lines = [];
+    let completeEpisodes = 0;
+    const errorEpisodes = [];
+    for (const ep of episodes) {
+        const epNum = Number(ep["episode"]);
+        const st = byEp.get(epNum) ?? { total: 0, done: 0, error: 0, errorKeys: [], reasons: new Set() };
+        let label;
+        if (st.total > 0 && st.done === st.total) {
+            label = "done";
+            completeEpisodes++;
+        }
+        else if (st.error > 0) {
+            label = `ERROR (${st.done}/${st.total} done, ${st.error} err: ${[...st.reasons].join(",")})  [${st.errorKeys.join(",")}]`;
+            errorEpisodes.push(epNum);
         }
-        catch (exc) {
-            if (exc instanceof ScriptOutputApiError)
-                throw apiErrorToCli("PARSE PUBLISH BLOCKED: 入库写入失败", exc);
-            throw exc;
+        else {
+            label = `pending (${st.done}/${st.total} done)`;
         }
-        return [{
-                title: "PARSE PUBLISHED: 剧本已入库",
-                result: [
-                    `episodes: ${stats["episodes"] ?? results.length}`,
-                    `scenes: ${stats["scenes"] ?? 0}`,
-                    `actions: ${stats["actions"] ?? 0}`,
-                    `worldview: ${meta.worldview || "(unset)"}`,
-                    `base_revision: ${baseRevision}`,
-                    `revision: ${replaceRes["revision"]}`,
-                    `idempotent: ${replaceRes["idempotent"] ?? false}`,
-                ],
-                artifacts: [scriptPath],
-                next: ["剧本已入库。若发现问题，直接改 md 再 `scriptctl parse <dir> --publish` 覆盖。"],
-            }, EXIT_OK];
+        lines.push(`${episodeResultKey(ep)}  ${label}`);
     }
     const report = {
-        title: passed
-            ? "PARSE COMPLETE: 中间稿已生成（加 --publish 直接入库）"
-            : "PARSE NEEDS AGENT: 校验有问题，直接改 md 再 parse",
+        title: "DIRECT STATUS",
         result: [
-            `episodes: ${stats["episodes"] ?? results.length}`,
-            `scenes: ${stats["scenes"] ?? 0}`,
-            `actions: ${stats["actions"] ?? 0}`,
-            `asset docs: ${assetDocsFound.join(" / ") || "(none)"}`,
-            `worldview: ${meta.worldview || "(unset)"}`,
-            `style: ${meta.style || "(unset)"}`,
-            `synopsis: ${globalSynopsis ? "yes" : "no"}`,
-            `validation: ${passed ? "passed" : "needs repair"}`,
+            `episodes: ${completeEpisodes}/${episodes.length} done`,
+            `batches: ${doneTotal}/${batches.length} done, ${errorTotal} error`,
+            `error episodes: ${errorEpisodes.length === 0 ? "-" : errorEpisodes.join(", ")}`,
+            ...lines,
         ],
-        artifacts: [scriptPath, path.join(dd, "validation.json")],
-        issues: summarizeIssues(asList(validation["issues"])),
-        next: passed
-            ? ["加 `--publish` 直接入库。"]
-            : ["按 issue 直接改对应的 md（ep_*.md / 资产 md / 元信息.md），再重跑 parse。"],
+        artifacts: [batchResultsDir, path.join(dd, "episode_results"), path.join(dd, "run_state.json")],
+        next: errorEpisodes.length > 0
+            ? [`Re-run an errored episode with: direct init --episodes ${errorEpisodes[0]}  (or --batches <key>, or --retry-errors).`]
+            : ["All batches accounted for."],
     };
-    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+    return [report, EXIT_OK];
+}
+export function summarizeIssues(issues) {
+    if (issues.length === 0)
+        return [];
+    const counts = {};
+    for (const item of issues) {
+        const sev = strOf(item["severity"]);
+        counts[sev] = (counts[sev] ?? 0) + 1;
+    }
+    const parts = Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)).map(([sev, c]) => `${sev}: ${c}`);
+    const first = issues[0];
+    return [parts.join("; "), `first: ${first["code"]} - ${first["summary"]}`];
 }
 // ---------------------------------------------------------------------------
 // command_validate