@lingjingai/scriptctl 0.31.0 → 0.32.0

package/dist/domain/direct-core.js

@@ -1,4 +1,4 @@
-import { ACTION_TYPE_VALUES, CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_PROVIDER_ATTEMPTS, EXIT_NEEDS_AGENT, EXIT_RUNTIME, ROLE_TYPE_VALUES, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, WORLDVIEW_VALUES, fmtId, } from "../common.js";
+import { ACTION_TYPE_VALUES, CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_PROVIDER_ATTEMPTS, EXIT_NEEDS_AGENT, EXIT_RUNTIME, ROLE_TYPE_VALUES, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, SPEAKER_SOURCE_KINDS, WORLDVIEW_VALUES, fmtId, } from "../common.js";
 // ---------------------------------------------------------------------------
 // Regexes & lookup tables (shared with infra/converters.ts via re-export)
 // ---------------------------------------------------------------------------
@@ -2872,161 +2872,2942 @@ export function sceneAssetUsage(script, refKey, idKey) {
     }
     return usage;
 }
-function compactStateNames(asset) {
+function actionPreviewForAsset(script, kind, assetId, limit = 1) {
+    const idKey = assetIdKey(kind);
+    const refKey = assetListKey(kind);
+    const previews = [];
+    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 ctx = sceneContext(scene);
+            const inScene = asList(ctx[refKey]).some((ref) => isDict(ref) && strOf(ref[idKey]) === assetId);
+            if (!inScene)
+                continue;
+            const action = asList(scene["actions"]).map((it) => strOf(it["content"]).trim()).find((it) => it);
+            previews.push(`${episodeId}/${sceneId}: ${action ? action.slice(0, 100) : "(no action)"}`);
+            if (previews.length >= limit)
+                return previews;
+        }
+    }
+    return previews;
+}
+function emptyCurationEvidence() {
+    return {
+        sceneRefs: new Set(),
+        actionRefs: new Set(),
+        speakingScenes: new Set(),
+        dialogueCount: 0,
+        actionMentionCount: 0,
+        speakerIds: new Set(),
+        examples: [],
+        dialogueExamples: [],
+        coActors: new Set(),
+        coLocations: new Set(),
+        coProps: new Set(),
+    };
+}
+function pushLimitedUnique(out, value, limit) {
+    const text = value.trim();
+    if (!text || out.includes(text) || out.length >= limit)
+        return;
+    out.push(text);
+}
+function speakerSourceMap(script) {
+    const out = new Map();
+    for (const speaker of asList(script["speakers"])) {
+        if (!isDict(speaker))
+            continue;
+        const speakerId = strOf(speaker["speaker_id"]);
+        if (speakerId)
+            out.set(speakerId, speaker);
+    }
+    return out;
+}
+function actionSpeakerIds(action) {
+    const ids = [];
+    uniqueAdd(ids, strOf(action["speaker_id"]));
+    for (const speaker of asList(action["speakers"])) {
+        if (isDict(speaker))
+            uniqueAdd(ids, strOf(speaker["speaker_id"]));
+    }
+    for (const line of asList(action["lines"])) {
+        if (isDict(line))
+            uniqueAdd(ids, strOf(line["speaker_id"]));
+    }
+    return ids;
+}
+function assetNameMaps(script) {
+    const maps = {
+        actor: new Map(),
+        location: new Map(),
+        prop: new Map(),
+    };
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const id = strOf(asset[assetIdKey(kind)]);
+            const name = strOf(asset[assetNameKey(kind)]).trim();
+            if (id && name)
+                maps[kind].set(id, name);
+        }
+    }
+    return maps;
+}
+function findMentionedAssetIds(content, names) {
     const out = [];
-    for (const state of asList(asset["states"])) {
-        if (!isDict(state))
+    const text = content.trim();
+    if (!text)
+        return out;
+    for (const [id, name] of names) {
+        if (name.length >= 2 && text.includes(name))
+            out.push(id);
+    }
+    return out;
+}
+function ensureEvidence(map, id) {
+    if (!map.has(id))
+        map.set(id, emptyCurationEvidence());
+    return map.get(id);
+}
+function buildCurationEvidence(script) {
+    const evidence = {
+        actor: new Map(),
+        location: new Map(),
+        prop: new Map(),
+    };
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const id = strOf(asset[assetIdKey(kind)]);
+            if (id)
+                evidence[kind].set(id, emptyCurationEvidence());
+        }
+    }
+    const names = assetNameMaps(script);
+    const speakers = speakerSourceMap(script);
+    for (const speaker of speakers.values()) {
+        if (strOf(speaker["source_kind"]) !== "actor")
             continue;
-        const n = strOf(state["state_name"]).trim();
-        if (n)
-            out.push(n);
+        const actorId = strOf(speaker["source_id"]);
+        const speakerId = strOf(speaker["speaker_id"]);
+        if (actorId && speakerId)
+            ensureEvidence(evidence.actor, actorId).speakerIds.add(speakerId);
+    }
+    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 ? `/${sceneId}` : ""}`;
+            const ctx = sceneContext(scene);
+            const actorIds = asList(ctx["actors"]).map((ref) => strOf(ref["actor_id"])).filter((id) => id);
+            const locationIds = asList(ctx["locations"]).map((ref) => strOf(ref["location_id"])).filter((id) => id);
+            const propIds = asList(ctx["props"]).map((ref) => strOf(ref["prop_id"])).filter((id) => id);
+            for (const actorId of actorIds) {
+                const item = ensureEvidence(evidence.actor, actorId);
+                item.sceneRefs.add(sceneRef);
+                for (const locationId of locationIds) {
+                    const name = names.location.get(locationId);
+                    if (name)
+                        item.coLocations.add(`${locationId}:${name}`);
+                }
+                for (const propId of propIds) {
+                    const name = names.prop.get(propId);
+                    if (name)
+                        item.coProps.add(`${propId}:${name}`);
+                }
+            }
+            for (const locationId of locationIds) {
+                const item = ensureEvidence(evidence.location, locationId);
+                item.sceneRefs.add(sceneRef);
+                for (const otherLocationId of locationIds) {
+                    if (otherLocationId === locationId)
+                        continue;
+                    const name = names.location.get(otherLocationId);
+                    if (name)
+                        item.coLocations.add(`${otherLocationId}:${name}`);
+                }
+                for (const actorId of actorIds) {
+                    const name = names.actor.get(actorId);
+                    if (name)
+                        item.coActors.add(`${actorId}:${name}`);
+                }
+                for (const propId of propIds) {
+                    const name = names.prop.get(propId);
+                    if (name)
+                        item.coProps.add(`${propId}:${name}`);
+                }
+            }
+            for (const propId of propIds) {
+                const item = ensureEvidence(evidence.prop, propId);
+                item.sceneRefs.add(sceneRef);
+                for (const actorId of actorIds) {
+                    const name = names.actor.get(actorId);
+                    if (name)
+                        item.coActors.add(`${actorId}:${name}`);
+                }
+                for (const locationId of locationIds) {
+                    const name = names.location.get(locationId);
+                    if (name)
+                        item.coLocations.add(`${locationId}:${name}`);
+                }
+            }
+            for (let actionIndex = 0; actionIndex < asList(scene["actions"]).length; actionIndex++) {
+                const action = asList(scene["actions"])[actionIndex];
+                if (!isDict(action))
+                    continue;
+                const content = strOf(action["content"]).replace(/\s+/g, " ").trim();
+                const actionRef = `${sceneRef}#${actionIndex}`;
+                const actorId = strOf(action["actor_id"]);
+                if (actorId) {
+                    const item = ensureEvidence(evidence.actor, actorId);
+                    item.actionRefs.add(actionRef);
+                    item.actionMentionCount += 1;
+                    pushLimitedUnique(item.examples, `${actionRef}: ${content.slice(0, 120)}`, 3);
+                }
+                const speakerActorIds = new Set();
+                for (const speakerId of actionSpeakerIds(action)) {
+                    const speaker = speakers.get(speakerId);
+                    if (!speaker || strOf(speaker["source_kind"]) !== "actor")
+                        continue;
+                    const sourceId = strOf(speaker["source_id"]);
+                    if (sourceId)
+                        speakerActorIds.add(sourceId);
+                }
+                for (const sourceId of speakerActorIds) {
+                    const item = ensureEvidence(evidence.actor, sourceId);
+                    item.actionRefs.add(actionRef);
+                    item.speakingScenes.add(sceneRef);
+                    item.dialogueCount += 1;
+                    pushLimitedUnique(item.dialogueExamples, `${actionRef}: ${content.slice(0, 120)}`, 3);
+                }
+                for (const mentionedActorId of findMentionedAssetIds(content, names.actor)) {
+                    const item = ensureEvidence(evidence.actor, mentionedActorId);
+                    item.actionMentionCount += 1;
+                    item.actionRefs.add(actionRef);
+                    pushLimitedUnique(item.examples, `${actionRef}: ${content.slice(0, 120)}`, 3);
+                }
+                for (const mentionedPropId of findMentionedAssetIds(content, names.prop)) {
+                    const item = ensureEvidence(evidence.prop, mentionedPropId);
+                    item.actionRefs.add(actionRef);
+                    pushLimitedUnique(item.examples, `${actionRef}: ${content.slice(0, 120)}`, 3);
+                }
+                for (const mentionedLocationId of findMentionedAssetIds(content, names.location)) {
+                    const item = ensureEvidence(evidence.location, mentionedLocationId);
+                    item.actionRefs.add(actionRef);
+                    pushLimitedUnique(item.examples, `${actionRef}: ${content.slice(0, 120)}`, 3);
+                }
+            }
+        }
+    }
+    return evidence;
+}
+function stateCatalog(asset) {
+    return asList(asset["states"]).map((state) => ({
+        state_id: state["state_id"],
+        state_name: state["state_name"],
+        description: state["description"],
+    }));
+}
+function clusterMembersByAssetId(clusters) {
+    const out = new Map();
+    for (const cluster of clusters) {
+        const members = asList(cluster["members"]).filter(isDict);
+        const names = members.map((member) => strOf(member["name"]).trim()).filter((name) => name);
+        for (const member of members) {
+            const id = strOf(member["id"]);
+            const name = strOf(member["name"]).trim();
+            if (!id)
+                continue;
+            out.set(id, names.filter((candidate) => candidate && candidate !== name).slice(0, 8));
+        }
     }
     return out;
 }
