@lingjingai/scriptctl 0.10.3 → 0.11.0

package/dist/usecases/direct.js

@@ -1,7 +1,7 @@
 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, SUPPORTED_EXTS, deletePath, deleteTree, directDir, exists, readJson, readText, sha256Text, writeJson, } from "../common.js";
-import { compactBatchResult, compactEpisodeResult, buildBatchPlan, buildEpisodePlan, enrichEpisodePlanTitles, extractBatchWithRecovery, mergeEpisodeResults, normalizeEpisodeResult, normalizeInt, 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, 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, parseMarkdownBatch, recoverBatchFromSource, uniqueAdd, validateBatchExtractionQuality, validateEpisodeExtractionQuality, _md_push_asset, curateScriptAssets, applyMetadataToScript, } from "../domain/direct-core.js";
 import { validateScript } from "../domain/script-core.js";
 import { makeProvider } from "../infra/providers.js";
 import { makeSourceManifest, prepareSource, } from "../infra/converters.js";
@@ -66,6 +66,69 @@ function failureSignature(items) {
     out.sort();
     return out;
 }
+export function addInspectedTarget(workspace, target) {
+    const state = readRunState(workspace);
+    const targets = [];
+    for (const item of asList(state["inspected_targets"])) {
+        const s = strOf(item);
+        if (s)
+            targets.push(s);
+    }
+    if (!targets.includes(target))
+        targets.push(target);
+    const missing = [];
+    for (const t of REVIEW_TARGETS) {
+        if (!targets.includes(t))
+            missing.push(t);
+    }
+    const reviewStatus = missing.length === 0 ? "reviewed" : "in_progress";
+    return updateRunState(workspace, {
+        inspected_targets: targets,
+        review_status: reviewStatus,
+        review_missing: missing,
+        last_inspect_target: target,
+    });
+}
+export function markPatched(workspace, count) {
+    const state = readRunState(workspace);
+    const patchCount = Number(state["patch_count"] ?? 0) + count;
+    return updateRunState(workspace, {
+        patch_count: patchCount,
+        review_status: "patched",
+        review_missing: [],
+    });
+}
+export function markMetadataConfidenceReviewed(workspace, operations) {
+    const metadataOps = new Set(["meta.worldview.set", "asset.role.set", "asset.describe"]);
+    if (!operations.some((op) => isDict(op) && metadataOps.has(strOf(op["op"]))))
+        return;
+    const p = path.join(directDir(workspace), "asset_metadata.json");
+    if (!exists(p))
+        return;
+    let metadata;
+    try {
+        metadata = readJson(p);
+    }
+    catch {
+        return;
+    }
+    if (!isDict(metadata) || metadata["confidence"] !== "low")
+        return;
+    metadata["confidence"] = "medium";
+    metadata["confidence_reviewed_at"] = checkpointTimestamp();
+    writeJson(p, metadata);
+}
+export function reviewBlockers(state) {
+    if (Number(state["patch_count"] ?? 0) > 0)
+        return [];
+    const inspected = new Set();
+    for (const item of asList(state["inspected_targets"])) {
+        const s = strOf(item);
+        if (s)
+            inspected.add(s);
+    }
+    return REVIEW_TARGETS.filter((t) => !inspected.has(t));
+}
 // ---------------------------------------------------------------------------
 // Paths for episode/batch results
 // ---------------------------------------------------------------------------
