@lingjingai/scriptctl 0.32.0 → 0.34.0

package/dist/domain/direct-core.js

@@ -104,6 +104,9 @@ const _MD_ASSET_SUBSECTION_MAP = {
     "场景状态": "location_states", "地点状态": "location_states",
     "道具状态": "prop_states",
 };
+const _MD_STATE_REASON_RE = /^(?:提取缘由|抽取缘由|提取理由|状态缘由|状态理由)\s*[：:]\s*(.+)$/;
+const STATE_REASON_MAX_CHARS = 360;
+const MERGED_FROM_MAX_ITEMS = 12;
 // ---------------------------------------------------------------------------
 // Generic helpers (Python builtin equivalents)
 // ---------------------------------------------------------------------------
@@ -411,8 +414,19 @@ export function extractEpisodeTitleCandidate(header) {
 // ---------------------------------------------------------------------------
 // Episode plan
 // ---------------------------------------------------------------------------
+const _SCREENPLAY_BODY_MARKER_RE = /^[\t ]*(?:剧本正文|正文|短剧正文|正片剧本|剧本内容)[\t ]*[:：]?[\t ]*$/gim;
+function screenplayBodyStartOffset(sourceText) {
+    for (const match of reFindAllMatches(_SCREENPLAY_BODY_MARKER_RE, sourceText)) {
+        const start = match.index + match[0].length;
+        if (reFindAllMatches(_EP_HEADER_RE, sourceText.slice(start)).length > 0)
+            return start;
+    }
+    return 0;
+}
 export function buildEpisodePlan(sourceText) {
-    const matches = reFindAllMatches(_EP_HEADER_RE, sourceText);
+    const bodyStart = screenplayBodyStartOffset(sourceText);
+    const bodyText = bodyStart > 0 ? sourceText.slice(bodyStart) : sourceText;
+    const matches = reFindAllMatches(_EP_HEADER_RE, bodyText);
     const episodes = [];
     let confidence;
     let strategy;
@@ -436,7 +450,8 @@ export function buildEpisodePlan(sourceText) {
                 epNum = next;
             }
             usedEpNums.add(epNum);
-            const end = idx + 1 < matches.length ? matches[idx + 1].index : sourceText.length;
+            const start = bodyStart + match.index;
+            const end = idx + 1 < matches.length ? bodyStart + matches[idx + 1].index : sourceText.length;
             const header = match[0].trim();
             const rawTitle = extractEpisodeTitleCandidate(header);
             const title = formatEpisodeTitle(epNum, rawTitle);
@@ -448,13 +463,13 @@ export function buildEpisodePlan(sourceText) {
                 raw_title: rawTitle,
                 title_status: titleStatus,
                 title_source: title ? "source" : titleStatus,
-                source_span: { start: match.index, end },
-                header_span: { start: match.index, end: match.index + match[0].length },
-                char_count: end - match.index,
+                source_span: { start, end },
+                header_span: { start, end: start + match[0].length },
+                char_count: end - start,
             });
         }
         confidence = "high";