-function compactAssetRefs(refs, idKey, replacements, droppedIds) {
-    const compacted = [];
+function scopeCandidatesForLocation(name, relatedNames, coLocationNames = []) {
+    const scopes = [];
+    const addScope = (value) => {
+        const scope = value.trim();
+        if (scope)
+            uniqueAdd(scopes, scope);
+    };
+    for (const candidate of [name, ...relatedNames]) {
+        const dotIndex = candidate.indexOf("·");
+        if (dotIndex > 0)
+            addScope(candidate.slice(0, dotIndex));
+        const spacedIndex = candidate.indexOf(" ");
+        if (spacedIndex > 0)
+            addScope(candidate.slice(0, spacedIndex));
+    }
+    for (const candidate of coLocationNames) {
+        if (isLikelyScopeMarkerName(candidate))
+            addScope(candidate);
+    }
+    return scopes.slice(0, 4);
+}
+function idNameValuesToNames(values) {
+    const names = [];
+    for (const value of values) {
+        const index = value.indexOf(":");
+        const name = index >= 0 ? value.slice(index + 1).trim() : value.trim();
+        if (name)
+            uniqueAdd(names, name);
+    }
+    return names;
+}
+function idNameValuesToPairs(values) {
+    const pairs = [];
     const seen = new Set();
-    for (const ref of asList(refs)) {
-        if (!isDict(ref))
-            continue;
-        const rawId = strOf(ref[idKey]);
-        if (!rawId || droppedIds.has(rawId))
+    for (const value of values) {
+        const index = value.indexOf(":");
+        const id = index >= 0 ? value.slice(0, index).trim() : "";
+        const name = index >= 0 ? value.slice(index + 1).trim() : value.trim();
+        if (!id || !name)
             continue;
-        const nextId = replacements.get(rawId) ?? rawId;
-        const stateId = nextId !== rawId ? null : ref["state_id"];
-        const key = `${nextId}::${strOf(stateId)}`;
+        const key = `${id}:${name}`;
         if (seen.has(key))
             continue;
         seen.add(key);
-        compacted.push({ [idKey]: nextId, state_id: stateId });
+        pairs.push({ id, name });
     }
-    return compacted;
+    return pairs;
 }
-function addLocationAlias(target, aliasRaw) {
-    const alias = cleanName(aliasRaw);
-    const targetName = strOf(target["location_name"]).trim();
-    if (!alias || alias === targetName)
-        return;
-    if (!isList(target["aliases"]))
-        target["aliases"] = [];
-    uniqueAdd(target["aliases"], alias);
+function isLikelyScopeMarkerName(nameRaw) {
+    const name = cleanName(nameRaw);
+    return /(?:世界|领域|国度|界域|时空|宇宙|位面)$/.test(name) || /(?:仙界|神界|魔界|妖界|人间|凡间|地府)$/.test(name);
 }
-export function applyLocationMerges(script, replacements) {
-    if (replacements.size === 0)
+function hasScopedLocationCue(name, coLocationNames) {
+    if (!name || name.includes("·"))
+        return false;
+    return coLocationNames.some((candidate) => isLikelyScopeMarkerName(candidate));
+}
+function stripLocationScope(nameRaw) {
+    const name = cleanName(nameRaw);
+    const dotIndex = name.indexOf("·");
+    if (dotIndex > 0 && dotIndex < name.length - 1) {
+        return { scope: name.slice(0, dotIndex), base: name.slice(dotIndex + 1) };
+    }
+    return { scope: "", base: name };
+}
+function locationParentCandidates(script, sourceId, sourceNameRaw) {
+    const source = stripLocationScope(sourceNameRaw);
+    if (!source.base)
+        return [];
+    const out = [];
+    for (const loc of asList(script["locations"])) {
+        if (!isDict(loc))
+            continue;
+        const id = strOf(loc["location_id"]);
+        const rawName = strOf(loc["location_name"]);
+        if (!id || id === sourceId)
+            continue;
+        const candidate = stripLocationScope(rawName);
+        if (!candidate.base || candidate.base === source.base)
+            continue;
+        const sameScope = !source.scope || !candidate.scope || source.scope === candidate.scope;
+        if (!sameScope)
+            continue;
+        const childContainsParent = source.base.length > candidate.base.length + 1 && source.base.includes(candidate.base);
+        const parentContainsChild = candidate.base.length > source.base.length + 1 && candidate.base.includes(source.base);
+        if (childContainsParent || parentContainsChild)
+            uniqueAdd(out, `${id}:${rawName}`);
+        if (out.length >= 6)
+            break;
+    }
+    return out;
+}
+function locationGranularityHint(nameRaw, parentCandidates) {
+    const { scope, base } = stripLocationScope(nameRaw);
+    if (isLikelyScopeMarkerName(base))
+        return "scope_marker";
+    if (scope && base)
+        return "scoped_set";
+    if (parentCandidates.length === 0)
+        return "";
+    if (/(?:门口|门外|门内|门前|门后|入口|出口|走廊|过道|附近|旁边|角落|边缘|上空|空中|屋顶|天台)$/.test(base)) {
+        return "micro_or_transition_space";
+    }
+    return "parent_child_candidate";
+}
+function scopedLocationRenameSuggestions(nameRaw, coLocationNames) {
+    const { base } = stripLocationScope(nameRaw);
+    if (!base)
+        return [];
+    const out = [];
+    for (const candidate of coLocationNames) {
+        if (!isLikelyScopeMarkerName(candidate))
+            continue;
+        uniqueAdd(out, `${candidate}·${base}`);
+        if (out.length >= 4)
+            break;
+    }
+    return out;
+}
+const ACTOR_FORM_MARKERS = [
+    "Q版",
+    "幻影",
+    "兽形",
+    "本体",
+    "真身",
+    "本尊",
+    "伪装",
+    "人形",
+    "神兽",
+    "分身",
+    "影子",
+    "幼年",
+    "老年",
+    "黑化",
+    "魔化",
+    "觉醒",
+];
+function actorFormMarker(nameRaw) {
+    const name = cleanName(nameRaw);
+    for (const marker of ACTOR_FORM_MARKERS) {
+        if (name.includes(marker))
+            return marker;
+    }
+    return "";
+}
+function compactEvidenceText(asset, evidence) {
+    const parts = [
+        strOf(asset["description"]),
+        ...asList(asset["aliases"]).map((alias) => strOf(alias)),
+        ...asList(asset["states"]).flatMap((state) => [strOf(state["state_name"]), strOf(state["description"])]),
+        ...evidence.examples,
+        ...evidence.dialogueExamples,
+    ];
+    return parts.join(" ");
+}
+function actorIdentityCandidates(script, sourceId, sourceNameRaw, evidence) {
+    const sourceName = cleanName(sourceNameRaw);
+    if (!sourceId || !sourceName)
+        return [];
+    const sourceAsset = assetMapById(script, "actor").get(sourceId) ?? {};
+    const evidenceText = compactEvidenceText(sourceAsset, evidence);
+    const marker = actorFormMarker(sourceName);
+    const out = [];
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const id = strOf(actor["actor_id"]);
+        const name = cleanName(strOf(actor["actor_name"]));
+        if (!id || id === sourceId || !name)
+            continue;
+        const candidateMarker = actorFormMarker(name);
+        const sourceWrapsCandidate = sourceName !== name && sourceName.includes(name) && (marker || sourceName.length > name.length + 1);
+        const candidateWrapsSource = sourceName !== name && name.includes(sourceName) && (candidateMarker || name.length > sourceName.length + 1);
+        const textMentionsCandidate = name.length >= 2 && evidenceText.includes(name);
+        const nicknameCandidate = sourceName.length === 2 &&
+            /^(?:小|老|阿)/.test(sourceName) &&
+            name.length >= 2 &&
+            name.includes(sourceName.slice(1));
+        if (sourceWrapsCandidate)
+            uniqueAdd(out, `${id}:${name}:form_base`);
+        else if (candidateWrapsSource)
+            uniqueAdd(out, `${id}:${name}:form_variant`);
+        else if (textMentionsCandidate)
+            uniqueAdd(out, `${id}:${name}:mentioned_in_evidence`);
+        else if (nicknameCandidate)
+            uniqueAdd(out, `${id}:${name}:nickname_candidate`);
+        if (out.length >= 6)
+            break;
+    }
+    return out;
+}
+function propContinuityHints(asset, evidence) {
+    const hints = [];
+    if (asList(asset["states"]).length > 0)
+        uniqueAdd(hints, "stateful");
+    if (evidence.sceneRefs.size >= 2)
+        uniqueAdd(hints, "multi_scene");
+    if (evidence.actionRefs.size >= 2)
+        uniqueAdd(hints, "action_referenced");
+    if (propHasSingleOwnerActor(evidence))
+        uniqueAdd(hints, "single_owner_actor");
+    if (evidence.sceneRefs.size <= 1 && evidence.actionRefs.size <= 1 && asList(asset["states"]).length === 0)
+        uniqueAdd(hints, "low_continuity");
+    return hints;
+}
+function propBoundaryHint(asset, evidence) {
+    if (asList(asset["states"]).length > 0)
+        return "hero_candidate_stateful";
+    if (evidence.sceneRefs.size >= 3 || evidence.actionRefs.size >= 4)
+        return "hero_candidate_recurring";
+    if (evidence.sceneRefs.size >= 2 && evidence.actionRefs.size >= 2)
+        return "possible_continuity_prop";
+    if (propHasSingleOwnerActor(evidence))
+        return "actor_bound_review";
+    return "minor_or_context_only";
+}
+function curationDecisionRequirement(kind, sceneCount, relatedNames, name, coLocationNames, extraSignals = []) {
+    if (kind === "prop")
+        return "prop_exhaustive";
+    if (kind === "actor" && sceneCount <= 1)
+        return "low_frequency_actor";
+    if (kind === "actor" && extraSignals.length > 0)
+        return "actor_identity_or_form_candidate";
+    if (kind === "location" && hasScopedLocationCue(name, coLocationNames))
+        return "scoped_location";
+    if (kind === "location" && extraSignals.length > 0)
+        return "location_granularity_review";
+    if (kind === "location" && relatedNames.length > 0)
+        return "clustered_location";
+    return "";
+}
+function compactSet(values, limit) {
+    return [...values].filter((value) => value).slice(0, limit);
+}
+function singleIdNameValue(values) {
+    const items = [...values].filter((value) => value.trim());
+    return items.length === 1 ? items[0] : "";
+}
+function compactAssetForCuration(script, kind, asset, usage, evidenceByKind, relatedById, crossKindNames) {
+    const id = strOf(asset[assetIdKey(kind)]);
+    const itemUsage = usage.get(id) ?? { episodes: new Set(), scenes: new Set() };
+    const evidence = evidenceByKind[kind].get(id) ?? emptyCurationEvidence();
+    const relatedNames = relatedById.get(id) ?? [];
+    const name = strOf(asset[assetNameKey(kind)]).trim();
+    const coLocationNames = kind === "location" ? idNameValuesToNames(evidence.coLocations) : [];
+    const actorIdentity = kind === "actor" ? actorIdentityCandidates(script, id, name, evidence) : [];
+    const locationParents = kind === "location" ? locationParentCandidates(script, id, name) : [];
+    const sceneCount = sceneCountFromUsage(itemUsage);
+    return {
+        kind,
+        id,
+        name: asset[assetNameKey(kind)],
+        aliases: asset["aliases"],
+        description: asset["description"],
+        states: stateCatalog(asset),
+        scene_count: sceneCount,
+        episode_count: itemUsage.episodes.size,
+        state_count: stateCatalog(asset).length,
+        dialogue_count: evidence.dialogueCount,
+        speaking_scene_count: evidence.speakingScenes.size,
+        action_mention_count: evidence.actionMentionCount,
+        action_ref_count: evidence.actionRefs.size,
+        speaker_ids: compactSet(evidence.speakerIds, 6),
+        scene_refs: compactSet(evidence.sceneRefs, 8),
+        related_names: relatedNames,
+        related_assets: kind === "location" ? locationParents : [],
+        identity_candidates: actorIdentity,
+        form_marker: kind === "actor" ? actorFormMarker(name) : "",
+        scope_candidates: kind === "location" ? scopeCandidatesForLocation(name, relatedNames, coLocationNames) : [],
+        scope_rename_suggestions: kind === "location" ? scopedLocationRenameSuggestions(name, coLocationNames) : [],
+        parent_locations: locationParents,
+        granularity_hint: kind === "location" ? locationGranularityHint(name, locationParents) : "",
+        cross_kind_same_names: crossKindNames.get(`${kind}:${id}`) ?? [],
+        co_actors: compactSet(evidence.coActors, 5),
+        owner_actor: kind === "prop" ? singleIdNameValue(evidence.coActors) : "",
+        co_locations: compactSet(evidence.coLocations, 5),
+        co_props: compactSet(evidence.coProps, 5),
+        continuity_hints: kind === "prop" ? propContinuityHints(asset, evidence) : [],
+        prop_boundary_hint: kind === "prop" ? propBoundaryHint(asset, evidence) : "",
+        decision_required: curationDecisionRequirement(kind, sceneCount, relatedNames, name, coLocationNames, kind === "actor" ? actorIdentity : locationParents),
+        examples: actionPreviewForAsset(script, kind, id),
+        action_examples: evidence.examples,
+        dialogue_examples: evidence.dialogueExamples,
+    };
+}
+function similarAssetClusters(script, kind) {
+    const items = asList(script[assetListKey(kind)]).filter(isDict);
+    const clusters = [];
+    for (let i = 0; i < items.length; i++) {
+        const left = items[i];
+        const leftName = strOf(left[assetNameKey(kind)]);
+        const leftKey = canonicalAssetNameKey(kind, leftName).split("::")[1] ?? "";
+        const members = [{ id: left[assetIdKey(kind)], name: leftName }];
+        for (let j = i + 1; j < items.length; j++) {
+            const right = items[j];
+            const rightName = strOf(right[assetNameKey(kind)]);
+            const rightKey = canonicalAssetNameKey(kind, rightName).split("::")[1] ?? "";
+            if (!leftKey || !rightKey)
+                continue;
+            if (leftKey.includes(rightKey) || rightKey.includes(leftKey)) {
+                members.push({ id: right[assetIdKey(kind)], name: rightName });
+            }
+        }
+        if (members.length > 1)
+            clusters.push({ kind, members });
+        if (clusters.length >= 80)
+            break;
+    }
+    return clusters;
+}
+function crossKindNameHints(script) {
+    const byName = new Map();
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const id = strOf(asset[assetIdKey(kind)]);
+            const name = strOf(asset[assetNameKey(kind)]).trim();
+            if (!id || !name)
+                continue;
+            const key = canonicalAssetNameKey(kind, name).split("::")[1] ?? name;
+            const item = `${kind}:${id}:${name}`;
+            const list = byName.get(key) ?? [];
+            list.push(item);
+            byName.set(key, list);
+        }
+    }
+    const out = new Map();
+    for (const list of byName.values()) {
+        if (list.length < 2)
+            continue;
+        for (const item of list) {
+            const [kind, id] = item.split(":");
+            if (!kind || !id)
+                continue;
+            out.set(`${kind}:${id}`, list.filter((candidate) => candidate !== item).slice(0, 6));
+        }
+    }
+    return out;
+}
+function normalizeAssetKindSelection(kinds) {
+    if (!kinds || kinds.length === 0)
+        return ["actor", "location", "prop"];
+    const out = [];
+    for (const kind of kinds) {
+        if (out.includes(kind))
+            continue;
+        out.push(kind);
+    }
+    return out;
+}
+function selectedAssetSections(kinds) {
+    const sections = [];
+    if (kinds.includes("actor"))
+        sections.push(["actors", "actor"]);
+    if (kinds.includes("location"))
+        sections.push(["locations", "location"]);
+    if (kinds.includes("prop"))
+        sections.push(["props", "prop"]);
+    return sections;
+}
+export const ASSET_GROUP_MAX_ITEMS = 8;
+export const ASSET_GROUP_MAX_CONTEXT_CHARS = 22000;
+function selectedAssetIds(selection, kind) {
+    const ids = selection?.[kind];
+    if (!ids || ids.length === 0)
+        return null;
+    return new Set(ids);
+}
+function filterAssetsForCuration(script, kind, selection) {
+    const ids = selectedAssetIds(selection, kind);
+    const idKey = assetIdKey(kind);
+    return asList(script[assetListKey(kind)])
+        .filter(isDict)
+        .filter((asset) => !ids || ids.has(strOf(asset[idKey])));
+}
+export function buildAssetCurationContext(script, kinds, selection) {
+    const selectedKinds = normalizeAssetKindSelection(kinds);
+    const actorUsage = sceneAssetUsage(script, "actors", "actor_id");
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    const propUsage = sceneAssetUsage(script, "props", "prop_id");
+    const evidence = buildCurationEvidence(script);
+    const clusters = selectedKinds.flatMap((kind) => similarAssetClusters(script, kind));
+    const relatedById = clusterMembersByAssetId(clusters);
+    const crossKindNames = crossKindNameHints(script);
+    return {
+        title: script["title"],
+        asset_kinds: selectedKinds,
+        policy: [
+            "Profile: align with a human-refined asset boundary.",
+            "Actors: keep named, speaking, visually identifiable, or plot-functional roles even when low-frequency.",
+            "Actor forms: move Q版/幻影/兽形/本体/真身/伪装 forms into states on the base actor.",
+            "Actor identity hints list possible base actors or aliases; merge/form-state only when evidence supports the same identity.",
+            "Locations: keep distinct production sets; do not blindly merge interiors, doors, rooftops, underground levels, warehouses, fields, pens, or sky/air variants.",
+            "Locations: parent/gran hints mark possible parent-child or micro/transition spaces; merge only non-distinct transitional/angle-only spaces into the parent.",
+            "Location names: prefer world/domain-scoped canonical names when the source distinguishes worlds or realms.",
+            "Location field scopeHint lists world/realm/domain markers co-occurring with an unscoped location; renameHint gives scoped canonical-name suggestions.",
+            "Props: strict refined prop boundary. Most visible or plot-mentioned objects should stay in action text or actor/location state, not standalone props.",
+            `Every KEEP prop reason must start like category=signature_instance; using one of ${propKeepCategoryList()}, followed by evidence.`,
+            "Props: KEEP named/signature physical instances when they have standalone continuity, are exchanged/carried/inspected as the same object, carry readable evidence/rules/secrets, drive transformations/conflicts, or function as recurring character/faction equipment.",
+            "Props: do not KEEP merely because an object is repeated, plot-functional, held, used, UI/display content, ordinary document/bill, food, or set dressing.",
+            "Props: body marks and worn appearance should become actor state; detachable named devices/weapons/tools/accessories with continuity may stay props.",
+            "Prop field cont/boundary gives continuity hints only; the model still decides KEEP/DROP/STATE from the evidence lines.",
+        ],
+        coverage_policy: {
+            props: "every prop line is decision-required",
+            actors: "actors with scene_count <= 1 or identity/form hints are decision-required",
+            locations: "locations with scopeHint, parent/granularity hints, or similar/name clusters are decision-required",
+        },
+        assets: {
+            actors: selectedKinds.includes("actor") ? filterAssetsForCuration(script, "actor", selection).map((asset) => compactAssetForCuration(script, "actor", asset, actorUsage, evidence, relatedById, crossKindNames)) : [],
+            locations: selectedKinds.includes("location") ? filterAssetsForCuration(script, "location", selection).map((asset) => compactAssetForCuration(script, "location", asset, locationUsage, evidence, relatedById, crossKindNames)) : [],
+            props: selectedKinds.includes("prop") ? filterAssetsForCuration(script, "prop", selection).map((asset) => compactAssetForCuration(script, "prop", asset, propUsage, evidence, relatedById, crossKindNames)) : [],
+        },
+        speakers: selectedKinds.includes("actor") ? asList(script["speakers"]).filter(isDict).map((speaker) => ({
+            speaker_id: speaker["speaker_id"],
+            display_name: speaker["display_name"],
+            source_kind: speaker["source_kind"],
+            source_id: speaker["source_id"],
+        })) : [],
+        similar_clusters: clusters,
+    };
+}
+function compactCurationText(value, maxChars = 160) {
+    const text = strOf(value)
+        .replace(/\s+/g, " ")
+        .replace(/\|/g, "/")
+        .trim();
+    return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}
+function assetPrefixForCuration(kind) {
+    if (kind === "actor")
+        return "A";
+    if (kind === "location")
+        return "L";
+    if (kind === "prop")
+        return "P";
+    return "X";
+}
+function formatCurationStates(states) {
+    const items = asList(states)
+        .filter(isDict)
+        .map((state) => {
+        const id = compactCurationText(state["state_id"], 40);
+        const name = compactCurationText(state["state_name"], 80);
+        if (!id || !name)
+            return "";
+        return `${id}:${name}`;
+    })
+        .filter((item) => item);
+    return items.length > 0 ? items.join(",") : "-";
+}
+function formatCurationAliases(aliases) {
+    const items = asList(aliases)
+        .map((item) => compactCurationText(item, 60))
+        .filter((item) => item);
+    return items.length > 0 ? items.join(",") : "-";
+}
+function formatCurationList(value, limit = 6) {
+    const items = asList(value)
+        .map((item) => compactCurationText(item, 70))
+        .filter((item) => item)
+        .slice(0, limit);
+    return items.length > 0 ? items.join(",") : "-";
+}
+function formatCurationAssetLine(asset) {
+    const kind = strOf(asset["kind"]);
+    const id = compactCurationText(asset["id"], 40);
+    const name = compactCurationText(asset["name"], 80);
+    const sceneCount = Number(asset["scene_count"] ?? 0);
+    const episodeCount = Number(asset["episode_count"] ?? 0);
+    const stateCount = Number(asset["state_count"] ?? 0);
+    const requirement = compactCurationText(asset["decision_required"], 80);
+    const required = Boolean(requirement);
+    const parts = [
+        assetPrefixForCuration(kind),
+        id,
+        name,
+        `req=${requirement ? `Y:${requirement}` : "-"}`,
+        `sc=${Number.isFinite(sceneCount) ? sceneCount : 0}`,
+        `ep=${Number.isFinite(episodeCount) ? episodeCount : 0}`,
+        `st=${Number.isFinite(stateCount) ? stateCount : 0}`,
+        `alias=${formatCurationAliases(asset["aliases"])}`,
+        `states=${formatCurationStates(asset["states"])}`,
+    ];
+    if (kind === "actor") {
+        parts.push(`dlg=${Number(asset["dialogue_count"] ?? 0) || 0}`, `sp_sc=${Number(asset["speaking_scene_count"] ?? 0) || 0}`, `mention=${Number(asset["action_mention_count"] ?? 0) || 0}`, `spk=${formatCurationList(asset["speaker_ids"], 5)}`, `form=${compactCurationText(asset["form_marker"], 40) || "-"}`, `identity=${formatCurationList(asset["identity_candidates"], 6)}`);
+    }
+    else if (kind === "location") {
+        parts.push(`scope=${formatCurationList(asset["scope_candidates"], 4)}`, `scopeHint=${formatCurationList(asset["scope_candidates"], 4)}`, `renameHint=${formatCurationList(asset["scope_rename_suggestions"], 4)}`, `parent=${formatCurationList(asset["parent_locations"], 6)}`, `gran=${compactCurationText(asset["granularity_hint"], 60) || "-"}`, `related=${formatCurationList(asset["related_names"], 6)}`, `coL=${formatCurationList(asset["co_locations"], 4)}`, `coA=${formatCurationList(asset["co_actors"], 4)}`, `coP=${formatCurationList(asset["co_props"], 4)}`);
+    }
+    else if (kind === "prop") {
+        parts.push(`actrefs=${Number(asset["action_ref_count"] ?? 0) || 0}`, `cont=${formatCurationList(asset["continuity_hints"], 5)}`, `boundary=${compactCurationText(asset["prop_boundary_hint"], 60) || "-"}`, `same=${formatCurationList(asset["cross_kind_same_names"], 4)}`, `ownerA=${compactCurationText(asset["owner_actor"], 80) || "-"}`, `coA=${formatCurationList(asset["co_actors"], 4)}`, `coL=${formatCurationList(asset["co_locations"], 4)}`);
+    }
+    parts.push(`desc=${compactCurationText(asset["description"], 120) || "-"}`);
+    const line = parts.join(" | ");
+    const lines = [line];
+    const pushExamples = (label, values, limit) => {
+        if (limit <= 0)
+            return;
+        for (const example of asList(values).slice(0, limit)) {
+            const text = compactCurationText(example, 96);
+            if (text)
+                lines.push(`  ${label}=${text}`);
+        }
+    };
+    if (kind === "actor") {
+        pushExamples("dlg_ex", asset["dialogue_examples"], required ? 2 : 0);
+        pushExamples("act_ex", asset["action_examples"], required ? 1 : 0);
+    }
+    else if (kind === "location") {
+        pushExamples("scene_ex", asset["examples"], required ? 1 : 0);
+        pushExamples("act_ex", asset["action_examples"], required ? 1 : 0);
+    }
+    else if (kind === "prop") {
+        pushExamples("act_ex", asset["action_examples"], 1);
+        pushExamples("scene_ex", asset["examples"], 1);
+    }
+    return lines;
+}
+function requiredCurationIds(items) {
+    return items
+        .map((asset) => compactCurationText(asset["decision_required"], 80) ? compactCurationText(asset["id"], 40) : "")
+        .filter((id) => id);
+}
+function pushRequiredCurationIdLines(lines, label, ids) {
+    if (ids.length === 0) {
+        lines.push(`- ${label}: -`);
         return;
-    const locations = asList(script["locations"]);
-    const byId = new Map();
-    for (const loc of locations) {
-        if (isDict(loc))
-            byId.set(strOf(loc["location_id"]), loc);
     }
-    for (const [oldId, targetId] of replacements) {
-        const old = byId.get(oldId);
-        const target = byId.get(targetId);
-        if (!old || !target)
+    const chunkSize = 36;
+    for (let index = 0; index < ids.length; index += chunkSize) {
+        const suffix = index === 0 ? "" : "+";
+        lines.push(`- ${label}${suffix}: ${ids.slice(index, index + chunkSize).join(",")}`);
+    }
+}
+export function formatAssetCurationContextText(context) {
+    const lines = [];
+    lines.push("# Asset Curation Context");
+    lines.push(`title: ${compactCurationText(context["title"], 100) || "-"}`);
+    const kinds = normalizeAssetKindSelection(asList(context["asset_kinds"]));
+    lines.push(`asset_kinds: ${kinds.join(",")}`);
+    lines.push("");
+    lines.push("policy:");
+    for (const item of asList(context["policy"])) {
+        const text = compactCurationText(item, 160);
+        if (text)
+            lines.push(`- ${text}`);
+    }
+    const coveragePolicy = asDict(context["coverage_policy"]);
+    const coverageLines = [
+        compactCurationText(coveragePolicy["props"], 160),
+        compactCurationText(coveragePolicy["actors"], 160),
+        compactCurationText(coveragePolicy["locations"], 160),
+    ].filter((line) => line);
+    if (coverageLines.length > 0) {
+        lines.push("");
+        lines.push("coverage:");
+        for (const line of coverageLines)
+            lines.push(`- ${line}`);
+    }
+    const assets = asDict(context["assets"]);
+    const sections = selectedAssetSections(kinds).map(([key]) => [key, `${key}:`]);
+    lines.push("");
+    lines.push("required_decision_ids:");
+    for (const [key] of sections) {
+        pushRequiredCurationIdLines(lines, key, requiredCurationIds(asList(assets[key]).filter(isDict)));
+    }
+    for (const [key, header] of sections) {
+        lines.push("");
+        lines.push(header);
+        const items = asList(assets[key]).filter(isDict);
+        if (items.length === 0) {
+            lines.push("-");
+            continue;
+        }
+        for (const asset of items)
+            lines.push(...formatCurationAssetLine(asset));
+    }
+    if (kinds.includes("actor")) {
+        lines.push("");
+        lines.push("speakers:");
+        const speakers = asList(context["speakers"]).filter(isDict);
+        if (speakers.length === 0) {
+            lines.push("-");
+        }
+        else {
+            for (const speaker of speakers) {
+                const sourceKind = compactCurationText(speaker["source_kind"], 40) || "-";
+                const sourceId = compactCurationText(speaker["source_id"], 40) || "-";
+                lines.push([
+                    "S",
+                    compactCurationText(speaker["speaker_id"], 50),
+                    compactCurationText(speaker["display_name"], 80),
+                    `${sourceKind}:${sourceId}`,
+                ].join(" | "));
+            }
+        }
+    }
+    lines.push("");
+    lines.push("similar_clusters:");
+    const clusters = asList(context["similar_clusters"]).filter(isDict);
+    if (clusters.length === 0) {
+        lines.push("-");
+    }
+    else {
+        for (const cluster of clusters) {
+            const members = asList(cluster["members"]).filter(isDict).map((member) => {
+                const id = compactCurationText(member["id"], 40);
+                const name = compactCurationText(member["name"], 80);
+                return id && name ? `${id}:${name}` : "";
+            }).filter((member) => member);
+            if (members.length > 0)
+                lines.push(`C ${compactCurationText(cluster["kind"], 20)} | ${members.join(" ~ ")}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function buildAssetCurationContextText(script, kinds, selection) {
+    return formatAssetCurationContextText(buildAssetCurationContext(script, kinds, selection));
+}
+export function buildAssetGroupingContextText(script, kind) {
+    const lines = [];
+    lines.push("# Asset Grouping Context");
+    lines.push(`kind: ${kind}`);
+    lines.push("");
+    lines.push("task:");
+    lines.push("- Group asset ids that should be reviewed together in the later full curation step.");
+    lines.push("- This is not the curation decision step. Do not decide keep/drop/state/rename.");
+    lines.push("- Use names only. Omit an id only when it is an obvious duplicate of a retained id with the same normalized name.");
+    lines.push(`- Each <group> may contain at most ${ASSET_GROUP_MAX_ITEMS} ids.`);
+    lines.push("- Every non-duplicate id must appear exactly once.");
+    lines.push("");
+    lines.push("output:");
+    lines.push(`- One line per group: <group>${kind} <id> [id...] # short reason</group>`);
+    lines.push("- No JSON, markdown tables, headings, or prose outside <group> tags.");
+    lines.push("");
+    lines.push("assets:");
+    const idKey = assetIdKey(kind);
+    const nameKey = assetNameKey(kind);
+    for (const asset of asList(script[assetListKey(kind)])) {
+        if (!isDict(asset))
+            continue;
+        const id = compactCurationText(asset[idKey], 40);
+        const name = compactCurationText(asset[nameKey], 100);
+        if (id && name)
+            lines.push(`${assetPrefixForCuration(kind)} | ${id} | ${name}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function assetIdsForCurationKind(script, kind) {
+    const idKey = assetIdKey(kind);
+    return asList(script[assetListKey(kind)])
+        .filter(isDict)
+        .map((asset) => strOf(asset[idKey]).trim())
+        .filter((id) => id);
+}
+function selectionForCurationIds(kind, ids) {
+    if (kind === "actor")
+        return { actor: ids };
+    if (kind === "location")
+        return { location: ids };
+    return { prop: ids };
+}
+export function buildPrimaryAssetCurationChunks(script, kind, options = { maxItems: ASSET_GROUP_MAX_ITEMS, maxContextChars: ASSET_GROUP_MAX_CONTEXT_CHARS }) {
+    const ids = assetIdsForCurationKind(script, kind);
+    const chunks = [];
+    let current = [];
+    const maxItems = Math.max(1, Math.floor(options.maxItems) || 1);
+    const maxContextChars = Math.max(1000, Math.floor(options.maxContextChars) || 1000);
+    const contextLength = (values) => buildAssetCurationContextText(script, [kind], selectionForCurationIds(kind, values)).length;
+    for (const id of ids) {
+        const next = [...current, id];
+        const tooMany = next.length > maxItems;
+        const tooLong = current.length > 0 && contextLength(next) > maxContextChars;
+        if (tooMany || tooLong) {
+            chunks.push(current);
+            current = [id];
+        }
+        else {
+            current = next;
+        }
+        if (current.length === 1 && contextLength(current) > maxContextChars) {
+            chunks.push(current);
+            current = [];
+        }
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}
+export function extractAssetGroupingExpressions(rawText) {
+    const groups = [];
+    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());
+        lastIndex = match.index + match[0].length;
+    }
+    outside += rawText.slice(lastIndex);
+    if (outside.trim()) {
+        curationBlocked("Asset grouping response must contain only <group>...</group> lines.", [outside.trim().slice(0, 200)]);
+    }
+    if (groups.length === 0) {
+        curationBlocked("Asset grouping response did not contain any <group> expressions.", [rawText.slice(0, 200)]);
+    }
+    return groups;
+}
+function parseAssetGroupingExpression(expression) {
+    const hashIndex = expression.lastIndexOf("#");
+    if (hashIndex < 0)
+        curationBlocked("Asset grouping expression is missing reason.", [expression]);
+    const command = expression.slice(0, hashIndex).trim();
+    const reason = expression.slice(hashIndex + 1).trim();
+    if (!reason)
+        curationBlocked("Asset grouping expression is missing reason.", [expression]);
+    const tokens = command.split(/\s+/).filter((token) => token);
+    const kind = strOf(tokens[0]).toLowerCase();
+    if (kind !== "actor" && kind !== "location" && kind !== "prop") {
+        curationBlocked("Asset grouping expression has unknown kind.", [expression]);
+    }
+    const ids = tokens.slice(1);
+    if (ids.length === 0)
+        curationBlocked("Asset grouping expression needs at least one id.", [expression]);
+    if (ids.length > ASSET_GROUP_MAX_ITEMS) {
+        curationBlocked(`Asset grouping expression exceeds ${ASSET_GROUP_MAX_ITEMS} ids.`, [expression]);
+    }
+    return { kind, ids, reason };
+}
+export function parseAssetGroupingExpressions(rawText) {
+    const expressions = extractAssetGroupingExpressions(rawText);
+    const groups = expressions.map((expression) => parseAssetGroupingExpression(expression));
+    return {
+        version: 1,
+        format: "asset-grouping-v1",
+        expression_text: rawText,
+        expressions,
+        groups,
+    };
+}
+function assetGroupingNameKey(kind, rawName) {
+    return canonicalAssetNameKey(kind, rawName).split("::")[1] ?? cleanName(rawName);
+}
+export function validateAssetGroupingPlan(script, kind, rawPlan) {
+    const inputIds = assetIdsForCurationKind(script, kind);
+    const inputIdSet = new Set(inputIds);
+    const assetsById = assetMapById(script, kind);
+    const groups = [];
+    const mentioned = new Set();
+    const normalizations = [];
+    const invalid = [];
+    for (const group of asList(rawPlan["groups"]).filter(isDict)) {
+        const groupKind = strOf(group["kind"]);
+        if (groupKind !== kind) {
+            invalid.push(`wrong kind ${groupKind || "<empty>"} for ${kind}`);
+            continue;
+        }
+        const rawIds = asList(group["ids"]).map((id) => strOf(id).trim()).filter((id) => id);
+        if (rawIds.length === 0 || rawIds.length > ASSET_GROUP_MAX_ITEMS) {
+            invalid.push(`${kind} group size ${rawIds.length}`);
+            continue;
+        }
+        const ids = [];
+        const seenInGroup = new Set();
+        for (const id of rawIds) {
+            if (!inputIdSet.has(id)) {
+                normalizations.push({ kind, id, action: "drop_unknown_id", reason: "grouping expression referenced an id not present in the asset table" });
+                continue;
+            }
+            if (seenInGroup.has(id) || mentioned.has(id)) {
+                normalizations.push({ kind, id, action: "drop_duplicate_mention", reason: "grouping expression mentioned this id more than once; first mention kept" });
+                continue;
+            }
+            seenInGroup.add(id);
+            mentioned.add(id);
+            ids.push(id);
+        }
+        if (ids.length === 0) {
+            normalizations.push({ kind, action: "drop_empty_group", reason: "all ids in the group were already mentioned or invalid" });
+            continue;
+        }
+        groups.push({ kind, ids, reason: strOf(group["reason"]).trim() || "name-related group" });
+    }
+    if (invalid.length > 0)
+        curationBlocked("Asset grouping plan is invalid.", invalid.slice(0, 40));
+    const retainedByName = new Map();
+    for (const id of mentioned) {
+        const asset = assetsById.get(id);
+        if (!asset)
+            continue;
+        const key = assetGroupingNameKey(kind, asset[assetNameKey(kind)]);
+        if (!key)
+            continue;
+        const list = retainedByName.get(key) ?? [];
+        list.push(id);
+        retainedByName.set(key, list);
+    }
+    const duplicateMerges = [];
+    const omittedInvalid = [];
+    for (const id of inputIds) {
+        if (mentioned.has(id))
+            continue;
+        const asset = assetsById.get(id);
+        if (!asset)
+            continue;
+        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)])}`);
+            continue;
+        }
+        duplicateMerges.push({
+            kind,
+            source_id: id,
+            decision: "merge",
+            target_kind: kind,
+            target_id: targets[0],
+            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",
+        kind,
+        expression_text: rawPlan["expression_text"],
+        expressions: rawPlan["expressions"],
+        groups,
+        duplicate_merge_decisions: duplicateMerges,
+        normalizations,
+        summary: {
+            input_count: inputIds.length,
+            group_count: groups.length,
+            mentioned_count: mentioned.size,
+            omitted_duplicate_count: duplicateMerges.length,
+            normalization_count: normalizations.length,
+        },
+    };
+}
+export function groupedAssetCurationChunks(script, kind, groups, options = { maxItems: ASSET_GROUP_MAX_ITEMS, maxContextChars: ASSET_GROUP_MAX_CONTEXT_CHARS }) {
+    const chunks = [];
+    const seen = new Set();
+    const existing = new Set(assetIdsForCurationKind(script, kind));
+    const pushSplitGroup = (ids) => {
+        let current = [];
+        const maxItems = Math.max(1, Math.floor(options.maxItems) || 1);
+        const maxContextChars = Math.max(1000, Math.floor(options.maxContextChars) || 1000);
+        const contextLength = (values) => buildAssetCurationContextText(script, [kind], selectionForCurationIds(kind, values)).length;
+        for (const id of ids) {
+            const next = [...current, id];
+            if (current.length > 0 && (next.length > maxItems || contextLength(next) > maxContextChars)) {
+                chunks.push(current);
+                current = [id];
+            }
+            else {
+                current = next;
+            }
+            if (current.length === 1 && contextLength(current) > maxContextChars) {
+                chunks.push(current);
+                current = [];
+            }
+        }
+        if (current.length > 0)
+            chunks.push(current);
+    };
+    for (const group of groups) {
+        if (strOf(group["kind"]) !== kind)
+            continue;
+        const ids = asList(group["ids"]).map((id) => strOf(id).trim()).filter((id) => id && existing.has(id) && !seen.has(id));
+        for (const id of ids)
+            seen.add(id);
+        if (ids.length > 0)
+            pushSplitGroup(ids);
+    }
+    const missing = assetIdsForCurationKind(script, kind).filter((id) => !seen.has(id));
+    if (missing.length > 0)
+        pushSplitGroup(missing);
+    return chunks;
+}
+export function buildAssetCurationRepairContextText(opts) {
+    const lines = [];
+    lines.push("# Asset Curation Repair Context");
+    lines.push("");
+    lines.push("Task: repair only the listed broken or missing curation expressions.");
+    lines.push("- Output only <exp>...</exp> lines.");
+    lines.push("- Output expressions only for repair_required_source_keys.");
+    lines.push("- Keep already accepted decisions unless the same source is listed for repair.");
+    lines.push("- Use the same expression grammar and policy as the base context.");
+    lines.push("- If no listed source needs a replacement expression, output exactly <exp>NOOP # no asset curation changes</exp>.");
+    lines.push("");
+    lines.push("repair_required_source_keys:");
+    if (opts.repairSourceKeys.length === 0)
+        lines.push("-");
+    else
+        for (const key of opts.repairSourceKeys)
+            lines.push(`- ${key}`);
+    lines.push("");
+    lines.push("rejected_expressions:");
+    if (opts.rejectedExpressions.length === 0) {
+        lines.push("-");
+    }
+    else {
+        const repairKeys = new Set(opts.repairSourceKeys);
+        for (const item of opts.rejectedExpressions) {
+            const sourceKey = strOf(item["source_key"]);
+            lines.push(`- index=${strOf(item["index"])} source=${sourceKey || "-"} error=${compactCurationText(item["error"], 220)}`);
+            if (sourceKey && repairKeys.has(sourceKey)) {
+                lines.push(`  raw=${compactCurationText(item["raw"], 360)}`);
+            }
+            else {
+                lines.push("  raw=[omitted: invalid output was not tied to one repair source; use repair_required_source_keys and focused context below]");
+            }
+        }
+    }
+    const repairKeys = new Set(opts.repairSourceKeys);
+    const acceptedForSameSource = opts.acceptedDecisions.filter((decision) => repairKeys.has(curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]))));
+    lines.push("");
+    lines.push("accepted_decisions_for_repair_sources:");
+    if (acceptedForSameSource.length === 0) {
+        lines.push("-");
+    }
+    else {
+        for (const decision of acceptedForSameSource)
+            lines.push(`- ${renderAssetCurationDecisionExpression(decision)}`);
+    }
+    lines.push("");
+    lines.push("base_context:");
+    lines.push(opts.baseContextText.trim());
+    return `${lines.join("\n")}\n`;
+}
+function curationCoverageRequirements(script) {
+    const requirements = {
+        actor: new Map(),
+        location: new Map(),
+        prop: new Map(),
+    };
+    const evidence = buildCurationEvidence(script);
+    const actorUsage = sceneAssetUsage(script, "actors", "actor_id");
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const actorId = strOf(actor["actor_id"]);
+        if (!actorId)
+            continue;
+        const actorEvidence = evidence.actor.get(actorId) ?? emptyCurationEvidence();
+        const identityCandidates = actorIdentityCandidates(script, actorId, strOf(actor["actor_name"]), actorEvidence);
+        const sceneCount = sceneCountFromUsage(actorUsage.get(actorId) ?? { episodes: new Set(), scenes: new Set() });
+        const requirement = curationDecisionRequirement("actor", sceneCount, [], strOf(actor["actor_name"]).trim(), [], identityCandidates);
+        if (requirement)
+            requirements.actor.set(actorId, requirement);
+    }
+    for (const prop of asList(script["props"])) {
+        if (!isDict(prop))
+            continue;
+        const propId = strOf(prop["prop_id"]);
+        if (propId)
+            requirements.prop.set(propId, "prop_exhaustive");
+    }
+    const locationRelatedById = clusterMembersByAssetId(similarAssetClusters(script, "location"));
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    for (const location of asList(script["locations"])) {
+        if (!isDict(location))
+            continue;
+        const locationId = strOf(location["location_id"]);
+        if (!locationId)
+            continue;
+        const relatedNames = locationRelatedById.get(locationId) ?? [];
+        const locationEvidence = evidence.location.get(locationId) ?? emptyCurationEvidence();
+        const name = strOf(location["location_name"]).trim();
+        const sceneCount = sceneCountFromUsage(locationUsage.get(locationId) ?? { episodes: new Set(), scenes: new Set() });
+        const parentCandidates = locationParentCandidates(script, locationId, name);
+        const requirement = curationDecisionRequirement("location", sceneCount, relatedNames, name, idNameValuesToNames(locationEvidence.coLocations), parentCandidates);
+        if (requirement)
+            requirements.location.set(locationId, requirement);
+    }
+    return requirements;
+}
+function implicitAuditCandidates(script, decisions) {
+    const requirements = curationCoverageRequirements(script);
+    const decided = curationDecisionSourceSet(decisions);
+    const evidence = buildCurationEvidence(script);
+    const candidates = [];
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const actorId = strOf(actor["actor_id"]);
+        if (!actorId || decided.has(curationSourceKey("actor", actorId)))
+            continue;
+        if (requirements.actor.has(actorId))
+            continue;
+        if (hasEnumeratedActorName(strOf(actor["actor_name"]))) {
+            candidates.push({ kind: "actor", id: actorId, reason: "implicit_keep_enumerated_actor_review" });
+        }
+    }
+    for (const location of asList(script["locations"])) {
+        if (!isDict(location))
+            continue;
+        const locationId = strOf(location["location_id"]);
+        if (!locationId || decided.has(curationSourceKey("location", locationId)))
+            continue;
+        if (requirements.location.has(locationId))
+            continue;
+        const item = evidence.location.get(locationId) ?? emptyCurationEvidence();
+        if (hasScopedLocationCue(strOf(location["location_name"]), idNameValuesToNames(item.coLocations))) {
+            candidates.push({ kind: "location", id: locationId, reason: "implicit_keep_scoped_location_canonical_review" });
+        }
+    }
+    return candidates;
+}
+function curationDecisionSourceSet(decisions) {
+    const out = new Set();
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        const sourceId = strOf(decision["source_id"]);
+        if (kind && sourceId)
+            out.add(curationSourceKey(kind, sourceId));
+    }
+    return out;
+}
+function missingCurationRequirements(script, decisions) {
+    const requirements = curationCoverageRequirements(script);
+    const decided = curationDecisionSourceSet(decisions);
+    const missing = [];
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const [id, reason] of requirements[kind]) {
+            if (!decided.has(curationSourceKey(kind, id)))
+                missing.push({ kind, id, reason });
+        }
+    }
+    return missing;
+}
+export function missingAssetCurationRequiredSourceKeys(script, rawPlan) {
+    return missingCurationRequirements(script, normalizedCurationDecisions(rawPlan))
+        .map((item) => curationSourceKey(item.kind, item.id));
+}
+export function assetCurationAuditCandidateSourceKeys(script, rawPlan) {
+    return implicitAuditCandidates(script, normalizedCurationDecisions(rawPlan))
+        .map((item) => curationSourceKey(item.kind, item.id));
+}
+export function assetCurationAuditSourceKeys(script, rawPlan) {
+    const decisions = normalizedCurationDecisions(rawPlan);
+    normalizeCurationPlanTargets(script, decisions);
+    const evidence = buildCurationEvidence(script);
+    const clusters = [
+        ...similarAssetClusters(script, "actor"),
+        ...similarAssetClusters(script, "location"),
+        ...similarAssetClusters(script, "prop"),
+    ];
+    const relatedById = clusterMembersByAssetId(clusters);
+    const keys = [];
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        if (kind !== "actor" && kind !== "location" && kind !== "prop")
+            continue;
+        const sourceId = strOf(decision["source_id"]);
+        if (!sourceId || !auditCandidateReason(script, decision, evidence, relatedById))
+            continue;
+        uniqueAdd(keys, curationSourceKey(kind, sourceId));
+    }
+    for (const missing of missingCurationRequirements(script, decisions)) {
+        uniqueAdd(keys, curationSourceKey(missing.kind, missing.id));
+    }
+    for (const candidate of implicitAuditCandidates(script, decisions)) {
+        uniqueAdd(keys, curationSourceKey(candidate.kind, candidate.id));
+    }
+    return keys;
+}
+function assertCurationCoverage(script, decisions) {
+    const requirements = curationCoverageRequirements(script);
+    const decided = curationDecisionSourceSet(decisions);
+    const missing = [];
+    const invalidPropKeeps = [];
+    const requiredCounts = {};
+    const missingCounts = {};
+    const propKeepCategories = {};
+    for (const kind of ["actor", "location", "prop"]) {
+        requiredCounts[kind] = requirements[kind].size;
+        missingCounts[kind] = 0;
+        for (const [id, reason] of requirements[kind]) {
+            if (decided.has(curationSourceKey(kind, id)))
+                continue;
+            missingCounts[kind] += 1;
+            missing.push(`${kind}:${id} (${reason})`);
+        }
+    }
+    for (const decision of decisions) {
+        if (strOf(decision["kind"]) !== "prop" || strOf(decision["decision"]) !== "keep")
+            continue;
+        const category = propKeepCategory(decision["reason"]);
+        const sourceId = strOf(decision["source_id"]);
+        if (!category) {
+            invalidPropKeeps.push(`prop:${sourceId || "<empty>"} (${strOf(decision["reason"]).slice(0, 120) || "missing category"})`);
+            continue;
+        }
+        propKeepCategories[category] = (propKeepCategories[category] ?? 0) + 1;
+    }
+    if (missing.length > 0) {
+        curationBlocked("Curation plan is missing required asset decisions.", missing.slice(0, 80));
+    }
+    if (invalidPropKeeps.length > 0) {
+        curationBlocked(`Prop KEEP decisions must include category=<${propKeepCategoryList()}> in the reason.`, invalidPropKeeps.slice(0, 80));
+    }
+    return {
+        required: requiredCounts,
+        missing: missingCounts,
+        prop_keep_categories: propKeepCategories,
+        policy: {
+            props: "exhaustive",
+            actors: "scene_count <= 1",
+            locations: "scoped locations and similar/name cluster members",
+        },
+    };
+}
+function normalizedCurationDecisions(rawPlan) {
+    const payload = isDict(rawPlan) ? rawPlan : {};
+    return dedupeCurationDecisions(asList(payload["decisions"]).filter(isDict).map((item) => normalizeCurationDecision(item)));
+}
+function hasEnumeratedActorName(nameRaw) {
+    const name = cleanName(nameRaw);
+    return name.length > 1 && /(?:[甲乙丙丁戊己庚辛壬癸]|[A-Z]|[0-9]+)$/.test(name);
+}
+const PROP_KEEP_CATEGORIES = new Set([
+    "readable_evidence",
+    "container_device",
+    "transformation_key",
+    "exchanged_object",
+    "signature_instance",
+    "character_bound_core",
+    "signature_weapon",
+    "visual_symbol",
+    "set_device",
+]);
+function propKeepCategory(reasonRaw) {
+    const reason = strOf(reasonRaw);
+    const match = /\bcategory=([a-z_]+)\b/.exec(reason);
+    if (!match)
+        return "";
+    const category = match[1];
+    return PROP_KEEP_CATEGORIES.has(category) ? category : "";
+}
+function propKeepCategoryList() {
+    return [...PROP_KEEP_CATEGORIES].join("|");
+}
+function propHasSingleOwnerActor(item) {
+    return singleIdNameValue(item.coActors) !== "";
+}
+function propHasHeroRescueEvidence(asset, item) {
+    if (propHasSingleOwnerActor(item)) {
+        return asList(asset["states"]).length > 0 || (item.sceneRefs.size >= 2 && item.actionRefs.size >= 2) || item.actionRefs.size >= 4;
+    }
+    return asList(asset["states"]).length > 0 || item.sceneRefs.size >= 3 || (item.sceneRefs.size >= 2 && item.actionRefs.size >= 2);
+}
+function auditCandidateReason(script, decision, evidence, relatedById) {
+    const kind = strOf(decision["kind"]);
+    const sourceId = strOf(decision["source_id"]);
+    const action = strOf(decision["decision"]);
+    if (kind === "actor") {
+        const item = evidence.actor.get(sourceId) ?? emptyCurationEvidence();
+        const asset = assetMapById(script, "actor").get(sourceId);
+        if (action === "drop" || action === "move_to_speaker") {
+            if (item.dialogueCount > 0 || item.speakingScenes.size > 0)
+                return "speaking_actor_removed_or_speaker";
+        }
+        if (action === "keep" && asset) {
+            if (hasEnumeratedActorName(strOf(asset["actor_name"])))
+                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";
+            if (item.sceneRefs.size <= 1 && item.dialogueCount === 0 && item.actionMentionCount === 0)
+                return "kept_low_evidence_actor_review";
+        }
+    }
+    if (kind === "location" && (action === "drop" || action === "merge")) {
+        const asset = assetMapById(script, "location").get(sourceId);
+        if (!asset)
+            return "";
+        const item = evidence.location.get(sourceId) ?? emptyCurationEvidence();
+        if (asList(asset["states"]).length > 0 || item.sceneRefs.size > 1)
+            return "stateful_or_multiscene_location_removed_or_merged";
+    }
+    if (kind === "location" && action === "keep") {
+        const asset = assetMapById(script, "location").get(sourceId);
+        if (!asset)
+            return "";
+        const item = evidence.location.get(sourceId) ?? emptyCurationEvidence();
+        const relatedNames = relatedById.get(sourceId) ?? [];
+        if (hasScopedLocationCue(strOf(asset["location_name"]), idNameValuesToNames(item.coLocations)))
+            return "kept_scoped_location_canonical_review";
+        if (locationParentCandidates(script, sourceId, strOf(asset["location_name"])).length > 0)
+            return "kept_parent_child_location_review";
+        if (relatedNames.length > 0 && item.sceneRefs.size <= 2)
+            return "kept_clustered_location_canonical_review";
+    }
+    if (kind === "prop" && action === "keep") {
+        const item = evidence.prop.get(sourceId) ?? emptyCurationEvidence();
+        if (!propKeepCategory(decision["reason"]))
+            return "kept_prop_missing_keep_category_review";
+        if (propHasSingleOwnerActor(item))
+            return "kept_owner_bound_prop_state_review";
+        return "kept_prop_strict_review";
+    }
+    if (kind === "prop" && (action === "drop" || action === "move_to_state" || action === "merge")) {
+        const asset = assetMapById(script, "prop").get(sourceId);
+        if (!asset)
+            return "";
+        const item = evidence.prop.get(sourceId) ?? emptyCurationEvidence();
+        if (propHasHeroRescueEvidence(asset, item))
+            return "dropped_or_moved_prop_hero_rescue_review";
+    }
+    return "";
+}
+export function buildAssetCurationAuditContextText(script, primaryPlan, selectedSourceKeys) {
+    const decisions = normalizedCurationDecisions(primaryPlan);
+    normalizeCurationPlanTargets(script, decisions);
+    const missingRequired = missingCurationRequirements(script, decisions);
+    const implicitAudit = implicitAuditCandidates(script, decisions);
+    const selected = selectedSourceKeys && selectedSourceKeys.length > 0 ? new Set(selectedSourceKeys) : null;
+    const includeCandidate = (kind, id) => !selected || selected.has(curationSourceKey(kind, id));
+    const evidence = buildCurationEvidence(script);
+    const actorUsage = sceneAssetUsage(script, "actors", "actor_id");
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    const propUsage = sceneAssetUsage(script, "props", "prop_id");
+    const clusters = [
+        ...similarAssetClusters(script, "actor"),
+        ...similarAssetClusters(script, "location"),
+        ...similarAssetClusters(script, "prop"),
+    ];
+    const relatedById = clusterMembersByAssetId(clusters);
+    const crossKindNames = crossKindNameHints(script);
+    const usageByKind = {
+        actor: actorUsage,
+        location: locationUsage,
+        prop: propUsage,
+    };
+    const lines = [];
+    lines.push("# Asset Curation Audit Context");
+    lines.push("mode: audit-overrides-only");
+    lines.push("policy:");
+    lines.push("- Return only <exp>...</exp> lines. The first character of the response must be <.");
+    lines.push("- Do not write headings, bullet explanations, candidate reviews, or prose outside expressions.");
+    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 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.");
+    lines.push(`- Every KEEP prop reason must start like category=signature_instance; using one of ${propKeepCategoryList()}, followed by concrete evidence.`);
+    lines.push("- Review props with a strict refined prop boundary: keep named/signature physical instances with continuity, including readable evidence, devices, transformation keys, exchanged objects, signature weapons/tools, visual symbols, and recurring character-bound core props.");
+    lines.push("- Drop UI, ordinary documents, food, generic set dressing, and context-only objects.");
+    lines.push("- When a prop line has ownerA=actor_id:name, use STATE only for body marks or worn appearance; detachable named devices/weapons/tools/accessories with continuity may remain KEEP.");
+    lines.push("- For STATE/PROP/MERGE targets, use only ids visible in the candidate line/context such as identity=, parent=, same=, coA=, coL=, or cluster ids. If no valid target id is visible, choose DROP instead of guessing.");
+    lines.push("");
+    lines.push("candidates:");
+    let count = 0;
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        if (kind !== "actor" && kind !== "location" && kind !== "prop")
+            continue;
+        const sourceId = strOf(decision["source_id"]);
+        if (!includeCandidate(kind, sourceId))
+            continue;
+        const reason = auditCandidateReason(script, decision, evidence, relatedById);
+        if (!sourceId || !reason)
+            continue;
+        const asset = assetMapById(script, kind).get(sourceId);
+        if (!asset)
+            continue;
+        count += 1;
+        lines.push(`candidate ${count}: primary=${renderAssetCurationDecisionExpression(decision)} | audit_reason=${reason}`);
+        const compact = compactAssetForCuration(script, kind, asset, usageByKind[kind], evidence, relatedById, crossKindNames);
+        for (const line of formatCurationAssetLine(compact))
+            lines.push(`  ${line}`);
+    }
+    for (const missing of missingRequired) {
+        if (!includeCandidate(missing.kind, missing.id))
+            continue;
+        const asset = assetMapById(script, missing.kind).get(missing.id);
+        if (!asset)
+            continue;
+        count += 1;
+        lines.push(`candidate ${count}: primary=MISSING ${missing.kind}:${missing.id} | audit_reason=missing_required_decision:${missing.reason}`);
+        const compact = compactAssetForCuration(script, missing.kind, asset, usageByKind[missing.kind], evidence, relatedById, crossKindNames);
+        for (const line of formatCurationAssetLine(compact))
+            lines.push(`  ${line}`);
+    }
+    for (const candidate of implicitAudit) {
+        if (!includeCandidate(candidate.kind, candidate.id))
+            continue;
+        const asset = assetMapById(script, candidate.kind).get(candidate.id);
+        if (!asset)
+            continue;
+        count += 1;
+        lines.push(`candidate ${count}: primary=IMPLICIT_KEEP ${candidate.kind}:${candidate.id} | audit_reason=${candidate.reason}`);
+        const compact = compactAssetForCuration(script, candidate.kind, asset, usageByKind[candidate.kind], evidence, relatedById, crossKindNames);
+        for (const line of formatCurationAssetLine(compact))
+            lines.push(`  ${line}`);
+    }
+    if (count === 0)
+        lines.push("-");
+    lines.push("");
+    lines.push(`candidate_count: ${count}`);
+    return `${lines.join("\n")}\n`;
+}
+function curationDecisionBySource(decisions) {
+    const out = new Map();
+    for (const decision of decisions) {
+        const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (key)
+            out.set(key, decision);
+    }
+    return out;
+}
+function locationCanonicalizationCandidates(script, decisions) {
+    const evidence = buildCurationEvidence(script);
+    const relatedById = clusterMembersByAssetId(similarAssetClusters(script, "location"));
+    const bySource = curationDecisionBySource(decisions);
+    const out = [];
+    for (const location of asList(script["locations"])) {
+        if (!isDict(location))
+            continue;
+        const id = strOf(location["location_id"]);
+        if (!id)
+            continue;
+        const item = evidence.location.get(id) ?? emptyCurationEvidence();
+        const relatedNames = relatedById.get(id) ?? [];
+        const hasScope = hasScopedLocationCue(strOf(location["location_name"]), idNameValuesToNames(item.coLocations));
+        const hasParentGranularity = locationParentCandidates(script, id, strOf(location["location_name"])).length > 0;
+        const hasCluster = relatedNames.length > 0;
+        if (!hasScope && !hasParentGranularity && !hasCluster)
+            continue;
+        const decision = bySource.get(curationSourceKey("location", id));
+        const reason = hasScope
+            ? "location_scope_canonicalization"
+            : hasParentGranularity
+                ? "location_granularity_canonicalization"
+                : "location_cluster_canonicalization";
+        out.push({
+            id,
+            reason,
+            primary: decision ? renderAssetCurationDecisionExpression(decision) : `IMPLICIT_KEEP location:${id}`,
+        });
+    }
+    return out;
+}
+export function locationCanonicalizationCandidateSourceKeys(script, rawPlan) {
+    const decisions = normalizedCurationDecisions(rawPlan);
+    return locationCanonicalizationCandidates(script, decisions).map((item) => curationSourceKey("location", item.id));
+}
+function locationCanonicalizationCoverage(script, decisions) {
+    const candidates = locationCanonicalizationCandidates(script, decisions);
+    const decided = curationDecisionSourceSet(decisions);
+    const requiredScoped = candidates.filter((candidate) => candidate.reason === "location_scope_canonicalization");
+    const missing = requiredScoped
+        .map((candidate) => curationSourceKey("location", candidate.id))
+        .filter((key) => key && !decided.has(key));
+    if (missing.length > 0) {
+        curationBlocked("Location canonicalization is missing required scoped location coverage.", missing.slice(0, 80));
+    }
+    return {
+        location_canonical_candidates: candidates.length,
+        location_canonical_required_scoped: requiredScoped.length,
+        location_canonical_missing_required_scoped: missing.length,
+    };
+}
+export function buildLocationCanonicalizationAuditContextText(script, rawPlan, selectedSourceKeys) {
+    const decisions = normalizedCurationDecisions(rawPlan);
+    normalizeCurationPlanTargets(script, decisions);
+    const evidence = buildCurationEvidence(script);
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    const clusters = similarAssetClusters(script, "location");
+    const relatedById = clusterMembersByAssetId(clusters);
+    const crossKindNames = crossKindNameHints(script);
+    const selected = selectedSourceKeys && selectedSourceKeys.length > 0 ? new Set(selectedSourceKeys) : null;
+    const candidates = locationCanonicalizationCandidates(script, decisions)
+        .filter((candidate) => !selected || selected.has(curationSourceKey("location", candidate.id)));
+    const lines = [];
+    lines.push("# Location Canonicalization Audit Context");
+    lines.push("mode: location-rename-merge-only");
+    lines.push("policy:");
+    lines.push("- Return only <exp>...</exp> lines. The first character of the response must be <.");
+    lines.push("- Output only RENAME location, MERGE location, or NOOP. Do not output KEEP, DROP, STATE, PROP, SPEAKER, actor, or prop operations.");
+    lines.push("- For unchanged candidates, output nothing. KEEP is invalid in this pass and must not be used to confirm a location.");
+    lines.push("- Audit expressions must reference source ids listed here. Existing primary sources are overridden; primary=IMPLICIT_KEEP sources are added.");
+    lines.push("- Prefer scoped canonical names when a location co-occurs with a world/realm/domain marker and the unscoped name would be ambiguous.");
+    lines.push("- For candidates with scopeHint, prefer RENAME to `<scopeHint>·<name>` unless it should MERGE into an existing scoped duplicate or the name is intentionally cross-scope.");
+    lines.push("- Use RENAME for the same production set whose name lacks useful scope. Use MERGE only for duplicate aliases of the same production set.");
+    lines.push("- For candidates with parent/gran hints, MERGE only when the child is a non-distinct transition, doorway, angle, nearby, or overhead view of the parent; leave distinct shootable sets unchanged.");
+    lines.push("- If no listed candidate needs canonicalization, output exactly <exp>NOOP # no location canonicalization changes</exp>.");
+    lines.push("");
+    lines.push("required_scoped_location_ids:");
+    pushRequiredCurationIdLines(lines, "locations", candidates.filter((candidate) => candidate.reason === "location_scope_canonicalization").map((candidate) => candidate.id));
+    lines.push("");
+    lines.push("candidates:");
+    let count = 0;
+    for (const candidate of candidates) {
+        const asset = assetMapById(script, "location").get(candidate.id);
+        if (!asset)
+            continue;
+        count += 1;
+        lines.push(`candidate ${count}: primary=${candidate.primary} | audit_reason=${candidate.reason}`);
+        const compact = compactAssetForCuration(script, "location", asset, locationUsage, evidence, relatedById, crossKindNames);
+        for (const line of formatCurationAssetLine(compact))
+            lines.push(`  ${line}`);
+    }
+    if (count === 0)
+        lines.push("-");
+    lines.push("");
+    lines.push("similar_location_clusters:");
+    if (clusters.length === 0) {
+        lines.push("-");
+    }
+    else {
+        for (const cluster of clusters) {
+            const members = asList(cluster["members"]).filter(isDict).map((member) => {
+                const id = compactCurationText(member["id"], 40);
+                const name = compactCurationText(member["name"], 80);
+                return id && name ? `${id}:${name}` : "";
+            }).filter((member) => member);
+            if (members.length > 0)
+                lines.push(`C location | ${members.join(" ~ ")}`);
+        }
+    }
+    lines.push("");
+    lines.push(`candidate_count: ${count}`);
+    return `${lines.join("\n")}\n`;
+}
+export function assertLocationCanonicalizationPlan(rawPlan) {
+    const invalid = [];
+    for (const decision of normalizedCurationDecisions(rawPlan)) {
+        const kind = strOf(decision["kind"]);
+        const 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>"}`);
+        }
+    }
+    if (invalid.length > 0) {
+        curationBlocked("Location canonicalization audit may only output location RENAME/MERGE expressions or NOOP.", invalid);
+    }
+}
+export function combineLocationCanonicalizationPlan(script, basePlan, locationPlan, allowedNewLocationSources = []) {
+    assertLocationCanonicalizationPlan(locationPlan);
+    const baseDecisions = asList(basePlan["decisions"]).filter(isDict);
+    const locationDecisions = asList(locationPlan["decisions"]).filter(isDict);
+    const baseKeys = curationDecisionSourceSet(baseDecisions);
+    const allowedNewKeys = new Set(allowedNewLocationSources);
+    let addedLocationDecisions = 0;
+    for (const decision of locationDecisions) {
+        const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (!baseKeys.has(key) && allowedNewKeys.has(key))
+            addedLocationDecisions += 1;
+    }
+    const combined = combineAssetCurationPlans(basePlan, locationPlan, allowedNewLocationSources);
+    const locationCoverage = locationCanonicalizationCoverage(script, normalizedCurationDecisions(combined));
+    const primaryExpressionText = strOf(basePlan["primary_expression_text"]).trim();
+    const auditExpressionText = strOf(basePlan["audit_expression_text"]).trim();
+    const locationExpressionText = strOf(locationPlan["expression_text"]).trim();
+    const expressionTexts = [
+        strOf(basePlan["expression_text"]).trim(),
+        locationExpressionText,
+    ].filter((text) => text);
+    const auditSummary = isDict(basePlan["audit_summary"]) ? { ...basePlan["audit_summary"] } : {};
+    auditSummary["location_canonical_decisions"] = locationDecisions.length;
+    auditSummary["location_canonical_added_decisions"] = addedLocationDecisions;
+    auditSummary["location_canonical_noop"] = locationDecisions.length === 0;
+    Object.assign(auditSummary, locationCoverage);
+    return {
+        ...combined,
+        primary_expression_text: primaryExpressionText || strOf(basePlan["expression_text"]),
+        audit_expression_text: auditExpressionText,
+        location_canonical_expression_text: locationExpressionText,
+        expression_text: expressionTexts.join("\n"),
+        primary_expressions: asList(basePlan["primary_expressions"]),
+        audit_expressions: asList(basePlan["audit_expressions"]),
+        location_canonical_expressions: asList(locationPlan["expressions"]),
+        expressions: [...asList(basePlan["expressions"]), ...asList(locationPlan["expressions"])],
+        audit_summary: auditSummary,
+    };
+}
+function compactStateNames(asset) {
+    const out = [];
+    for (const state of asList(asset["states"])) {
+        if (!isDict(state))
+            continue;
+        const n = strOf(state["state_name"]).trim();
+        if (n)
+            out.push(n);
+    }
+    return out;
+}
+function compactAssetRefs(refs, idKey, replacements, droppedIds) {
+    const compacted = [];
+    const seen = new Set();
+    for (const ref of asList(refs)) {
+        if (!isDict(ref))
+            continue;
+        const rawId = strOf(ref[idKey]);
+        const hasReplacement = replacements.has(rawId);
+        if (!rawId || (!hasReplacement && droppedIds.has(rawId)))
+            continue;
+        const nextId = replacements.get(rawId) ?? rawId;
+        const stateId = nextId !== rawId ? null : ref["state_id"];
+        const key = `${nextId}::${strOf(stateId)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        compacted.push({ [idKey]: nextId, state_id: stateId });
+    }
+    return compacted;
+}
+function assetListKey(kind) {
+    if (kind === "actor")
+        return "actors";
+    if (kind === "location")
+        return "locations";
+    return "props";
+}
+function assetIdKey(kind) {
+    if (kind === "actor")
+        return "actor_id";
+    if (kind === "location")
+        return "location_id";
+    return "prop_id";
+}
+function assetNameKey(kind) {
+    if (kind === "actor")
+        return "actor_name";
+    if (kind === "location")
+        return "location_name";
+    return "prop_name";
+}
+function addAssetAlias(target, kind, aliasRaw) {
+    const alias = cleanName(aliasRaw);
+    const targetName = strOf(target[assetNameKey(kind)]).trim();
+    if (!alias || alias === targetName)
+        return;
+    if (!isList(target["aliases"]))
+        target["aliases"] = [];
+    uniqueAdd(target["aliases"], alias);
+}
+function assetMapById(script, kind) {
+    const out = new Map();
+    for (const item of asList(script[assetListKey(kind)])) {
+        if (!isDict(item))
+            continue;
+        const id = strOf(item[assetIdKey(kind)]).trim();
+        if (id)
+            out.set(id, item);
+    }
+    return out;
+}
+function nextNumericId(existing, prefix) {
+    let max = 0;
+    const re = new RegExp(`^${prefix}_(\\d+)$`);
+    for (const id of existing) {
+        const match = re.exec(id);
+        if (!match)
+            continue;
+        max = Math.max(max, Number(match[1] ?? 0));
+    }
+    return fmtId(prefix, max + 1);
+}
+function nextAssetId(script, kind) {
+    const prefix = kind === "actor" ? "act" : kind === "location" ? "loc" : "prp";
+    return nextNumericId(assetMapById(script, kind).keys(), prefix);
+}
+function nextStateId(script) {
+    const ids = [];
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            for (const state of asList(asset["states"])) {
+                const id = strOf(state["state_id"]).trim();
+                if (id)
+                    ids.push(id);
+            }
+        }
+    }
+    return nextNumericId(ids, "st");
+}
+function appendState(asset, script, stateNameRaw, descriptionRaw = "") {
+    const stateName = strOf(stateNameRaw).trim();
+    if (!stateName) {
+        throw new CliError("DIRECT CURATION BLOCKED: invalid state name", "Invalid state name.", {
+            exitCode: EXIT_NEEDS_AGENT,
+            required: ["non-empty state_name"],
+            received: ["empty state_name"],
+            nextSteps: ["Inspect asset_curation.json and rerun direct init after fixing the provider plan."],
+        });
+    }
+    if (!isList(asset["states"]))
+        asset["states"] = [];
+    for (const state of asList(asset["states"])) {
+        if (strOf(state["state_name"]).trim() === stateName)
+            return strOf(state["state_id"]);
+    }
+    const state = { state_id: nextStateId(script), state_name: stateName };
+    const description = strOf(descriptionRaw).trim();
+    if (description)
+        state["description"] = description;
+    asset["states"].push(state);
+    return strOf(state["state_id"]);
+}
+function speakerIdForActor(actorId) {
+    return `spk_${actorId}`;
+}
+function nextSpeakerId(script, sourceKind) {
+    const prefix = `spk_${sourceKind}`;
+    let max = 0;
+    const re = new RegExp(`^${prefix}_(\\d+)$`);
+    for (const speaker of asList(script["speakers"])) {
+        const id = strOf(speaker["speaker_id"]);
+        const match = re.exec(id);
+        if (!match)
+            continue;
+        max = Math.max(max, Number(match[1] ?? 0));
+    }
+    return `${prefix}_${String(max + 1).padStart(3, "0")}`;
+}
+function addLocationAlias(target, aliasRaw) {
+    const alias = cleanName(aliasRaw);
+    const targetName = strOf(target["location_name"]).trim();
+    if (!alias || alias === targetName)
+        return;
+    if (!isList(target["aliases"]))
+        target["aliases"] = [];
+    uniqueAdd(target["aliases"], alias);
+}
+export function applyLocationMerges(script, replacements) {
+    if (replacements.size === 0)
+        return;
+    const locations = asList(script["locations"]);
+    const byId = new Map();
+    for (const loc of locations) {
+        if (isDict(loc))
+            byId.set(strOf(loc["location_id"]), loc);
+    }
+    for (const [oldId, targetId] of replacements) {
+        const old = byId.get(oldId);
+        const target = byId.get(targetId);
+        if (!old || !target)
+            continue;
+        addLocationAlias(target, strOf(old["location_name"]));
+        for (const alias of asList(old["aliases"])) {
+            addLocationAlias(target, strOf(alias));
+        }
+    }
+    script["locations"] = locations.filter((loc) => isDict(loc) && !replacements.has(strOf(loc["location_id"])));
+}
+function sceneCountFromUsage(usage) {
+    return usage.scenes.size;
+}
+export function actorCurationDecisions(script) {
+    const usage = sceneAssetUsage(script, "actors", "actor_id");
+    const decisions = [];
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const actorId = strOf(actor["actor_id"]);
+        const u = usage.get(actorId) ?? { episodes: new Set(), scenes: new Set() };
+        const sceneCount = sceneCountFromUsage(u);
+        const decision = "keep";
+        const reason = `保留：出现在 ${sceneCount} 个 scene。`;
+        decisions.push({ actor_id: actorId, name: actor["actor_name"], scene_count: sceneCount, decision, reason });
+    }
+    return decisions;
+}
+export function propCurationDecisions(script) {
+    const usage = sceneAssetUsage(script, "props", "prop_id");
+    const decisions = [];
+    for (const prop of asList(script["props"])) {
+        if (!isDict(prop))
+            continue;
+        const propId = strOf(prop["prop_id"]);
+        const u = usage.get(propId) ?? { episodes: new Set(), scenes: new Set() };
+        const sceneCount = sceneCountFromUsage(u);
+        const decision = "keep";
+        const reason = `保留：出现在 ${sceneCount} 个 scene。`;
+        decisions.push({ prop_id: propId, name: prop["prop_name"], scene_count: sceneCount, decision, reason });
+    }
+    return decisions;
+}
+function rewriteStateChanges(changes, locationReplacements, droppedPropIds, droppedActorIds) {
+    const rewritten = [];
+    for (const change of asList(changes)) {
+        if (!isDict(change))
+            continue;
+        const targetKind = strOf(change["target_kind"]);
+        const targetId = strOf(change["target_id"]);
+        if (targetKind === "actor" && droppedActorIds.has(targetId))
+            continue;
+        if (targetKind === "prop" && droppedPropIds.has(targetId))
+            continue;
+        const next = { ...change };
+        if (targetKind === "location" && locationReplacements.has(targetId)) {
+            next["target_id"] = locationReplacements.get(targetId);
+            delete next["from_state_id"];
+            delete next["to_state_id"];
+        }
+        rewritten.push(next);
+    }
+    return rewritten;
+}
+function rewriteTransitionPrompt(transition, locationReplacements, droppedPropIds, droppedActorIds) {
+    if (!isDict(transition))
+        return transition;
+    const targetKind = strOf(transition["target_kind"]);
+    const targetId = strOf(transition["target_id"]);
+    if (targetKind === "actor" && droppedActorIds.has(targetId))
+        return null;
+    if (targetKind === "prop" && droppedPropIds.has(targetId))
+        return null;
+    const next = { ...transition };
+    if (targetKind === "location" && locationReplacements.has(targetId)) {
+        next["target_id"] = locationReplacements.get(targetId);
+    }
+    return next;
+}
+function applyAssetCurationRefs(script, locationReplacements, droppedPropIds, droppedActorIds) {
+    if (locationReplacements.size === 0 && droppedPropIds.size === 0 && droppedActorIds.size === 0)
+        return;
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const ctx = sceneContext(scene);
+            if (locationReplacements.size > 0) {
+                ctx["locations"] = compactAssetRefs(ctx["locations"], "location_id", locationReplacements, new Set());
+            }
+            if (droppedActorIds.size > 0) {
+                ctx["actors"] = compactAssetRefs(ctx["actors"], "actor_id", new Map(), droppedActorIds);
+            }
+            if (droppedPropIds.size > 0) {
+                ctx["props"] = compactAssetRefs(ctx["props"], "prop_id", new Map(), droppedPropIds);
+            }
+            setSceneContext(scene, ctx);
+            for (const action of asList(scene["actions"])) {
+                if (!isDict(action))
+                    continue;
+                if (droppedActorIds.has(strOf(action["actor_id"])))
+                    delete action["actor_id"];
+                if (action["state_changes"] !== undefined && action["state_changes"] !== null) {
+                    action["state_changes"] = rewriteStateChanges(action["state_changes"], locationReplacements, droppedPropIds, droppedActorIds);
+                }
+                if (action["transition_prompt"] !== undefined && action["transition_prompt"] !== null) {
+                    const transition = rewriteTransitionPrompt(action["transition_prompt"], locationReplacements, droppedPropIds, droppedActorIds);
+                    if (transition === null)
+                        delete action["transition_prompt"];
+                    else
+                        action["transition_prompt"] = transition;
+                }
+            }
+        }
+    }
+    for (const speaker of asList(script["speakers"])) {
+        if (!isDict(speaker))
+            continue;
+        const sourceKind = strOf(speaker["source_kind"]);
+        const sourceId = strOf(speaker["source_id"]);
+        if (sourceKind === "actor" && droppedActorIds.has(sourceId)) {
+            speaker["source_kind"] = "other";
+            speaker["source_id"] = null;
+        }
+        else if (sourceKind === "location" && locationReplacements.has(sourceId)) {
+            speaker["source_id"] = locationReplacements.get(sourceId);
+        }
+        else if (sourceKind === "prop" && droppedPropIds.has(sourceId)) {
+            speaker["source_kind"] = "other";
+            speaker["source_id"] = null;
+        }
+    }
+}
+function curationBlocked(message, received) {
+    throw new CliError("DIRECT CURATION BLOCKED: invalid provider plan", message, {
+        exitCode: EXIT_NEEDS_AGENT,
+        required: ["valid asset curation plan referencing existing ids"],
+        received,
+        nextSteps: ["Inspect asset_curation.json, adjust the draft manually, or rerun direct init after provider plan fixes."],
+    });
+}
+function quoteCurationExpressionString(value) {
+    return `"${strOf(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function unquoteCurationExpressionString(value) {
+    let out = "";
+    let escaped = false;
+    for (const ch of value) {
+        if (escaped) {
+            if (ch !== "\\" && ch !== "\"") {
+                curationBlocked("Unsupported escape sequence in curation expression string.", [`\\${ch}`]);
+            }
+            out += ch;
+            escaped = false;
+        }
+        else if (ch === "\\") {
+            escaped = true;
+        }
+        else {
+            out += ch;
+        }
+    }
+    if (escaped)
+        curationBlocked("Unterminated escape sequence in curation expression string.", [value]);
+    return out;
+}
+function splitCurationExpressionReason(expression) {
+    let inQuote = false;
+    let escaped = false;
+    for (let i = 0; i < expression.length; i++) {
+        const ch = expression[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === "\"") {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (ch === "#" && !inQuote) {
+            const command = expression.slice(0, i).trim();
+            const reason = expression.slice(i + 1).trim();
+            if (!command)
+                curationBlocked("Curation expression is missing an operation before # reason.", [expression]);
+            if (!reason)
+                curationBlocked("Curation expression is missing reason text after #.", [expression]);
+            return { command, reason };
+        }
+    }
+    curationBlocked("Curation expression must include `# reason`.", [expression]);
+}
+function parseCurationExpression(expression) {
+    if (expression.includes("\n") || expression.includes("\r")) {
+        curationBlocked("Each curation expression must be a single line.", [expression]);
+    }
+    const { command, reason } = splitCurationExpressionReason(expression.trim());
+    if (/^NOOP$/i.test(command))
+        return null;
+    let match = /^MERGE\s+(actor|location|prop)\s+(\S+)\s+->\s+(\S+)$/i.exec(command);
+    if (match) {
+        const kind = match[1].toLowerCase();
+        return { kind, source_id: match[2], decision: "merge", target_kind: kind, target_id: match[3], reason };
+    }
+    match = /^MERGE\s+(actor|location|prop)\s+(\S+)\s+->\s+(actor|location|prop)\s+(\S+)$/i.exec(command);
+    if (match) {
+        const kind = match[1].toLowerCase();
+        const targetKind = match[3].toLowerCase();
+        if (targetKind === kind) {
+            return { kind, source_id: match[2], decision: "merge", target_kind: kind, target_id: match[4], reason };
+        }
+        if (targetKind === "prop") {
+            return {
+                kind,
+                source_id: match[2],
+                decision: "move_to_prop",
+                target_kind: "prop",
+                target_id: match[4],
+                new_name: "",
+                reason,
+            };
+        }
+        curationBlocked("Cross-kind MERGE is only supported when the target is an existing prop.", [expression]);
+    }
+    match = /^DROP\s+(actor|location|prop)\s+(\S+)$/i.exec(command);
+    if (match)
+        return { kind: match[1].toLowerCase(), source_id: match[2], decision: "drop", reason };
+    match = /^KEEP\s+(actor|location|prop)\s+(\S+)$/i.exec(command);
+    if (match)
+        return { kind: match[1].toLowerCase(), source_id: match[2], decision: "keep", reason };
+    match = /^RENAME\s+(actor|location|prop)\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            source_id: match[2],
+            decision: "rename",
+            new_name: unquoteCurationExpressionString(match[3]),
+            reason,
+        };
+    }
+    match = /^STATE\s+(actor|location|prop)\s+(\S+)\s+->\s+(actor|location|prop)\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            source_id: match[2],
+            decision: "move_to_state",
+            target_kind: match[3].toLowerCase(),
+            target_id: match[4],
+            state_name: unquoteCurationExpressionString(match[5]),
+            reason,
+        };
+    }
+    match = /^SPEAKER\s+(actor|location|prop)\s+(\S+)\s+->\s+(system|broadcast|group|other)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            source_id: match[2],
+            decision: "move_to_speaker",
+            speaker_kind: match[3].toLowerCase(),
+            new_name: unquoteCurationExpressionString(match[4]),
+            reason,
+        };
+    }
+    match = /^SPEAKER\s+(actor|location|prop)\s+(\S+)\s+(system|broadcast|group|other)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            source_id: match[2],
+            decision: "move_to_speaker",
+            speaker_kind: match[3].toLowerCase(),
+            new_name: unquoteCurationExpressionString(match[4]),
+            reason,
+        };
+    }
+    match = /^PROP\s+(actor|location|prop)\s+(\S+)\s+->\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        const target = match[3];
+        const decision = {
+            kind: match[1].toLowerCase(),
+            source_id: match[2],
+            decision: "move_to_prop",
+            target_kind: "prop",
+            new_name: unquoteCurationExpressionString(match[4]),
+            reason,
+        };
+        if (target.toUpperCase() !== "NEW")
+            decision["target_id"] = target;
+        return decision;
+    }
+    curationBlocked("Unknown or malformed curation expression.", [expression]);
+}
+export function extractAssetCurationExpressions(rawText) {
+    const expressions = [];
+    const re = /<exp>([\s\S]*?)<\/exp>/g;
+    let outside = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = re.exec(rawText)) !== null) {
+        outside += rawText.slice(lastIndex, match.index);
+        expressions.push(strOf(match[1]).trim());
+        lastIndex = match.index + match[0].length;
+    }
+    outside += rawText.slice(lastIndex);
+    if (outside.trim()) {
+        curationBlocked("Asset curation response must contain only <exp>...</exp> lines.", [outside.trim().slice(0, 200)]);
+    }
+    if (expressions.length === 0) {
+        curationBlocked("Asset curation response did not contain any <exp> expressions.", [rawText.slice(0, 200)]);
+    }
+    return expressions;
+}
+function curationErrorText(error) {
+    const e = error;
+    return `${e?.name ?? "Error"}: ${e?.message ?? ""}`.trim();
+}
+export function guessAssetCurationExpressionSourceKey(rawExpression) {
+    const match = /^\s*(?:KEEP|MERGE|DROP|RENAME|STATE|SPEAKER|PROP)\s+(actor|location|prop)\s+(\S+)/i.exec(rawExpression);
+    if (!match)
+        return null;
+    const kind = match[1].toLowerCase();
+    const sourceId = strOf(match[2]).trim();
+    return sourceId ? curationSourceKey(kind, sourceId) : null;
+}
+function extractAssetCurationExpressionsTolerant(rawText) {
+    const expressions = [];
+    const rejected = [];
+    const re = /<exp>([\s\S]*?)<\/exp>/g;
+    let outside = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = re.exec(rawText)) !== null) {
+        outside += rawText.slice(lastIndex, match.index);
+        expressions.push({ index: expressions.length, raw: strOf(match[1]).trim() });
+        lastIndex = match.index + match[0].length;
+    }
+    outside += rawText.slice(lastIndex);
+    if (outside.trim()) {
+        rejected.push({
+            index: -1,
+            raw: outside.trim().slice(0, 2000),
+            error: "Asset curation response must contain only <exp>...</exp> lines.",
+            source_key: guessAssetCurationExpressionSourceKey(outside),
+        });
+    }
+    if (expressions.length === 0) {
+        rejected.push({
+            index: -1,
+            raw: rawText.slice(0, 2000),
+            error: "Asset curation response did not contain any <exp> expressions.",
+            source_key: guessAssetCurationExpressionSourceKey(rawText),
+        });
+    }
+    return { expressions, rejected };
+}
+export function parseAssetCurationExpressionsTolerant(rawText) {
+    const extracted = extractAssetCurationExpressionsTolerant(rawText);
+    const decisions = [];
+    const acceptedExpressions = [];
+    const rejected = [...extracted.rejected];
+    const noopIndexes = [];
+    for (const expression of extracted.expressions) {
+        try {
+            const decision = parseCurationExpression(expression.raw);
+            if (decision === null) {
+                noopIndexes.push(expression.index);
+            }
+            else {
+                decisions.push(decision);
+                acceptedExpressions.push(expression.raw);
+            }
+        }
+        catch (error) {
+            rejected.push({
+                index: expression.index,
+                raw: expression.raw,
+                error: curationErrorText(error),
+                source_key: guessAssetCurationExpressionSourceKey(expression.raw),
+            });
+        }
+    }
+    if (noopIndexes.length > 0 && decisions.length > 0) {
+        for (const index of noopIndexes) {
+            const expression = extracted.expressions.find((item) => item.index === index);
+            rejected.push({
+                index,
+                raw: expression?.raw ?? "NOOP",
+                error: "NOOP cannot be combined with actionable curation expressions.",
+                source_key: null,
+            });
+        }
+    }
+    else if (noopIndexes.length > 1) {
+        for (const index of noopIndexes.slice(1)) {
+            const expression = extracted.expressions.find((item) => item.index === index);
+            rejected.push({
+                index,
+                raw: expression?.raw ?? "NOOP",
+                error: "Curation response can contain at most one NOOP expression.",
+                source_key: null,
+            });
+        }
+        acceptedExpressions.push("NOOP # no asset curation changes");
+    }
+    else if (noopIndexes.length === 1) {
+        const expression = extracted.expressions.find((item) => item.index === noopIndexes[0]);
+        acceptedExpressions.push(expression?.raw ?? "NOOP # no asset curation changes");
+    }
+    return {
+        version: 3,
+        format: "asset-curation-exp-v1",
+        expression_text: rawText,
+        expressions: acceptedExpressions.length > 0 ? acceptedExpressions : extracted.expressions.map((item) => item.raw),
+        accepted_expressions: acceptedExpressions,
+        rejected_expressions: rejected,
+        decisions,
+        partial: rejected.length > 0,
+    };
+}
+export function parseAssetCurationExpressions(rawText) {
+    const parsed = parseAssetCurationExpressionsTolerant(rawText);
+    const rejected = asList(parsed["rejected_expressions"]).filter(isDict);
+    if (rejected.length > 0) {
+        const first = rejected[0];
+        curationBlocked(strOf(first["error"]) || "Curation expression parse failed.", [strOf(first["raw"]).slice(0, 200)]);
+    }
+    const expressions = asList(parsed["accepted_expressions"]);
+    const decisions = asList(parsed["decisions"]).filter(isDict);
+    return {
+        version: 3,
+        format: "asset-curation-exp-v1",
+        expression_text: rawText,
+        expressions,
+        decisions,
+    };
+}
+function renderAssetCurationDecisionExpression(decision) {
+    const kind = strOf(decision["kind"]);
+    const sourceId = strOf(decision["source_id"]);
+    const action = strOf(decision["decision"]);
+    const reason = strOf(decision["reason"]).trim() || "curation decision";
+    if (action === "merge")
+        return `MERGE ${kind} ${sourceId} -> ${strOf(decision["target_id"])} # ${reason}`;
+    if (action === "drop")
+        return `DROP ${kind} ${sourceId} # ${reason}`;
+    if (action === "keep")
+        return `KEEP ${kind} ${sourceId} # ${reason}`;
+    if (action === "rename")
+        return `RENAME ${kind} ${sourceId} ${quoteCurationExpressionString(decision["new_name"])} # ${reason}`;
+    if (action === "move_to_state") {
+        return `STATE ${kind} ${sourceId} -> ${strOf(decision["target_kind"])} ${strOf(decision["target_id"])} ${quoteCurationExpressionString(decision["state_name"])} # ${reason}`;
+    }
+    if (action === "move_to_speaker") {
+        return `SPEAKER ${kind} ${sourceId} -> ${strOf(decision["speaker_kind"])} ${quoteCurationExpressionString(decision["new_name"])} # ${reason}`;
+    }
+    if (action === "move_to_prop") {
+        const target = strOf(decision["target_id"]).trim() || "NEW";
+        return `PROP ${kind} ${sourceId} -> ${target} ${quoteCurationExpressionString(decision["new_name"])} # ${reason}`;
+    }
+    curationBlocked("Cannot render unknown curation decision.", [`decision: ${action || "<empty>"}`]);
+}
+export function formatAssetCurationDecisionExpressions(plan) {
+    const decisions = asList(plan["decisions"]).filter(isDict);
+    if (decisions.length === 0)
+        return "<exp>NOOP # no asset curation changes</exp>";
+    return `${decisions.map((decision) => `<exp>${renderAssetCurationDecisionExpression(decision)}</exp>`).join("\n")}\n`;
+}
+export function combineAssetCurationExpressionPlans(plans) {
+    const decisions = plans.flatMap((plan) => asList(plan["decisions"]).filter(isDict));
+    const rawExpressions = plans.flatMap((plan) => asList(plan["expressions"]));
+    const actionableExpressions = rawExpressions.filter((expression) => !/^NOOP(?:\s|#|$)/.test(expression.trim()));
+    const expressions = actionableExpressions.length > 0 ? actionableExpressions : ["NOOP # no asset curation changes"];
+    return {
+        version: 3,
+        format: "asset-curation-exp-v1",
+        expression_text: formatAssetCurationDecisionExpressions({ decisions }),
+        expressions,
+        decisions,
+    };
+}
+export function combinePrimaryAssetCurationPlans(plans) {
+    const combined = combineAssetCurationExpressionPlans(plans);
+    const expressionTextByPlan = plans
+        .map((plan) => strOf(plan["expression_text"]).trim())
+        .filter((text) => text);
+    return {
+        ...combined,
+        primary_parts: plans.map((plan) => ({
+            expression_text: strOf(plan["expression_text"]),
+            expressions: asList(plan["expressions"]),
+            decision_count: asList(plan["decisions"]).filter(isDict).length,
+        })),
+        primary_part_expression_text: expressionTextByPlan.join("\n"),
+    };
+}
+export function combineAssetCurationPlans(primaryPlan, auditPlan, allowedNewAuditSources = []) {
+    const primaryDecisions = asList(primaryPlan["decisions"]).filter(isDict);
+    const auditDecisions = 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 key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (primaryKeys.has(key))
+            continue;
+        if (allowedNewKeys.has(key)) {
+            addedAuditDecisions += 1;
+            continue;
+        }
+        invalidAuditSources.push(key);
+    }
+    if (invalidAuditSources.length > 0) {
+        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"]);
+    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"),
+        primary_expressions: primaryExpressions,
+        audit_expressions: auditExpressions,
+        expressions: [...primaryExpressions, ...auditExpressions],
+        decisions: [...primaryDecisions, ...auditDecisions],
+        audit_summary: {
+            primary_decisions: primaryDecisions.length,
+            audit_decisions: auditDecisions.length,
+            audit_added_decisions: addedAuditDecisions,
+            audit_noop: auditDecisions.length === 0,
+        },
+    };
+}
+function normalizeCurationDecision(item) {
+    const kind = strOf(item["kind"]);
+    const sourceId = strOf(item["source_id"]);
+    const decision = strOf(item["decision"]);
+    const reason = strOf(item["reason"]).trim();
+    if (kind !== "actor" && kind !== "location" && kind !== "prop")
+        curationBlocked("Unknown curation kind.", [`kind: ${kind || "<empty>"}`]);
+    if (!sourceId)
+        curationBlocked("Curation decision is missing source_id.", [`decision: ${decision || "<empty>"}`]);
+    const validDecisions = new Set(["keep", "merge", "drop", "move_to_speaker", "move_to_prop", "move_to_state", "rename"]);
+    if (!validDecisions.has(decision))
+        curationBlocked("Unknown curation decision.", [`decision: ${decision || "<empty>"}`]);
+    if (!reason)
+        curationBlocked("Curation decision is missing reason.", [`${kind}:${sourceId}`]);
+    return {
+        kind,
+        source_id: sourceId,
+        decision,
+        target_id: strOf(item["target_id"]).trim(),
+        target_kind: strOf(item["target_kind"]).trim(),
+        new_name: cleanName(item["new_name"]),
+        speaker_kind: strOf(item["speaker_kind"]).trim(),
+        state_name: strOf(item["state_name"]).trim(),
+        reason,
+    };
+}
+function assertAssetExists(script, kind, id) {
+    const asset = assetMapById(script, kind).get(id);
+    if (!asset)
+        curationBlocked("Curation decision references an unknown asset.", [`${kind}:${id}`]);
+    return asset;
+}
+function assertMergeAcyclic(decisions) {
+    const edges = new Map();
+    for (const decision of decisions) {
+        if (decision["decision"] !== "merge")
+            continue;
+        const kind = strOf(decision["kind"]);
+        const sourceId = strOf(decision["source_id"]);
+        const targetId = strOf(decision["target_id"]);
+        if (sourceId && targetId)
+            edges.set(`${kind}:${sourceId}`, `${kind}:${targetId}`);
+    }
+    for (const start of edges.keys()) {
+        const seen = new Set();
+        let cursor = start;
+        while (edges.has(cursor)) {
+            if (seen.has(cursor))
+                curationBlocked("Curation merge plan contains a cycle.", [`cycle at ${cursor}`]);
+            seen.add(cursor);
+            cursor = edges.get(cursor);
+        }
+    }
+}
+function isAssetKindValue(value) {
+    return value === "actor" || value === "location" || value === "prop";
+}
+function curationSourceKey(kind, sourceId) {
+    return `${kind}:${sourceId}`;
+}
+function buildCurationDecisionIndex(decisions) {
+    const decisionBySource = new Map();
+    const bySource = new Map();
+    for (const decision of decisions) {
+        const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (decisionBySource.has(key))
+            curationBlocked("Curation plan has duplicate decisions for one source asset.", [key]);
+        decisionBySource.set(key, strOf(decision["decision"]));
+        bySource.set(key, decision);
+    }
+    return bySource;
+}
+function dedupeCurationDecisions(decisions) {
+    const lastIndexBySource = new Map();
+    const duplicateCounts = new Map();
+    for (let index = 0; index < decisions.length; index++) {
+        const decision = decisions[index];
+        const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (lastIndexBySource.has(key))
+            duplicateCounts.set(key, (duplicateCounts.get(key) ?? 1) + 1);
+        lastIndexBySource.set(key, index);
+    }
+    const out = [];
+    for (let index = 0; index < decisions.length; index++) {
+        const decision = decisions[index];
+        const key = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (lastIndexBySource.get(key) !== index)
+            continue;
+        if (duplicateCounts.has(key)) {
+            appendCurationNormalizationReason(decision, "deterministic duplicate normalization kept the last decision for this source asset.");
+        }
+        out.push(decision);
+    }
+    return out;
+}
+function mergeTargetKind(decision, fallbackKind) {
+    const raw = strOf(decision["target_kind"]) || fallbackKind;
+    return isAssetKindValue(raw) ? raw : null;
+}
+function chooseCanonicalMergeTarget(script, kind, ids) {
+    const usage = sceneAssetUsage(script, assetListKey(kind), assetIdKey(kind));
+    const byId = assetMapById(script, kind);
+    const sorted = [...ids].sort((left, right) => {
+        const leftUsage = usage.get(left) ?? { episodes: new Set(), scenes: new Set() };
+        const rightUsage = usage.get(right) ?? { episodes: new Set(), scenes: new Set() };
+        const sceneDelta = rightUsage.scenes.size - leftUsage.scenes.size;
+        if (sceneDelta !== 0)
+            return sceneDelta;
+        const episodeDelta = rightUsage.episodes.size - leftUsage.episodes.size;
+        if (episodeDelta !== 0)
+            return episodeDelta;
+        const leftName = strOf(byId.get(left)?.[assetNameKey(kind)]).trim();
+        const rightName = strOf(byId.get(right)?.[assetNameKey(kind)]).trim();
+        const lengthDelta = leftName.length - rightName.length;
+        if (lengthDelta !== 0)
+            return lengthDelta;
+        return left.localeCompare(right);
+    });
+    return sorted[0] ?? ids[0] ?? "";
+}
+function normalizeMergeCycles(script, decisions) {
+    const decisionsBySource = buildCurationDecisionIndex(decisions);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const decision of decisions) {
+            if (decision["decision"] !== "merge")
+                continue;
+            const kindRaw = strOf(decision["kind"]);
+            if (!isAssetKindValue(kindRaw))
+                continue;
+            const path = [];
+            const seenIndex = new Map();
+            let cursor = curationSourceKey(kindRaw, strOf(decision["source_id"]));
+            while (cursor) {
+                if (seenIndex.has(cursor)) {
+                    const cycleKeys = path.slice(seenIndex.get(cursor));
+                    const cycleIds = cycleKeys.map((key) => key.split(":")[1] ?? "").filter((id) => id);
+                    const canonicalId = chooseCanonicalMergeTarget(script, kindRaw, cycleIds);
+                    for (const key of cycleKeys) {
+                        const cycleDecision = decisionsBySource.get(key);
+                        if (!cycleDecision)
+                            continue;
+                        const sourceId = strOf(cycleDecision["source_id"]);
+                        if (sourceId === canonicalId) {
+                            cycleDecision["decision"] = "keep";
+                            cycleDecision["target_id"] = "";
+                            cycleDecision["target_kind"] = "";
+                            cycleDecision["reason"] = `${strOf(cycleDecision["reason"])}；deterministic cycle normalization kept the canonical target.`;
+                            ensureNormalizedPropKeepCategory(cycleDecision, "deterministic merge-cycle canonical prop.");
+                        }
+                        else {
+                            cycleDecision["target_kind"] = kindRaw;
+                            cycleDecision["target_id"] = canonicalId;
+                            cycleDecision["reason"] = `${strOf(cycleDecision["reason"])}；deterministic cycle normalization selected ${kindRaw}:${canonicalId}.`;
+                        }
+                    }
+                    changed = true;
+                    break;
+                }
+                seenIndex.set(cursor, path.length);
+                path.push(cursor);
+                const current = decisionsBySource.get(cursor);
+                if (!current || current["decision"] !== "merge")
+                    break;
+                const targetKind = mergeTargetKind(current, kindRaw);
+                if (targetKind !== kindRaw)
+                    break;
+                const targetId = strOf(current["target_id"]);
+                if (!targetId)
+                    break;
+                cursor = curationSourceKey(kindRaw, targetId);
+            }
+            if (changed)
+                break;
+        }
+    }
+}
+function resolveStableCurationTarget(decisionsBySource, targetKind, targetId, sourceLabel) {
+    let cursor = targetId;
+    const seen = new Set();
+    while (cursor) {
+        const key = curationSourceKey(targetKind, cursor);
+        if (seen.has(key))
+            curationBlocked("Curation merge plan contains a cycle.", [`cycle at ${key}`]);
+        seen.add(key);
+        const targetDecision = decisionsBySource.get(key);
+        if (!targetDecision)
+            return cursor;
+        const action = strOf(targetDecision["decision"]);
+        if (action === "keep" || action === "rename")
+            return cursor;
+        if (isSelfStateDecision(targetDecision))
+            return cursor;
+        if (action !== "merge") {
+            curationBlocked("Curation target is not stable.", [`${sourceLabel} -> ${targetKind}:${targetId} (${action})`]);
+        }
+        const nextKind = strOf(targetDecision["target_kind"]) || targetKind;
+        if (nextKind !== targetKind) {
+            curationBlocked("merge decision target_kind must match source kind.", [`${targetKind}:${cursor} -> ${nextKind}:${targetDecision["target_id"]}`]);
+        }
+        const nextId = strOf(targetDecision["target_id"]);
+        if (!nextId || nextId === cursor) {
+            curationBlocked("merge decision requires a different target_id.", [`${targetKind}:${cursor}`]);
+        }
+        cursor = nextId;
+    }
+    return targetId;
+}
+function isSelfStateDecision(decision) {
+    if (strOf(decision["decision"]) !== "move_to_state")
+        return false;
+    const kind = strOf(decision["kind"]);
+    const sourceId = strOf(decision["source_id"]);
+    const targetKind = strOf(decision["target_kind"]);
+    const targetId = strOf(decision["target_id"]);
+    return kind === targetKind && sourceId === targetId && isAssetKindValue(kind) && sourceId.length > 0;
+}
+function resolveStableCurationStateTarget(decisionsBySource, targetKind, targetId, sourceLabel) {
+    let cursorKind = targetKind;
+    let cursorId = targetId;
+    const seen = new Set();
+    while (cursorId) {
+        const key = curationSourceKey(cursorKind, cursorId);
+        if (seen.has(key))
+            curationBlocked("Curation state target plan contains a cycle.", [`cycle at ${key}`]);
+        seen.add(key);
+        const targetDecision = decisionsBySource.get(key);
+        if (!targetDecision)
+            return { kind: cursorKind, id: cursorId };
+        const action = strOf(targetDecision["decision"]);
+        if (action === "keep" || action === "rename")
+            return { kind: cursorKind, id: cursorId };
+        if (isSelfStateDecision(targetDecision))
+            return { kind: cursorKind, id: cursorId };
+        if (action === "merge") {
+            const nextKind = strOf(targetDecision["target_kind"]) || cursorKind;
+            if (nextKind !== cursorKind) {
+                curationBlocked("merge decision target_kind must match source kind.", [`${cursorKind}:${cursorId} -> ${nextKind}:${targetDecision["target_id"]}`]);
+            }
+            const nextId = strOf(targetDecision["target_id"]);
+            if (!nextId || nextId === cursorId) {
+                curationBlocked("merge decision requires a different target_id.", [`${cursorKind}:${cursorId}`]);
+            }
+            cursorId = nextId;
+            continue;
+        }
+        if (action === "move_to_state") {
+            const nextKind = strOf(targetDecision["target_kind"]);
+            const nextId = strOf(targetDecision["target_id"]);
+            if (!isAssetKindValue(nextKind) || !nextId) {
+                curationBlocked("move_to_state requires target_kind and target_id.", [`${sourceLabel} -> ${nextKind}:${nextId}`]);
+            }
+            if (nextKind === cursorKind && nextId === cursorId) {
+                curationBlocked("move_to_state requires a different target asset.", [`${cursorKind}:${cursorId}`]);
+            }
+            cursorKind = nextKind;
+            cursorId = nextId;
+            continue;
+        }
+        curationBlocked("Curation state target is not stable.", [`${sourceLabel} -> ${cursorKind}:${targetId} (${action})`]);
+    }
+    return { kind: targetKind, id: targetId };
+}
+function appendCurationNormalizationReason(decision, detail) {
+    const reason = strOf(decision["reason"]).trim();
+    decision["reason"] = reason ? `${reason}；${detail}` : detail;
+}
+function ensureNormalizedPropKeepCategory(decision, detail) {
+    if (strOf(decision["kind"]) !== "prop" || strOf(decision["decision"]) !== "keep")
+        return;
+    if (propKeepCategory(decision["reason"]))
+        return;
+    const reason = strOf(decision["reason"]).trim();
+    decision["reason"] = `category=signature_instance; ${detail}${reason ? ` (${reason})` : ""}`;
+}
+function clearCurationTargetFields(decision) {
+    decision["target_id"] = "";
+    decision["target_kind"] = "";
+}
+function normalizeMergeToDownstreamAction(decisionsBySource, decision, targetDecision, sourceLabel) {
+    const downstreamAction = strOf(targetDecision["decision"]);
+    if (downstreamAction === "drop") {
+        decision["decision"] = "drop";
+        clearCurationTargetFields(decision);
+        appendCurationNormalizationReason(decision, "deterministic target normalization: merge target is dropped, so source is dropped too.");
+        return true;
+    }
+    if (downstreamAction === "move_to_speaker") {
+        decision["decision"] = "move_to_speaker";
+        clearCurationTargetFields(decision);
+        decision["speaker_kind"] = targetDecision["speaker_kind"];
+        decision["new_name"] = targetDecision["new_name"];
+        appendCurationNormalizationReason(decision, "deterministic target normalization: merge target moves to speaker, so source follows.");
+        return true;
+    }
+    if (downstreamAction === "move_to_prop") {
+        const targetKind = strOf(targetDecision["target_kind"]) || "prop";
+        if (targetKind !== "prop") {
+            curationBlocked("move_to_prop target_kind must be prop.", [`${sourceLabel} -> ${targetKind}:${targetDecision["target_id"]}`]);
+        }
+        const targetId = strOf(targetDecision["target_id"]);
+        decision["decision"] = "move_to_prop";
+        decision["target_kind"] = "prop";
+        decision["target_id"] = targetId
+            ? resolveStableCurationTarget(decisionsBySource, "prop", targetId, sourceLabel)
+            : "";
+        decision["new_name"] = targetDecision["new_name"];
+        appendCurationNormalizationReason(decision, "deterministic target normalization: merge target moves to prop, so source follows.");
+        return true;
+    }
+    if (downstreamAction === "move_to_state") {
+        const targetKind = strOf(targetDecision["target_kind"]);
+        const targetId = strOf(targetDecision["target_id"]);
+        if (!isAssetKindValue(targetKind) || !targetId) {
+            curationBlocked("move_to_state requires target_kind and target_id.", [`${sourceLabel} -> ${targetKind}:${targetId}`]);
+        }
+        decision["decision"] = "move_to_state";
+        decision["target_kind"] = targetKind;
+        decision["target_id"] = resolveStableCurationTarget(decisionsBySource, targetKind, targetId, sourceLabel);
+        decision["state_name"] = targetDecision["state_name"];
+        decision["new_name"] = targetDecision["new_name"];
+        appendCurationNormalizationReason(decision, "deterministic target normalization: merge target moves to state, so source follows.");
+        return true;
+    }
+    return false;
+}
+function findMergeDownstreamAction(decisionsBySource, targetKind, targetId) {
+    let cursor = targetId;
+    const seen = new Set();
+    while (cursor) {
+        const key = curationSourceKey(targetKind, cursor);
+        if (seen.has(key))
+            curationBlocked("Curation merge plan contains a cycle.", [`cycle at ${key}`]);
+        seen.add(key);
+        const targetDecision = decisionsBySource.get(key);
+        if (!targetDecision)
+            return null;
+        const targetAction = strOf(targetDecision["decision"]);
+        if (targetAction === "keep" || targetAction === "rename")
+            return null;
+        if (isSelfStateDecision(targetDecision))
+            return null;
+        if (targetAction !== "merge")
+            return targetDecision;
+        const nextKind = strOf(targetDecision["target_kind"]) || targetKind;
+        if (nextKind !== targetKind) {
+            curationBlocked("merge decision target_kind must match source kind.", [`${targetKind}:${cursor} -> ${nextKind}:${targetDecision["target_id"]}`]);
+        }
+        const nextId = strOf(targetDecision["target_id"]);
+        if (!nextId || nextId === cursor) {
+            curationBlocked("merge decision requires a different target_id.", [`${targetKind}:${cursor}`]);
+        }
+        cursor = nextId;
+    }
+    return null;
+}
+function normalizeCurationPlanTargets(script, decisions) {
+    normalizeMergeCycles(script, decisions);
+    const decisionsBySource = buildCurationDecisionIndex(decisions);
+    for (const decision of decisions) {
+        const action = strOf(decision["decision"]);
+        if (action !== "merge" && action !== "move_to_state" && action !== "move_to_prop")
+            continue;
+        const targetId = strOf(decision["target_id"]);
+        if (!targetId)
+            continue;
+        const targetKindRaw = strOf(decision["target_kind"]) || (action === "move_to_prop" ? "prop" : strOf(decision["kind"]));
+        if (!isAssetKindValue(targetKindRaw))
+            continue;
+        const sourceLabel = curationSourceKey(strOf(decision["kind"]), strOf(decision["source_id"]));
+        if (action === "merge") {
+            const downstreamAction = findMergeDownstreamAction(decisionsBySource, targetKindRaw, targetId);
+            if (downstreamAction && normalizeMergeToDownstreamAction(decisionsBySource, decision, downstreamAction, sourceLabel)) {
+                continue;
+            }
+        }
+        if (action === "move_to_state") {
+            const resolved = resolveStableCurationStateTarget(decisionsBySource, targetKindRaw, targetId, sourceLabel);
+            if (resolved.kind !== targetKindRaw || resolved.id !== targetId) {
+                appendCurationNormalizationReason(decision, `deterministic state target normalization: target resolved to ${resolved.kind}:${resolved.id}.`);
+            }
+            decision["target_kind"] = resolved.kind;
+            decision["target_id"] = resolved.id;
             continue;
-        addLocationAlias(target, strOf(old["location_name"]));
-        for (const alias of asList(old["aliases"])) {
-            addLocationAlias(target, strOf(alias));
         }
+        const resolvedTargetId = resolveStableCurationTarget(decisionsBySource, targetKindRaw, targetId, sourceLabel);
+        decision["target_kind"] = targetKindRaw;
+        decision["target_id"] = resolvedTargetId;
     }
-    script["locations"] = locations.filter((loc) => isDict(loc) && !replacements.has(strOf(loc["location_id"])));
-}
-function sceneCountFromUsage(usage) {
-    return usage.scenes.size;
 }
-export function actorCurationDecisions(script) {
-    const usage = sceneAssetUsage(script, "actors", "actor_id");
-    const decisions = [];
-    for (const actor of asList(script["actors"])) {
-        if (!isDict(actor))
+function rewriteSpeakerRefs(value, speakerReplacements) {
+    if (!isList(value) || speakerReplacements.size === 0)
+        return value;
+    const out = [];
+    const seen = new Set();
+    for (const item of asList(value)) {
+        if (!isDict(item))
             continue;
-        const actorId = strOf(actor["actor_id"]);
-        const u = usage.get(actorId) ?? { episodes: new Set(), scenes: new Set() };
-        const sceneCount = sceneCountFromUsage(u);
-        const decision = "keep";
-        const reason = `保留：出现在 ${sceneCount} 个 scene。`;
-        decisions.push({ actor_id: actorId, name: actor["actor_name"], scene_count: sceneCount, decision, reason });
+        const raw = strOf(item["speaker_id"]);
+        const speakerId = speakerReplacements.get(raw) ?? raw;
+        if (!speakerId || seen.has(speakerId))
+            continue;
+        seen.add(speakerId);
+        out.push({ ...item, speaker_id: speakerId });
     }
-    return decisions;
+    return out;
 }
-export function propCurationDecisions(script) {
-    const usage = sceneAssetUsage(script, "props", "prop_id");
-    const decisions = [];
-    for (const prop of asList(script["props"])) {
-        if (!isDict(prop))
+function compactRefsWithStateMap(refs, idKey, replacements, droppedIds, stateReplacements) {
+    const compacted = [];
+    const seen = new Set();
+    for (const ref of asList(refs)) {
+        if (!isDict(ref))
             continue;
-        const propId = strOf(prop["prop_id"]);
-        const u = usage.get(propId) ?? { episodes: new Set(), scenes: new Set() };
-        const sceneCount = sceneCountFromUsage(u);
-        const decision = "keep";
-        const reason = `保留：出现在 ${sceneCount} 个 scene。`;
-        decisions.push({ prop_id: propId, name: prop["prop_name"], scene_count: sceneCount, decision, reason });
+        const rawId = strOf(ref[idKey]);
+        const hasReplacement = replacements.has(rawId);
+        if (!rawId || (!hasReplacement && droppedIds.has(rawId)))
+            continue;
+        const nextId = replacements.get(rawId) ?? rawId;
+        const rawState = strOf(ref["state_id"]);
+        const stateId = stateReplacements.get(rawState) ?? (nextId !== rawId ? "" : rawState);
+        const key = `${nextId}::${stateId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        compacted.push({ [idKey]: nextId, state_id: stateId || null });
     }
-    return decisions;
+    return compacted;
 }
-function rewriteStateChanges(changes, locationReplacements, droppedPropIds, droppedActorIds) {
+function rewriteCurationStateChanges(changes, replacementsByKind, droppedByKind, stateReplacements) {
     const rewritten = [];
     for (const change of asList(changes)) {
         if (!isDict(change))
             continue;
         const targetKind = strOf(change["target_kind"]);
-        const targetId = strOf(change["target_id"]);
-        if (targetKind === "actor" && droppedActorIds.has(targetId))
+        if (targetKind !== "actor" && targetKind !== "location" && targetKind !== "prop")
             continue;
-        if (targetKind === "prop" && droppedPropIds.has(targetId))
+        const targetId = strOf(change["target_id"]);
+        const nextTargetId = replacementsByKind[targetKind].get(targetId) ?? targetId;
+        if (nextTargetId === targetId && droppedByKind[targetKind].has(targetId))
             continue;
-        const next = { ...change };
-        if (targetKind === "location" && locationReplacements.has(targetId)) {
-            next["target_id"] = locationReplacements.get(targetId);
-            delete next["from_state_id"];
-            delete next["to_state_id"];
+        const next = { ...change, target_id: nextTargetId };
+        const fromStateId = strOf(change["from_state_id"]);
+        const toStateId = strOf(change["to_state_id"]);
+        if (fromStateId) {
+            const mapped = stateReplacements.get(fromStateId);
+            if (mapped)
+                next["from_state_id"] = mapped;
+            else if (nextTargetId !== targetId)
+                delete next["from_state_id"];
+        }
+        if (toStateId) {
+            const mapped = stateReplacements.get(toStateId);
+            if (mapped)
+                next["to_state_id"] = mapped;
+            else if (nextTargetId !== targetId)
+                delete next["to_state_id"];
         }
         rewritten.push(next);
     }
     return rewritten;
 }
-function rewriteTransitionPrompt(transition, locationReplacements, droppedPropIds, droppedActorIds) {
+function rewriteCurationTransition(transition, replacementsByKind, droppedByKind) {
     if (!isDict(transition))
         return transition;
     const targetKind = strOf(transition["target_kind"]);
+    if (targetKind !== "actor" && targetKind !== "location" && targetKind !== "prop")
+        return transition;
     const targetId = strOf(transition["target_id"]);
-    if (targetKind === "actor" && droppedActorIds.has(targetId))
-        return null;
-    if (targetKind === "prop" && droppedPropIds.has(targetId))
+    const nextTargetId = replacementsByKind[targetKind].get(targetId) ?? targetId;
+    if (nextTargetId === targetId && droppedByKind[targetKind].has(targetId))
         return null;
-    const next = { ...transition };
-    if (targetKind === "location" && locationReplacements.has(targetId)) {
-        next["target_id"] = locationReplacements.get(targetId);
-    }
-    return next;
+    return { ...transition, target_id: nextTargetId };
 }
-function applyAssetCurationRefs(script, locationReplacements, droppedPropIds, droppedActorIds) {
-    if (locationReplacements.size === 0 && droppedPropIds.size === 0 && droppedActorIds.size === 0)
-        return;
+function rewriteCurationRefs(script, replacementsByKind, droppedByKind, stateReplacements, speakerReplacements) {
     for (const ep of asList(script["episodes"])) {
         for (const scene of asList(ep["scenes"])) {
             const ctx = sceneContext(scene);
-            if (locationReplacements.size > 0) {
-                ctx["locations"] = compactAssetRefs(ctx["locations"], "location_id", locationReplacements, new Set());
-            }
-            if (droppedActorIds.size > 0) {
-                ctx["actors"] = compactAssetRefs(ctx["actors"], "actor_id", new Map(), droppedActorIds);
-            }
-            if (droppedPropIds.size > 0) {
-                ctx["props"] = compactAssetRefs(ctx["props"], "prop_id", new Map(), droppedPropIds);
-            }
+            ctx["actors"] = compactRefsWithStateMap(ctx["actors"], "actor_id", replacementsByKind.actor, droppedByKind.actor, stateReplacements);
+            ctx["locations"] = compactRefsWithStateMap(ctx["locations"], "location_id", replacementsByKind.location, droppedByKind.location, stateReplacements);
+            ctx["props"] = compactRefsWithStateMap(ctx["props"], "prop_id", replacementsByKind.prop, droppedByKind.prop, stateReplacements);
             setSceneContext(scene, ctx);
             for (const action of asList(scene["actions"])) {
                 if (!isDict(action))
                     continue;
-                if (droppedActorIds.has(strOf(action["actor_id"])))
+                const actorId = strOf(action["actor_id"]);
+                if (replacementsByKind.actor.has(actorId))
+                    action["actor_id"] = replacementsByKind.actor.get(actorId);
+                else if (droppedByKind.actor.has(actorId))
                     delete action["actor_id"];
+                const speakerId = strOf(action["speaker_id"]);
+                if (speakerReplacements.has(speakerId))
+                    action["speaker_id"] = speakerReplacements.get(speakerId);
+                action["speakers"] = rewriteSpeakerRefs(action["speakers"], speakerReplacements);
+                action["lines"] = rewriteSpeakerRefs(action["lines"], speakerReplacements);
                 if (action["state_changes"] !== undefined && action["state_changes"] !== null) {
-                    action["state_changes"] = rewriteStateChanges(action["state_changes"], locationReplacements, droppedPropIds, droppedActorIds);
+                    action["state_changes"] = rewriteCurationStateChanges(action["state_changes"], replacementsByKind, droppedByKind, stateReplacements);
+                    if (asList(action["state_changes"]).length === 0)
+                        delete action["state_changes"];
                 }
                 if (action["transition_prompt"] !== undefined && action["transition_prompt"] !== null) {
-                    const transition = rewriteTransitionPrompt(action["transition_prompt"], locationReplacements, droppedPropIds, droppedActorIds);
+                    const transition = rewriteCurationTransition(action["transition_prompt"], replacementsByKind, droppedByKind);
                     if (transition === null)
                         delete action["transition_prompt"];
                     else
@@ -3035,23 +5816,241 @@ function applyAssetCurationRefs(script, locationReplacements, droppedPropIds, dr
             }
         }
     }
+}
+function copyStatesForMerge(script, kind, source, target, stateReplacements) {
+    for (const state of asList(source["states"])) {
+        const sourceStateId = strOf(state["state_id"]);
+        const stateName = strOf(state["state_name"]).trim();
+        if (!sourceStateId || !stateName)
+            continue;
+        const targetStateId = appendState(target, script, stateName, state["description"]);
+        stateReplacements.set(sourceStateId, targetStateId);
+    }
+    addAssetAlias(target, kind, strOf(source[assetNameKey(kind)]));
+    for (const alias of asList(source["aliases"]))
+        addAssetAlias(target, kind, alias);
+}
+function upsertPropFromAsset(script, source, sourceKind, decision) {
+    const targetId = strOf(decision["target_id"]);
+    if (targetId) {
+        assertAssetExists(script, "prop", targetId);
+        return targetId;
+    }
+    const propId = nextAssetId(script, "prop");
+    const name = cleanName(decision["new_name"]) || strOf(source[assetNameKey(sourceKind)]);
+    const prop = { prop_id: propId, prop_name: name, description: source["description"] ?? "" };
+    script["props"].push(prop);
+    return propId;
+}
+function upsertSpeakerForMove(script, source, sourceKind, decision) {
+    const sourceId = strOf(source[assetIdKey(sourceKind)]);
+    const sourceKindForSpeaker = strOf(decision["speaker_kind"]) || "other";
+    if (!SPEAKER_SOURCE_KINDS.has(sourceKindForSpeaker) || sourceKindForSpeaker === "actor" || sourceKindForSpeaker === "location" || sourceKindForSpeaker === "prop") {
+        curationBlocked("move_to_speaker requires system/broadcast/group/other speaker_kind.", [`speaker_kind: ${sourceKindForSpeaker || "<empty>"}`]);
+    }
+    const displayName = cleanName(decision["new_name"]) || strOf(source[assetNameKey(sourceKind)]);
+    const existingSameSpeaker = asList(script["speakers"]).find((speaker) => strOf(speaker["display_name"]).trim() === displayName && strOf(speaker["source_kind"]).trim() === sourceKindForSpeaker);
+    if (existingSameSpeaker)
+        return strOf(existingSameSpeaker["speaker_id"]);
+    if (sourceKind === "actor") {
+        const actorSpeakerId = speakerIdForActor(sourceId);
+        const existingActorSpeaker = asList(script["speakers"]).find((speaker) => strOf(speaker["speaker_id"]) === actorSpeakerId);
+        if (existingActorSpeaker) {
+            existingActorSpeaker["source_kind"] = sourceKindForSpeaker;
+            existingActorSpeaker["source_id"] = null;
+            existingActorSpeaker["display_name"] = displayName;
+            return actorSpeakerId;
+        }
+    }
+    const speakerId = nextSpeakerId(script, sourceKindForSpeaker);
+    const speaker = {
+        speaker_id: speakerId,
+        display_name: displayName,
+        source_kind: sourceKindForSpeaker,
+        source_id: null,
+        voice_desc: "",
+    };
+    if (!isList(script["speakers"]))
+        script["speakers"] = [];
+    script["speakers"].push(speaker);
+    return speakerId;
+}
+function replaceAssetListsAfterCuration(script, droppedByKind) {
+    for (const kind of ["actor", "location", "prop"]) {
+        const idKey = assetIdKey(kind);
+        script[assetListKey(kind)] = asList(script[assetListKey(kind)]).filter((asset) => isDict(asset) && !droppedByKind[kind].has(strOf(asset[idKey])));
+    }
+}
+function summarizeActionableCuration(decisions) {
+    const summary = {};
+    for (const decision of decisions) {
+        const key = `${decision["kind"]}_${decision["decision"]}`;
+        summary[key] = (summary[key] ?? 0) + 1;
+    }
+    return summary;
+}
+function applyAssetCurationDecisions(script, decisions, coverageSummary, defaultPolicy) {
+    const actorsBefore = asList(script["actors"]).length;
+    const locationsBefore = asList(script["locations"]).length;
+    const propsBefore = asList(script["props"]).length;
+    if (!isList(script["props"]))
+        script["props"] = [];
+    if (!isList(script["speakers"]))
+        script["speakers"] = [];
+    const replacementsByKind = {
+        actor: new Map(),
+        location: new Map(),
+        prop: new Map(),
+    };
+    const droppedByKind = {
+        actor: new Set(),
+        location: new Set(),
+        prop: new Set(),
+    };
+    const stateReplacements = new Map();
+    const speakerReplacements = new Map();
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        const sourceId = strOf(decision["source_id"]);
+        const source = assertAssetExists(script, kind, sourceId);
+        const action = strOf(decision["decision"]);
+        if (action === "rename") {
+            const newName = cleanName(decision["new_name"]);
+            if (!newName)
+                curationBlocked("rename decision requires new_name.", [`${kind}:${sourceId}`]);
+            const oldName = strOf(source[assetNameKey(kind)]);
+            source[assetNameKey(kind)] = newName;
+            addAssetAlias(source, kind, oldName);
+        }
+        else if (action === "merge") {
+            const targetId = strOf(decision["target_id"]);
+            const targetKind = strOf(decision["target_kind"]) || kind;
+            if (targetKind !== kind)
+                curationBlocked("merge decision target_kind must match source kind.", [`${kind}:${sourceId} -> ${targetKind}:${targetId}`]);
+            if (!targetId || targetId === sourceId)
+                curationBlocked("merge decision requires a different target_id.", [`${kind}:${sourceId}`]);
+            const target = assertAssetExists(script, kind, targetId);
+            copyStatesForMerge(script, kind, source, target, stateReplacements);
+            replacementsByKind[kind].set(sourceId, targetId);
+            droppedByKind[kind].add(sourceId);
+            if (kind === "actor")
+                speakerReplacements.set(speakerIdForActor(sourceId), speakerIdForActor(targetId));
+        }
+        else if (action === "drop") {
+            droppedByKind[kind].add(sourceId);
+        }
+        else if (action === "move_to_prop") {
+            const propId = upsertPropFromAsset(script, source, kind, decision);
+            if (kind === "prop") {
+                replacementsByKind.prop.set(sourceId, propId);
+            }
+            else {
+                droppedByKind[kind].add(sourceId);
+            }
+            if (kind === "actor")
+                speakerReplacements.set(speakerIdForActor(sourceId), speakerIdForActor(sourceId));
+            addAssetAlias(assertAssetExists(script, "prop", propId), "prop", strOf(source[assetNameKey(kind)]));
+        }
+        else if (action === "move_to_speaker") {
+            const speakerId = upsertSpeakerForMove(script, source, kind, decision);
+            if (kind === "actor")
+                speakerReplacements.set(speakerIdForActor(sourceId), speakerId);
+            droppedByKind[kind].add(sourceId);
+        }
+        else if (action === "move_to_state") {
+            const targetKind = strOf(decision["target_kind"]);
+            const targetId = strOf(decision["target_id"]);
+            if (targetKind !== "actor" && targetKind !== "location" && targetKind !== "prop")
+                curationBlocked("move_to_state requires target_kind actor/location/prop.", [`${kind}:${sourceId}`]);
+            const target = assertAssetExists(script, targetKind, targetId);
+            const stateName = strOf(decision["state_name"]) || cleanName(decision["new_name"]) || strOf(source[assetNameKey(kind)]);
+            const stateId = appendState(target, script, stateName, source["description"]);
+            if (targetKind === kind && targetId === sourceId)
+                continue;
+            addAssetAlias(target, targetKind, strOf(source[assetNameKey(kind)]));
+            for (const alias of asList(source["aliases"]))
+                addAssetAlias(target, targetKind, alias);
+            if (targetKind === kind)
+                replacementsByKind[kind].set(sourceId, targetId);
+            droppedByKind[kind].add(sourceId);
+            for (const state of asList(source["states"])) {
+                const sourceStateId = strOf(state["state_id"]);
+                if (sourceStateId)
+                    stateReplacements.set(sourceStateId, stateId);
+            }
+            if (kind === "actor" && targetKind === "actor")
+                speakerReplacements.set(speakerIdForActor(sourceId), speakerIdForActor(targetId));
+        }
+    }
+    rewriteCurationRefs(script, replacementsByKind, droppedByKind, stateReplacements, speakerReplacements);
+    replaceAssetListsAfterCuration(script, droppedByKind);
+    const replacedSpeakerIds = new Set();
+    for (const [sourceSpeakerId, targetSpeakerId] of speakerReplacements) {
+        if (sourceSpeakerId && targetSpeakerId && sourceSpeakerId !== targetSpeakerId)
+            replacedSpeakerIds.add(sourceSpeakerId);
+    }
+    if (replacedSpeakerIds.size > 0) {
+        script["speakers"] = asList(script["speakers"]).filter((speaker) => isDict(speaker) && !replacedSpeakerIds.has(strOf(speaker["speaker_id"])));
+    }
     for (const speaker of asList(script["speakers"])) {
         if (!isDict(speaker))
             continue;
         const sourceKind = strOf(speaker["source_kind"]);
         const sourceId = strOf(speaker["source_id"]);
-        if (sourceKind === "actor" && droppedActorIds.has(sourceId)) {
-            speaker["source_kind"] = "other";
-            speaker["source_id"] = null;
-        }
-        else if (sourceKind === "location" && locationReplacements.has(sourceId)) {
-            speaker["source_id"] = locationReplacements.get(sourceId);
-        }
-        else if (sourceKind === "prop" && droppedPropIds.has(sourceId)) {
-            speaker["source_kind"] = "other";
-            speaker["source_id"] = null;
+        if (sourceKind === "actor" || sourceKind === "location" || sourceKind === "prop") {
+            if (droppedByKind[sourceKind].has(sourceId)) {
+                speaker["source_kind"] = "other";
+                speaker["source_id"] = null;
+            }
+            else if (replacementsByKind[sourceKind].has(sourceId)) {
+                speaker["source_id"] = replacementsByKind[sourceKind].get(sourceId);
+            }
         }
     }
+    const actorsAfter = asList(script["actors"]).length;
+    const locationsAfter = asList(script["locations"]).length;
+    const propsAfter = asList(script["props"]).length;
+    const totalBefore = actorsBefore + locationsBefore + propsBefore;
+    const explicitKeepCount = decisions.filter((decision) => decision["decision"] === "keep").length;
+    return {
+        version: 3,
+        summary: {
+            actors_before: actorsBefore,
+            actors_after: actorsAfter,
+            actors_removed: actorsBefore - actorsAfter,
+            props_before: propsBefore,
+            props_after: propsAfter,
+            props_removed: propsBefore - propsAfter,
+            locations_before: locationsBefore,
+            locations_after: locationsAfter,
+            locations_merged: locationsBefore - locationsAfter,
+            decisions: decisions.length,
+            explicit_keep_count: explicitKeepCount,
+            implicit_keep_count: Math.max(0, totalBefore - decisions.length),
+            default_policy: defaultPolicy,
+            coverage: coverageSummary,
+            actions: summarizeActionableCuration(decisions),
+        },
+        decisions,
+    };
+}
+export function applyAssetCurationPlan(script, rawPlan) {
+    const decisions = normalizedCurationDecisions(rawPlan);
+    normalizeCurationPlanTargets(script, decisions);
+    const coverageSummary = assertCurationCoverage(script, decisions);
+    assertMergeAcyclic(decisions);
+    return applyAssetCurationDecisions(script, decisions, coverageSummary, "required assets must have explicit decisions; optional omitted actors/locations are kept");
+}
+export function applyAssetGroupingDuplicateMerges(script, rawPlan) {
+    const decisions = normalizedCurationDecisions(rawPlan);
+    const invalid = decisions
+        .filter((decision) => decision["decision"] !== "merge")
+        .map((decision) => `${strOf(decision["kind"])}:${strOf(decision["source_id"])}:${strOf(decision["decision"])}`);
+    if (invalid.length > 0)
+        curationBlocked("Asset grouping can only apply duplicate merge decisions.", invalid.slice(0, 40));
+    normalizeCurationPlanTargets(script, decisions);
+    assertMergeAcyclic(decisions);
+    return applyAssetCurationDecisions(script, decisions, { skipped: true, reason: "asset grouping duplicate merge runs before full curation coverage" }, "asset grouping may omit only exact normalized-name duplicates; omitted duplicates are merged before full curation");
 }
 export function normalizeAssetCuration(script, rawCuration) {
     const payload = isDict(rawCuration) ? rawCuration : {};
@@ -3121,6 +6120,9 @@ export function normalizeAssetCuration(script, rawCuration) {
     };
 }
 export function curateScriptAssets(script, rawCuration = null) {
+    if (isDict(rawCuration) && isList(rawCuration["decisions"])) {
+        return applyAssetCurationPlan(script, rawCuration);
+    }
     const actorsBefore = asList(script["actors"]).length;
     const propsBefore = asList(script["props"]).length;
     const locationsBefore = asList(script["locations"]).length;
@@ -3168,6 +6170,361 @@ export function curateScriptAssets(script, rawCuration = null) {
         locations: locationDecisions,
     };
 }
+// ---------------------------------------------------------------------------
+// State binding
+// ---------------------------------------------------------------------------
+function stateBindingBlocked(message, received) {
+    throw new CliError("DIRECT STATE BINDING BLOCKED: invalid provider plan", message, {
+        exitCode: EXIT_NEEDS_AGENT,
+        required: ["valid state binding plan referencing existing scene/action/asset/state ids"],
+        received,
+        nextSteps: ["Inspect state_binding.json, adjust the draft manually, or rerun direct init after provider plan fixes."],
+    });
+}
+export function normalizeStateBindingPlanShape(rawPlan) {
+    if (!isDict(rawPlan))
+        return null;
+    const scenes = rawPlan["scenes"];
+    if (isList(scenes))
+        return rawPlan;
+    if (typeof scenes === "string") {
+        const text = scenes.trim();
+        if (!text)
+            return rawPlan;
+        try {
+            const parsed = JSON.parse(text);
+            if (isList(parsed))
+                return { ...rawPlan, scenes: parsed };
+        }
+        catch {
+            return rawPlan;
+        }
+    }
+    return rawPlan;
+}
+function stateIdsByAssetId(script) {
+    const out = new Map();
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            const assetId = strOf(asset[assetIdKey(kind)]);
+            if (!assetId)
+                continue;
+            out.set(assetId, new Set(asList(asset["states"]).map((state) => strOf(state["state_id"])).filter((id) => id)));
+        }
+    }
+    return out;
+}
+function stateNameById(asset, stateId) {
+    for (const state of asList(asset["states"])) {
+        if (strOf(state["state_id"]) === stateId)
+            return strOf(state["state_name"]);
+    }
+    return "";
+}
+function bindableDefaultStateId(asset) {
+    const states = asList(asset["states"]);
+    if (states.length === 0)
+        return "";
+    const defaultState = states.find((state) => strOf(state["state_name"]).trim() === "默认");
+    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;
+    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() === "默认"))
+                continue;
+            appendState(asset, script, "默认", asset["description"]);
+            added += 1;
+        }
+    }
+    return { default_states_added: added };
+}
+export function bindDefaultStateRefsInScript(script) {
+    const assetMaps = {
+        actor: assetMapById(script, "actor"),
+        location: assetMapById(script, "location"),
+        prop: assetMapById(script, "prop"),
+    };
+    let bound = 0;
+    let unresolved = 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) || ref["state_id"])
+                        continue;
+                    const asset = assetMaps[kind].get(strOf(ref[idKey]));
+                    if (!asset || asList(asset["states"]).length === 0)
+                        continue;
+                    const stateId = bindableDefaultStateId(asset);
+                    if (stateId) {
+                        ref["state_id"] = stateId;
+                        bound += 1;
+                    }
+                    else {
+                        unresolved += 1;
+                    }
+                }
+            }
+            setSceneContext(scene, ctx);
+        }
+    }
+    return { default_or_unique_refs_bound: bound, unresolved_stateful_refs: unresolved };
+}
+function compactStateBindingAsset(kind, asset) {
+    return {
+        kind,
+        id: asset[assetIdKey(kind)],
+        name: asset[assetNameKey(kind)],
+        description: asset["description"],
+        states: stateCatalog(asset),
+    };
+}
+function stateBindingAssetRefIds(sceneContexts, refKey) {
+    const ids = new Set();
+    for (const scene of sceneContexts) {
+        const refs = asDict(scene["refs"]);
+        for (const ref of asList(refs[refKey])) {
+            const id = strOf(ref["id"]);
+            if (id)
+                ids.add(id);
+        }
+    }
+    return ids;
+}
+function sceneNeedsLlmStateBinding(sceneContext) {
+    const refs = asDict(sceneContext["refs"]);
+    for (const refKey of ["actors", "locations", "props"]) {
+        for (const ref of asList(refs[refKey])) {
+            if (asList(ref["states"]).length > 1)
+                return true;
+        }
+    }
+    return false;
+}
+function sceneBindingContext(script, ep, scene) {
+    const actorMap = assetMapById(script, "actor");
+    const locationMap = assetMapById(script, "location");
+    const propMap = assetMapById(script, "prop");
+    const ctx = sceneContext(scene);
+    const refsFor = (kind) => {
+        const idKey = assetIdKey(kind);
+        const refKey = assetListKey(kind);
+        const assets = kind === "actor" ? actorMap : kind === "location" ? locationMap : propMap;
+        return asList(ctx[refKey]).map((ref) => {
+            const asset = assets.get(strOf(ref[idKey]));
+            return {
+                id: ref[idKey],
+                name: asset ? asset[assetNameKey(kind)] : "",
+                current_state_id: ref["state_id"] ?? null,
+                current_state_name: asset && ref["state_id"] ? stateNameById(asset, strOf(ref["state_id"])) : "",
+                states: asset ? stateCatalog(asset) : [],
+            };
+        });
+    };
+    return {
+        episode_id: ep["episode_id"],
+        scene_id: scene["scene_id"],
+        environment: scene["environment"],
+        refs: {
+            actors: refsFor("actor"),
+            locations: refsFor("location"),
+            props: refsFor("prop"),
+        },
+        actions: asList(scene["actions"]).map((action, index) => ({
+            index,
+            type: action["type"],
+            content: action["content"],
+            actor_id: action["actor_id"],
+            speaker_id: action["speaker_id"],
+            emotion: action["emotion"],
+        })),
+    };
+}
+export function buildStateBindingContexts(script, chunkSize = 10) {
+    const scenes = [];
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const sceneContext = sceneBindingContext(script, ep, scene);
+            if (sceneNeedsLlmStateBinding(sceneContext))
+                scenes.push(sceneContext);
+        }
+    }
+    const actorMap = assetMapById(script, "actor");
+    const locationMap = assetMapById(script, "location");
+    const propMap = assetMapById(script, "prop");
+    const chunks = [];
+    const size = Math.max(1, Math.floor(chunkSize) || 1);
+    for (let i = 0; i < scenes.length; i += size) {
+        const chunkScenes = scenes.slice(i, i + size);
+        const actorIds = stateBindingAssetRefIds(chunkScenes, "actors");
+        const locationIds = stateBindingAssetRefIds(chunkScenes, "locations");
+        const propIds = stateBindingAssetRefIds(chunkScenes, "props");
+        const assetCatalog = {
+            actors: [...actorIds].map((id) => actorMap.get(id)).filter(isDict).map((asset) => compactStateBindingAsset("actor", asset)),
+            locations: [...locationIds].map((id) => locationMap.get(id)).filter(isDict).map((asset) => compactStateBindingAsset("location", asset)),
+            props: [...propIds].map((id) => propMap.get(id)).filter(isDict).map((asset) => compactStateBindingAsset("prop", asset)),
+        };
+        chunks.push({
+            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.",
+                "Emit state_changes only for explicit transformation, outfit, damage, breakage, repair, or form-change actions.",
+                "Do not invent new states or assets.",
+            ],
+            assets: assetCatalog,
+            scenes: chunkScenes,
+        });
+    }
+    return chunks;
+}
+function findSceneById(script, sceneId) {
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            if (strOf(scene["scene_id"]) === sceneId)
+                return scene;
+        }
+    }
+    return null;
+}
+function resolveStateForAsset(stateIdsByAsset, assetId, stateIdRaw, label, mode, stats) {
+    if (stateIdRaw === null || stateIdRaw === undefined || stateIdRaw === "")
+        return null;
+    const stateId = strOf(stateIdRaw);
+    if (!(stateIdsByAsset.get(assetId) ?? new Set()).has(stateId)) {
+        if (mode === "skip") {
+            if (label.startsWith("state_changes."))
+                stats.invalid_state_changes_skipped += 1;
+            else
+                stats.invalid_scene_refs_skipped += 1;
+            return undefined;
+        }
+        stateBindingBlocked("State binding references a state_id that does not belong to the asset.", [`${label}: ${assetId}/${stateId}`]);
+    }
+    return stateId;
+}
+function applyStateRefsForScene(ctx, planScene, refKey, idKey, stateIdsByAsset, mode, stats) {
+    const refs = asList(ctx[refKey]);
+    const byId = new Map(refs.map((ref) => [strOf(ref[idKey]), ref]));
+    let bound = 0;
+    for (const planned of asList(planScene[refKey])) {
+        if (!isDict(planned))
+            continue;
+        const assetId = strOf(planned[idKey]);
+        const ref = byId.get(assetId);
+        if (!ref) {
+            if (mode === "skip") {
+                stats.invalid_scene_refs_skipped += 1;
+                continue;
+            }
+            stateBindingBlocked("State binding references an asset not present in the scene.", [`${refKey}:${assetId}`]);
+        }
+        const stateId = resolveStateForAsset(stateIdsByAsset, assetId, planned["state_id"], `${refKey}.state_id`, mode, stats);
+        if (stateId === undefined)
+            continue;
+        if (stateId && ref["state_id"] !== stateId) {
+            ref["state_id"] = stateId;
+            bound += 1;
+        }
+    }
+    return bound;
+}
+function sceneHasAssetRef(ctx, kind, assetId) {
+    const idKey = assetIdKey(kind);
+    const refs = asList(ctx[assetListKey(kind)]);
+    return refs.some((ref) => strOf(ref[idKey]) === assetId);
+}
+export function applyStateBindingPlan(script, rawPlan, options = {}) {
+    const payload = isDict(rawPlan) ? rawPlan : {};
+    const stateIdsByAsset = stateIdsByAssetId(script);
+    const mode = options.invalidStateMode ?? "reject";
+    const stats = { invalid_scene_refs_skipped: 0, invalid_state_changes_skipped: 0 };
+    let sceneRefsBound = 0;
+    let stateChangesApplied = 0;
+    for (const planScene of asList(payload["scenes"])) {
+        if (!isDict(planScene))
+            continue;
+        const sceneId = strOf(planScene["scene_id"]);
+        const scene = findSceneById(script, sceneId);
+        if (!scene)
+            stateBindingBlocked("State binding references an unknown scene_id.", [`scene_id: ${sceneId || "<empty>"}`]);
+        const ctx = sceneContext(scene);
+        sceneRefsBound += applyStateRefsForScene(ctx, planScene, "actors", "actor_id", stateIdsByAsset, mode, stats);
+        sceneRefsBound += applyStateRefsForScene(ctx, planScene, "locations", "location_id", stateIdsByAsset, mode, stats);
+        sceneRefsBound += applyStateRefsForScene(ctx, planScene, "props", "prop_id", stateIdsByAsset, mode, stats);
+        setSceneContext(scene, ctx);
+        const actions = asList(scene["actions"]);
+        for (const change of asList(planScene["state_changes"])) {
+            if (!isDict(change))
+                continue;
+            const actionIndex = Number(change["action_index"]);
+            const action = actions[actionIndex];
+            if (!Number.isInteger(actionIndex) || !action) {
+                if (mode === "skip") {
+                    stats.invalid_state_changes_skipped += 1;
+                    continue;
+                }
+                stateBindingBlocked("State binding references an unknown action_index.", [`${sceneId}#${change["action_index"]}`]);
+            }
+            const targetKind = strOf(change["target_kind"]);
+            if (!SCRIPT_TARGET_KINDS.has(targetKind))
+                stateBindingBlocked("State change target_kind is invalid.", [`target_kind: ${targetKind || "<empty>"}`]);
+            const targetId = strOf(change["target_id"]);
+            if (!sceneHasAssetRef(ctx, targetKind, targetId)) {
+                if (mode === "skip") {
+                    stats.invalid_state_changes_skipped += 1;
+                    continue;
+                }
+                stateBindingBlocked("State change references an asset not present in the scene.", [`${sceneId}#${actionIndex}:${targetKind}:${targetId}`]);
+            }
+            const toStateId = resolveStateForAsset(stateIdsByAsset, targetId, change["to_state_id"], "state_changes.to_state_id", mode, stats);
+            if (toStateId === undefined)
+                continue;
+            if (!toStateId) {
+                if (mode === "skip") {
+                    stats.invalid_state_changes_skipped += 1;
+                    continue;
+                }
+                stateBindingBlocked("State change requires to_state_id.", [`${sceneId}#${actionIndex}`]);
+            }
+            const fromStateId = resolveStateForAsset(stateIdsByAsset, targetId, change["from_state_id"], "state_changes.from_state_id", mode, stats);
+            if (fromStateId === undefined)
+                continue;
+            const effectiveFrom = strOf(change["effective_from"] || "after_action");
+            if (effectiveFrom !== "before_action" && effectiveFrom !== "after_action")
+                stateBindingBlocked("State change effective_from is invalid.", [`effective_from: ${effectiveFrom}`]);
+            const nextChange = {
+                target_kind: targetKind,
+                target_id: targetId,
+                from_state_id: fromStateId || "",
+                to_state_id: toStateId,
+                effective_from: effectiveFrom,
+            };
+            const existing = asList(action["state_changes"]).filter((item) => !(strOf(item["target_kind"]) === targetKind && strOf(item["target_id"]) === targetId));
+            existing.push(nextChange);
+            action["state_changes"] = existing;
+            stateChangesApplied += 1;
+        }
+    }
+    return {
+        scene_refs_bound: sceneRefsBound,
+        state_changes_applied: stateChangesApplied,
+        invalid_scene_refs_skipped: stats.invalid_scene_refs_skipped,
+        invalid_state_changes_skipped: stats.invalid_state_changes_skipped,
+    };
+}
 function emptyAssetNormalizationReport() {
     return {
         version: 1,