@@ -522,7 +585,7 @@ function writeBatchFailure(dir, batch, exc) {
 function initFailedReport(workspace, opts) {
     const payload = {
         status: "init_failed",
-        command: "import init",
+        command: "direct init",
         init_stage: opts.stage,
         last_error: { title: opts.title, received: opts.received, failed_at: checkpointTimestamp() },
     };
@@ -657,7 +720,7 @@ export async function commandInit(opts) {
     const previousStateBeforeInit = readRunState(workspace);
     updateRunState(workspace, {
         status: "init_running",
-        command: "import init",
+        command: "direct init",
         init_stage: "source_prepare",
         provider: providerName,
         model,
@@ -910,11 +973,11 @@ export async function commandInit(opts) {
             : "INIT INCOMPLETE: Batch extraction failed";
         const nextSteps = sameFailuresRepeated
             ? [
-                "Read failed batch details in draft/scriptctl/direct/batch_results/*.error.json (run_state.json lists failed_batches).",
+                "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.",
             ]
             : [
-                "Read failed batches in draft/scriptctl/direct/batch_results/*.error.json (run_state.json lists failed_batches).",
+                "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);
@@ -957,6 +1020,7 @@ export async function commandInit(opts) {
             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 = {
@@ -1147,7 +1211,7 @@ export async function commandInit(opts) {
     const status = passed ? "ready_for_agent" : "needs_agent_repair";
     updateRunState(workspace, {
         status,
-        command: "import init",
+        command: "direct init",
         init_stage: "complete",
         checkpoint,
         batch_checkpoint: batchCheckpoint,
@@ -1176,10 +1240,11 @@ export async function commandInit(opts) {
         failure_signature: [],
         failure_streak: 0,
         last_error: null,
-        // Informational only — not a gate. Marks the freshly-imported script as not
-        // yet self-reviewed; the post-push review is tracked by the agent
-        // orchestration (script-reviewer subagent), not by a scriptctl command.
         review_status: "pending",
+        review_missing: [...REVIEW_TARGETS],
+        inspected_targets: [],
+        patch_count: 0,
+        exportable: providerName !== "mock",
     });
     const title = passed
         ? "INIT COMPLETE: Initial script ready"
@@ -1196,7 +1261,7 @@ export async function commandInit(opts) {
             `episode checkpoint reused: ${skipped.length}`,
             `batches: ${completedBatches}/${asList(batchPlan["batches"]).length} completed`,
             `batch checkpoint reused: ${skippedEpisodeBatchCount + skippedBatches.length}`,
-            "review: pending (post-push self-review)",
+            "agent_review: pending",
         ],
         artifacts: [
             path.join(workspace, "source.txt"),
@@ -1214,10 +1279,10 @@ export async function commandInit(opts) {
         issues: summarizeIssues(asList(validation["issues"])),
         next: providerName === "mock"
             ? [
-                "Do not push mock-provider results for delivery.",
-                "Rerun init with --provider anthropic, then run scriptctl import push.",
+                "Run inspect for issue, episode, and asset; apply patches if needed; then validate/export.",
+                "Do not export mock-provider results for delivery.",
             ]
-            : ["Run scriptctl import push to publish the script to the DB."],
+            : ["Run inspect for issue, episode, and asset; apply patches if needed; then validate/export."],
     };
     return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
 }
@@ -1233,4 +1298,580 @@ export function summarizeIssues(issues) {
     const first = issues[0];
     return [parts.join("; "), `first: ${first["code"]} - ${first["summary"]}`];
 }
+// ---------------------------------------------------------------------------
+// command_parse — subagent-authored four-document md → script.initial.json
+//
+// Deterministic, no-LLM counterpart of `direct init`: instead of extracting an
+// LLM-written spec md from raw source, it parses md that subagents already wrote
+// (per-episode 正文 md + one shared 资产.md), assembles the same
+// script.initial.json, and hands off to the existing direct
+// inspect/validate/export downstream (zero changes there).
+// ---------------------------------------------------------------------------
+const _EP_FILE_RE = /^ep[_-]?0*(\d+)\.(?:md|markdown)$/i;
+function resolveAssetsPath(opts, mdDir) {
+    const explicit = strOf(opts["assets"]).trim();
+    if (explicit) {
+        if (!exists(explicit) || !fs.statSync(explicit).isFile()) {
+            throw new CliError("PARSE BLOCKED: assets md not found", "assets md not found.", {
+                exitCode: EXIT_INPUT,
+                required: ["--assets: existing shared 资产 md file"],
+                received: [`--assets: ${explicit}`],
+                nextSteps: ["Point --assets at the shared 资产.md, or omit it to auto-detect in the md dir."],
+            });
+        }
+        return explicit;
+    }
+    for (const name of ["资产.md", "assets.md", "资产.markdown"]) {
+        const p = path.join(mdDir, name);
+        if (exists(p))
+            return p;
+    }
+    return null;
+}
+function collectEpisodeMdFiles(dir, assetsPath) {
+    if (!exists(dir) || !fs.statSync(dir).isDirectory())
+        return [];
+    const assetsAbs = assetsPath ? path.resolve(assetsPath) : "";
+    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 (path.resolve(full) === assetsAbs)
+            continue;
+        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 function commandParse(opts) {
+    if (opts["spec"]) {
+        return [{ title: "PARSE SPEC: 四文档 md 写法", body: PARSE_MD_SPEC }, EXIT_OK];
+    }
+    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."],
+        });
+    }
+    const assetsPath = resolveAssetsPath(opts, mdDir);
+    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, assetsPath);
+    if (bodyFiles.length === 0) {
+        throw new CliError("PARSE BLOCKED: no episode md found", "no episode md 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."],
+        });
+    }
+    let bible = null;
+    if (assetsPath) {
+        try {
+            bible = parseMarkdownBatch(readText(assetsPath), { episode: 0, part: 1 }, { fragmentMode: true, allowEmptyScenes: true });
+        }
+        catch (exc) {
+            const e = exc;
+            throw new CliError("PARSE BLOCKED: assets md invalid", "assets md invalid.", {
+                exitCode: EXIT_INPUT,
+                required: ["shared 资产 md following `scriptctl parse --spec`"],
+                received: [`${path.basename(assetsPath)}: ${(e?.message ?? "").slice(0, 200)}`],
+                nextSteps: ["Fix the 资产 md and re-run parse."],
+            });
+        }
+    }
+    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 shared asset declarations into the first episode result so their
+    // descriptions / states flow into the merge. Asset names are deduplicated
+    // globally by mergeEpisodeResults, so prepending bible-first gives the shared
+    // (canonical) descriptions priority over anything inferred per episode.
+    if (bible && 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 = strOf(opts["title"]).trim() || path.basename(path.resolve(mdDir));
+    const script = mergeEpisodeResults(results, title);
+    const globalSynopsis = bible ? strOf(bible["synopsis"]).trim() : "";
+    if (globalSynopsis)
+        script["synopsis"] = globalSynopsis;
+    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 report = {
+        title: passed
+            ? "PARSE COMPLETE: Initial script ready"
+            : "PARSE NEEDS AGENT: Initial script written with repair issues",
+        result: [
+            `episodes: ${stats["episodes"] ?? results.length}`,
+            `scenes: ${stats["scenes"] ?? 0}`,
+            `actions: ${stats["actions"] ?? 0}`,
+            `assets md: ${assetsPath ? path.basename(assetsPath) : "(none)"}`,
+            `synopsis: ${globalSynopsis ? "yes" : "no"}`,
+            `validation: ${passed ? "passed" : "needs repair"}`,
+            "agent_review: pending",
+        ],
+        artifacts: [scriptPath, path.join(dd, "validation.json"), path.join(dd, "run_state.json")],
+        issues: summarizeIssues(asList(validation["issues"])),
+        next: ["Run direct inspect (episode/asset/issue) for the two-stage review; apply patches if needed; then direct validate/export."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+// ---------------------------------------------------------------------------
+// command_validate
+// ---------------------------------------------------------------------------
+export function commandValidate(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const scriptPath = opts["script_path"] ? strOf(opts["script_path"]) : null;
+    const validation = validateScript(workspace, scriptPath);
+    const stats = validation["stats"] ?? {};
+    const passed = Boolean(validation["passed"]);
+    const report = {
+        title: passed ? "VALIDATE PASSED: Script is ready" : "VALIDATE NEEDS AGENT: Repair issues found",
+        result: [
+            `episodes: ${stats["episodes"] ?? 0}`,
+            `scenes: ${stats["scenes"] ?? 0}`,
+            `actions: ${stats["actions"] ?? 0}`,
+        ],
+        artifacts: [path.join(directDir(workspace), "validation.json")],
+        issues: summarizeIssues(asList(validation["issues"])),
+        next: [passed ? "Export script.json." : "Inspect issues and apply structured patches."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+// ---------------------------------------------------------------------------
+// command_inspect (incl. review rendering)
+// ---------------------------------------------------------------------------
+function renderReviewEpisode(sourceText, episodePlan, script, episodeNum) {
+    const epId = fmtId("ep", episodeNum);
+    const scriptEp = asList(script["episodes"]).find((ep) => ep["episode_id"] === epId);
+    const planEp = asList(episodePlan["episodes"]).find((ep) => Number(ep["episode"] ?? 0) === episodeNum);
+    const lines = [];
+    if (!planEp && !scriptEp) {
+        lines.push(`⚠ Episode ${episodeNum} not found in episode_plan.json or script.initial.json.`);
+        const available = [...new Set(asList(episodePlan["episodes"]).map((ep) => Number(ep["episode"] ?? 0)))].sort((a, b) => a - b);
+        if (available.length > 0)
+            lines.push(`Available episodes: ${available.join(", ")}`);
+        return lines;
+    }
+    const title = (scriptEp?.["title"] ?? planEp?.["title"]) || "(无标题)";
+    lines.push("=".repeat(72));
+    lines.push(`EPISODE ${episodeNum} / ${epId} — ${title}`);
+    lines.push("=".repeat(72));
+    lines.push("");
+    lines.push("--- 原文 source.txt ---");
+    if (planEp) {
+        const span = isDict(planEp["source_span"]) ? planEp["source_span"] : {};
+        const start = Number(span["start"] ?? 0);
+        const end = Number(span["end"] ?? sourceText.length);
+        const snippet = sourceText.slice(start, end).replace(/\s+$/, "");
+        lines.push(snippet || "(empty)");
+    }
+    else {
+        lines.push("(no episode_plan entry; source span unavailable)");
+    }
+    lines.push("");
+    lines.push("--- 抽取 script.initial.json ---");
+    if (scriptEp) {
+        const actorIdToName = new Map();
+        for (const a of asList(script["actors"]))
+            actorIdToName.set(strOf(a["actor_id"]), strOf(a["actor_name"]));
+        const speakerIdToName = new Map();
+        for (const s of asList(script["speakers"]))
+            speakerIdToName.set(strOf(s["speaker_id"]), strOf(s["display_name"]));
+        const locationIdToName = new Map();
+        for (const l of asList(script["locations"]))
+            locationIdToName.set(strOf(l["location_id"]), strOf(l["location_name"]));
+        const propIdToName = new Map();
+        for (const p of asList(script["props"]))
+            propIdToName.set(strOf(p["prop_id"]), strOf(p["prop_name"]));
+        for (const scene of asList(scriptEp["scenes"])) {
+            const env = isDict(scene["environment"]) ? scene["environment"] : {};
+            const space = strOf(env["space"]) || "?";
+            const timeOfDay = strOf(env["time"]) || "?";
+            const sceneId = strOf(scene["scene_id"]) || "?";
+            let locName = "";
+            for (const ref of asList(scene["locations"])) {
+                locName = locationIdToName.get(strOf(ref["location_id"])) || locName;
+                break;
+            }
+            const actorNames = [];
+            for (const ref of asList(scene["actors"])) {
+                const n = actorIdToName.get(strOf(ref["actor_id"]));
+                if (n)
+                    actorNames.push(n);
+            }
+            const propNames = [];
+            for (const ref of asList(scene["props"])) {
+                const n = propIdToName.get(strOf(ref["prop_id"]));
+                if (n)
+                    propNames.push(n);
+            }
+            lines.push("");
+            lines.push(`Scene ${sceneId} [${space} ${timeOfDay}] ${locName || "(未知场景)"}`);
+            if (actorNames.length > 0)
+                lines.push(`  Actors: ${actorNames.join(", ")}`);
+            if (propNames.length > 0)
+                lines.push(`  Props:  ${propNames.join(", ")}`);
+            for (const action of asList(scene["actions"])) {
+                const kind = strOf(action["type"]);
+                const content = strOf(action["content"]).replace(/\n/g, "\n         ");
+                let tag;
+                if (kind === "dialogue") {
+                    const speaker = actorIdToName.get(strOf(action["actor_id"])) || speakerIdToName.get(strOf(action["speaker_id"])) || strOf(action["speaker"]) || "?";
+                    const emotion = strOf(action["emotion"]);
+                    tag = `dlg|${speaker}` + (emotion ? `|${emotion}` : "");
+                }
+                else if (kind === "inner_thought") {
+                    const speaker = actorIdToName.get(strOf(action["actor_id"])) || speakerIdToName.get(strOf(action["speaker_id"])) || strOf(action["speaker"]) || "?";
+                    const emotion = strOf(action["emotion"]);
+                    tag = `think|${speaker}` + (emotion ? `|${emotion}` : "");
+                }
+                else {
+                    tag = "act";
+                }
+                lines.push(`  [${tag}] ${content}`);
+            }
+        }
+    }
+    else {
+        lines.push("(script.initial.json contains no entry for this episode)");
+    }
+    if (scriptEp) {
+        const actorIdsInEp = new Set();
+        const locationIdsInEp = new Set();
+        const propIdsInEp = new Set();
+        for (const scene of asList(scriptEp["scenes"])) {
+            for (const ref of asList(scene["actors"])) {
+                if (ref["actor_id"])
+                    actorIdsInEp.add(strOf(ref["actor_id"]));
+            }
+            for (const ref of asList(scene["locations"])) {
+                if (ref["location_id"])
+                    locationIdsInEp.add(strOf(ref["location_id"]));
+            }
+            for (const ref of asList(scene["props"])) {
+                if (ref["prop_id"])
+                    propIdsInEp.add(strOf(ref["prop_id"]));
+            }
+            for (const action of asList(scene["actions"])) {
+                if (action["actor_id"])
+                    actorIdsInEp.add(strOf(action["actor_id"]));
+            }
+        }
+        if (actorIdsInEp.size > 0 || locationIdsInEp.size > 0 || propIdsInEp.size > 0) {
+            lines.push("");
+            lines.push(`--- Episode ${episodeNum} 资产 ---`);
+        }
+        if (actorIdsInEp.size > 0) {
+            lines.push("Actors:");
+            for (const actor of asList(script["actors"])) {
+                if (!actorIdsInEp.has(strOf(actor["actor_id"])))
+                    continue;
+                const desc = strOf(actor["description"]).trim() || "(无描述)";
+                const role = strOf(actor["role_type"]) || "?";
+                lines.push(`  - ${actor["actor_id"]} ${actor["actor_name"]} [${role}] — ${desc}`);
+            }
+        }
+        if (locationIdsInEp.size > 0) {
+            lines.push("Locations:");
+            for (const loc of asList(script["locations"])) {
+                if (!locationIdsInEp.has(strOf(loc["location_id"])))
+                    continue;
+                const desc = strOf(loc["description"]).trim() || "(无描述)";
+                lines.push(`  - ${loc["location_id"]} ${loc["location_name"]} — ${desc}`);
+            }
+        }
+        if (propIdsInEp.size > 0) {
+            lines.push("Props:");
+            for (const prop of asList(script["props"])) {
+                if (!propIdsInEp.has(strOf(prop["prop_id"])))
+                    continue;
+                const desc = strOf(prop["description"]).trim() || "(无描述)";
+                lines.push(`  - ${prop["prop_id"]} ${prop["prop_name"]} — ${desc}`);
+            }
+        }
+    }
+    return lines;
+}
+function renderAssetCurationSummary(curation) {
+    const summary = isDict(curation["summary"]) ? curation["summary"] : {};
+    const lines = [
+        `curation: ` +
+            `actors ${summary["actors_before"] ?? 0}->${summary["actors_after"] ?? 0} ` +
+            `(removed ${summary["actors_removed"] ?? 0}), ` +
+            `props ${summary["props_before"] ?? 0}->${summary["props_after"] ?? 0} ` +
+            `(removed ${summary["props_removed"] ?? 0}), ` +
+            `locations ${summary["locations_before"] ?? 0}->${summary["locations_after"] ?? 0} ` +
+            `(merged ${summary["locations_merged"] ?? 0})`,
+    ];
+    for (const actor of asList(curation["actors"])) {
+        if (!isDict(actor) || actor["decision"] !== "remove")
+            continue;
+        lines.push(`curation actor ${actor["actor_id"]}: remove ${actor["name"] || "-"} (scenes=${actor["scene_count"] ?? 0}) — ${actor["reason"] || "-"}`);
+    }
+    for (const prop of asList(curation["props"])) {
+        if (!isDict(prop) || prop["decision"] !== "remove")
+            continue;
+        lines.push(`curation prop ${prop["prop_id"]}: remove ${prop["name"] || "-"} (scenes=${prop["scene_count"] ?? 0}) — ${prop["reason"] || "-"}`);
+    }
+    for (const loc of asList(curation["locations"])) {
+        if (!isDict(loc) || loc["decision"] !== "merge")
+            continue;
+        lines.push(`curation location ${loc["location_id"]}: merge ${loc["name"] || "-"} -> ${loc["target_location_id"] || "-"} — ${loc["reason"] || "-"}`);
+    }
+    return lines;
+}
+export function commandInspect(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const target = strOf(opts["target"]);
+    const itemId = opts["id"] ? strOf(opts["id"]) : null;
+    const dd = directDir(workspace);
+    const scriptPath = path.join(dd, "script.initial.json");
+    const validationPath = path.join(dd, "validation.json");
+    if (!exists(scriptPath) && target === "asset") {
+        throw new CliError("INSPECT BLOCKED: script.initial.json not found", "script.initial.json not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["workspace/draft/scriptctl/direct/script.initial.json"],
+            received: [scriptPath],
+            nextSteps: ["Run scriptctl direct init first."],
+        });
+    }
+    const script = exists(scriptPath)
+        ? readJson(scriptPath)
+        : { episodes: [], actors: [], locations: [], props: [] };
+    let validation = exists(validationPath) ? readJson(validationPath) : { issues: [] };
+    if (target === "issue" && exists(scriptPath)) {
+        validation = validateScript(workspace, scriptPath, { requireSource: false });
+    }
+    const batchPlanPath = path.join(dd, "batch_plan.json");
+    const batchPlan = exists(batchPlanPath) ? readJson(batchPlanPath) : { batches: [] };
+    const batchCounts = new Map();
+    for (const batch of asList(batchPlan["batches"])) {
+        if (!isDict(batch))
+            continue;
+        const ep = Number(batch["episode"] ?? 0);
+        batchCounts.set(ep, (batchCounts.get(ep) ?? 0) + 1);
+    }
+    const failedByEpisode = new Map();
+    const batchResultsDir = path.join(dd, "batch_results");
+    if (exists(batchResultsDir)) {
+        const files = fs.readdirSync(batchResultsDir).filter((n) => n.endsWith(".error.json")).sort();
+        for (const name of files) {
+            const errorFile = path.join(batchResultsDir, name);
+            try {
+                const error = readJson(errorFile);
+                const episodeNum = Number(error["episode"] ?? 0);
+                if (!failedByEpisode.has(episodeNum))
+                    failedByEpisode.set(episodeNum, []);
+                failedByEpisode.get(episodeNum).push(strOf(error["batch_id"]) || name.replace(/\.error\.json$/, ""));
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    const lines = [];
+    if (target === "episode") {
+        if (exists(scriptPath)) {
+            for (const ep of asList(script["episodes"])) {
+                if (itemId && itemId !== strOf(ep["episode_id"]))
+                    continue;
+                const scenes = asList(ep["scenes"]);
+                const sceneCount = scenes.length;
+                let actionCount = 0;
+                for (const scene of scenes)
+                    actionCount += asList(scene["actions"]).length;
+                const rawNum = normalizeInt(strOf(ep["episode_id"]), lines.length + 1);
+                const failed = (failedByEpisode.get(rawNum) ?? []).join(",") || "-";
+                lines.push(`${ep["episode_id"]}: scenes=${sceneCount}, actions=${actionCount}, batches=${batchCounts.get(rawNum) ?? 0}, failed_batches=${failed}, title=${ep["title"] || "-"}`);
+            }
+        }
+        else {
+            const planPath = path.join(dd, "episode_plan.json");
+            const plan = exists(planPath) ? readJson(planPath) : { episodes: [] };
+            for (const ep of asList(plan["episodes"])) {
+                const epId = fmtId("ep", Number(ep["episode"] ?? 0));
+                if (itemId && itemId !== epId && itemId !== strOf(ep["episode"]))
+                    continue;
+                const episodeNum = Number(ep["episode"] ?? 0);
+                const failed = (failedByEpisode.get(episodeNum) ?? []).join(",") || "-";
+                lines.push(`${epId}: batches=${batchCounts.get(episodeNum) ?? 0}, failed_batches=${failed}, title=${ep["title"] || "-"}`);
+            }
+        }
+    }
+    else if (target === "asset") {
+        const curationPath = path.join(dd, "asset_curation.json");
+        if (!itemId && exists(curationPath)) {
+            const curation = readJson(curationPath);
+            if (isDict(curation))
+                lines.push(...renderAssetCurationSummary(curation));
+        }
+        for (const [key, idKey, nameKey] of [["actors", "actor_id", "actor_name"], ["locations", "location_id", "location_name"], ["props", "prop_id", "prop_name"]]) {
+            for (const asset of asList(script[key])) {
+                if (itemId && itemId !== strOf(asset[idKey]) && itemId !== strOf(asset[nameKey]))
+                    continue;
+                const aliases = asList(asset["aliases"]).length;
+                const states = asList(asset["states"]).length;
+                const role = key === "actors" ? `, role_type=${asset["role_type"]}` : "";
+                const description = strOf(asset["description"]).trim() ? "yes" : "missing";
+                const singular = key.slice(0, -1);
+                lines.push(`${singular} ${asset[idKey]}: ${asset[nameKey]} aliases=${aliases}, states=${states}${role}, description=${description}`);
+            }
+        }
+    }
+    else if (target === "issue") {
+        for (const errors of failedByEpisode.values()) {
+            for (const batchId of errors) {
+                const errorPath = path.join(batchResultsDir, `${batchId}.error.json`);
+                if (!exists(errorPath))
+                    continue;
+                let error;
+                try {
+                    error = readJson(errorPath);
+                }
+                catch {
+                    continue;
+                }
+                if (itemId && itemId !== strOf(error["batch_id"]) && itemId !== strOf(error["episode"]) && itemId !== strOf(error["error_type"]))
+                    continue;
+                lines.push(`error BATCH_FAILED: ${error["batch_id"]} episode ${error["episode"]} part ${error["part"]} - ${error["message"]}`);
+            }
+        }
+        for (const issue of asList(validation["issues"])) {
+            if (itemId && itemId !== strOf(issue["code"]) && itemId !== strOf(issue["severity"]))
+                continue;
+            const whereParts = [];
+            for (const k of ["episode", "scene", "action_index"]) {
+                if (issue[k] !== null && issue[k] !== undefined)
+                    whereParts.push(strOf(issue[k]));
+            }
+            const where = whereParts.join(" ");
+            lines.push(`${issue["severity"]} ${issue["code"]}: ${issue["summary"]}${where ? ` [${where}]` : ""}`);
+        }
+    }
+    else if (target === "review") {
+        const episodeArg = strOf(opts["episode"]).trim();
+        if (!episodeArg) {
+            throw new CliError("INSPECT BLOCKED: --episode required for review", "--episode required for review.", {
+                exitCode: EXIT_USAGE,
+                required: ["--episode <n>[,<n>...]"],
+                received: ["--episode not provided"],
+                nextSteps: ["Pass --episode 1 (single) or --episode 1,15,30 (multiple)."],
+            });
+        }
+        let episodeFilters;
+        try {
+            episodeFilters = episodeArg.split(",").map((s) => s.trim()).filter((s) => s).map((s) => {
+                const n = parseInt(s, 10);
+                if (Number.isNaN(n))
+                    throw new Error("nan");
+                return n;
+            });
+        }
+        catch {
+            throw new CliError("INSPECT BLOCKED: --episode must be integers", "--episode must be integers.", {
+                exitCode: EXIT_USAGE,
+                required: ["--episode <n>[,<n>...]"],
+                received: [`--episode ${episodeArg}`],
+                nextSteps: ["Pass episode numbers like --episode 1,15,30."],
+            });
+        }
+        const sourcePath = path.join(workspace, "source.txt");
+        if (!exists(sourcePath)) {
+            throw new CliError("INSPECT BLOCKED: source.txt not found", "source.txt not found.", {
+                exitCode: EXIT_INPUT,
+                required: [sourcePath],
+                received: ["source.txt missing"],
+                nextSteps: ["Run scriptctl direct init first."],
+            });
+        }
+        const sourceText = readText(sourcePath);
+        const episodePlanPath = path.join(dd, "episode_plan.json");
+        const episodePlan = exists(episodePlanPath) ? readJson(episodePlanPath) : { episodes: [] };
+        for (let idx = 0; idx < episodeFilters.length; idx++) {
+            if (idx > 0) {
+                lines.push("");
+                lines.push("");
+            }
+            lines.push(...renderReviewEpisode(sourceText, episodePlan, script, episodeFilters[idx]));
+        }
+    }
+    else {
+        throw new CliError("INSPECT BLOCKED: Invalid target", "Invalid inspect target.", {
+            exitCode: EXIT_USAGE,
+            required: ["--target: episode, asset, issue, or review"],
+            received: [`--target: ${target}`],
+            nextSteps: ["Use one of the supported inspect targets."],
+        });
+    }
+    const state = addInspectedTarget(workspace, target);
+    const missingReview = reviewBlockers(state);
+    const report = {
+        title: `INSPECT: ${target}`,
+        result: lines.length > 0 ? lines : ["No matching items."],
+        next: [
+            "Use inspect details to prepare a structured patch, or continue required review.",
+            missingReview.length === 0 ? "Review complete; run validate/export." : `Still inspect: ${missingReview.join(", ")}.`,
+        ],
+    };
+    return [report, EXIT_OK];
+}
 //# sourceMappingURL=direct.js.map