-        strategy = "explicit_episode_markers";
+        strategy = bodyStart > 0 ? "body_marker_episode_markers" : "explicit_episode_markers";
     }
     else {
         episodes.push({
@@ -475,6 +490,7 @@ export function buildEpisodePlan(sourceText) {
         version: 1,
         strategy,
         boundary_confidence: confidence,
+        body_start_offset: bodyStart,
         total_episodes: episodes.length,
         episodes,
     };
@@ -492,6 +508,11 @@ export function splitEntityState(raw) {
     if (!value)
         return ["", null];
     const states = [];
+    for (const item of reFindAll(_LOC_STATE_RE, value)) {
+        const v = item.trim();
+        if (v)
+            states.push(v);
+    }
     for (const item of reFindAll(_STATE_RE, value)) {
         const v = item.trim();
         if (v)
@@ -502,7 +523,7 @@ export function splitEntityState(raw) {
         if (v)
             states.push(v);
     }
-    return [cleanName(value), states.length > 0 ? states[states.length - 1] : null];
+    return [cleanName(reReplace(_LOC_STATE_RE, value, "")), states.length > 0 ? states[states.length - 1] : null];
 }
 export function splitLocationState(raw) {
     const value = strOf(raw).trim();
@@ -1189,19 +1210,21 @@ export function isRecoverableBatchCliError(exc) {
 export function isRetryableProviderError(exc) {
     const anyExc = exc;
     const statusCode = normalizeInt(anyExc?.status_code ?? anyExc?.statusCode ?? anyExc?.status, 0);
-    if ([408, 409, 429, 500, 502, 503, 504, 529].includes(statusCode))
-        return true;
-    if ([400, 401, 403, 404].includes(statusCode))
-        return false;
     const name = (anyExc?.name ?? "").toLowerCase();
     const message = (typeof exc === "object" && exc !== null && "message" in exc ? String(exc.message) : String(exc)).toLowerCase();
     const retryMarkers = [
         "apierror", "apiconnectionerror", "apitimeouterror", "ratelimiterror",
         "remoteprotocolerror", "timeout", "overloaded", "rate_limit", "temporarily",
         "service unavailable", "bad gateway", "gateway timeout", "connection reset",
-        "peer closed", "incomplete chunked read",
+        "peer closed", "incomplete chunked read", "all connection attempts failed",
     ];
-    return retryMarkers.some((m) => name.includes(m) || message.includes(m));
+    if (retryMarkers.some((m) => name.includes(m) || message.includes(m)))
+        return true;
+    if ([408, 409, 429, 500, 502, 503, 504, 529].includes(statusCode))
+        return true;
+    if ([400, 401, 403, 404].includes(statusCode))
+        return false;
+    return false;
 }
 export function providerAttempts() {
     const raw = (process.env.SCRIPTCTL_PROVIDER_ATTEMPTS ?? "").trim();
@@ -1276,20 +1299,35 @@ export function _md_push_asset(items, rawName, description) {
     }
     items.push({ name, description: description || null });
 }
-function _md_push_state_def(items, kind, rawName, description) {
+function cleanStateReason(raw) {
+    const text = strOf(raw).replace(/\s+/g, " ").trim();
+    if (!text)
+        return "";
+    return text.length > STATE_REASON_MAX_CHARS ? `${text.slice(0, STATE_REASON_MAX_CHARS - 1)}…` : text;
+}
+function setStateReason(item, reason) {
+    const text = cleanStateReason(reason);
+    if (text && !item["state_reason"])
+        item["state_reason"] = text;
+}
+function _md_push_state_def(items, kind, rawName, description, stateReason = "") {
     const [namePart, sep, statePart] = partition(strOf(rawName), "|");
     const assetName = cleanName(namePart);
     const stateName = statePart.trim();
     if (!sep || !assetName || !stateName)
-        return;
+        return null;
     for (const item of items) {
         if (item["kind"] === kind && item["asset_name"] === assetName && item["state_name"] === stateName) {
             if (description && !item["description"])
                 item["description"] = description;
-            return;
+            setStateReason(item, stateReason);
+            return item;
         }
     }
-    items.push({ kind, asset_name: assetName, state_name: stateName, description: description || null });
+    const item = { kind, asset_name: assetName, state_name: stateName, description: description || null };
+    setStateReason(item, stateReason);
+    items.push(item);
+    return item;
 }
 export function parseSpeakerRef(raw) {
     const value = strOf(raw).trim();
@@ -1330,7 +1368,7 @@ export function inferNonActorSpeakerKind(name, scene = null) {
         return "system";
     if (reSearch(/广播(?!员)|喇叭|电台|播报|通知|警报/, value))
         return "broadcast";
-    if (reSearch(/众人|众|群体|全体|大家|人群/, value))
+    if (reSearch(/众人|众|群体|全体|大家|人群|宾客|观众|群众|围观者/, value))
         return "group";
     if (scene) {
         const propSet = new Set(asList(scene["prop_names"]).map((p) => strOf(p).trim()));
@@ -1500,6 +1538,7 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
     const speakers = [];
     const stateDefs = [];
     let lastAction = null;
+    let lastStateDef = null;
     // synopsis (## 梗概 sub-header → per-episode; # 梗概 top header → whole-script)
     // and the episode title carried as the first non-section top header.
     const synopsisLines = [];
@@ -1515,6 +1554,7 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
         if (subMatch && !sceneMatch && subMatch[1].trim() === "梗概") {
             capturingSynopsis = true;
             lastAction = null;
+            lastStateDef = null;
             continue;
         }
         if (sceneMatch && section === "script") {
@@ -1531,6 +1571,7 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                 actions: [],
             });
             lastAction = null;
+            lastStateDef = null;
             continue;
         }
         if (subMatch && section === "asset") {
@@ -1538,11 +1579,13 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
             const heading = subMatch[1].trim();
             assetSubsection = _MD_ASSET_SUBSECTION_MAP[heading] ?? null;
             lastAction = null;
+            lastStateDef = null;
             continue;
         }
         if (subMatch) {
             capturingSynopsis = false;
             lastAction = null;
+            lastStateDef = null;
             continue;
         }
         const topMatch = reMatch(_MD_TOP_HEADER_RE, stripped);
@@ -1571,6 +1614,7 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                 section = null;
             }
             lastAction = null;
+            lastStateDef = null;
             continue;
         }
         // Inside a synopsis block, capture prose lines until the next header.
@@ -1651,6 +1695,7 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                     }
                 }
                 lastAction = null;
+                lastStateDef = null;
                 continue;
             }
             const actionMatch = reMatch(_MD_ACTION_ANCHOR_RE, stripped);
@@ -1674,10 +1719,12 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                 }
                 scenes[scenes.length - 1]["actions"].push(action);
                 lastAction = action;
+                lastStateDef = null;
                 continue;
             }
             if (!stripped) {
                 lastAction = null;
+                lastStateDef = null;
                 continue;
             }
             if (lastAction !== null && !stripped.startsWith("-")) {
@@ -1693,8 +1740,14 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
         else if (section === "asset") {
             if (assetSubsection === null || !stripped)
                 continue;
+            const reasonMatch = reMatch(_MD_STATE_REASON_RE, stripped);
+            if (reasonMatch && lastStateDef !== null && /_states$/.test(assetSubsection)) {
+                setStateReason(lastStateDef, reasonMatch[1]);
+                continue;
+            }
             const entryMatch = reMatch(_MD_ASSET_ENTRY_RE, stripped);
             if (entryMatch) {
+                lastStateDef = null;
                 const name = entryMatch[1].trim();
                 const description = (entryMatch[2] || "").trim() || null;
                 if (assetSubsection === "actors")
@@ -1709,15 +1762,18 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                         speakers.push({ name: displayName, source_kind: sourceKind, description });
                 }
                 else if (assetSubsection === "actor_states") {
-                    _md_push_state_def(stateDefs, "actor", name, description);
+                    lastStateDef = _md_push_state_def(stateDefs, "actor", name, description);
                 }
                 else if (assetSubsection === "location_states") {
-                    _md_push_state_def(stateDefs, "location", name, description);
+                    lastStateDef = _md_push_state_def(stateDefs, "location", name, description);
                 }
                 else if (assetSubsection === "prop_states") {
-                    _md_push_state_def(stateDefs, "prop", name, description);
+                    lastStateDef = _md_push_state_def(stateDefs, "prop", name, description);
                 }
             }
+            else {
+                lastStateDef = null;
+            }
         }
     }
     for (const scene of scenes) {
@@ -1771,15 +1827,23 @@ export function parseAssetDoc(text, kind) {
     const stateDefs = [];
     const stateKind = kind === "actors" ? "actor" : kind === "locations" ? "location" : "prop";
     let currentAsset = null;
+    let currentStateDef = null;
     for (const rawLine of text.split(/\r?\n/)) {
         const stripped = rawLine.trim();
         if (!stripped)
             continue;
         if (reMatch(_MD_SUB_HEADER_RE, stripped) || reMatch(_MD_TOP_HEADER_RE, stripped))
             continue; // headers ignored
+        const reasonMatch = reMatch(_MD_STATE_REASON_RE, stripped);
+        if (reasonMatch && currentStateDef !== null) {
+            setStateReason(currentStateDef, reasonMatch[1]);
+            continue;
+        }
         const m = reMatch(_MD_ASSET_ENTRY_RE, stripped);
-        if (!m)
+        if (!m) {
+            currentStateDef = null;
             continue;
+        }
         const name = m[1].trim();
         const description = (m[2] || "").trim() || null;
         if (!name)
@@ -1788,15 +1852,14 @@ export function parseAssetDoc(text, kind) {
         if (kind !== "speakers") {
             // Flat self-contained state: `- name|state: desc`.
             if (name.includes("|")) {
-                _md_push_state_def(stateDefs, stateKind, name, description);
+                currentStateDef = _md_push_state_def(stateDefs, stateKind, name, description);
                 continue;
             }
             // An indented bullet is always a state sub-bullet — never a top-level
             // asset. Attach to the most recent asset; if there is none yet (malformed
             // input), skip it rather than registering a spurious asset.
             if (indented) {
-                if (currentAsset)
-                    _md_push_state_def(stateDefs, stateKind, `${currentAsset}|${name}`, description);
+                currentStateDef = currentAsset ? _md_push_state_def(stateDefs, stateKind, `${currentAsset}|${name}`, description) : null;
                 continue;
             }
         }
@@ -1810,9 +1873,11 @@ export function parseAssetDoc(text, kind) {
             const [sourceKind, displayName] = parseSpeakerAsset(name);
             if (displayName)
                 speakers.push({ name: displayName, source_kind: sourceKind, description });
+            currentStateDef = null;
             continue;
         }
         currentAsset = name;
+        currentStateDef = null;
     }
     return { actors, locations, props, speakers, state_definitions: stateDefs };
 }
@@ -2074,6 +2139,24 @@ export function expandCompactEpisodeResult(result, episodePlan) {
         expanded["synopsis"] = synopsis;
     return expanded;
 }
+const COMPACT_EPISODE_CARRIED_LIST_KEYS = ["actors", "locations", "props", "speakers", "state_definitions"];
+function carryCompactEpisodeLists(result, compact) {
+    for (const key of COMPACT_EPISODE_CARRIED_LIST_KEYS) {
+        const items = result[key];
+        if (!isList(items) || items.length === 0)
+            continue;
+        compact[key] = items.map((item) => {
+            if (!isDict(item))
+                return item;
+            const cleaned = {};
+            for (const [k, v] of Object.entries(item)) {
+                if (v !== null && v !== undefined)
+                    cleaned[k] = v;
+            }
+            return cleaned;
+        });
+    }
+}
 export function compactEpisodeResult(result) {
     const compactScenes = [];
     for (const scene of asList(result["scenes"])) {
@@ -2174,6 +2257,7 @@ export function compactEpisodeResult(result) {
         compactScenes.push(compactScene);
     }
     const compacted = { sc: compactScenes };
+    carryCompactEpisodeLists(result, compacted);
     // Carry the synopsis through the compact round-trip (short key `syn`). Without
     // this, any synopsis written upstream (## 梗概 → batch result, or the episode
     // reduce) would silently evaporate the moment the result is persisted.
@@ -2198,21 +2282,6 @@ export function compactBatchResult(result) {
             compactActions[j]["r"] = refs.map((r) => strOf(r).trim()).filter((r) => r);
         }
     }
-    for (const key of ["actors", "locations", "props", "speakers", "state_definitions"]) {
-        const items = result[key];
-        if (isList(items) && items.length > 0) {
-            compact[key] = items.map((item) => {
-                if (!isDict(item))
-                    return item;
-                const cleaned = {};
-                for (const [k, v] of Object.entries(item)) {
-                    if (v !== null && v !== undefined)
-                        cleaned[k] = v;
-                }
-                return cleaned;
-            });
-        }
-    }
     return compact;
 }
 /**
@@ -2435,9 +2504,9 @@ export function normalizeEpisodeResult(result, episodePlan) {
         }
         scene["actions"] = actions;
     }
-    normalized["actors"] = _normalizeAssetList(normalized["actors"]);
-    normalized["locations"] = _normalizeAssetList(normalized["locations"]);
-    normalized["props"] = _normalizeAssetList(normalized["props"]);
+    normalized["actors"] = _normalizeAssetList(normalized["actors"], "actor");
+    normalized["locations"] = _normalizeAssetList(normalized["locations"], "location");
+    normalized["props"] = _normalizeAssetList(normalized["props"], "prop");
     normalized["speakers"] = _normalize_speaker_list(normalized["speakers"]);
     normalized["state_definitions"] = _normalizeStateDefinitions(normalized["state_definitions"]);
     for (const scene of scenes) {
@@ -2453,7 +2522,7 @@ export function normalizeEpisodeResult(result, episodePlan) {
     }
     return normalized;
 }
-function _normalizeAssetList(items) {
+function _normalizeAssetList(items, kind) {
     if (!isList(items))
         return [];
     const out = [];
@@ -2462,11 +2531,22 @@ function _normalizeAssetList(items) {
         let name = "";
         let description = null;
         if (isDict(item)) {
-            name = cleanName(strOf(item["name"]));
+            const rawName = strOf(item["name"]);
+            if (kind === "actor")
+                [name] = splitEntityState(rawName);
+            else if (kind === "location" || kind === "prop")
+                [name] = splitLocationState(rawName);
+            else
+                name = cleanName(rawName);
             description = strOf(item["description"]).trim() || null;
         }
         else if (typeof item === "string") {
-            name = cleanName(item);
+            if (kind === "actor")
+                [name] = splitEntityState(item);
+            else if (kind === "location" || kind === "prop")
+                [name] = splitLocationState(item);
+            else
+                name = cleanName(item);
         }
         else
             continue;
@@ -2506,7 +2586,13 @@ export function _normalize_speaker_list(items) {
         const [parsedKind, parsedName] = parseSpeakerAsset(rawName);
         let kind = sourceKind || parsedKind;
         kind = _MD_SPEAKER_KIND_NORM[kind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[kind] ?? "other";
-        const name = cleanName(parsedName);
+        let name = "";
+        if (kind === "actor")
+            [name] = splitEntityState(parsedName);
+        else if (kind === "location" || kind === "prop")
+            [name] = splitLocationState(parsedName);
+        else
+            name = cleanName(parsedName);
         if (!name || seen.has(name))
             continue;
         seen.add(name);
@@ -2525,7 +2611,14 @@ function _normalizeStateDefinitions(items) {
         const kind = strOf(item["kind"] || item["target_kind"]).trim();
         if (!SCRIPT_TARGET_KINDS.has(kind))
             continue;
-        const assetName = cleanName(strOf(item["asset_name"] || item["name"]));
+        const rawAssetName = strOf(item["asset_name"] || item["name"]);
+        let assetName = "";
+        if (kind === "actor")
+            [assetName] = splitEntityState(rawAssetName);
+        else if (kind === "location" || kind === "prop")
+            [assetName] = splitLocationState(rawAssetName);
+        else
+            assetName = cleanName(rawAssetName);
         const stateName = strOf(item["state_name"] || item["state"]).trim();
         if (!assetName || !stateName || stateRejectionReason(kind, stateName))
             continue;
@@ -2533,12 +2626,16 @@ function _normalizeStateDefinitions(items) {
         if (seen.has(key))
             continue;
         seen.add(key);
-        out.push({
+        const normalized = {
             kind,
             asset_name: assetName,
             state_name: stateName,
             description: strOf(item["description"]).trim() || null,
-        });
+        };
+        const stateReason = cleanStateReason(item["state_reason"]);
+        if (stateReason)
+            normalized["state_reason"] = stateReason;
+        out.push(normalized);
     }
     return out;
 }
@@ -3819,17 +3916,31 @@ export function buildPrimaryAssetCurationChunks(script, kind, options = { maxIte
 }
 export function extractAssetGroupingExpressions(rawText) {
     const groups = [];
+    const blocks = [];
+    let currentBlock = [];
     const re = /<group>([\s\S]*?)<\/group>/g;
     let outside = "";
     let lastIndex = 0;
     let match;
     while ((match = re.exec(rawText)) !== null) {
-        outside += rawText.slice(lastIndex, match.index);
-        groups.push(strOf(match[1]).trim());
+        const gap = rawText.slice(lastIndex, match.index);
+        outside += gap;
+        if (gap.trim() && currentBlock.length > 0) {
+            blocks.push(currentBlock);
+            currentBlock = [];
+        }
+        const expression = strOf(match[1]).trim();
+        groups.push(expression);
+        currentBlock.push(expression);
         lastIndex = match.index + match[0].length;
     }
     outside += rawText.slice(lastIndex);
+    if (currentBlock.length > 0)
+        blocks.push(currentBlock);
     if (outside.trim()) {
+        const lastBlock = blocks[blocks.length - 1] ?? [];
+        if (blocks.length > 1 && lastBlock.length > 0)
+            return lastBlock;
         curationBlocked("Asset grouping response must contain only <group>...</group> lines.", [outside.trim().slice(0, 200)]);
     }
     if (groups.length === 0) {
@@ -3927,7 +4038,7 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
         retainedByName.set(key, list);
     }
     const duplicateMerges = [];
-    const omittedInvalid = [];
+    const omittedSingletons = [];
     for (const id of inputIds) {
         if (mentioned.has(id))
             continue;
@@ -3937,7 +4048,13 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
         const key = assetGroupingNameKey(kind, asset[assetNameKey(kind)]);
         const targets = key ? retainedByName.get(key) ?? [] : [];
         if (targets.length === 0) {
-            omittedInvalid.push(`${kind}:${id}:${strOf(asset[assetNameKey(kind)])}`);
+            groups.push({
+                kind,
+                ids: [id],
+                reason: "omitted by grouping; review as standalone asset",
+            });
+            mentioned.add(id);
+            omittedSingletons.push(id);
             continue;
         }
         duplicateMerges.push({
@@ -3949,9 +4066,6 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
             reason: "name-level duplicate omitted by asset grouping",
         });
     }
-    if (omittedInvalid.length > 0) {
-        curationBlocked("Asset grouping omitted non-duplicate asset ids.", omittedInvalid.slice(0, 40));
-    }
     return {
         version: 1,
         format: "asset-grouping-v1",
@@ -3966,6 +4080,7 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
             group_count: groups.length,
             mentioned_count: mentioned.size,
             omitted_duplicate_count: duplicateMerges.length,
+            omitted_singleton_count: omittedSingletons.length,
             normalization_count: normalizations.length,
         },
     };
@@ -4295,8 +4410,9 @@ function auditCandidateReason(script, decision, evidence, relatedById) {
                 return "speaking_actor_removed_or_speaker";
         }
         if (action === "keep" && asset) {
-            if (hasEnumeratedActorName(strOf(asset["actor_name"])))
+            if (hasEnumeratedActorName(strOf(asset["actor_name"])) && item.dialogueCount === 0 && item.speakingScenes.size === 0) {
                 return "kept_enumerated_actor_review";
+            }
             const identity = actorIdentityCandidates(script, sourceId, strOf(asset["actor_name"]), item);
             if (identity.length > 0)
                 return "kept_actor_identity_or_form_review";
@@ -4375,7 +4491,8 @@ export function buildAssetCurationAuditContextText(script, primaryPlan, selected
     lines.push("- Output expressions only for listed candidates when the primary decision should be corrected or when the candidate is marked primary=MISSING.");
     lines.push("- Otherwise output exactly <exp>NOOP # no asset curation changes</exp>.");
     lines.push("- Audit expressions must reference source ids listed here. Existing primary sources are overridden; primary=MISSING and primary=IMPLICIT_KEEP sources are added.");
-    lines.push("- For primary KEEP actor candidates, output SPEAKER/MERGE/RENAME only when the kept actor is a generic numbered role, anonymous crowd, pure voice label, or duplicate identity.");
+    lines.push("- For primary KEEP actor candidates, output SPEAKER/MERGE/RENAME only when the kept actor is an anonymous crowd, pure voice label, duplicate identity, or a generic numbered role without dialogue.");
+    lines.push("- 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 众人/宾客们/围观者.");
     lines.push("- For primary KEEP location candidates, output RENAME/MERGE only when canonical scope or duplicate/parent-child granularity is wrong; otherwise leave it unchanged.");
     lines.push(`- For primary KEEP prop candidates, output DROP/MERGE/STATE/RENAME when the prop is too broad; output KEEP only to add/replace a valid category reason from ${propKeepCategoryList()}.`);
     lines.push("- For primary DROP/MERGE/STATE prop candidates, output KEEP/RENAME/MERGE only when standalone hero-prop continuity is stronger than the primary decision.");
@@ -4563,7 +4680,7 @@ export function assertLocationCanonicalizationPlan(rawPlan) {
     const invalid = [];
     for (const decision of normalizedCurationDecisions(rawPlan)) {
         const kind = strOf(decision["kind"]);
-        const action = strOf(decision["decision"]);
+        let action = strOf(decision["decision"]);
         const sourceId = strOf(decision["source_id"]);
         if (kind !== "location" || (action !== "rename" && action !== "merge")) {
             invalid.push(`${kind || "<empty>"}:${sourceId || "<empty>"} ${action || "<empty>"}`);
@@ -5049,6 +5166,14 @@ function parseCurationExpression(expression) {
     match = /^PROP\s+(actor|location|prop)\s+(\S+)\s+->\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
     if (match) {
         const target = match[3];
+        const normalizedTarget = target.toLowerCase();
+        const targetPrefix = /^([A-Za-z]+):(.+)$/.exec(target);
+        if ((targetPrefix && targetPrefix[1].toLowerCase() !== "prop") ||
+            normalizedTarget === "actor" ||
+            normalizedTarget === "location" ||
+            normalizedTarget === "prop") {
+            curationBlocked("PROP target must be NEW or an existing prop id.", [expression]);
+        }
         const decision = {
             kind: match[1].toLowerCase(),
             source_id: match[2],
@@ -5058,7 +5183,7 @@ function parseCurationExpression(expression) {
             reason,
         };
         if (target.toUpperCase() !== "NEW")
-            decision["target_id"] = target;
+            decision["target_id"] = targetPrefix ? targetPrefix[2] : target;
         return decision;
     }
     curationBlocked("Unknown or malformed curation expression.", [expression]);
@@ -5266,34 +5391,44 @@ export function combinePrimaryAssetCurationPlans(plans) {
         primary_part_expression_text: expressionTextByPlan.join("\n"),
     };
 }
-export function combineAssetCurationPlans(primaryPlan, auditPlan, allowedNewAuditSources = []) {
+export function combineAssetCurationPlans(primaryPlan, auditPlan, allowedNewAuditSources = [], options = {}) {
     const primaryDecisions = asList(primaryPlan["decisions"]).filter(isDict);
-    const auditDecisions = asList(auditPlan["decisions"]).filter(isDict);
+    const rawAuditDecisions = asList(auditPlan["decisions"]).filter(isDict);
     const primaryKeys = curationDecisionSourceSet(primaryDecisions);
     const allowedNewKeys = new Set(allowedNewAuditSources);
     const invalidAuditSources = [];
     let addedAuditDecisions = 0;
-    for (const decision of auditDecisions) {
+    const auditDecisions = [];
+    for (const decision of rawAuditDecisions) {
         const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
-        if (primaryKeys.has(key))
+        if (primaryKeys.has(key)) {
+            auditDecisions.push(decision);
             continue;
+        }
         if (allowedNewKeys.has(key)) {
             addedAuditDecisions += 1;
+            auditDecisions.push(decision);
             continue;
         }
         invalidAuditSources.push(key);
     }
-    if (invalidAuditSources.length > 0) {
+    if (invalidAuditSources.length > 0 && !options.salvageInvalidAuditSources) {
         curationBlocked("Audit curation expressions may only override primary decision sources or listed missing required sources.", invalidAuditSources);
     }
     const primaryExpressions = asList(primaryPlan["expressions"]);
-    const auditExpressions = asList(auditPlan["expressions"]);
+    const auditExpressions = invalidAuditSources.length > 0 && options.salvageInvalidAuditSources
+        ? auditDecisions.map(renderAssetCurationDecisionExpression)
+        : asList(auditPlan["expressions"]);
+    const auditExpressionText = invalidAuditSources.length > 0 && options.salvageInvalidAuditSources
+        ? formatAssetCurationDecisionExpressions({ decisions: auditDecisions })
+        : strOf(auditPlan["expression_text"]);
     return {
         version: 3,
         format: "asset-curation-exp-v1",
         primary_expression_text: strOf(primaryPlan["expression_text"]),
-        audit_expression_text: strOf(auditPlan["expression_text"]),
-        expression_text: [strOf(primaryPlan["expression_text"]).trim(), strOf(auditPlan["expression_text"]).trim()].filter((text) => text).join("\n"),
+        audit_expression_text: auditExpressionText,
+        audit_raw_expression_text: invalidAuditSources.length > 0 && options.salvageInvalidAuditSources ? strOf(auditPlan["expression_text"]) : undefined,
+        expression_text: [strOf(primaryPlan["expression_text"]).trim(), auditExpressionText.trim()].filter((text) => text).join("\n"),
         primary_expressions: primaryExpressions,
         audit_expressions: auditExpressions,
         expressions: [...primaryExpressions, ...auditExpressions],
@@ -5301,7 +5436,10 @@ export function combineAssetCurationPlans(primaryPlan, auditPlan, allowedNewAudi
         audit_summary: {
             primary_decisions: primaryDecisions.length,
             audit_decisions: auditDecisions.length,
+            audit_raw_decisions: rawAuditDecisions.length,
             audit_added_decisions: addedAuditDecisions,
+            audit_rejected_decisions: invalidAuditSources.length,
+            audit_rejected_sources: invalidAuditSources,
             audit_noop: auditDecisions.length === 0,
         },
     };
@@ -5667,7 +5805,7 @@ function normalizeCurationPlanTargets(script, decisions) {
     normalizeMergeCycles(script, decisions);
     const decisionsBySource = buildCurationDecisionIndex(decisions);
     for (const decision of decisions) {
-        const action = strOf(decision["decision"]);
+        let action = strOf(decision["decision"]);
         if (action !== "merge" && action !== "move_to_state" && action !== "move_to_prop")
             continue;
         const targetId = strOf(decision["target_id"]);
@@ -5817,6 +5955,71 @@ function rewriteCurationRefs(script, replacementsByKind, droppedByKind, stateRep
         }
     }
 }
+function normalizeNonActorSpeakersToActorSpeakers(script) {
+    const actorIdByName = new Map();
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const name = strOf(actor["actor_name"]).trim();
+        const id = strOf(actor["actor_id"]).trim();
+        if (name && id)
+            actorIdByName.set(name, id);
+    }
+    const actorSpeakerByActorId = new Map();
+    for (const speaker of asList(script["speakers"])) {
+        if (!isDict(speaker))
+            continue;
+        if (strOf(speaker["source_kind"]) !== "actor")
+            continue;
+        const sourceId = strOf(speaker["source_id"]).trim();
+        const speakerId = strOf(speaker["speaker_id"]).trim();
+        if (sourceId && speakerId)
+            actorSpeakerByActorId.set(sourceId, speakerId);
+    }
+    const speakerReplacements = new Map();
+    for (const speaker of asList(script["speakers"])) {
+        if (!isDict(speaker))
+            continue;
+        if (strOf(speaker["source_kind"]) === "actor")
+            continue;
+        const speakerId = strOf(speaker["speaker_id"]).trim();
+        const displayName = strOf(speaker["display_name"]).trim();
+        const actorId = actorIdByName.get(displayName);
+        const actorSpeakerId = actorId ? actorSpeakerByActorId.get(actorId) : "";
+        if (speakerId && actorSpeakerId && speakerId !== actorSpeakerId)
+            speakerReplacements.set(speakerId, actorSpeakerId);
+    }
+    if (speakerReplacements.size === 0)
+        return { speaker_refs_normalized: 0, speakers_removed: 0 };
+    let speakerRefsNormalized = 0;
+    const rewriteSpeakerId = (value) => {
+        const speakerId = strOf(value).trim();
+        const replacement = speakerReplacements.get(speakerId);
+        if (!replacement)
+            return speakerId;
+        speakerRefsNormalized += 1;
+        return replacement;
+    };
+    for (const episode of asList(script["episodes"])) {
+        for (const scene of asList(episode["scenes"])) {
+            for (const action of asList(scene["actions"])) {
+                if (!isDict(action))
+                    continue;
+                const rewrittenSpeakerId = rewriteSpeakerId(action["speaker_id"]);
+                if (rewrittenSpeakerId) {
+                    action["speaker_id"] = rewrittenSpeakerId;
+                    const actorId = rewrittenSpeakerId.startsWith("spk_act_") ? rewrittenSpeakerId.slice(4) : "";
+                    if (actorId)
+                        action["actor_id"] = actorId;
+                }
+                action["speakers"] = rewriteSpeakerRefs(action["speakers"], speakerReplacements);
+                action["lines"] = rewriteSpeakerRefs(action["lines"], speakerReplacements);
+            }
+        }
+    }
+    script["speakers"] = asList(script["speakers"]).filter((speaker) => isDict(speaker) && !speakerReplacements.has(strOf(speaker["speaker_id"])));
+    return { speaker_refs_normalized: speakerRefsNormalized, speakers_removed: speakerReplacements.size };
+}
 function copyStatesForMerge(script, kind, source, target, stateReplacements) {
     for (const state of asList(source["states"])) {
         const sourceStateId = strOf(state["state_id"]);
@@ -6007,6 +6210,7 @@ function applyAssetCurationDecisions(script, decisions, coverageSummary, default
             }
         }
     }
+    const speakerNormalizationSummary = normalizeNonActorSpeakersToActorSpeakers(script);
     const actorsAfter = asList(script["actors"]).length;
     const locationsAfter = asList(script["locations"]).length;
     const propsAfter = asList(script["props"]).length;
@@ -6030,6 +6234,8 @@ function applyAssetCurationDecisions(script, decisions, coverageSummary, default
             default_policy: defaultPolicy,
             coverage: coverageSummary,
             actions: summarizeActionableCuration(decisions),
+            speaker_refs_normalized: speakerNormalizationSummary["speaker_refs_normalized"],
+            speakers_normalized_removed: speakerNormalizationSummary["speakers_removed"],
         },
         decisions,
     };
@@ -6171,6 +6377,907 @@ export function curateScriptAssets(script, rawCuration = null) {
     };
 }
 // ---------------------------------------------------------------------------
+// State curation
+// ---------------------------------------------------------------------------
+export const STATE_CURATION_MAX_ASSETS = 4;
+export const STATE_CURATION_MAX_CONTEXT_CHARS = 28000;
+function stateCurationBlocked(message, received) {
+    throw new CliError("DIRECT STATE CURATION BLOCKED: invalid provider plan", message, {
+        exitCode: EXIT_NEEDS_AGENT,
+        required: ["valid state curation expressions referencing existing asset/state ids"],
+        received,
+        nextSteps: ["Inspect state_curation.json, adjust the draft manually, or rerun direct init after provider plan fixes."],
+    });
+}
+function stateCurationSourceKey(kind, assetId, stateId) {
+    return `${kind}:${assetId}/${stateId}`;
+}
+function stateCurationDecisionSourceKey(decision) {
+    return stateCurationSourceKey(strOf(decision["kind"]), strOf(decision["asset_id"]), strOf(decision["state_id"]));
+}
+function stateCurationAssetSourceKey(kind, assetId) {
+    return `${kind}:${assetId}`;
+}
+function stateCurationDefaultSelectionSourceKey(selection) {
+    return stateCurationAssetSourceKey(strOf(selection["kind"]), strOf(selection["asset_id"]));
+}
+function stateCurationUsageFor(script) {
+    const usage = new Map();
+    const ensure = (kind, assetId, stateId) => {
+        const key = stateCurationSourceKey(kind, assetId, stateId);
+        const current = usage.get(key);
+        if (current)
+            return current;
+        const next = { sceneRefs: new Set(), stateChanges: new Set() };
+        usage.set(key, next);
+        return next;
+    };
+    for (const ep of asList(script["episodes"])) {
+        const episodeId = strOf(ep["episode_id"]);
+        for (const scene of asList(ep["scenes"])) {
+            const sceneId = strOf(scene["scene_id"]);
+            const sceneRef = [episodeId, sceneId].filter((item) => item).join("/");
+            const ctx = sceneContext(scene);
+            for (const kind of ["actor", "location", "prop"]) {
+                const idKey = assetIdKey(kind);
+                const refKey = assetListKey(kind);
+                for (const ref of asList(ctx[refKey])) {
+                    const assetId = strOf(ref[idKey]);
+                    const stateId = strOf(ref["state_id"]);
+                    if (assetId && stateId && sceneRef)
+                        ensure(kind, assetId, stateId).sceneRefs.add(sceneRef);
+                }
+            }
+            for (const [actionIndex, action] of asList(scene["actions"]).entries()) {
+                if (!isDict(action))
+                    continue;
+                for (const change of asList(action["state_changes"])) {
+                    if (!isDict(change))
+                        continue;
+                    const kind = strOf(change["target_kind"]);
+                    if (!isAssetKindValue(kind))
+                        continue;
+                    const assetId = strOf(change["target_id"]);
+                    if (!assetId)
+                        continue;
+                    const actionRef = `${sceneRef}#${actionIndex}`;
+                    const fromStateId = strOf(change["from_state_id"]);
+                    const toStateId = strOf(change["to_state_id"]);
+                    if (fromStateId)
+                        ensure(kind, assetId, fromStateId).stateChanges.add(actionRef);
+                    if (toStateId)
+                        ensure(kind, assetId, toStateId).stateChanges.add(actionRef);
+                }
+            }
+        }
+    }
+    return usage;
+}
+function statefulAssetsForCuration(script) {
+    const refs = [];
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const assetId = strOf(asset[assetIdKey(kind)]).trim();
+            if (!assetId || asList(asset["states"]).filter(isDict).length === 0)
+                continue;
+            refs.push({ kind, asset_id: assetId });
+        }
+    }
+    return refs;
+}
+function stateCurationAssetByRef(script, ref) {
+    return assetMapById(script, ref.kind).get(ref.asset_id) ?? null;
+}
+function compactStateCurationText(value, maxChars = 120) {
+    const text = strOf(value).replace(/\s+/g, " ").replace(/\|/g, "/").trim();
+    return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}
+function formatStateCurationUsage(usage) {
+    if (!usage)
+        return "refs=0 changes=0";
+    return `refs=${usage.sceneRefs.size} changes=${usage.stateChanges.size}`;
+}
+function stateCurationClusterKey(stateName) {
+    const name = strOf(stateName).replace(/[默认基础普通日常]/g, "").replace(/(?:状态|形态|造型|姿态|阶段|版本|版|态|装)$/g, "").trim();
+    const cjk = /[\u4e00-\u9fff]{2,}/.exec(name);
+    if (cjk)
+        return cjk[0].slice(0, 2);
+    const ascii = /[A-Za-z0-9]{3,}/.exec(name);
+    return ascii ? ascii[0].slice(0, 6).toLowerCase() : "";
+}
+function formatStateCurationClusterHints(states) {
+    const buckets = new Map();
+    for (const state of states) {
+        const stateId = compactStateCurationText(state["state_id"], 40);
+        const stateName = compactStateCurationText(state["state_name"], 80);
+        if (!stateId || !stateName || stateName === "默认")
+            continue;
+        const key = stateCurationClusterKey(stateName);
+        if (!key)
+            continue;
+        if (!buckets.has(key))
+            buckets.set(key, []);
+        buckets.get(key).push(`${stateId}:${stateName}`);
+    }
+    const lines = [];
+    for (const [key, members] of buckets) {
+        if (members.length < 2)
+            continue;
+        lines.push(`  C | similar_name_cluster=${key} | ${members.slice(0, 12).join(" ~ ")}`);
+    }
+    return lines;
+}
+function stateCurationPrefix(kind) {
+    if (kind === "actor")
+        return "A";
+    if (kind === "location")
+        return "L";
+    return "P";
+}
+function formatStateCurationAssetBlock(script, ref, usageByKey) {
+    const asset = stateCurationAssetByRef(script, ref);
+    if (!asset)
+        return [];
+    const name = compactStateCurationText(asset[assetNameKey(ref.kind)], 80);
+    const description = compactStateCurationText(asset["description"], 160);
+    const states = asList(asset["states"]).filter(isDict);
+    const lines = [
+        `${stateCurationPrefix(ref.kind)} | ${ref.kind} | ${ref.asset_id} | ${name || "-"} | states=${states.length} | desc=${description || "-"}`,
+    ];
+    for (const state of states) {
+        const stateId = compactStateCurationText(state["state_id"], 40);
+        const stateName = compactStateCurationText(state["state_name"], 80);
+        if (!stateId || !stateName)
+            continue;
+        const usage = usageByKey.get(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        const stateReason = compactStateCurationText(state["state_reason"], 220);
+        lines.push(`  S | ${stateId} | ${stateName} | ${formatStateCurationUsage(usage)} | desc=${compactStateCurationText(state["description"], 180) || "-"} | reason=${stateReason || "-"}`);
+    }
+    lines.push(...formatStateCurationClusterHints(states));
+    return lines;
+}
+export function buildStateCurationContextText(script, refs) {
+    const selectedRefs = refs && refs.length > 0 ? refs : statefulAssetsForCuration(script);
+    const usage = stateCurationUsageFor(script);
+    const lines = [];
+    lines.push("# State Curation Context");
+    lines.push(`title: ${compactStateCurationText(script["title"], 120) || "-"}`);
+    lines.push("");
+    lines.push("Goal: compress each asset's states to reusable production visual states.");
+    lines.push("");
+    lines.push("Policy:");
+    lines.push("- A state is a large reusable visual asset form, not a plot/action/emotion/pose label.");
+    lines.push("- KEEP only macro states that require a visibly different reusable asset: major form transformation, Q version, non-human/beast/god/giant form, durable outfit/appearance redesign, major damage/repair condition, a prop/location physical condition that must recur, or a location time/lighting state from a scene header such as 黄昏/夜晚/清晨.");
+    lines.push("- Actor VFX/power intensity is not a separate state by itself: 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.");
+    lines.push("- Actor base human/humanoid shape 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.");
+    lines.push("- Prefer one broad macro state over many process frames. MERGE states that are only degree/progress variants of the same major appearance.");
+    lines.push("- DROP or ACTION_STATE transient states: emotions, poses, unconscious/asleep/lying/sitting, holding/carrying an item, temporary glow/VFX intensity, fading/transparent/solidifying progress frames, minor mark brightness/thickness/spread, one-off ordinary clothing, camera effects, or scene-only actions.");
+    lines.push("- Treat each `reason=` field as evidence text, not as a keep decision. Phrases like `needs a separate image`, `reusable`, or `stable` in the extraction reason are not enough to KEEP unless the name/description show a distinct macro form.");
+    lines.push("- 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, or mark spreading.");
+    lines.push("- For actor states, held objects are not actor states. If the state is just holding/using an item, use ACTION_STATE unless the item must remain a separate prop.");
+    lines.push("- 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.");
+    lines.push("- When keeping a useful state whose description contains camera/staging/story wording, keep the state and rewrite the description with DESC.");
+    lines.push("- Every S line below must receive exactly one expression.");
+    lines.push("- Every asset block with at least one S line must also receive exactly one DEFAULT_STATE expression.");
+    lines.push("- DEFAULT_STATE selects the most common normal appearance for that asset. Keep the selected state's readable state_name; only its state_id will become `default` during deterministic apply.");
+    lines.push("- Use only state_id values listed under the same asset block. Do not invent ids or cross-asset merge targets.");
+    lines.push("- If a broad canonical state name is needed, RENAME_STATE one existing representative state and MERGE_STATE the variants into it.");
+    lines.push("");
+    lines.push("Expression grammar:");
+    lines.push("- <exp>KEEP_STATE <kind> <asset_id> <state_id> [DESC=\"<clean visual description>\"] # reason</exp>");
+    lines.push("- <exp>MERGE_STATE <kind> <asset_id> <state_id> -> <target_state_id> # reason</exp>");
+    lines.push("- <exp>DROP_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <exp>ACTION_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <exp>RENAME_STATE <kind> <asset_id> <state_id> \"<new_name>\" [DESC=\"<clean visual description>\"] # reason</exp>");
+    lines.push("- <exp>DEFAULT_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <kind> is one of actor, location, prop. Use double quotes for names; escape only \\\" and \\\\.");
+    lines.push("");
+    lines.push("Assets:");
+    for (const ref of selectedRefs) {
+        const block = formatStateCurationAssetBlock(script, ref, usage);
+        if (block.length > 0)
+            lines.push(...block);
+    }
+    lines.push("");
+    lines.push("required_state_ids:");
+    for (const ref of selectedRefs) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                lines.push(`- ${stateCurationSourceKey(ref.kind, ref.asset_id, stateId)}`);
+        }
+    }
+    lines.push("");
+    lines.push("required_default_assets:");
+    for (const ref of selectedRefs) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset || asList(asset["states"]).filter(isDict).length === 0)
+            continue;
+        lines.push(`- ${stateCurationAssetSourceKey(ref.kind, ref.asset_id)}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function buildStateCurationChunks(script, options = {}) {
+    const maxAssets = Math.max(1, Math.floor(options.maxAssets ?? STATE_CURATION_MAX_ASSETS));
+    const maxContextChars = Math.max(2000, Math.floor(options.maxContextChars ?? STATE_CURATION_MAX_CONTEXT_CHARS));
+    const refs = statefulAssetsForCuration(script);
+    const chunks = [];
+    let current = [];
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        chunks.push({ part_id: `part.${String(chunks.length + 1).padStart(3, "0")}`, refs: current });
+        current = [];
+    };
+    for (const ref of refs) {
+        const singletonLength = buildStateCurationContextText(script, [ref]).length;
+        if (current.length === 0) {
+            current.push(ref);
+            if (singletonLength > maxContextChars)
+                flush();
+            continue;
+        }
+        const candidate = [...current, ref];
+        if (candidate.length > maxAssets || buildStateCurationContextText(script, candidate).length > maxContextChars) {
+            flush();
+            current.push(ref);
+            if (singletonLength > maxContextChars)
+                flush();
+        }
+        else {
+            current = candidate;
+        }
+    }
+    flush();
+    return chunks;
+}
+function splitStateCurationExpressionReason(expression) {
+    let inQuote = false;
+    let escaped = false;
+    for (let index = 0; index < expression.length; index += 1) {
+        const ch = expression[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === "\"") {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (ch === "#" && !inQuote) {
+            const command = expression.slice(0, index).trim();
+            const reason = expression.slice(index + 1).trim();
+            if (!command)
+                stateCurationBlocked("State curation expression is missing an operation before # reason.", [expression]);
+            if (!reason)
+                stateCurationBlocked("State curation expression is missing reason text after #.", [expression]);
+            return { command, reason };
+        }
+    }
+    stateCurationBlocked("State curation expression must include `# reason`.", [expression]);
+}
+function unquoteStateCurationExpressionString(value) {
+    let out = "";
+    let escaped = false;
+    for (const ch of value) {
+        if (escaped) {
+            if (ch !== "\\" && ch !== "\"")
+                stateCurationBlocked("Unsupported escape sequence in state curation expression string.", [`\\${ch}`]);
+            out += ch;
+            escaped = false;
+        }
+        else if (ch === "\\") {
+            escaped = true;
+        }
+        else {
+            out += ch;
+        }
+    }
+    if (escaped)
+        stateCurationBlocked("Unterminated escape sequence in state curation expression string.", [value]);
+    return out;
+}
+function parseStateCurationExpression(expression) {
+    if (expression.includes("\n") || expression.includes("\r")) {
+        stateCurationBlocked("Each state curation expression must be a single line.", [expression]);
+    }
+    const { command, reason } = splitStateCurationExpressionReason(expression.trim());
+    if (/^NOOP$/i.test(command))
+        return null;
+    let match = /^DEFAULT_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            asset_id: match[2],
+            state_id: match[3],
+            decision: "default",
+            reason,
+        };
+    }
+    match = /^KEEP_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)(?:\s+DESC="(.*)")?$/i.exec(command);
+    if (match) {
+        const decision = { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "keep", reason };
+        if (match[4] !== undefined)
+            decision["new_description"] = unquoteStateCurationExpressionString(match[4]);
+        return decision;
+    }
+    match = /^MERGE_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)\s+->\s+(\S+)$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            asset_id: match[2],
+            state_id: match[3],
+            decision: "merge",
+            target_state_id: match[4],
+            reason,
+        };
+    }
+    match = /^DROP_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)(?:\s+DESC=".*")?$/i.exec(command);
+    if (match) {
+        return { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "drop", reason };
+    }
+    match = /^ACTION_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)(?:\s+DESC=".*")?$/i.exec(command);
+    if (match) {
+        return { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "action_desc", reason };
+    }
+    match = /^RENAME_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)\s+"((?:\\.|[^"\\])*)"(?:\s+DESC="(.*)")?$/i.exec(command);
+    if (match) {
+        const decision = {
+            kind: match[1].toLowerCase(),
+            asset_id: match[2],
+            state_id: match[3],
+            decision: "rename",
+            new_name: unquoteStateCurationExpressionString(match[4]),
+            reason,
+        };
+        if (match[5] !== undefined)
+            decision["new_description"] = unquoteStateCurationExpressionString(match[5]);
+        return decision;
+    }
+    stateCurationBlocked("Unknown or malformed state curation expression.", [expression]);
+}
+function extractStateCurationExpressions(rawText) {
+    const expressions = [];
+    const re = /<exp>([\s\S]*?)<\/exp>/g;
+    let match;
+    while ((match = re.exec(rawText)) !== null) {
+        expressions.push(strOf(match[1]).trim());
+    }
+    if (expressions.length === 0) {
+        stateCurationBlocked("State curation response did not contain any <exp> expressions.", [rawText.slice(0, 200)]);
+    }
+    return expressions;
+}
+export function parseStateCurationExpressions(rawText) {
+    const decisions = [];
+    const defaultSelections = [];
+    const expressions = extractStateCurationExpressions(rawText);
+    let noop = false;
+    for (const expression of expressions) {
+        const decision = parseStateCurationExpression(expression);
+        if (decision === null)
+            noop = true;
+        else if (strOf(decision["decision"]) === "default")
+            defaultSelections.push(decision);
+        else
+            decisions.push(decision);
+    }
+    if (noop && (decisions.length > 0 || defaultSelections.length > 0)) {
+        stateCurationBlocked("NOOP cannot be combined with actionable state curation expressions.", [rawText.slice(0, 200)]);
+    }
+    return {
+        version: 1,
+        format: "state-curation-exp-v1",
+        expression_text: rawText,
+        expressions,
+        decisions,
+        default_selections: defaultSelections,
+    };
+}
+function renderStateCurationDecisionExpression(decision) {
+    const kind = strOf(decision["kind"]);
+    const assetId = strOf(decision["asset_id"]);
+    const stateId = strOf(decision["state_id"]);
+    const reason = strOf(decision["reason"]).trim() || "state curation decision";
+    const action = strOf(decision["decision"]);
+    if (action === "default")
+        return `DEFAULT_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "merge")
+        return `MERGE_STATE ${kind} ${assetId} ${stateId} -> ${strOf(decision["target_state_id"])} # ${reason}`;
+    if (action === "drop")
+        return `DROP_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "action_desc")
+        return `ACTION_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "keep") {
+        const desc = Object.prototype.hasOwnProperty.call(decision, "new_description")
+            ? ` DESC=${quoteCurationExpressionString(decision["new_description"])}`
+            : "";
+        return `KEEP_STATE ${kind} ${assetId} ${stateId}${desc} # ${reason}`;
+    }
+    if (action === "rename") {
+        const desc = Object.prototype.hasOwnProperty.call(decision, "new_description")
+            ? ` DESC=${quoteCurationExpressionString(decision["new_description"])}`
+            : "";
+        return `RENAME_STATE ${kind} ${assetId} ${stateId} ${quoteCurationExpressionString(decision["new_name"])}${desc} # ${reason}`;
+    }
+    stateCurationBlocked("Cannot render unknown state curation decision.", [`decision: ${action || "<empty>"}`]);
+}
+export function formatStateCurationDecisionExpressions(plan) {
+    const decisions = asList(plan["decisions"]).filter(isDict);
+    const defaultSelections = asList(plan["default_selections"]).filter(isDict);
+    const expressions = [...decisions, ...defaultSelections].map((decision) => `<exp>${renderStateCurationDecisionExpression(decision)}</exp>`);
+    if (expressions.length === 0)
+        return "<exp>NOOP # no state curation changes</exp>";
+    return `${expressions.join("\n")}\n`;
+}
+function stateCurationAllSourceKeys(script) {
+    const keys = [];
+    for (const ref of statefulAssetsForCuration(script)) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                keys.push(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        }
+    }
+    return keys;
+}
+export function stateCurationSourceKeysForRefs(script, refs) {
+    const keys = [];
+    for (const ref of refs) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                keys.push(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        }
+    }
+    return keys;
+}
+function stateCurationDecisionMap(decisions) {
+    const map = new Map();
+    for (const decision of decisions) {
+        map.set(stateCurationDecisionSourceKey(decision), decision);
+    }
+    return map;
+}
+export function missingStateCurationRequiredSourceKeys(script, plan, requiredKeys) {
+    const keys = requiredKeys && requiredKeys.length > 0 ? [...requiredKeys] : stateCurationAllSourceKeys(script);
+    const decisions = stateCurationDecisionMap(asList(plan["decisions"]).filter(isDict));
+    return keys.filter((key) => !decisions.has(key));
+}
+function stateCurationRequiredDefaultAssetKeys(script, requiredKeys) {
+    if (requiredKeys && requiredKeys.length > 0) {
+        const keys = new Set();
+        for (const key of requiredKeys) {
+            const match = /^(actor|location|prop):([^/]+)\//.exec(key);
+            if (match)
+                keys.add(stateCurationAssetSourceKey(match[1], match[2]));
+        }
+        return [...keys];
+    }
+    return statefulAssetsForCuration(script).map((ref) => stateCurationAssetSourceKey(ref.kind, ref.asset_id));
+}
+function stateCurationDefaultSelectionMap(selections) {
+    const map = new Map();
+    for (const selection of selections) {
+        const key = stateCurationDefaultSelectionSourceKey(selection);
+        if (map.has(key))
+            stateCurationBlocked("State curation plan selects more than one default state for an asset.", [key]);
+        map.set(key, selection);
+    }
+    return map;
+}
+function assertStateExistsForCuration(script, kind, assetId, stateId) {
+    const asset = assertAssetExists(script, kind, assetId);
+    for (const state of asList(asset["states"])) {
+        if (strOf(state["state_id"]) === stateId)
+            return state;
+    }
+    stateCurationBlocked("State curation decision references an unknown state.", [stateCurationSourceKey(kind, assetId, stateId)]);
+}
+function validateStateCurationDecision(script, decision) {
+    const kind = strOf(decision["kind"]);
+    if (!isAssetKindValue(kind))
+        stateCurationBlocked("Unknown state curation kind.", [`kind: ${kind || "<empty>"}`]);
+    const assetId = strOf(decision["asset_id"]);
+    const stateId = strOf(decision["state_id"]);
+    const action = strOf(decision["decision"]);
+    const reason = strOf(decision["reason"]);
+    const rewritesDescription = Object.prototype.hasOwnProperty.call(decision, "new_description");
+    if (!assetId || !stateId)
+        stateCurationBlocked("State curation decision is missing asset_id/state_id.", [`${kind}:${assetId}/${stateId}`]);
+    if (!reason)
+        stateCurationBlocked("State curation decision is missing reason.", [`${kind}:${assetId}/${stateId}`]);
+    assertStateExistsForCuration(script, kind, assetId, stateId);
+    if (action === "default") {
+        if (rewritesDescription)
+            stateCurationBlocked("DEFAULT_STATE cannot rewrite descriptions.", [`${kind}:${assetId}/${stateId}`]);
+        return;
+    }
+    if (rewritesDescription) {
+        const newDescription = strOf(decision["new_description"]).trim();
+        if (!newDescription)
+            stateCurationBlocked("State description rewrite requires a non-empty description.", [`${kind}:${assetId}/${stateId}`]);
+        if (action !== "keep" && action !== "rename") {
+            stateCurationBlocked("State description rewrite is only valid on KEEP_STATE or RENAME_STATE.", [`${kind}:${assetId}/${stateId}:${action}`]);
+        }
+    }
+    if (action === "merge") {
+        const targetStateId = strOf(decision["target_state_id"]);
+        if (!targetStateId || targetStateId === stateId) {
+            stateCurationBlocked("MERGE_STATE requires a different target_state_id.", [`${kind}:${assetId}/${stateId}`]);
+        }
+        assertStateExistsForCuration(script, kind, assetId, targetStateId);
+    }
+    else if (action === "rename") {
+        const newName = strOf(decision["new_name"]).trim();
+        if (!newName)
+            stateCurationBlocked("RENAME_STATE requires a non-empty new_name.", [`${kind}:${assetId}/${stateId}`]);
+    }
+    else if (action !== "keep" && action !== "drop" && action !== "action_desc") {
+        stateCurationBlocked("Unknown state curation decision.", [`decision: ${action || "<empty>"}`]);
+    }
+}
+function normalizeStateCurationMergeTargets(decisions) {
+    const bySource = stateCurationDecisionMap(decisions);
+    for (const decision of decisions) {
+        if (strOf(decision["decision"]) !== "merge")
+            continue;
+        const kind = strOf(decision["kind"]);
+        const assetId = strOf(decision["asset_id"]);
+        let targetStateId = strOf(decision["target_state_id"]);
+        const seen = new Set([stateCurationDecisionSourceKey(decision)]);
+        while (targetStateId) {
+            const targetKey = stateCurationSourceKey(kind, assetId, targetStateId);
+            if (seen.has(targetKey))
+                stateCurationBlocked("State curation merge plan contains a cycle.", [`cycle at ${targetKey}`]);
+            seen.add(targetKey);
+            const targetDecision = bySource.get(targetKey);
+            if (!targetDecision)
+                break;
+            const targetAction = strOf(targetDecision["decision"]);
+            if (targetAction === "merge") {
+                targetStateId = strOf(targetDecision["target_state_id"]);
+                decision["target_state_id"] = targetStateId;
+                continue;
+            }
+            if (targetAction === "drop" || targetAction === "action_desc") {
+                decision["decision"] = targetAction;
+                delete decision["target_state_id"];
+            }
+            break;
+        }
+    }
+}
+export function assertStateCurationPlan(script, plan, requiredKeys) {
+    const rawDecisions = asList(plan["decisions"]).filter(isDict);
+    const decisions = [...stateCurationDecisionMap(rawDecisions).values()];
+    const defaultSelections = asList(plan["default_selections"]).filter(isDict);
+    for (const decision of decisions)
+        validateStateCurationDecision(script, decision);
+    for (const selection of defaultSelections)
+        validateStateCurationDecision(script, selection);
+    normalizeStateCurationMergeTargets(decisions);
+    const missing = missingStateCurationRequiredSourceKeys(script, { decisions }, requiredKeys);
+    if (missing.length > 0) {
+        stateCurationBlocked("State curation plan is missing required state decisions.", missing.slice(0, 80));
+    }
+    const defaultMap = stateCurationDefaultSelectionMap(defaultSelections);
+    const missingDefaults = stateCurationRequiredDefaultAssetKeys(script, requiredKeys).filter((key) => !defaultMap.has(key));
+    if (missingDefaults.length > 0) {
+        stateCurationBlocked("State curation plan is missing required DEFAULT_STATE selections.", missingDefaults.slice(0, 80));
+    }
+    return {
+        ...plan,
+        decisions,
+        default_selections: [...defaultMap.values()],
+    };
+}
+function mapStateForCuration(kind, assetId, stateId, replacements, removed) {
+    const id = strOf(stateId);
+    if (!id)
+        return null;
+    const key = stateCurationSourceKey(kind, assetId, id);
+    const replacement = replacements.get(key);
+    if (replacement)
+        return replacement;
+    if (removed.has(key))
+        return null;
+    return id;
+}
+function rewriteRefsAfterStateCuration(script, replacements, removed) {
+    let sceneRefsCleared = 0;
+    let sceneRefsMerged = 0;
+    let stateChangesRemoved = 0;
+    let stateChangesRewritten = 0;
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const ctx = sceneContext(scene);
+            for (const kind of ["actor", "location", "prop"]) {
+                const idKey = assetIdKey(kind);
+                const refKey = assetListKey(kind);
+                for (const ref of asList(ctx[refKey])) {
+                    if (!isDict(ref))
+                        continue;
+                    const assetId = strOf(ref[idKey]);
+                    const prior = strOf(ref["state_id"]);
+                    const next = mapStateForCuration(kind, assetId, prior, replacements, removed);
+                    if (!next && prior) {
+                        ref["state_id"] = null;
+                        sceneRefsCleared += 1;
+                    }
+                    else if (next && next !== prior) {
+                        ref["state_id"] = next;
+                        sceneRefsMerged += 1;
+                    }
+                }
+            }
+            setSceneContext(scene, ctx);
+            for (const action of asList(scene["actions"])) {
+                if (!isDict(action) || action["state_changes"] === undefined || action["state_changes"] === null)
+                    continue;
+                const nextChanges = [];
+                for (const change of asList(action["state_changes"])) {
+                    if (!isDict(change))
+                        continue;
+                    const kind = strOf(change["target_kind"]);
+                    if (!isAssetKindValue(kind))
+                        continue;
+                    const assetId = strOf(change["target_id"]);
+                    const toState = mapStateForCuration(kind, assetId, change["to_state_id"], replacements, removed);
+                    if (!toState) {
+                        stateChangesRemoved += 1;
+                        continue;
+                    }
+                    const fromState = mapStateForCuration(kind, assetId, change["from_state_id"], replacements, removed);
+                    if (fromState && fromState === toState) {
+                        stateChangesRemoved += 1;
+                        continue;
+                    }
+                    const next = { ...change, to_state_id: toState };
+                    if (fromState)
+                        next["from_state_id"] = fromState;
+                    else
+                        delete next["from_state_id"];
+                    if (toState !== strOf(change["to_state_id"]) || fromState !== strOf(change["from_state_id"]))
+                        stateChangesRewritten += 1;
+                    nextChanges.push(next);
+                }
+                if (nextChanges.length > 0)
+                    action["state_changes"] = nextChanges;
+                else
+                    delete action["state_changes"];
+            }
+        }
+    }
+    return {
+        scene_refs_cleared: sceneRefsCleared,
+        scene_refs_merged: sceneRefsMerged,
+        state_changes_removed: stateChangesRemoved,
+        state_changes_rewritten: stateChangesRewritten,
+    };
+}
+function appendStateCurationMergedFrom(script, kind, assetId, sourceStateId, targetStateId, reason) {
+    const source = assertStateExistsForCuration(script, kind, assetId, sourceStateId);
+    const target = assertStateExistsForCuration(script, kind, assetId, targetStateId);
+    const sourceName = strOf(source["state_name"]).trim();
+    if (!sourceName)
+        return;
+    const existing = asList(target["merged_from"]).filter(isDict);
+    if (existing.some((item) => item["state_name"] === sourceName))
+        return;
+    const next = [
+        ...existing,
+        {
+            state_name: sourceName,
+            reason: cleanStateReason(reason),
+        },
+    ].slice(0, MERGED_FROM_MAX_ITEMS);
+    target["merged_from"] = next;
+}
+function synthesizedDefaultState(asset) {
+    const state = {
+        state_id: "default",
+        state_name: "默认",
+    };
+    const description = strOf(asset["description"]).trim();
+    if (description)
+        state["description"] = description;
+    return state;
+}
+function canonicalizeDefaultStatesAfterCuration(script, defaultSelections, replacements, removed) {
+    const selectionByAsset = stateCurationDefaultSelectionMap([...defaultSelections]);
+    const defaultReplacements = new Map();
+    const selectedDefaults = [];
+    let synthesized = 0;
+    let rewritten = 0;
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const assetId = strOf(asset[assetIdKey(kind)]);
+            if (!assetId)
+                continue;
+            const assetKey = stateCurationAssetSourceKey(kind, assetId);
+            const states = asList(asset["states"]).filter(isDict);
+            if (states.length === 0) {
+                asset["states"] = [synthesizedDefaultState(asset)];
+                synthesized += 1;
+                selectedDefaults.push({
+                    kind,
+                    asset_id: assetId,
+                    input_state_id: null,
+                    final_state_id: "default",
+                    state_name: "默认",
+                    synthesized: true,
+                    reason: "asset has no surviving explicit states",
+                });
+                continue;
+            }
+            const selection = selectionByAsset.get(assetKey);
+            if (!selection) {
+                stateCurationBlocked("State curation default canonicalization is missing a DEFAULT_STATE selection.", [assetKey]);
+            }
+            const inputStateId = strOf(selection["state_id"]);
+            const selectedStateId = mapStateForCuration(kind, assetId, inputStateId, replacements, removed);
+            if (!selectedStateId) {
+                stateCurationBlocked("DEFAULT_STATE selection was removed while other states survived.", [
+                    `${assetKey}/${inputStateId}`,
+                ]);
+            }
+            const selectedState = states.find((state) => strOf(state["state_id"]) === selectedStateId);
+            if (!selectedState) {
+                stateCurationBlocked("DEFAULT_STATE selection does not resolve to a surviving state.", [
+                    `${assetKey}/${inputStateId} -> ${selectedStateId}`,
+                ]);
+            }
+            const existingDefault = states.find((state) => strOf(state["state_id"]) === "default");
+            if (existingDefault && existingDefault !== selectedState) {
+                stateCurationBlocked("State curation would create two `default` states for one asset.", [
+                    `${assetKey}: selected=${selectedStateId}`,
+                ]);
+            }
+            if (selectedStateId !== "default") {
+                selectedState["state_id"] = "default";
+                defaultReplacements.set(stateCurationSourceKey(kind, assetId, selectedStateId), "default");
+                rewritten += 1;
+            }
+            selectedDefaults.push({
+                kind,
+                asset_id: assetId,
+                input_state_id: inputStateId,
+                final_state_id: "default",
+                original_final_state_id: selectedStateId,
+                state_name: selectedState["state_name"],
+                synthesized: false,
+                reason: selection["reason"],
+            });
+        }
+    }
+    const rewriteSummary = rewriteRefsAfterStateCuration(script, defaultReplacements, new Set());
+    return {
+        default_states_synthesized: synthesized,
+        default_state_ids_rewritten: rewritten,
+        default_ref_rewrite: rewriteSummary,
+        selected_default_states: selectedDefaults,
+    };
+}
+export function applyStateCurationPlan(script, rawPlan) {
+    const plan = assertStateCurationPlan(script, rawPlan);
+    const decisions = asList(plan["decisions"]).filter(isDict);
+    const defaultSelections = asList(plan["default_selections"]).filter(isDict);
+    const beforeByKind = { actor: 0, location: 0, prop: 0 };
+    const afterByKind = { actor: 0, location: 0, prop: 0 };
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)]))
+            beforeByKind[kind] += asList(asset["states"]).filter(isDict).length;
+    }
+    const replacements = new Map();
+    const removed = new Set();
+    const decisionSummary = {
+        keep: 0,
+        merge: 0,
+        drop: 0,
+        action_desc: 0,
+        rename: 0,
+        description_rewrite: 0,
+    };
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        const assetId = strOf(decision["asset_id"]);
+        const stateId = strOf(decision["state_id"]);
+        const key = stateCurationSourceKey(kind, assetId, stateId);
+        const action = strOf(decision["decision"]);
+        const inputState = assertStateExistsForCuration(script, kind, assetId, stateId);
+        const inputStateName = strOf(inputState["state_name"]).trim();
+        if (inputStateName)
+            decision["input_state_name"] = inputStateName;
+        const inputStateReason = cleanStateReason(inputState["state_reason"]);
+        if (inputStateReason)
+            decision["input_state_reason"] = inputStateReason;
+        decisionSummary[action] = Number(decisionSummary[action] ?? 0) + 1;
+        if (action === "keep" || action === "rename") {
+            const state = inputState;
+            if (action === "rename")
+                state["state_name"] = strOf(decision["new_name"]).trim();
+            if (Object.prototype.hasOwnProperty.call(decision, "new_description")) {
+                const newDescription = strOf(decision["new_description"]).trim();
+                if (strOf(state["description"]) !== newDescription)
+                    decisionSummary["description_rewrite"] = Number(decisionSummary["description_rewrite"] ?? 0) + 1;
+                state["description"] = newDescription;
+            }
+        }
+        else if (action === "merge") {
+            const targetStateId = strOf(decision["target_state_id"]);
+            appendStateCurationMergedFrom(script, kind, assetId, stateId, targetStateId, strOf(decision["reason"]));
+            replacements.set(key, targetStateId);
+            removed.add(key);
+        }
+        else if (action === "drop" || action === "action_desc") {
+            removed.add(key);
+        }
+    }
+    const rewriteSummary = rewriteRefsAfterStateCuration(script, replacements, removed);
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const assetId = strOf(asset[assetIdKey(kind)]);
+            asset["states"] = asList(asset["states"]).filter((state) => {
+                if (!isDict(state))
+                    return false;
+                const key = stateCurationSourceKey(kind, assetId, strOf(state["state_id"]));
+                return !removed.has(key);
+            });
+        }
+    }
+    const defaultSummary = canonicalizeDefaultStatesAfterCuration(script, defaultSelections, replacements, removed);
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)]))
+            afterByKind[kind] += asList(asset["states"]).filter(isDict).length;
+    }
+    const statesBefore = beforeByKind.actor + beforeByKind.location + beforeByKind.prop;
+    const statesAfter = afterByKind.actor + afterByKind.location + afterByKind.prop;
+    const synthesizedDefaults = Number(defaultSummary["default_states_synthesized"] ?? 0);
+    return {
+        version: 1,
+        format: "state-curation-exp-v1",
+        summary: {
+            states_before: statesBefore,
+            states_after: statesAfter,
+            states_removed: statesBefore - statesAfter + synthesizedDefaults,
+            actor_states_before: beforeByKind.actor,
+            actor_states_after: afterByKind.actor,
+            location_states_before: beforeByKind.location,
+            location_states_after: afterByKind.location,
+            prop_states_before: beforeByKind.prop,
+            prop_states_after: afterByKind.prop,
+            decisions: decisionSummary,
+            ...rewriteSummary,
+            default_states_synthesized: synthesizedDefaults,
+            default_state_ids_rewritten: defaultSummary["default_state_ids_rewritten"],
+            default_ref_rewrite: defaultSummary["default_ref_rewrite"],
+        },
+        decisions,
+        default_selections: defaultSelections,
+        selected_default_states: defaultSummary["selected_default_states"],
+    };
+}
+// ---------------------------------------------------------------------------
 // State binding
 // ---------------------------------------------------------------------------
 function stateBindingBlocked(message, received) {
@@ -6223,29 +7330,35 @@ function stateNameById(asset, stateId) {
 }
 function bindableDefaultStateId(asset) {
     const states = asList(asset["states"]);
-    if (states.length === 0)
-        return "";
-    const defaultState = states.find((state) => strOf(state["state_name"]).trim() === "默认");
+    const defaultState = states.find((state) => strOf(state["state_id"]).trim() === "default");
     if (defaultState)
         return strOf(defaultState["state_id"]);
-    if (states.length === 1)
-        return strOf(states[0]["state_id"]);
     return "";
 }
 export function ensureDefaultStates(script) {
-    let added = 0;
+    let synthesized = 0;
+    let missing = 0;
     for (const kind of ["actor", "location", "prop"]) {
         for (const asset of asList(script[assetListKey(kind)])) {
-            const states = asList(asset["states"]);
-            if (states.length <= 1)
-                continue;
-            if (states.some((state) => strOf(state["state_name"]).trim() === "默认"))
+            if (!isDict(asset))
                 continue;
-            appendState(asset, script, "默认", asset["description"]);
-            added += 1;
+            const states = asList(asset["states"]).filter(isDict);
+            const defaults = states.filter((state) => strOf(state["state_id"]).trim() === "default");
+            if (states.length === 0) {
+                asset["states"] = [synthesizedDefaultState(asset)];
+                synthesized += 1;
+            }
+            else if (defaults.length === 0) {
+                missing += 1;
+            }
+            else if (defaults.length > 1) {
+                stateBindingBlocked("Asset has more than one `default` state.", [
+                    `${kind}:${strOf(asset[assetIdKey(kind)])}`,
+                ]);
+            }
         }
     }
-    return { default_states_added: added };
+    return { default_states_synthesized: synthesized, assets_missing_default_state: missing };
 }
 export function bindDefaultStateRefsInScript(script) {
     const assetMaps = {
@@ -6280,7 +7393,7 @@ export function bindDefaultStateRefsInScript(script) {
             setSceneContext(scene, ctx);
         }
     }
-    return { default_or_unique_refs_bound: bound, unresolved_stateful_refs: unresolved };
+    return { default_refs_bound: bound, unresolved_stateful_refs: unresolved };
 }
 function compactStateBindingAsset(kind, asset) {
     return {
@@ -6380,7 +7493,8 @@ export function buildStateBindingContexts(script, chunkSize = 10) {
             title: script["title"],
             policy: [
                 "Bind each scene asset ref to the best existing state_id when the actions/context show a durable visual state.",
-                "Use null only when no existing state fits and no default/unique state should apply.",
+                "Each asset should already have an asset-scoped state_id `default`; keep current_state_id unless actions prove a non-default state.",
+                "Use null only when no existing state fits and current_state_id is already null.",
                 "Emit state_changes only for explicit transformation, outfit, damage, breakage, repair, or form-change actions.",
                 "Do not invent new states or assets.",
             ],
@@ -6599,18 +7713,27 @@ function splitLocationStatePhrase(rawName) {
         return null;
     return { name: locationName, state };
 }
-function addStateDefinition(stateDefinitions, seen, kind, assetName, stateName, description = null) {
+function addStateDefinition(stateDefinitions, seen, kind, assetName, stateName, description = null, stateReason = "") {
     const state = strOf(stateName).trim();
     if (!assetName || !state || stateRejectionReason(kind, state))
         return;
     const key = `${kind}::${assetName}::${state}`;
-    if (seen.has(key))
+    if (seen.has(key)) {
+        const existing = stateDefinitions.find((item) => item["kind"] === kind && item["asset_name"] === assetName && item["state_name"] === state);
+        if (existing) {
+            const desc = strOf(description).trim();
+            if (desc && !existing["description"])
+                existing["description"] = desc;
+            setStateReason(existing, stateReason);
+        }
         return;
+    }
     seen.add(key);
     const item = { kind, asset_name: assetName, state_name: state };
     const desc = strOf(description).trim();
     if (desc)
         item["description"] = desc;
+    setStateReason(item, stateReason);
     stateDefinitions.push(item);
 }
 function rawStringMap(value) {
@@ -6624,31 +7747,78 @@ function rawStringMap(value) {
     }
     return out;
 }
+const ACTOR_VOICE_SUFFIX_RE = /\s*(?:VO|V\.O\.|OS|O\.S\.|旁白|画外音|内心独白|内心)\s*$/i;
+const LEADING_ACTION_ACTOR_PREFIX_RE = /^\s*([^:：]{1,24})[:：]\s*(\S[\s\S]*)$/;
+function actorVoiceDisplayName(speaker, actorRegistry, report) {
+    const raw = cleanName(speaker);
+    if (!raw || !ACTOR_VOICE_SUFFIX_RE.test(raw))
+        return null;
+    const base = cleanName(raw.replace(ACTOR_VOICE_SUFFIX_RE, ""));
+    if (!base || base === raw)
+        return null;
+    if (inferNonActorSpeakerKind(base) !== "actor")
+        return null;
+    return canonicalAssetDisplay(actorRegistry, base, report);
+}
+function actionPrefixActorDisplayName(prefix, actorRegistry) {
+    const raw = cleanName(prefix);
+    if (!raw)
+        return "";
+    const direct = actorRegistry.displayByKey.get(canonicalAssetNameKey("actor", raw));
+    if (direct)
+        return direct;
+    if (!hasEnumeratedActorName(raw))
+        return "";
+    const base = cleanName(raw.replace(/(?:[甲乙丙丁戊己庚辛壬癸]|[A-Z]|[0-9]+)$/u, ""));
+    if (!base || base === raw)
+        return "";
+    return actorRegistry.displayByKey.get(canonicalAssetNameKey("actor", base)) || "";
+}
 function normalizeSpeakerNameInAction(action, actorRegistry, locationRegistry, propRegistry, report) {
     const item = { ...action };
     const normalizeByKind = (speaker, speakerKind) => {
+        const actorVoice = actorVoiceDisplayName(speaker, actorRegistry, report);
+        if (actorVoice)
+            return { speaker: actorVoice, speaker_kind: "actor" };
         const kind = strOf(speakerKind || "actor").trim() || "actor";
         if (kind === "actor")
-            return canonicalAssetDisplay(actorRegistry, speaker, report);
+            return { speaker: canonicalAssetDisplay(actorRegistry, speaker, report), speaker_kind: "actor" };
         if (kind === "location")
-            return canonicalAssetDisplay(locationRegistry, speaker, report);
+            return { speaker: canonicalAssetDisplay(locationRegistry, speaker, report), speaker_kind: "location" };
         if (kind === "prop")
-            return canonicalAssetDisplay(propRegistry, speaker, report);
-        return cleanName(speaker);
+            return { speaker: canonicalAssetDisplay(propRegistry, speaker, report), speaker_kind: "prop" };
+        return { speaker: cleanName(speaker), speaker_kind: kind };
     };
-    if (item["speaker"])
-        item["speaker"] = normalizeByKind(item["speaker"], item["speaker_kind"]);
+    if (item["speaker"]) {
+        const normalized = normalizeByKind(item["speaker"], item["speaker_kind"]);
+        item["speaker"] = normalized.speaker;
+        if (normalized.speaker_kind === "actor")
+            delete item["speaker_kind"];
+        else
+            item["speaker_kind"] = normalized.speaker_kind;
+    }
     if (isList(item["speakers"])) {
-        item["speakers"] = asList(item["speakers"]).map((speaker) => ({
-            ...speaker,
-            speaker: normalizeByKind(speaker["speaker"], speaker["speaker_kind"]),
-        }));
+        item["speakers"] = asList(item["speakers"]).map((speaker) => {
+            const normalized = normalizeByKind(speaker["speaker"], speaker["speaker_kind"]);
+            return { ...speaker, speaker: normalized.speaker, speaker_kind: normalized.speaker_kind };
+        });
     }
     if (isList(item["lines"])) {
-        item["lines"] = asList(item["lines"]).map((line) => ({
-            ...line,
-            speaker: normalizeByKind(line["speaker"], line["speaker_kind"]),
-        }));
+        item["lines"] = asList(item["lines"]).map((line) => {
+            const normalized = normalizeByKind(line["speaker"], line["speaker_kind"]);
+            return { ...line, speaker: normalized.speaker, speaker_kind: normalized.speaker_kind };
+        });
+    }
+    if (strOf(item["type"]) === "action") {
+        const content = strOf(item["content"]).trim();
+        const prefixed = LEADING_ACTION_ACTOR_PREFIX_RE.exec(content);
+        if (prefixed) {
+            const rawPrefix = cleanName(prefixed[1]);
+            const rest = strOf(prefixed[2]).trim();
+            const actorName = actionPrefixActorDisplayName(rawPrefix, actorRegistry);
+            if (actorName && rest)
+                item["content"] = `${actorName}${rest}`;
+        }
     }
     return item;
 }
@@ -6684,10 +7854,13 @@ function normalizeEpisodeResultsForAssets(results, opts) {
         for (const asset of asList(result["actors"])) {
             if (!isDict(asset))
                 continue;
-            const rawName = cleanName(asset["name"]);
+            const [rawName, stateFromName] = splitEntityState(asset["name"]);
             const name = canonicalAssetDisplay(actorRegistry, rawName, report);
             if (name)
                 normalized["actors"].push({ ...asset, name });
+            if (name && stateFromName) {
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", name, stateFromName, asset["description"]);
+            }
         }
         for (const asset of asList(result["locations"])) {
             if (!isDict(asset))
@@ -6719,7 +7892,11 @@ function normalizeEpisodeResultsForAssets(results, opts) {
             if (!isDict(speaker))
                 continue;
             const sourceKind = strOf(speaker["source_kind"] || "other").trim();
-            if (sourceKind === "prop") {
+            const actorVoice = actorVoiceDisplayName(speaker["name"], actorRegistry, report);
+            if (actorVoice) {
+                normalized["actors"].push({ name: actorVoice });
+            }
+            else if (sourceKind === "prop") {
                 normalized["speakers"].push({
                     ...speaker,
                     name: canonicalAssetDisplay(propRegistry, speaker["name"], report),
@@ -6732,9 +7909,10 @@ function normalizeEpisodeResultsForAssets(results, opts) {
                 });
             }
             else if (sourceKind === "actor") {
+                const [speakerName] = splitEntityState(speaker["name"]);
                 normalized["speakers"].push({
                     ...speaker,
-                    name: canonicalAssetDisplay(actorRegistry, speaker["name"], report),
+                    name: canonicalAssetDisplay(actorRegistry, speakerName, report),
                 });
             }
             else {
@@ -6748,14 +7926,18 @@ function normalizeEpisodeResultsForAssets(results, opts) {
             if (kind !== "actor" && kind !== "location" && kind !== "prop")
                 continue;
             if (kind === "actor") {
-                const assetName = canonicalAssetDisplay(actorRegistry, stateDef["asset_name"], report);
-                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", assetName, stateDef["state_name"], stateDef["description"]);
+                const [assetBaseName, stateFromAssetName] = splitEntityState(stateDef["asset_name"]);
+                const assetName = canonicalAssetDisplay(actorRegistry, assetBaseName, report);
+                if (stateFromAssetName) {
+                    addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", assetName, stateFromAssetName, stateDef["description"], stateDef["state_reason"]);
+                }
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", assetName, stateDef["state_name"], stateDef["description"], stateDef["state_reason"]);
             }
             else if (kind === "location") {
                 const split = splitLocationStatePhrase(stateDef["asset_name"]);
                 const assetName = canonicalAssetDisplay(locationRegistry, split ? split.name : stateDef["asset_name"], report);
                 if (split) {
-                    addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, split.state, stateDef["description"]);
+                    addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, split.state, stateDef["description"], stateDef["state_reason"]);
                     addNormalizationDecision(report, {
                         action: "location_state_from_name",
                         kind: "location",
@@ -6765,11 +7947,11 @@ function normalizeEpisodeResultsForAssets(results, opts) {
                         reason: "地点状态定义的资产名含时间状态，拆成稳定地点 + 状态。",
                     });
                 }
-                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, stateDef["state_name"], stateDef["description"]);
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, stateDef["state_name"], stateDef["description"], stateDef["state_reason"]);
             }
             else {
                 const assetName = canonicalAssetDisplay(propRegistry, stateDef["asset_name"], report);
-                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "prop", assetName, stateDef["state_name"], stateDef["description"]);
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "prop", assetName, stateDef["state_name"], stateDef["description"], stateDef["state_reason"]);
             }
         }
         const scenes = [];
@@ -6813,12 +7995,12 @@ function normalizeEpisodeResultsForAssets(results, opts) {
             const propNames = [];
             const normalizedPropStates = {};
             for (const rawActor of asList(scene["actor_names"])) {
-                const cleanActor = cleanName(rawActor);
+                const [cleanActor, stateFromName] = splitEntityState(rawActor);
                 const actorName = canonicalAssetDisplay(actorRegistry, cleanActor, report);
                 if (!actorName)
                     continue;
                 uniqueAdd(actorNames, actorName);
-                const state = actorStates[cleanActor] || actorStates[actorName] || "";
+                const state = actorStates[cleanActor] || actorStates[actorName] || stateFromName || "";
                 if (!state)
                     continue;
                 normalizedActorStates[actorName] = state;
@@ -7033,6 +8215,12 @@ function mergeEpisodeResultsInternal(results, title, opts = {}) {
     for (const name of speakerOrder) {
         const record = speakerRecords.get(name) ?? { source_kind: "other" };
         let sourceKind = record.source_kind || "other";
+        if ((sourceKind === "system" || sourceKind === "broadcast" || sourceKind === "other") && actorIds.has(name)) {
+            const speakerId = `spk_${actorIds.get(name)}`;
+            speakerIdsByName.set(`${sourceKind}::${name}`, speakerId);
+            speakerIdsByName.set(`${record.source_kind}::${name}`, speakerId);
+            continue;
+        }
         let sourceId = null;
         if (sourceKind === "prop")
             sourceId = propIds.get(name) ?? null;
@@ -7082,6 +8270,9 @@ function mergeEpisodeResultsInternal(results, title, opts = {}) {
             const description = strOf(stateDef["description"]).trim();
             if (description)
                 stateEntry["description"] = description;
+            const stateReason = cleanStateReason(stateDef["state_reason"]);
+            if (stateReason)
+                stateEntry["state_reason"] = stateReason;
             states.push(stateEntry);
         }
         if (states.length > 0)
@@ -7107,6 +8298,9 @@ function mergeEpisodeResultsInternal(results, title, opts = {}) {
             const description = strOf(stateDef["description"]).trim();
             if (description)
                 stateEntry["description"] = description;
+            const stateReason = cleanStateReason(stateDef["state_reason"]);
+            if (stateReason)
+                stateEntry["state_reason"] = stateReason;
             states.push(stateEntry);
         }
         if (states.length > 0)
@@ -7132,6 +8326,9 @@ function mergeEpisodeResultsInternal(results, title, opts = {}) {
             const description = strOf(stateDef["description"]).trim();
             if (description)
                 stateEntry["description"] = description;
+            const stateReason = cleanStateReason(stateDef["state_reason"]);
+            if (stateReason)
+                stateEntry["state_reason"] = stateReason;
             states.push(stateEntry);
         }
         if (states.length > 0)
@@ -7146,6 +8343,8 @@ function mergeEpisodeResultsInternal(results, title, opts = {}) {
         if (speakerKind === "actor" && actorIds.has(speaker))
             return `spk_${actorIds.get(speaker)}`;
         const normKind = _MD_SPEAKER_KIND_NORM[speakerKind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[speakerKind] ?? "other";
+        if ((normKind === "system" || normKind === "broadcast" || normKind === "other") && actorIds.has(speaker))
+            return `spk_${actorIds.get(speaker)}`;
         return speakerIdsByName.get(`${normKind}::${speaker}`) ?? speakerIdsByName.get(`other::${speaker}`) ?? null;
     };
     const stateIdForRef = (kind, assetName, explicitState, unresolved) => {