@lingjingai/scriptctl 0.35.0 → 0.36.0

package/dist/infra/providers.js

@@ -1,1396 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { CliError, DEFAULT_BATCH_MAX_TOKENS, DEFAULT_MAX_TOKENS, DEFAULT_THINKING_BUDGET_TOKENS, EPISODE_SYNOPSIS_SCHEMA, EPISODE_TITLE_EXTRACTION_SCHEMA, EXIT_RUNTIME, EXIT_USAGE, DEFAULT_METADATA_ASSET_CHUNK, MARKDOWN_BATCH_PROMPT_SPEC, METADATA_DESC_MD_SPEC, METADATA_GLOBAL_MD_SPEC, SCRIPT_SYNOPSIS_SCHEMA, STATE_BINDING_SCHEMA, } from "../common.js";
-import { ASSET_GROUP_MAX_ITEMS, _md_push_asset, _normalize_speaker_list, assembleMetadataFromParts, cleanSynopsisList, buildEpisodeTitleContext, buildMetadataContext, deterministicEpisodeShortTitle, deterministicExtractEpisode, deterministicExtractMetadata, episodesNeedingGeneratedTitles, formatBatchSource, formatAssetCurationDecisionExpressions, formatStateCurationDecisionExpressions, isRetryableProviderError, parseAssetDescriptionsMd, parseGlobalMetadataMd, parseMarkdownBatch, providerAttempts, } from "../domain/direct-core.js";
-const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 240_000;
-function providerRequestTimeoutMs() {
-    const raw = (process.env.SCRIPTCTL_PROVIDER_REQUEST_TIMEOUT_MS ?? "").trim();
-    if (!raw)
-        return DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed))
-        return DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
-    return Math.max(30_000, parsed);
-}
-function providerRequestOptions() {
-    return { timeout: providerRequestTimeoutMs() };
-}
-const PROVIDER_CAPABILITIES = {
-    mock: {
-        completeText: true,
-        extractBatch: true,
-        extractEpisode: true,
-        extractMetadata: true,
-        groupAssets: true,
-        curateAssets: true,
-        curateStates: true,
-        bindStates: true,
-        extractEpisodeTitles: true,
-        extractEpisodeSynopsis: true,
-        extractScriptSynopsis: true,
-    },
-    anthropic: {
-        completeText: true,
-        extractBatch: true,
-        extractEpisode: true,
-        extractMetadata: true,
-        groupAssets: true,
-        curateAssets: true,
-        curateStates: true,
-        bindStates: true,
-        extractEpisodeTitles: true,
-        extractEpisodeSynopsis: true,
-        extractScriptSynopsis: true,
-    },
-    openai: {
-        completeText: true,
-        extractBatch: false,
-        extractEpisode: false,
-        extractMetadata: false,
-        groupAssets: false,
-        curateAssets: false,
-        curateStates: false,
-        bindStates: false,
-        extractEpisodeTitles: false,
-        extractEpisodeSynopsis: false,
-        extractScriptSynopsis: false,
-    },
-};
-export function providerCapabilities(name) {
-    return PROVIDER_CAPABILITIES[name] ?? null;
-}
-function strOf(v) {
-    if (v === null || v === undefined)
-        return "";
-    return String(v);
-}
-function isList(v) {
-    return Array.isArray(v);
-}
-function asList(v) {
-    return Array.isArray(v) ? v : [];
-}
-function isDict(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function sleepMs(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-// ---------------------------------------------------------------------------
-// Mock provider
-// ---------------------------------------------------------------------------
-export class MockProvider {
-    name = "mock";
-    completeText(request) {
-        const system = request.system;
-        const user = request.user;
-        let text = "";
-        if (system.includes("## 片段梗概")) {
-            const body = firstNonEmptySourceLine(user);
-            text = [
-                "## 片段梗概",
-                `片段梗概：${body}`,
-                "",
-                "## 关键事件",
-                `- ${body}`,
-                "",
-                "## 人物变化",
-                "- 陈默 | 继续推进当前剧情",
-                "",
-                "## 结尾钩子",
-                body,
-            ].join("\n");
-        }
-        else if (system.includes("## 分集梗概")) {
-            const body = firstNonEmptySourceLine(user);
-            text = [
-                "## 分集梗概",
-                `分集梗概：${body}`,
-                "",
-                "## 单句梗概",
-                body,
-                "",
-                "## 关键事件",
-                `- ${body}`,
-            ].join("\n");
-        }
-        else if (system.includes("## 阶段梗概")) {
-            const body = firstNonEmptySourceLine(user);
-            text = [
-                "## 阶段梗概",
-                `阶段梗概：${body}`,
-                "",
-                "## 关键转折",
-                `- ${body}`,
-                "",
-                "## 未解决悬念",
-                "- ",
-            ].join("\n");
-        }
-        else if (system.includes("## 全文梗概")) {
-            const body = firstNonEmptySourceLine(user);
-            text = [
-                "## 全文梗概",
-                `全文梗概：${body}`,
-                "",
-                "## 主题",
-                "mock-theme",
-                "",
-                "## 一句话",
-                "mock-logline",
-                "",
-                "## 风格",
-                "mock-style",
-                "",
-                "## 主要人物",
-                "- 陈默 | 主角",
-            ].join("\n");
-        }
-        else {
-            text = firstNonEmptySourceLine(user);
-        }
-        return { text, raw: { provider: "mock", system, user } };
-    }
-    extractEpisode(sourceText, episodePlan) {
-        return this.extractBatch(sourceText, episodePlan);
-    }
-    extractBatch(sourceText, batchPlan) {
-        const result = deterministicExtractEpisode(sourceText, batchPlan);
-        const actors = [];
-        const locations = [];
-        const props = [];
-        const speakers = [];
-        for (const scene of asList(result["scenes"])) {
-            for (const name of asList(scene["actor_names"])) {
-                _md_push_asset(actors, strOf(name).trim(), null);
-            }
-            const loc = strOf(scene["location_name"]).trim();
-            if (loc && loc !== "未知场景")
-                _md_push_asset(locations, loc, null);
-            for (const prop of asList(scene["prop_names"])) {
-                _md_push_asset(props, strOf(prop).trim(), null);
-            }
-            for (const action of asList(scene["actions"])) {
-                const speaker = strOf(action["speaker"]).trim();
-                const speakerKind = strOf(action["speaker_kind"]).trim();
-                if (speaker && speakerKind && speakerKind !== "actor") {
-                    speakers.push({ name: speaker, source_kind: speakerKind, description: null });
-                }
-            }
-        }
-        result["actors"] = actors;
-        result["locations"] = locations;
-        result["props"] = props;
-        result["speakers"] = _normalize_speaker_list(speakers);
-        // Deterministic fragment synopsis so the mock-flow e2e can verify the whole
-        // synopsis chain end-to-end: take the first non-empty action content.
-        const firstContent = asList(result["scenes"])
-            .flatMap((scene) => asList(scene["actions"]))
-            .map((action) => strOf(action["content"]).trim())
-            .find((c) => c.length > 0);
-        if (firstContent)
-            result["synopsis"] = firstContent.slice(0, 40);
-        return result;
-    }
-    extractMetadata(_sourceText, script) {
-        return deterministicExtractMetadata(script);
-    }
-    groupAssets(_script, contextText) {
-        const kind = strOf(/^kind:\s*(actor|location|prop)$/m.exec(contextText)?.[1]);
-        const rows = contextText
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => /^(?:A|L|P)\s+\|/.test(line))
-            .map((line) => {
-            const parts = line.split("|").map((part) => part.trim());
-            return { id: parts[1] ?? "", name: parts[2] ?? "" };
-        })
-            .filter((row) => row.id && row.name);
-        const seenNames = new Set();
-        const keptIds = [];
-        for (const row of rows) {
-            const key = row.name.replace(/[\s_\-–—·.,，、:：;；'"“”‘’()[\]{}（）【】《》<>]+/g, "").toLowerCase();
-            if (seenNames.has(key))
-                continue;
-            seenNames.add(key);
-            keptIds.push(row.id);
-        }
-        const expressions = [];
-        for (let index = 0; index < keptIds.length; index += ASSET_GROUP_MAX_ITEMS) {
-            expressions.push(`<group>${kind} ${keptIds.slice(index, index + ASSET_GROUP_MAX_ITEMS).join(" ")} # mock name-order group</group>`);
-        }
-        return expressions.length > 0 ? expressions.join("\n") : `<group>${kind} __empty__ # mock empty group</group>`;
-    }
-    curateAssets(script, contextText) {
-        if (contextText.includes("# Asset Curation Audit Context") || contextText.includes("# Location Canonicalization Audit Context")) {
-            return "<exp>NOOP # no asset curation changes</exp>";
-        }
-        const decisions = [];
-        const actors = asList(script["actors"]).filter(isDict);
-        const locations = asList(script["locations"]).filter(isDict);
-        const props = asList(script["props"]).filter(isDict);
-        const actorByName = new Map();
-        for (const actor of actors) {
-            const name = mockAssetName(actor, "actor");
-            if (name)
-                actorByName.set(name, actor);
-        }
-        for (const actor of actors) {
-            const id = mockAssetId(actor, "actor");
-            const name = mockAssetName(actor, "actor");
-            if (!id)
-                continue;
-            const variant = actorVisualVariant(name);
-            const base = variant ? actorByName.get(variant.baseName) : null;
-            if (variant && base && mockAssetId(base, "actor") !== id) {
-                decisions.push({
-                    kind: "actor",
-                    source_id: id,
-                    decision: "move_to_state",
-                    target_kind: "actor",
-                    target_id: mockAssetId(base, "actor"),
-                    state_name: variant.stateName,
-                    reason: "mock: visual form variant belongs to the base actor state catalog.",
-                });
-                continue;
-            }
-            if (looksLikeGroupSpeaker(name)) {
-                decisions.push({
-                    kind: "actor",
-                    source_id: id,
-                    decision: "move_to_speaker",
-                    speaker_kind: "group",
-                    new_name: name,
-                    reason: "mock: crowd/extra label is a speaker source, not a reusable actor asset.",
-                });
-            }
-            else {
-                decisions.push({
-                    kind: "actor",
-                    source_id: id,
-                    decision: "keep",
-                    reason: "mock: named actor remains an actor asset.",
-                });
-            }
-        }
-        for (const loc of locations) {
-            const id = mockAssetId(loc, "location");
-            const name = mockAssetName(loc, "location");
-            if (!id)
-                continue;
-            const target = locations.find((candidate) => {
-                const candidateId = mockAssetId(candidate, "location");
-                const candidateName = mockAssetName(candidate, "location");
-                return Boolean(candidateId && candidateId !== id && candidateName && candidateName.length < name.length && name.includes(candidateName) && isMicroLocationName(name));
-            });
-            if (target) {
-                decisions.push({
-                    kind: "location",
-                    source_id: id,
-                    decision: "merge",
-                    target_kind: "location",
-                    target_id: mockAssetId(target, "location"),
-                    reason: "mock: micro-location folds into the stable parent location.",
-                });
-            }
-            else {
-                decisions.push({
-                    kind: "location",
-                    source_id: id,
-                    decision: "keep",
-                    reason: "mock: stable location remains a production set.",
-                });
-            }
-        }
-        for (const prop of props) {
-            const id = mockAssetId(prop, "prop");
-            const name = mockAssetName(prop, "prop");
-            if (!id)
-                continue;
-            if (isDisposableOrUiProp(name)) {
-                decisions.push({
-                    kind: "prop",
-                    source_id: id,
-                    decision: "drop",
-                    reason: "mock: disposable UI/screen detail stays in action text.",
-                });
-            }
-            else {
-                decisions.push({
-                    kind: "prop",
-                    source_id: id,
-                    decision: "keep",
-                    reason: "category=signature_instance; mock: hero prop remains explicit.",
-                });
-            }
-        }
-        return formatAssetCurationDecisionExpressions({ decisions });
-    }
-    curateStates(_script, contextText) {
-        return formatStateCurationDecisionExpressions(mockStateCurationPlan(contextText));
-    }
-    bindStates(_script, context) {
-        const scenes = [];
-        for (const scene of asList(context["scenes"])) {
-            if (!isDict(scene))
-                continue;
-            const actions = asList(scene["actions"]);
-            const actionText = actions.map((action) => strOf(action["content"])).join("\n");
-            const actors = mockBindingRefs(scene, "actors", "actor_id", actionText);
-            const locations = mockBindingRefs(scene, "locations", "location_id", actionText);
-            const props = mockBindingRefs(scene, "props", "prop_id", actionText);
-            scenes.push({
-                scene_id: scene["scene_id"],
-                actors,
-                locations,
-                props,
-                state_changes: mockStateChanges(scene, actions),
-            });
-        }
-        return { scenes };
-    }
-    extractEpisodeSynopsis(synopses, _ctx) {
-        // Prefix marks that this deterministic STITCH ran — lets e2e tests tell a
-        // real reduce-step call apart from the plain-join fallback (which has no
-        // prefix) and prove the multi-group reduce path actually executed.
-        return { synopsis: `stitch:${cleanSynopsisList(synopses).join(" ")}` };
-    }
-    extractScriptSynopsis(synopses, _ctx) {
-        const joined = cleanSynopsisList(synopses).join(" ");
-        return {
-            synopsis: joined,
-            theme: "mock-theme",
-            logline: "mock-logline",
-            style: "mock-style",
-            main_characters: [],
-        };
-    }
-    extractEpisodeTitles(sourceText, episodePlan) {
-        return {
-            episode_titles: episodesNeedingGeneratedTitles(episodePlan).map((ep) => ({
-                episode: Number(ep["episode"] ?? 0),
-                title: deterministicEpisodeShortTitle(sourceText, ep),
-            })),
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Anthropic provider
-// ---------------------------------------------------------------------------
-export class AnthropicProvider {
-    name = "anthropic";
-    client;
-    model;
-    constructor(model) {
-        const apiKey = (process.env.PROJECT_LITELLM_GATEWAY_API_KEY ?? "").trim();
-        if (!apiKey) {
-            throw new CliError("INIT FAILED: provider not configured", "Provider credentials are not configured for this environment.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["PROJECT_LITELLM_GATEWAY_API_KEY"],
-                received: ["no API key environment variable"],
-                nextSteps: ["Run `scriptctl doctor` to identify missing configuration."],
-                errorCode: "PROVIDER_AUTH_MISSING",
-            });
-        }
-        const baseUrl = (process.env.PROJECT_LITELLM_GATEWAY_BASE_URL ?? "").trim();
-        const opts = { apiKey };
-        if (baseUrl)
-            opts.baseURL = baseUrl;
-        this.client = new Anthropic(opts);
-        this.model = model;
-    }
-    messageRequest(prompt, maxTokens) {
-        const rawMaxTokens = (process.env.SCRIPTCTL_MAX_TOKENS ?? "").trim();
-        let configuredMaxTokens = DEFAULT_MAX_TOKENS;
-        if (rawMaxTokens) {
-            const parsed = parseInt(rawMaxTokens, 10);
-            if (!Number.isNaN(parsed))
-                configuredMaxTokens = parsed;
-        }
-        let tokenBudget = maxTokens !== undefined ? maxTokens : configuredMaxTokens;
-        tokenBudget = Math.max(1024, Math.min(tokenBudget, configuredMaxTokens, DEFAULT_MAX_TOKENS));
-        const request = {
-            model: this.model,
-            max_tokens: tokenBudget,
-            messages: [{ role: "user", content: prompt }],
-        };
-        if (this.model.endsWith("-think")) {
-            const rawBudget = (process.env.SCRIPTCTL_THINKING_BUDGET_TOKENS ?? "").trim();
-            let budget = DEFAULT_THINKING_BUDGET_TOKENS;
-            if (rawBudget) {
-                const parsed = parseInt(rawBudget, 10);
-                if (!Number.isNaN(parsed))
-                    budget = parsed;
-            }
-            request.thinking = { type: "enabled", budget_tokens: Math.max(1024, Math.min(budget, tokenBudget - 1000)) };
-        }
-        return request;
-    }
-    textMessageRequest(system, user, maxTokens) {
-        const request = this.messageRequest(user, maxTokens);
-        return system.trim() ? { ...request, system } : request;
-    }
-    async collectResponseText(request) {
-        // Non-streaming: the LiteLLM gateway drops idle streaming connections
-        // ("Premature close"), so every extraction uses the create path and is sized
-        // to fit a single response (see collectToolUseInput for the same policy).
-        const response = await this.client.messages.create(request, providerRequestOptions());
-        return [textFromResponse(response), strOf(response.stop_reason)];
-    }
-    /**
-     * Run a request that forces a specific tool call via `tool_choice`, then return that
-     * tool's `input` dict (already parsed by the SDK — no JSON.parse needed). Returns
-     * `null` when the provider didn't emit the expected tool_use block (e.g. refusal,
-     * truncated before tool call, gateway dropped tools field), letting the caller
-     * raise a method-specific CliError.
-     */
-    async collectToolUseInput(request, toolName) {
-        // Always non-streaming. The LiteLLM gateway drops idle streaming connections
-        // ("Premature close"), and every extraction is sized to fit a single create
-        // response. (A request over NONSTREAMING_MAX_TOKENS used to stream; that path
-        // was the source of the gateway drops and is intentionally gone — keep all
-        // tool-use callers below that ceiling.)
-        const response = (await this.client.messages.create(request, providerRequestOptions()));
-        return [findToolUseInput(response.content ?? [], toolName), strOf(response.stop_reason)];
-    }
-    /**
-     * Shared forced-tool-use round-trip: build the request with a single forced
-     * tool, run it, and map the two failure modes (max_tokens truncation, missing
-     * tool_use block) to method-specific CliErrors. Every tool_use extraction
-     * (titles / curation / metadata / episode-synopsis / script-synopsis) routes
-     * through here so the protocol and error contract live in one place.
-     */
-    async runToolUse(spec) {
-        const request = { ...this.messageRequest(spec.prompt, spec.maxTokens) };
-        request["tools"] = [{ name: spec.toolName, description: spec.description, input_schema: spec.schema }];
-        request["tool_choice"] = { type: "tool", name: spec.toolName };
-        const [input, stopReason] = await this.collectToolUseInput(request, spec.toolName);
-        if (stopReason === "max_tokens") {
-            throw new CliError(spec.truncatedTitle, `${spec.truncatedTitle}.`, {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete JSON within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request["max_tokens"]}`],
-                nextSteps: spec.nextSteps,
-            });
-        }
-        if (!input) {
-            throw new CliError(spec.invalidTitle, `${spec.invalidTitle}.`, {
-                exitCode: EXIT_RUNTIME,
-                required: [`tool_use block with name "${spec.toolName}"`],
-                received: [`stop_reason: ${stopReason || "unknown"}`, `missing tool_use block: ${spec.toolName}`],
-                nextSteps: spec.nextSteps,
-            });
-        }
-        return input;
-    }
-    extractEpisode(sourceText, episodePlan) {
-        return this.extractBatch(sourceText, episodePlan);
-    }
-    async completeText(request) {
-        const msg = this.textMessageRequest(request.system, request.user, DEFAULT_BATCH_MAX_TOKENS);
-        const [raw, stopReason] = await this.collectResponseTextWithRetry(msg);
-        if (stopReason === "max_tokens") {
-            throw new CliError("LLM FAILED: Provider output truncated", "Provider output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete text within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${msg.max_tokens}`, `raw chars: ${raw.length}`, `tail: ${raw.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun the command; completed checkpoints will be reused. If this repeats, lower the input chunk size."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!raw.trim()) {
-            throw new CliError("LLM FAILED: Provider returned empty text", "Provider returned an empty response.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["non-empty text response"],
-                received: [`stop_reason: ${stopReason || "unknown"}`, "raw chars: 0"],
-                nextSteps: ["Rerun with a smaller chunk or adjust the prompt/spec."],
-                errorCode: "PROVIDER_EMPTY_RESPONSE",
-            });
-        }
-        return { text: raw, raw: { stop_reason: stopReason } };
-    }
-    async extractBatch(sourceText, batchPlan) {
-        const context = isList(batchPlan["context"]) || typeof batchPlan["context"] === "object" && batchPlan["context"] !== null
-            ? batchPlan["context"]
-            : {};
-        const numberedSource = formatBatchSource(sourceText, batchPlan);
-        const prompt = "You convert one batch from an existing script into the documented markdown template.\n" +
-            "\n" +
-            `${MARKDOWN_BATCH_PROMPT_SPEC}\n` +
-            "\n" +
-            "Batch plan:\n" +
-            `${JSON.stringify(batchPlan)}\n` +
-            "\n" +
-            "Read-only context:\n" +
-            `${JSON.stringify(context)}\n` +
-            "\n" +
-            "Batch Source:\n" +
-            `${numberedSource}\n`;
-        const request = this.messageRequest(prompt, DEFAULT_BATCH_MAX_TOKENS);
-        const [raw, stopReason] = await this.collectResponseText(request);
-        if (stopReason === "max_tokens") {
-            throw new CliError("INIT FAILED: Provider output truncated", "Provider output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete markdown within provider max_tokens"],
-                received: [
-                    `stop_reason: ${stopReason}`,
-                    `max_tokens: ${request.max_tokens}`,
-                    `raw chars: ${raw.length}`,
-                    `tail: ${raw.slice(-160) || "<empty response>"}`,
-                ],
-                nextSteps: ["Rerun init; completed batch checkpoints will be reused. If this repeats, split the source episode."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!raw.trim()) {
-            // Empty body with a non-max_tokens stop reason is how an Anthropic content
-            // filter / refusal surfaces: the model emits no markdown at all. Mark it
-            // distinctly so init can classify it as terminal (retrying the same source
-            // will deterministically refuse again) instead of an open-ended failure.
-            throw new CliError("INIT FAILED: Provider refused content", "Provider returned an empty response (content filter / refusal).", {
-                exitCode: EXIT_RUNTIME,
-                required: ["non-empty markdown for the batch"],
-                received: [`stop_reason: ${stopReason || "unknown"}`, "raw chars: 0"],
-                nextSteps: [
-                    "This batch is blocked by the provider's content filter and will not succeed on a plain rerun.",
-                    "Soften the offending source span, then re-run just this unit: `scriptctl direct init --episodes <N>` (or `--batches <key>`).",
-                ],
-                errorCode: "PROVIDER_CONTENT_FILTERED",
-            });
-        }
-        const parsed = parseMarkdownBatch(raw, batchPlan);
-        parsed["_raw_markdown"] = raw;
-        return parsed;
-    }
-    async extractEpisodeTitles(sourceText, episodePlan) {
-        const context = buildEpisodeTitleContext(sourceText, episodePlan);
-        if (context.length === 0)
-            return { episode_titles: [] };
-        const prompt = "You generate missing episode titles for a direct script conversion.\n" +
-            "Use only each episode excerpt below. Do not invent plot events outside it.\n" +
-            "Return JSON matching the configured schema.\n" +
-            "\n" +
-            "Requirements:\n" +
-            "- Return one item for every input episode.\n" +
-            "- The title field must be a short Chinese episode title, 2-8 Chinese characters when possible.\n" +
-            "- Do not include episode numbers, `ep_###`, `Episode ###`, punctuation wrappers, or quotes.\n" +
-            "- Prefer concrete plot hooks, conflicts, reversals, or memorable images from the episode.\n" +
-            "\n" +
-            "Episodes needing titles:\n" +
-            `${JSON.stringify(context)}\n`;
-        return this.runToolUse({
-            prompt,
-            maxTokens: 4096,
-            toolName: "submit_episode_titles",
-            description: "Return generated short Chinese titles for every input episode.",
-            schema: EPISODE_TITLE_EXTRACTION_SCHEMA,
-            truncatedTitle: "INIT FAILED: Episode title output truncated",
-            invalidTitle: "INIT FAILED: Provider returned invalid episode title JSON",
-            nextSteps: ["Rerun init; title generation will retry before batch extraction."],
-        });
-    }
-    async groupAssets(_script, contextText) {
-        const prompt = "You plan small asset review groups for `scriptctl direct init`.\n" +
-            "You receive only asset ids and names. Do not make final keep/drop/merge/state decisions.\n" +
-            "\n" +
-            "Rules:\n" +
-            `- Output only <group>...</group> lines, with at most ${ASSET_GROUP_MAX_ITEMS} ids per group.\n` +
-            "- Group ids whose names suggest they should be reviewed together later: same identity/form, alias-like names, same place family, or same prop family.\n" +
-            "- Output only groups that should be reviewed together later; unchanged standalone assets may be omitted to save tokens.\n" +
-            "- Omit a duplicate id only when it is an obvious duplicate of a retained id with the same normalized name.\n" +
-            "- Any omitted non-duplicate id will be reviewed as its own singleton group; do not omit merely because an asset seems unimportant.\n" +
-            "- Mentioned ids must appear at most once. Do not invent ids.\n" +
-            "- No JSON, markdown, headings, bullets, or prose outside group tags.\n" +
-            "\n" +
-            "Expression grammar:\n" +
-            "- `<group><kind> <source_id> [source_id...] # reason</group>`\n" +
-            "- `<kind>` is the context kind: actor, location, or prop.\n" +
-            "\n" +
-            "Context:\n" +
-            `${contextText}\n`;
-        const request = this.messageRequest(prompt, 8000);
-        const [raw, stopReason] = await this.collectResponseTextWithRetry(request);
-        if (stopReason === "max_tokens") {
-            throw new CliError("INIT FAILED: Asset grouping output truncated", "Asset grouping output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete asset grouping expressions within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request.max_tokens}`, `raw chars: ${raw.length}`, `tail: ${raw.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and asset grouping will retry."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!raw.trim()) {
-            throw new CliError("INIT FAILED: Provider returned empty asset grouping", "Provider returned an empty asset grouping response.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["one or more <group> asset grouping expressions"],
-                received: [`stop_reason: ${stopReason || "unknown"}`, "raw chars: 0"],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and asset grouping will retry."],
-                errorCode: "PROVIDER_EMPTY_RESPONSE",
-            });
-        }
-        return raw;
-    }
-    async curateAssets(_script, contextText) {
-        const prompt = "You curate assets for `scriptctl direct init` after batch merge.\n" +
-            "Return only asset curation operation expressions. The caller will parse and apply them deterministically.\n" +
-            "\n" +
-            "Policy:\n" +
-            "- Target profile: align with a human-refined asset boundary for AI short-drama production.\n" +
-            "- Actors: keep named, speaking, visually identifiable, or plot-functional roles even when they appear only once.\n" +
-            "- Move only anonymous crowds, system/broadcast sources, or pure voice labels into speakers.\n" +
-            "- Move Q版 / 幻影 / 兽形 / 本体 / 真身 / 伪装 / alternate visual form actors into states on the base actor.\n" +
-            "- Use `identity=` hints to merge same-identity aliases/forms/titles when evidence supports it; do not keep duplicate base/form actors apart.\n" +
-            "- Merge duplicate names, aliases, typo variants, and same-identity titles into stable canonical assets.\n" +
-            "- Locations: keep visually distinct production sets; do not blindly merge interiors, doors, rooftops, underground levels, warehouses, fields, pens, sky/air variants, or other shootable sub-spaces.\n" +
-            "- Use `parent=` and `gran=` hints to MERGE non-distinct doorway/transition/nearby/overhead/angle-only micro locations into a parent; KEEP distinct shootable subspaces.\n" +
-            "- Location canonical names should preserve world/domain scope when the context distinguishes worlds or realms.\n" +
-            "- If a location co-occurs with a scope marker such as a world/realm/domain location, prefer `renameHint=` scoped canonical names via RENAME when the unscoped name would be ambiguous.\n" +
-            "- Props: use a strict refined prop boundary. Most visible or plot-mentioned objects should stay in action text or actor/location state, not standalone props.\n" +
-            "- Default prop decision is DROP unless standalone continuity is clear.\n" +
-            "- KEEP a prop when it is a named/signature physical instance whose visual identity must be reused, the same object is exchanged/carried/inspected across scenes, it carries readable evidence/rules/secrets, drives a transformation/conflict, functions as recurring character/faction equipment, or is a functional set device with continuity.\n" +
-            "- Every KEEP prop reason must start with one category: category=readable_evidence; category=container_device; category=transformation_key; category=exchanged_object; category=signature_instance; category=character_bound_core; category=signature_weapon; category=visual_symbol; or category=set_device; then cite concise evidence.\n" +
-            "- Do not KEEP merely because an object appears multiple times, is plot-functional, held/used by a character, or is UI/display content, an ordinary document/bill, food, or generic set dressing.\n" +
-            "- Move actor body marks and worn appearance into actor states; detachable named devices/weapons/tools/accessories with standalone continuity may remain props.\n" +
-            "- When a prop line has `ownerA=actor_id:name`, distinguish body/worn styling (STATE) from detachable recurring core objects (KEEP with category=character_bound_core or category=signature_weapon).\n" +
-            "- In long scripts, keep a compact prop catalog; prefer the strongest standalone hero props and DROP/STATE borderline objects.\n" +
-            "- For each duplicate group, choose one final canonical target (prefer higher scene_count, then shorter stable name); merge every other source directly into that final target.\n" +
-            "- MERGE is for same-kind duplicates. For actor/location entries that are really props, use PROP instead of cross-kind MERGE.\n" +
-            "- PROP targets must be `NEW` or an existing prop id only. Never use actor/location ids as PROP targets; if a prop is really a location/set element, DROP it or handle the location asset separately.\n" +
-            "- Never create reciprocal merges or merge cycles. Do not merge A->B and B->A, and do not create A->B->C chains when A can point to C.\n" +
-            "- Every asset line with `req=Y:*` must receive an expression, including KEEP if it should stay.\n" +
-            "- Every prop line must receive an expression. Do not omit props.\n" +
-            "- Use `required_decision_ids` as the coverage checklist before final output.\n" +
-            "- Assets with `req=-` should be omitted when unchanged; do not spend output on KEEP for req=- assets.\n" +
-            "- If output is long, prioritize every req=Y decision over any optional req=- expression.\n" +
-            "- If the context header is `# Asset Curation Audit Context`, output only corrective expressions for listed candidates, or NOOP if no correction is needed.\n" +
-            "- If the context header is `# Location Canonicalization Audit Context`, output only RENAME/MERGE location expressions for listed candidates, or NOOP if no location canonicalization is needed.\n" +
-            "- If the context header is `# Asset Curation Repair Context`, output replacement expressions only for `repair_required_source_keys`; do not repeat unrelated accepted decisions.\n" +
-            "- In audit mode, the first character of your response must be `<`. Do not write candidate reviews, headings, bullets, or prose outside expressions.\n" +
-            "- In audit mode, primary KEEP actor candidates may be corrected to SPEAKER, MERGE, or RENAME when they are anonymous crowds, pure voice labels, duplicate identities, or generic numbered roles without dialogue.\n" +
-            "- In audit mode, do not downgrade a numbered/title-like actor to SPEAKER when it has dialogue or speaking-scene evidence; keep it as an actor unless it is truly a crowd label such as 众人/宾客们/围观者.\n" +
-            "- In audit mode, primary KEEP location candidates may be corrected to RENAME or MERGE when scoped canonical naming or duplicate/parent-child granularity is wrong.\n" +
-            "- In audit mode, primary KEEP prop candidates may output KEEP only to add/replace a valid category reason; otherwise output DROP/MERGE/STATE/RENAME when KEEP is too broad.\n" +
-            "- In audit mode, primary KEEP props with `ownerA=` should become STATE only for body marks or worn appearance; keep detachable recurring core objects when evidence supports it.\n" +
-            "- In audit mode, primary DROP/MERGE/STATE prop candidates may be corrected to KEEP/RENAME/MERGE when the evidence shows standalone hero-prop continuity.\n" +
-            "- In location canonicalization mode, do not output KEEP, DROP, STATE, PROP, SPEAKER, actor, or prop operations.\n" +
-            "- In location canonicalization mode, omit unchanged candidates; KEEP is invalid and will fail validation.\n" +
-            "- In location canonicalization mode, use `scopeHint=`/`renameHint=` to RENAME ambiguous unscoped locations into scoped canonical names; use `parent=`/`gran=` to MERGE only non-distinct micro/transition/angle locations into a parent; leave distinct shootable subspaces unchanged.\n" +
-            "- For STATE/PROP/MERGE targets, use only existing target ids visible in the context line, such as `identity=`, `parent=`, `same=`, `coA=`, `coL=`, or related cluster ids. If no valid target id is visible, choose DROP instead of guessing.\n" +
-            "- Reference existing ids only. Do not invent source_id or target_id values.\n" +
-            "- For every actionable merge/drop/move/rename, give a short concrete reason from the context.\n" +
-            "- For every KEEP expression, give a short concrete reason from the context; KEEP prop reasons must begin like `category=signature_instance; ...` using one allowed category.\n" +
-            "- Keep reasons short. Prefer one precise phrase over long explanations.\n" +
-            "\n" +
-            "Output format:\n" +
-            "- Output plain text only. Do not output JSON, markdown tables, fenced code blocks, or explanations outside expressions.\n" +
-            "- Each expression must be one line wrapped exactly as `<exp>...</exp>`.\n" +
-            "- Every expression must include `# reason` at the end; the reason is required for audit.\n" +
-            "- If there are no changes, output exactly `<exp>NOOP # no asset curation changes</exp>`.\n" +
-            "\n" +
-            "Expression grammar:\n" +
-            "- `<exp>KEEP <kind> <source_id> # reason</exp>`\n" +
-            "- `<exp>MERGE <kind> <source_id> -> <target_id> # reason</exp>`\n" +
-            "- `<exp>DROP <kind> <source_id> # reason</exp>`\n" +
-            "- `<exp>RENAME <kind> <source_id> \"<new_name>\" # reason</exp>`\n" +
-            "- `<exp>STATE <kind> <source_id> -> <target_kind> <target_id> \"<state_name>\" # reason</exp>`\n" +
-            "- `<exp>SPEAKER <kind> <source_id> -> <speaker_kind> \"<display_name>\" # reason</exp>`\n" +
-            "- `<exp>PROP <kind> <source_id> -> <target_prop_id|NEW> \"<prop_name>\" # reason</exp>`\n" +
-            "- `<kind>` is one of actor, location, prop. `<target_kind>` is one of actor, location, prop.\n" +
-            "- `<speaker_kind>` is one of system, broadcast, group, other.\n" +
-            "- Use double quotes for names. Escape only `\"` and `\\\\` inside quoted strings.\n" +
-            "- Do not write natural-language operations. If an operation cannot fit this grammar, omit it.\n" +
-            "\n" +
-            "Context:\n" +
-            `${contextText}\n`;
-        const request = this.messageRequest(prompt, 20000);
-        const [raw, stopReason] = await this.collectResponseTextWithRetry(request);
-        if (stopReason === "max_tokens") {
-            throw new CliError("INIT FAILED: Asset curation output truncated", "Asset curation output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete asset curation expressions within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request.max_tokens}`, `raw chars: ${raw.length}`, `tail: ${raw.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and asset curation will retry."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!raw.trim()) {
-            throw new CliError("INIT FAILED: Provider returned empty asset curation", "Provider returned an empty asset curation response.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["one or more <exp> asset curation expressions"],
-                received: [`stop_reason: ${stopReason || "unknown"}`, "raw chars: 0"],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and asset curation will retry."],
-                errorCode: "PROVIDER_EMPTY_RESPONSE",
-            });
-        }
-        return raw;
-    }
-    async curateStates(_script, contextText) {
-        const prompt = "You curate visual state catalogs for `scriptctl direct init` after asset curation.\n" +
-            "Return only state curation operation expressions. The caller will parse, validate, and apply them deterministically.\n" +
-            "\n" +
-            "Core definition:\n" +
-            "- A state is a reusable production visual asset state. It is NOT a story condition, action, pose, emotion, camera effect, or momentary VFX intensity.\n" +
-            "- Keep a state only when the asset needs a clearly different reusable macro visual form for image/video generation.\n" +
-            "\n" +
-            "Policy:\n" +
-            "- Actors: KEEP major macro form changes such as Q version, non-human/beast/god/giant form, durable alternate body/form, major recurring outfit/appearance redesign, or major recurring damage/repair condition.\n" +
-            "- Actors: DROP or ACTION_STATE emotions, poses, unconscious/asleep/lying/sitting, fatigue as behavior, holding/carrying/using an item, minor marks, temporary glow, brightness/thickness/spread changes, fading/transparent/solidifying progress frames, one-off ordinary clothes, and scene-only actions.\n" +
-            "- Actors: VFX/power intensity alone is not a state. Glowing, flashing, aura, light wall, brightness, totem spreading, transparent/solidifying/recovery frames, and one-action power bursts should MERGE into the nearest broad macro form or become ACTION_STATE.\n" +
-            "- Actors: ordinary human/humanoid form is not a separate state when the default actor already covers it. Keep human-form states only when they carry a distinct age period, disguise, outfit, or major body redesign.\n" +
-            "- Actors: keep at most one broad representative for a continuous transformation/recovery process. Do not keep separate process frames for half-transparent, head-only, partial solidifying, restored, brightness increasing, mark spreading, or power burst moments.\n" +
-            "- Locations: KEEP recurring physical set conditions and scene-header time/lighting states such as 黄昏/夜晚/清晨 that require a different reusable set look; DROP camera/action-only labels.\n" +
-            "- Props: KEEP physical condition variants such as broken/open/activated/repaired only when the prop itself remains a tracked asset; DROP use/action-only states.\n" +
-            "- MERGE states that differ only by degree/progress of the same major appearance. Prefer one broad macro canonical state over many micro-steps or process frames.\n" +
-            "- Treat extraction reasons as evidence, not as decisions. Ignore self-justifying phrases such as `needs a separate image`, `reusable`, or `stable` unless the name/description prove a distinct macro form.\n" +
-            "- For one continuous transformation/recovery process, keep at most one broad representative state for the asset form. MERGE/DROP intermediate frames such as half-transparent body, lower body vanished, only head remains, partial solidifying, brightness increasing, restored/recovered, or mark spreading.\n" +
-            "- If the best canonical state name is broader than any existing name, RENAME_STATE one representative state and MERGE_STATE the variants into it.\n" +
-            "- State descriptions must contain only durable visible appearance. Remove camera/staging/story wording such as back-to-camera, face hidden, close-up, initial pose, entering, taking hands, kissing, or standing in a scene.\n" +
-            "- When keeping a useful state whose description contains camera/staging/story wording, keep the state and rewrite the description with DESC.\n" +
-            "- Every S line in the context must receive exactly one expression. Do not omit any listed state.\n" +
-            "- Every asset block with one or more S lines must also receive exactly one DEFAULT_STATE expression.\n" +
-            "- DEFAULT_STATE selects the most common normal appearance for that asset. Keep its readable state_name; deterministic apply will rewrite only its state_id to `default`.\n" +
-            "- Use only existing state_id values listed under the same asset block. Never merge across assets. Never invent ids.\n" +
-            "- Use each state's extraction reason when present. If the reason says the state is a momentary process frame, action, VFX intensity, or ordinary clothing, prefer MERGE/DROP/ACTION_STATE unless there is strong reusable macro-form evidence.\n" +
-            "- For every expression, cite a concise concrete reason from the state name/description/extraction reason.\n" +
-            "- Keep reasons short. Prefer one precise phrase.\n" +
-            "\n" +
-            "Output format:\n" +
-            "- Output plain text only. Do not output JSON, markdown tables, fenced code blocks, or explanations outside expressions.\n" +
-            "- Each expression must be one line wrapped exactly as `<exp>...</exp>`.\n" +
-            "- Every expression must include `# reason` at the end.\n" +
-            "- If there are no states to curate, output exactly `<exp>NOOP # no state curation changes</exp>`.\n" +
-            "\n" +
-            "Expression grammar:\n" +
-            "- `<exp>KEEP_STATE <kind> <asset_id> <state_id> [DESC=\"<clean visual description>\"] # reason</exp>`\n" +
-            "- `<exp>MERGE_STATE <kind> <asset_id> <state_id> -> <target_state_id> # reason</exp>`\n" +
-            "- `<exp>DROP_STATE <kind> <asset_id> <state_id> # reason</exp>`\n" +
-            "- `<exp>ACTION_STATE <kind> <asset_id> <state_id> # reason</exp>`\n" +
-            "- `<exp>RENAME_STATE <kind> <asset_id> <state_id> \"<new_name>\" [DESC=\"<clean visual description>\"] # reason</exp>`\n" +
-            "- `<exp>DEFAULT_STATE <kind> <asset_id> <state_id> # reason</exp>`\n" +
-            "- `<kind>` is one of actor, location, prop.\n" +
-            "- Use double quotes for names. Escape only `\"` and `\\\\` inside quoted strings.\n" +
-            "\n" +
-            "Context:\n" +
-            `${contextText}\n`;
-        const request = this.messageRequest(prompt, 20000);
-        const [raw, stopReason] = await this.collectResponseTextWithRetry(request);
-        if (stopReason === "max_tokens") {
-            throw new CliError("INIT FAILED: State curation output truncated", "State curation output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete state curation expressions within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request.max_tokens}`, `raw chars: ${raw.length}`, `tail: ${raw.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and state curation will retry."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!raw.trim()) {
-            throw new CliError("INIT FAILED: Provider returned empty state curation", "Provider returned an empty state curation response.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["one or more <exp> state curation expressions"],
-                received: [`stop_reason: ${stopReason || "unknown"}`, "raw chars: 0"],
-                nextSteps: ["Rerun init; completed extraction checkpoints will be reused and state curation will retry."],
-                errorCode: "PROVIDER_EMPTY_RESPONSE",
-            });
-        }
-        return raw;
-    }
-    async bindStates(_script, context) {
-        const prompt = "You bind scene asset refs to existing visual states for `scriptctl direct init`.\n" +
-            "Return JSON through the forced tool call. The caller will reject unknown scene, asset, or state ids.\n" +
-            "\n" +
-            "Policy:\n" +
-            "- Use only state_id values listed under that exact scene ref's `states` array. Never borrow a state_id from another asset.\n" +
-            "- Each asset should already have an asset-scoped `default` state_id. Each ref usually has `current_state_id` from deterministic default binding.\n" +
-            "- Omit refs that should keep `current_state_id`; output a ref only when the scene/actions prove it should change to another existing state.\n" +
-            "- Do not output null for refs; omit the ref instead.\n" +
-            "- Emit state_changes only for explicit durable transitions: transformation/form change, outfit change, breakage, repair, damage state, or location condition change.\n" +
-            "- Do not emit state_changes for emotions, poses, camera effects, dialogue tone, or momentary actions.\n" +
-            "- Do not include reason or explanation fields; return only the schema fields needed for deterministic apply.\n" +
-            "- Include each scene from the input chunk, even if its arrays are empty.\n" +
-            "- `action_index` is the zero-based index from the scene actions array.\n" +
-            "\n" +
-            "Context:\n" +
-            `${JSON.stringify(context)}\n`;
-        return this.runToolUse({
-            prompt,
-            maxTokens: 16000,
-            toolName: "submit_state_binding",
-            description: "Return scene state refs and explicit state changes for deterministic application.",
-            schema: STATE_BINDING_SCHEMA,
-            truncatedTitle: "INIT FAILED: State binding output truncated",
-            invalidTitle: "INIT FAILED: Provider returned invalid state binding JSON",
-            nextSteps: ["Rerun init; completed extraction and curation checkpoints will be reused and state binding will retry."],
-        });
-    }
-    // Metadata is extracted as MANY small markdown requests instead of one big one:
-    // a single GLOBAL call (worldview + protagonists, tiny input/output) plus
-    // per-asset-chunk DESCRIPTION calls (≤ DEFAULT_METADATA_ASSET_CHUNK assets each).
-    // Every request is small on the non-streaming `messages.create` path the gateway
-    // doesn't drop, chunking bounds the output, and each call retries on transient
-    // gateway errors. Pieces merge through assembleMetadataFromParts (enum/role
-    // coercion + deterministic backfill).
-    async extractMetadata(_sourceText, script) {
-        const context = buildMetadataContext(script);
-        const actors = asList(context["actors"]);
-        const locations = asList(context["locations"]);
-        const props = asList(context["props"]);
-        // 1. GLOBAL: worldview + protagonists. Tiny input — names/titles, no examples.
-        const globalContext = {
-            title: context["title"],
-            worldview_options: context["worldview_options"],
-            episodes: context["episodes"],
-            actors: actors.map((a) => ({ actor_id: a["actor_id"], actor_name: a["actor_name"] })),
-        };
-        const globalRaw = await this.runMetadataMarkdown("You decide two global fields for a script: its worldview and which actors are protagonists.\n" +
-            "Use only the structured context below. Do not invent anything outside it.", METADATA_GLOBAL_MD_SPEC, globalContext);
-        const { worldviewRaw, protagonistIds } = parseGlobalMetadataMd(globalRaw);
-        // 2. DESCRIPTIONS: pool every asset (with a uniform `id`) and chunk so each
-        // request stays small in both input and output.
-        const pooled = [
-            ...actors.map((a) => ({ id: a["actor_id"], name: a["actor_name"], states: a["states"], examples: a["examples"] })),
-            ...locations.map((l) => ({ id: l["location_id"], name: l["location_name"], states: l["states"], examples: l["examples"] })),
-            ...props.map((p) => ({ id: p["prop_id"], name: p["prop_name"], examples: p["examples"] })),
-        ];
-        // Description chunks are independent (each merges into descriptionsById by
-        // id), so fan them out concurrently instead of one-await-at-a-time. Chunk
-        // count is small (≤ ceil(assets / DEFAULT_METADATA_ASSET_CHUNK)) and every
-        // request is already tiny + self-retrying, so a plain Promise.all is the
-        // right bound — this is what turns metadata from a serial back-to-back
-        // crawl into the same parallel profile as the other LLM stages.
-        const chunks = [];
-        for (let i = 0; i < pooled.length; i += DEFAULT_METADATA_ASSET_CHUNK) {
-            chunks.push(pooled.slice(i, i + DEFAULT_METADATA_ASSET_CHUNK));
-        }
-        const descriptionsById = new Map();
-        const rawChunks = await Promise.all(chunks.map((chunk) => this.runMetadataMarkdown("You write one concise visual description per asset, for downstream art generation.\n" +
-            "Use only the structured context below. Do not invent plot events outside it.\n" +
-            "Describe durable appearance/identity only; do not copy camera, staging, pose, entrance, hand-taking, kissing, or scene-position wording from state names or examples.", METADATA_DESC_MD_SPEC, { title: context["title"], assets: chunk })));
-        for (const raw of rawChunks) {
-            for (const [id, desc] of parseAssetDescriptionsMd(raw))
-                descriptionsById.set(id, desc);
-        }
-        if (descriptionsById.size === 0 && !worldviewRaw.trim() && protagonistIds.length === 0) {
-            // Every request came back unusable (prose refusal / wrong format) — reject
-            // instead of silently shipping a name-only deterministic baseline.
-            throw new CliError("INIT FAILED: Provider returned invalid metadata", "Provider returned no recognizable metadata markdown (content filter / wrong format).", {
-                exitCode: EXIT_RUNTIME,
-                required: ["metadata markdown (# 世界观 / # 主角 / # 描述 sections)"],
-                nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-                errorCode: "PROVIDER_CONTENT_FILTERED",
-            });
-        }
-        return assembleMetadataFromParts(script, worldviewRaw, protagonistIds, descriptionsById);
-    }
-    // Shared metadata round-trip: build the markdown prompt, run it on the
-    // non-streaming path with transient-error retry, and surface truncation as a
-    // CliError. Returns the raw markdown body.
-    async runMetadataMarkdown(intro, spec, context) {
-        const prompt = `${intro}\n\n${spec}\n\nContext:\n${JSON.stringify(context)}\n`;
-        const request = this.messageRequest(prompt, DEFAULT_BATCH_MAX_TOKENS);
-        const [raw, stopReason] = await this.collectResponseTextWithRetry(request);
-        if (stopReason === "max_tokens") {
-            throw new CliError("INIT FAILED: Metadata output truncated", "Metadata output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete metadata markdown within provider max_tokens"],
-                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request.max_tokens}`, `raw chars: ${raw.length}`, `tail: ${raw.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        return raw;
-    }
-    // collectResponseText + bounded backoff retry on transient gateway errors
-    // (peer closed / connection reset / 5xx — see isRetryableProviderError). Unlike
-    // extractBatch's bare call, metadata's small requests self-heal a flaky gateway
-    // instead of hard-failing the whole init on a single drop.
-    async collectResponseTextWithRetry(request) {
-        const attempts = providerAttempts();
-        let lastExc = null;
-        for (let attempt = 1; attempt <= attempts; attempt++) {
-            try {
-                return await this.collectResponseText(request);
-            }
-            catch (exc) {
-                if (isRetryableProviderError(exc) && attempt < attempts) {
-                    lastExc = exc;
-                    await sleepMs(Math.min(8000, 800 * attempt));
-                    continue;
-                }
-                throw exc;
-            }
-        }
-        throw lastExc ?? new Error("metadata request failed after retries");
-    }
-    async extractEpisodeSynopsis(synopses, ctx) {
-        const beats = cleanSynopsisList(synopses);
-        const label = strOf(ctx["title"]).trim() || strOf(ctx["episode"]).trim() || "this group";
-        const isEpisode = strOf(ctx["episode"]).trim().length > 0;
-        const lengthRequirement = isEpisode
-            ? "- synopsis: 200-300 Chinese characters, written as one connected paragraph.\n"
-            : "- synopsis: 400-600 Chinese characters, written as one connected stage/arc synopsis paragraph.\n";
-        const prompt = "You stitch ordered plot beats into ONE coherent synopsis.\n" +
-            "The beats below are in chronological order and all belong to the same unit\n" +
-            `(${label}). Produce a single connected synopsis, not a list.\n` +
-            "\n" +
-            "Requirements:\n" +
-            lengthRequirement +
-            "- Chinese plain text only.\n" +
-            "- Summarize ONLY the given beats. Do not invent events or add anything not present.\n" +
-            "- Do not spoil beyond the beats; do not list assets.\n" +
-            "- Keep the chronological order of the beats.\n" +
-            "\n" +
-            "Plot beats (ordered):\n" +
-            `${JSON.stringify(beats)}\n`;
-        return this.runToolUse({
-            prompt,
-            maxTokens: 2048,
-            toolName: "submit_episode_synopsis",
-            description: "Return one coherent synopsis stitched from the ordered plot beats.",
-            schema: EPISODE_SYNOPSIS_SCHEMA,
-            truncatedTitle: "SUMMARY FAILED: Synopsis output truncated",
-            invalidTitle: "SUMMARY FAILED: Provider returned invalid synopsis JSON",
-            nextSteps: ["Rerun init; the summary stage degrades to joined beats if this repeats."],
-        });
-    }
-    async extractScriptSynopsis(synopses, ctx) {
-        const episodeSynopses = cleanSynopsisList(synopses);
-        const title = strOf(ctx["title"]).trim();
-        const prompt = "You produce a whole-script overview from per-episode synopses.\n" +
-            `Script title: ${title || "(untitled)"}.\n` +
-            "Use ONLY the episode synopses below; do not invent plot, characters, or facts.\n" +
-            "Return JSON matching the configured schema.\n" +
-            "\n" +
-            "Requirements:\n" +
-            "- synopsis: 800-1200 Chinese characters; a connected whole-plot overview covering the main plot, key relationships, major conflicts, and ending direction.\n" +
-            "- theme: the central theme / 主旨, one short Chinese phrase or sentence.\n" +
-            "- logline: a single Chinese sentence capturing the whole story.\n" +
-            "- style: genre / tone as free Chinese text (e.g. 都市甜宠 / 悬疑复仇).\n" +
-            "- main_characters: the main people only, each with name and a short role (主角/配角/身份).\n" +
-            "- Ground everything in the episode synopses; if information is missing, keep it brief rather than inventing.\n" +
-            "\n" +
-            "Episode synopses (ordered):\n" +
-            `${JSON.stringify(episodeSynopses)}\n`;
-        return this.runToolUse({
-            prompt,
-            maxTokens: 2048,
-            toolName: "submit_script_synopsis",
-            description: "Return the whole-script overview (synopsis, theme, logline, style, main_characters).",
-            schema: SCRIPT_SYNOPSIS_SCHEMA,
-            truncatedTitle: "SUMMARY FAILED: Script synopsis output truncated",
-            invalidTitle: "SUMMARY FAILED: Provider returned invalid script synopsis JSON",
-            nextSteps: ["Rerun init; the summary stage leaves overview fields empty if this repeats."],
-        });
-    }
-}
-// ---------------------------------------------------------------------------
-// OpenAI-compatible text provider
-// ---------------------------------------------------------------------------
-const OPENAI_TEXT_MAX_TOKENS = 4096;
-export class OpenAICompatibleProvider {
-    name = "openai";
-    apiKey;
-    endpoint;
-    model;
-    constructor(model) {
-        const apiKey = (process.env.PROJECT_LITELLM_GATEWAY_API_KEY ?? "").trim();
-        if (!apiKey) {
-            throw new CliError("INIT FAILED: provider not configured", "Provider credentials are not configured for this environment.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["PROJECT_LITELLM_GATEWAY_API_KEY"],
-                received: ["no API key environment variable"],
-                nextSteps: ["Run `scriptctl doctor` to identify missing configuration."],
-                errorCode: "PROVIDER_AUTH_MISSING",
-            });
-        }
-        const baseUrl = (process.env.PROJECT_LITELLM_GATEWAY_BASE_URL ?? "").trim();
-        if (!baseUrl) {
-            throw new CliError("INIT FAILED: provider not configured", "Provider endpoint is not configured for this environment.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["PROJECT_LITELLM_GATEWAY_BASE_URL"],
-                received: ["no provider base URL"],
-                nextSteps: ["Run `scriptctl doctor` to identify missing configuration."],
-                errorCode: "PROVIDER_ENDPOINT_MISSING",
-            });
-        }
-        this.apiKey = apiKey;
-        this.endpoint = openAiChatCompletionsEndpoint(baseUrl);
-        this.model = model;
-    }
-    async completeText(request) {
-        const messages = [];
-        const system = request.system.trim();
-        if (system)
-            messages.push({ role: "system", content: system });
-        messages.push({ role: "user", content: request.user });
-        const body = {
-            model: this.model,
-            messages,
-            max_tokens: OPENAI_TEXT_MAX_TOKENS,
-        };
-        const response = await fetch(this.endpoint, {
-            method: "POST",
-            headers: {
-                "authorization": `Bearer ${this.apiKey}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify(body),
-            signal: request.signal,
-        });
-        const rawBody = await response.text();
-        if (!response.ok) {
-            throw new CliError("LLM FAILED: Provider request failed", "Provider request failed.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["successful OpenAI-compatible chat completion"],
-                received: [`status: ${response.status}`, `body: ${rawBody.slice(0, 500) || "<empty response>"}`],
-                nextSteps: ["Check the provider name/model and rerun; completed checkpoints will be reused."],
-                errorCode: "PROVIDER_REQUEST_FAILED",
-            });
-        }
-        const payload = parseJsonDict(rawBody, "LLM FAILED: Provider returned invalid JSON");
-        const choice = firstOpenAiChoice(payload);
-        const finishReason = choice ? strOf(choice["finish_reason"]).trim() : "";
-        const text = openAiChoiceContent(choice).trim();
-        if (finishReason === "length") {
-            throw new CliError("LLM FAILED: Provider output truncated", "Provider output truncated.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["complete text within provider max_tokens"],
-                received: [`finish_reason: ${finishReason}`, `max_tokens: ${OPENAI_TEXT_MAX_TOKENS}`, `raw chars: ${text.length}`, `tail: ${text.slice(-160) || "<empty response>"}`],
-                nextSteps: ["Rerun the command; completed checkpoints will be reused. If this repeats, lower the input chunk size."],
-                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
-            });
-        }
-        if (!text) {
-            throw new CliError("LLM FAILED: Provider returned empty text", "Provider returned an empty response.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["non-empty text response"],
-                received: [`finish_reason: ${finishReason || "unknown"}`, `raw chars: ${rawBody.length}`],
-                nextSteps: ["Rerun with a smaller chunk or adjust the prompt/spec."],
-                errorCode: "PROVIDER_EMPTY_RESPONSE",
-            });
-        }
-        return { text, raw: { finish_reason: finishReason } };
-    }
-}
-function textFromResponse(response) {
-    const parts = [];
-    for (const block of response.content ?? []) {
-        if (block.text)
-            parts.push(block.text);
-    }
-    return parts.join("\n").trim();
-}
-function firstNonEmptySourceLine(text) {
-    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-    return lines.find((line) => !line.endsWith("：") && !line.endsWith(":")) ?? lines[0] ?? "";
-}
-function mockAssetId(asset, kind) {
-    if (kind === "actor")
-        return strOf(asset["actor_id"]).trim();
-    if (kind === "location")
-        return strOf(asset["location_id"]).trim();
-    return strOf(asset["prop_id"]).trim();
-}
-function mockAssetName(asset, kind) {
-    if (kind === "actor")
-        return strOf(asset["actor_name"]).trim();
-    if (kind === "location")
-        return strOf(asset["location_name"]).trim();
-    return strOf(asset["prop_name"]).trim();
-}
-function actorVisualVariant(name) {
-    const prefix = /^(Q版|幻影|兽形|本体|灵体|黑化|幼年|少年|老年)[\s·：:、-]*(.+)$/.exec(name);
-    if (prefix)
-        return { baseName: prefix[2].trim(), stateName: prefix[1].trim() };
-    const suffix = /^(.+?)[\s·：:、-]*(Q版|幻影|兽形|本体|灵体|黑化|幼年|少年|老年)$/.exec(name);
-    if (suffix)
-        return { baseName: suffix[1].trim(), stateName: suffix[2].trim() };
-    return null;
-}
-function looksLikeGroupSpeaker(name) {
-    return /众人|群众|围观者|围观群众|路人们|大家|人群|村民们|族人们|员工们|同事们/.test(name) ||
-        /^路人[甲乙丙丁ABCD]$/.test(name);
-}
-function isMicroLocationName(name) {
-    return /门口|门前|门边|角落|墙边|窗边|桌边|床边|车旁|车前|车后|楼道|走廊/.test(name);
-}
-function isDisposableOrUiProp(name) {
-    return /一次性|手机画面|屏幕|界面|弹窗|提示框|聊天框|字幕条/.test(name);
-}
-function mockStateCategory(kind, name) {
-    if (kind === "location" && /^(白天|日间|上午|下午|午后|中午|清晨|早晨|黎明|夜晚|夜间|夜里|深夜|凌晨|黄昏|傍晚)$/.test(name)) {
-        return { action: "keep", group: `location-time:${name}` };
-    }
-    if (/默认/.test(name))
-        return { action: "keep", group: "default" };
-    if (/Q版|卡通/.test(name))
-        return { action: "rename", canonicalName: "Q版", group: "q" };
-    if (/透明|消融|半透明|仅余|残躯|凝实|复原中/.test(name))
-        return { action: "action_desc" };
-    if (/巨人|神像|神明|金身|百米/.test(name))
-        return { action: "rename", canonicalName: "百米金色巨人", group: "giant" };
-    if (/巨熊|熊形|兽形|神兽|真身|龙形|兽化/.test(name))
-        return { action: "rename", canonicalName: "标准巨熊", group: "beast" };
-    if (/战甲|铠甲|黑化|幼年|少年|老年|破损|碎裂|烧毁|修复|打开|关闭/.test(name))
-        return { action: "keep", group: name };
-    return { action: "action_desc" };
-}
-function mockStateCurationPlan(contextText) {
-    const decisions = [];
-    const defaultSelections = [];
-    let currentKind = null;
-    let currentAssetId = "";
-    let currentDefaultStateId = "";
-    let currentFirstStateId = "";
-    const groupTargetByAsset = new Map();
-    const flushDefault = () => {
-        if (!currentKind || !currentAssetId)
-            return;
-        const stateId = currentDefaultStateId || currentFirstStateId;
-        if (!stateId)
-            return;
-        defaultSelections.push({
-            kind: currentKind,
-            asset_id: currentAssetId,
-            state_id: stateId,
-            decision: "default",
-            reason: "mock: selected common baseline visual state.",
-        });
-    };
-    for (const rawLine of contextText.split(/\r?\n/)) {
-        const assetMatch = /^(?:A|L|P)\s+\|\s+(actor|location|prop)\s+\|\s+(\S+)/.exec(rawLine.trim());
-        if (assetMatch) {
-            flushDefault();
-            currentKind = assetMatch[1];
-            currentAssetId = assetMatch[2] ?? "";
-            currentDefaultStateId = "";
-            currentFirstStateId = "";
-            continue;
-        }
-        const stateMatch = /^\s*S\s+\|\s+(\S+)\s+\|\s+([^|]+?)\s+\|/.exec(rawLine);
-        if (!stateMatch || !currentKind || !currentAssetId)
-            continue;
-        const stateId = stateMatch[1] ?? "";
-        const stateName = strOf(stateMatch[2]).trim();
-        if (!currentFirstStateId)
-            currentFirstStateId = stateId;
-        const category = mockStateCategory(currentKind, stateName);
-        const groupKey = `${currentKind}:${currentAssetId}:${category.group ?? "action"}`;
-        if (category.action === "action_desc") {
-            decisions.push({
-                kind: currentKind,
-                asset_id: currentAssetId,
-                state_id: stateId,
-                decision: "action_desc",
-                reason: "mock: transient visual/action detail belongs in action text.",
-            });
-            continue;
-        }
-        const target = category.group ? groupTargetByAsset.get(groupKey) : null;
-        if (target && target !== stateId) {
-            decisions.push({
-                kind: currentKind,
-                asset_id: currentAssetId,
-                state_id: stateId,
-                decision: "merge",
-                target_state_id: target,
-                reason: "mock: degree variants collapse to one reusable visual state.",
-            });
-            continue;
-        }
-        if (category.group)
-            groupTargetByAsset.set(groupKey, stateId);
-        if (!currentDefaultStateId)
-            currentDefaultStateId = stateId;
-        if (category.action === "rename" && category.canonicalName && category.canonicalName !== stateName) {
-            decisions.push({
-                kind: currentKind,
-                asset_id: currentAssetId,
-                state_id: stateId,
-                decision: "rename",
-                new_name: category.canonicalName,
-                reason: "mock: broad canonical visual form.",
-            });
-        }
-        else {
-            decisions.push({
-                kind: currentKind,
-                asset_id: currentAssetId,
-                state_id: stateId,
-                decision: "keep",
-                reason: "mock: reusable visual state.",
-            });
-        }
-    }
-    flushDefault();
-    return { decisions, default_selections: defaultSelections };
-}
-function mockBindingRefs(scene, refKey, idKey, actionText) {
-    const refs = isDict(scene["refs"]) ? scene["refs"] : {};
-    const out = [];
-    for (const ref of asList(refs[refKey])) {
-        if (!isDict(ref))
-            continue;
-        const id = strOf(ref["id"]).trim();
-        const states = asList(ref["states"]);
-        if (!id || states.length === 0)
-            continue;
-        const stateId = pickMockStateId(states, actionText);
-        out.push({ [idKey]: id, state_id: stateId });
-    }
-    return out;
-}
-function pickMockStateId(states, actionText) {
-    for (const state of states) {
-        const name = strOf(state["state_name"]).trim();
-        const stateId = strOf(state["state_id"]).trim();
-        if (name && name !== "默认" && stateId && actionText.includes(name))
-            return stateId;
-    }
-    for (const state of states) {
-        if (strOf(state["state_id"]).trim() === "default")
-            return strOf(state["state_id"]).trim() || null;
-    }
-    return null;
-}
-function mockStateChanges(scene, actions) {
-    const refs = isDict(scene["refs"]) ? scene["refs"] : {};
-    const changeCues = /变成|变身|化作|恢复|变回|换上|穿上|脱下|破损|碎裂|修复|烧毁|亮起|熄灭/;
-    const out = [];
-    const seen = new Set();
-    for (let actionIndex = 0; actionIndex < actions.length; actionIndex++) {
-        const content = strOf(actions[actionIndex]["content"]);
-        if (!changeCues.test(content))
-            continue;
-        for (const [refKey, targetKind] of [
-            ["actors", "actor"],
-            ["locations", "location"],
-            ["props", "prop"],
-        ]) {
-            for (const ref of asList(refs[refKey])) {
-                if (!isDict(ref))
-                    continue;
-                const targetId = strOf(ref["id"]).trim();
-                const states = asList(ref["states"]);
-                const toStateId = pickExplicitMockStateId(states, content);
-                if (!targetId || !toStateId)
-                    continue;
-                const key = `${actionIndex}:${targetKind}:${targetId}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const defaultStateId = mockDefaultStateId(states);
-                out.push({
-                    action_index: actionIndex,
-                    target_kind: targetKind,
-                    target_id: targetId,
-                    from_state_id: defaultStateId || null,
-                    to_state_id: toStateId,
-                    effective_from: "after_action",
-                    reason: "mock: action contains an explicit durable visual state change.",
-                });
-            }
-        }
-    }
-    return out;
-}
-function pickExplicitMockStateId(states, content) {
-    for (const state of states) {
-        const name = strOf(state["state_name"]).trim();
-        const stateId = strOf(state["state_id"]).trim();
-        if (name && name !== "默认" && stateId && content.includes(name))
-            return stateId;
-    }
-    return "";
-}
-function mockDefaultStateId(states) {
-    for (const state of states) {
-        if (strOf(state["state_id"]).trim() === "default")
-            return strOf(state["state_id"]).trim();
-    }
-    return "";
-}
-/**
- * Find a forced tool_use block by name in a Message's content array.
- * Returns its `input` (already parsed by the SDK) or `null` when missing/non-object.
- */
-function findToolUseInput(content, toolName) {
-    for (const block of content) {
-        if (block?.type === "tool_use" && block.name === toolName) {
-            const inp = block.input;
-            if (inp && typeof inp === "object" && !Array.isArray(inp))
-                return inp;
-            return null;
-        }
-    }
-    return null;
-}
-function openAiChatCompletionsEndpoint(baseUrl) {
-    const base = baseUrl.trim().replace(/\/+$/, "");
-    if (base.endsWith("/chat/completions"))
-        return base;
-    if (base.endsWith("/v1"))
-        return `${base}/chat/completions`;
-    return `${base}/v1/chat/completions`;
-}
-function parseJsonDict(raw, title) {
-    try {
-        const payload = JSON.parse(raw);
-        if (isDict(payload))
-            return payload;
-    }
-    catch {
-        // Fall through to the structured provider error below.
-    }
-    throw new CliError(title, "Provider returned invalid JSON.", {
-        exitCode: EXIT_RUNTIME,
-        required: ["OpenAI-compatible JSON response"],
-        received: [`body: ${raw.slice(0, 500) || "<empty response>"}`],
-        nextSteps: ["Rerun the command; completed checkpoints will be reused."],
-        errorCode: "PROVIDER_INVALID_JSON",
-    });
-}
-function firstOpenAiChoice(payload) {
-    const choices = payload["choices"];
-    if (!Array.isArray(choices))
-        return null;
-    for (const choice of choices) {
-        if (isDict(choice))
-            return choice;
-    }
-    return null;
-}
-function openAiChoiceContent(choice) {
-    if (!choice)
-        return "";
-    const message = isDict(choice["message"]) ? choice["message"] : null;
-    if (!message)
-        return "";
-    const content = message["content"];
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    const parts = [];
-    for (const item of content) {
-        if (isDict(item) && typeof item["text"] === "string")
-            parts.push(item["text"]);
-    }
-    return parts.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-export function makeProvider(name, model) {
-    if (name === "mock")
-        return new MockProvider();
-    if (name === "anthropic")
-        return new AnthropicProvider(model);
-    if (name === "openai")
-        return new OpenAICompatibleProvider(model);
-    throw new CliError("INIT FAILED: Unsupported provider", "Unsupported provider.", {
-        exitCode: EXIT_USAGE,
-        required: ["--provider: anthropic | openai | mock"],
-        received: [`--provider: ${name}`],
-        nextSteps: ["Use --provider anthropic, --provider openai, or --provider mock."],
-    });
-}
-//# sourceMappingURL=providers.js.map