@lingjingai/scriptctl 0.20.0 → 0.22.0

package/dist/domain/script-core.js

@@ -1,3026 +0,0 @@
-import { ACTION_TYPE_VALUES, CliError, DELIVERY_VALUES, EFFECTIVE_FROM_VALUES, EXIT_INPUT, EXIT_USAGE, ROLE_TYPE_VALUES, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, SPEAKER_SOURCE_KINDS, WORLDVIEW_VALUES, directDir, exists, fmtId, readJson, readText, writeJson, } from "../common.js";
-import { cleanName, contentHasSpeakerPrefix, inferNonActorSpeakerKind, isTechnicalEpisodeTitle, sceneContext, setSceneContext, stateLabelError, stateRejectionReason, } from "./direct-core.js";
-import * as path from "node:path";
-function strOf(v) {
-    if (v === null || v === undefined)
-        return "";
-    return String(v);
-}
-function isDict(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isList(v) {
-    return Array.isArray(v);
-}
-function asList(v) {
-    return Array.isArray(v) ? v : [];
-}
-// ---------------------------------------------------------------------------
-// Find helpers
-// ---------------------------------------------------------------------------
-export function findAction(script, epId, sceneId, actionIndex) {
-    for (const ep of asList(script["episodes"])) {
-        if (ep["episode_id"] !== epId)
-            continue;
-        for (const scene of asList(ep["scenes"])) {
-            if (scene["scene_id"] === sceneId) {
-                const actions = asList(scene["actions"]);
-                if (actionIndex >= 0 && actionIndex < actions.length)
-                    return actions[actionIndex];
-            }
-        }
-    }
-    throw new CliError("PATCH BLOCKED: Action not found", "Action not found.", {
-        exitCode: EXIT_USAGE,
-        required: ["existing episode_id, scene_id, action_index"],
-        received: [`${epId} ${sceneId} ${actionIndex}`],
-        nextSteps: ["Inspect episodes and fix the patch."],
-    });
-}
-export function findEpisode(script, epId) {
-    for (const ep of asList(script["episodes"])) {
-        if (ep["episode_id"] === epId)
-            return ep;
-    }
-    throw new CliError("PATCH BLOCKED: Episode not found", "Episode not found.", {
-        exitCode: EXIT_USAGE,
-        required: ["existing episode_id"],
-        received: [epId],
-        nextSteps: ["Inspect episodes and fix the patch."],
-    });
-}
-export function findScene(script, epId, sceneId) {
-    const ep = findEpisode(script, epId);
-    for (const scene of asList(ep["scenes"])) {
-        if (scene["scene_id"] === sceneId)
-            return scene;
-    }
-    throw new CliError("PATCH BLOCKED: Scene not found", "Scene not found.", {
-        exitCode: EXIT_USAGE,
-        required: ["existing episode_id and scene_id"],
-        received: [`${epId} ${sceneId}`],
-        nextSteps: ["Inspect episodes and fix the patch."],
-    });
-}
-// ---------------------------------------------------------------------------
-// blank scaffold
-// ---------------------------------------------------------------------------
-/**
- * Minimal schema-v2 script skeleton: every required top-level field present,
- * all collections empty. It is the starting point for building a script
- * bottom-up with the atomic add/insert verbs instead of assembling it from
- * source material (direct) or md (parse). `worldview`/`style`/`title` are
- * present-but-empty so the field-presence checks pass; they get filled in
- * later via `worldview` / `patch`. A blank script validates clean: NO_EPISODES
- * is a completeness warning (`incomplete_ok`), not a blocker.
- */
-export function blankScript(title = "") {
-    return {
-        version: SCRIPT_SCHEMA_VERSION,
-        title: title,
-        worldview: "",
-        style: "",
-        actors: [],
-        locations: [],
-        props: [],
-        speakers: [],
-        episodes: [],
-    };
-}
-// Completeness vs. integrity. A script can be structurally sound but unfinished
-// (no episodes yet, an empty episode/scene, a scene without a location, an asset
-// without a description). Those gaps are emitted as `severity: "warning"` with
-// `incomplete_ok: true` directly at their source below — they never block, so an
-// unfinished-but-sound script is editable AND publishable. Only integrity
-// violations (dangling refs, duplicate ids, invalid enums, missing ids/names —
-// things that would corrupt the normalized DB graph) are `severity: "error"`.
-// One SCHEMA_ENTITY_FIELD_MISSING issue for a missing asset field. A missing
-// description is a completeness gap (warning); a missing id/name is an identity
-// error that would dangle in the DB graph. Shared by the actor/location/prop
-// validation loops so the severity/incomplete_ok/repair-hint policy lives once.
-function entityFieldMissingIssue(kindLabel, field, idValue) {
-    const isDescription = field === "description";
-    return {
-        code: "SCHEMA_ENTITY_FIELD_MISSING",
-        severity: isDescription ? "warning" : "error",
-        ...(isDescription ? { incomplete_ok: true } : {}),
-        summary: `${kindLabel} missing ${field}: ${idValue}`,
-        repair_hint: isDescription
-            ? "Describe with `describe` when ready (an undescribed asset is publishable)."
-            : `Patch ${kindLabel.toLowerCase()} metadata.`,
-    };
-}
-// ---------------------------------------------------------------------------
-// validate_script
-// ---------------------------------------------------------------------------
-/**
- * Validate a script's schema and asset wiring.
- *
- * Pass either:
- *   - `scriptPath: string` (or null → default to direct's script.initial.json), or
- *   - `opts.scriptData: Dict` to validate an in-memory object without writing to disk.
- *
- * Callers that already have the script as a parsed object (episode draft / publish
- * after assembly) should prefer `scriptData` to avoid the write-validate-rm dance.
- *
- * Completeness issues (no episodes, empty episode/scene, scene without location,
- * missing asset description) are emitted as warnings (`incomplete_ok`), not
- * errors — an unfinished but structurally-sound script passes. Only integrity
- * violations (dangling refs, dup ids, invalid enums, missing ids/names) fail it.
- */
-export function validateScript(workspace, scriptPath = null, opts = {}) {
-    const requireSource = opts.requireSource ?? true;
-    const dd = directDir(workspace);
-    const sourcePath = path.join(workspace, "source.txt");
-    if (requireSource && !exists(sourcePath)) {
-        throw new CliError("VALIDATE BLOCKED: source.txt not found", "source.txt not found.", {
-            exitCode: EXIT_INPUT,
-            required: ["workspace/source.txt"],
-            received: [sourcePath],
-            nextSteps: ["Run scriptctl direct init first."],
-        });
-    }
-    if (exists(sourcePath))
-        readText(sourcePath); // touch, mirror Python
-    let script;
-    if (opts.scriptData !== undefined) {
-        script = opts.scriptData;
-    }
-    else {
-        const finalScriptPath = scriptPath ?? path.join(dd, "script.initial.json");
-        if (!exists(finalScriptPath)) {
-            throw new CliError("VALIDATE BLOCKED: script not found", "Script JSON not found.", {
-                exitCode: EXIT_INPUT,
-                required: ["script.initial.json or --script-path"],
-                received: [finalScriptPath],
-                nextSteps: ["Run scriptctl direct init first."],
-            });
-        }
-        try {
-            script = readJson(finalScriptPath);
-        }
-        catch (exc) {
-            throw new CliError("VALIDATE BLOCKED: script JSON invalid", "Script JSON invalid.", {
-                exitCode: EXIT_INPUT,
-                required: ["valid script JSON"],
-                received: [`${finalScriptPath}: ${exc.message}`],
-                nextSteps: ["Fix script.initial.json or rerun init."],
-            });
-        }
-    }
-    const issues = [];
-    for (const field of ["version", "title", "worldview", "style", "actors", "locations", "props", "speakers", "episodes"]) {
-        if (!(field in script)) {
-            issues.push({
-                code: "SCHEMA_TOP_FIELD_MISSING",
-                severity: "error",
-                summary: `Top-level field missing: ${field}`,
-                repair_hint: "Patch script.json or rerun init.",
-            });
-        }
-    }
-    if (script["version"] !== SCRIPT_SCHEMA_VERSION && script["version"] !== String(SCRIPT_SCHEMA_VERSION)) {
-        issues.push({
-            code: "SCHEMA_VERSION_UNSUPPORTED",
-            severity: "warning",
-            summary: `script version should be ${SCRIPT_SCHEMA_VERSION}.`,
-            repair_hint: "Update the internal numeric version when migrating script.json.",
-        });
-    }
-    const actorIds = new Set();
-    for (const item of asList(script["actors"])) {
-        const id = strOf(item["actor_id"]);
-        if (id)
-            actorIds.add(id);
-    }
-    const locationIds = new Set();
-    for (const item of asList(script["locations"])) {
-        const id = strOf(item["location_id"]);
-        if (id)
-            locationIds.add(id);
-    }
-    const propIds = new Set();
-    for (const item of asList(script["props"])) {
-        const id = strOf(item["prop_id"]);
-        if (id)
-            propIds.add(id);
-    }
-    const speakerDisplayNames = new Set();
-    for (const item of asList(script["speakers"])) {
-        if (!isDict(item))
-            continue;
-        const name = strOf(item["display_name"]).trim();
-        if (name)
-            speakerDisplayNames.add(cleanName(name));
-    }
-    const actors = asList(script["actors"]);
-    for (let idx = 0; idx < actors.length; idx++) {
-        const actor = actors[idx];
-        if (!isDict(actor)) {
-            issues.push({
-                code: "SCHEMA_ENTITY_FIELD_MISSING",
-                severity: "error",
-                summary: `actors[${idx}] is not an object.`,
-                repair_hint: "Patch actor entry.",
-            });
-            continue;
-        }
-        const actorName = strOf(actor["actor_name"]).trim();
-        for (const field of ["actor_id", "actor_name", "description"]) {
-            if (!strOf(actor[field]).trim()) {
-                issues.push(entityFieldMissingIssue("Actor", field, strOf(actor["actor_id"]) || String(idx)));
-            }
-        }
-        if (actorName && cleanName(actorName) !== actorName) {
-            issues.push({
-                code: "ASSET_NAME_HAS_STATE_ANNOTATION",
-                severity: "error",
-                summary: `Actor name contains state annotation: ${actorName}`,
-                repair_hint: "Keep actor_name canonical and move state text to states[] or action content only if reusable.",
-            });
-        }
-        if (actorName && inferNonActorSpeakerKind(actorName) !== "actor") {
-            issues.push({
-                code: "NONHUMAN_AS_ACTOR",
-                severity: "error",
-                summary: `Non-human speaker is registered as actor: ${actorName}`,
-                repair_hint: "Use speakers[] with source_kind system/broadcast/prop/group/other; do not create an actor.",
-            });
-        }
-        if (actor["role_type"] && !ROLE_TYPE_VALUES.includes(strOf(actor["role_type"]))) {
-            issues.push({
-                code: "ENUM_ROLE_TYPE",
-                severity: "error",
-                summary: `Actor role_type invalid: ${actor["role_type"]}`,
-                repair_hint: "Patch role_type to 主角 or 配角.",
-            });
-        }
-    }
-    const locations = asList(script["locations"]);
-    for (let idx = 0; idx < locations.length; idx++) {
-        const loc = locations[idx];
-        if (!isDict(loc)) {
-            issues.push({
-                code: "SCHEMA_ENTITY_FIELD_MISSING",
-                severity: "error",
-                summary: `locations[${idx}] is not an object.`,
-                repair_hint: "Patch location entry.",
-            });
-            continue;
-        }
-        const locationName = strOf(loc["location_name"]).trim();
-        for (const field of ["location_id", "location_name", "description"]) {
-            if (!strOf(loc[field]).trim()) {
-                issues.push(entityFieldMissingIssue("Location", field, strOf(loc["location_id"]) || String(idx)));
-            }
-        }
-        if (locationName && cleanName(locationName) !== locationName) {
-            issues.push({
-                code: "ASSET_NAME_HAS_STATE_ANNOTATION",
-                severity: "error",
-                summary: `Location name contains state annotation: ${locationName}`,
-                repair_hint: "Keep location_name canonical and move durable visual variants to states[] only when reusable.",
-            });
-        }
-    }
-    const propsArr = asList(script["props"]);
-    for (let idx = 0; idx < propsArr.length; idx++) {
-        const prop = propsArr[idx];
-        if (!isDict(prop)) {
-            issues.push({
-                code: "SCHEMA_ENTITY_FIELD_MISSING",
-                severity: "error",
-                summary: `props[${idx}] is not an object.`,
-                repair_hint: "Patch prop entry.",
-            });
-            continue;
-        }
-        const propName = strOf(prop["prop_name"]).trim();
-        for (const field of ["prop_id", "prop_name", "description"]) {
-            if (!strOf(prop[field]).trim()) {
-                issues.push(entityFieldMissingIssue("Prop", field, strOf(prop["prop_id"]) || String(idx)));
-            }
-        }
-        if (propName && cleanName(propName) !== propName) {
-            issues.push({
-                code: "ASSET_NAME_HAS_STATE_ANNOTATION",
-                severity: "error",
-                summary: `Prop name contains state annotation: ${propName}`,
-                repair_hint: "Keep prop_name canonical and move durable visual variants to states[] only when reusable.",
-            });
-        }
-    }
-    const stateIdsByAsset = new Map();
-    for (const [collection, idKey] of [["actors", "actor_id"], ["locations", "location_id"], ["props", "prop_id"]]) {
-        const targetKind = { actors: "actor", locations: "location", props: "prop" }[collection];
-        for (const asset of asList(script[collection])) {
-            const assetId = strOf(asset[idKey]);
-            const rawStates = asset["states"];
-            stateIdsByAsset.set(assetId, new Set());
-            const seenStateNames = new Set();
-            // Mirror Python `asset.get("states", []) or []`: absent/null → empty list (no issue)
-            if (rawStates !== undefined && rawStates !== null && !isList(rawStates)) {
-                issues.push({
-                    code: "SCHEMA_STATE_LIST_INVALID",
-                    severity: "error",
-                    summary: `${collection} ${assetId} states must be an array.`,
-                    repair_hint: "Patch states to an array.",
-                });
-                continue;
-            }
-            const states = isList(rawStates) ? rawStates : [];
-            for (const state of states) {
-                if (!isDict(state)) {
-                    issues.push({
-                        code: "SCHEMA_STATE_INVALID",
-                        severity: "error",
-                        summary: `${collection} ${assetId} contains a non-object state.`,
-                        repair_hint: "Patch or remove the invalid state.",
-                    });
-                    continue;
-                }
-                const sid = strOf(state["state_id"]);
-                const sname = strOf(state["state_name"] || state["name"]);
-                if (!sid || !sname) {
-                    issues.push({
-                        code: "SCHEMA_STATE_FIELD_MISSING",
-                        severity: "error",
-                        summary: `${collection} ${assetId} state missing state_id or state_name.`,
-                        repair_hint: "Patch state_id/state_name.",
-                    });
-                }
-                if (sid && stateIdsByAsset.get(assetId).has(sid)) {
-                    issues.push({
-                        code: "DUPLICATE_STATE_ID",
-                        severity: "error",
-                        summary: `Duplicate state_id in ${assetId}: ${sid}`,
-                        repair_hint: "Rename or merge duplicate states.",
-                    });
-                }
-                if (sname && seenStateNames.has(sname)) {
-                    issues.push({
-                        code: "DUPLICATE_STATE_NAME",
-                        severity: "warning",
-                        summary: `Duplicate state_name in ${assetId}: ${sname}`,
-                        repair_hint: "Rename duplicate states if they are different shapes.",
-                    });
-                }
-                const reason = stateRejectionReason(targetKind, sname);
-                if (sname && reason) {
-                    issues.push({
-                        code: "STATE_LABEL_INVALID",
-                        severity: "error",
-                        summary: `${collection} ${assetId} state label invalid: ${sname}`,
-                        repair_hint: "Use one clear state label; do not combine multiple states into one label.",
-                    });
-                }
-                if (sid)
-                    stateIdsByAsset.get(assetId).add(sid);
-                if (sname)
-                    seenStateNames.add(sname);
-            }
-        }
-    }
-    const speakerIds = new Set();
-    const speakersArr = asList(script["speakers"]);
-    for (let idx = 0; idx < speakersArr.length; idx++) {
-        const speaker = speakersArr[idx];
-        if (!isDict(speaker)) {
-            issues.push({
-                code: "SCHEMA_SPEAKER_INVALID",
-                severity: "error",
-                summary: `speakers[${idx}] is not an object.`,
-                repair_hint: "Patch speaker entry.",
-            });
-            continue;
-        }
-        const speakerId = strOf(speaker["speaker_id"]);
-        const sourceKind = strOf(speaker["source_kind"]);
-        const sourceId = speaker["source_id"];
-        if (!speakerId || !strOf(speaker["display_name"]).trim()) {
-            issues.push({
-                code: "SCHEMA_SPEAKER_FIELD_MISSING",
-                severity: "error",
-                summary: `Speaker missing speaker_id or display_name: ${idx}`,
-                repair_hint: "Patch speaker metadata.",
-            });
-        }
-        if (speakerIds.has(speakerId)) {
-            issues.push({
-                code: "DUPLICATE_SPEAKER_ID",
-                severity: "error",
-                summary: `Duplicate speaker_id: ${speakerId}`,
-                repair_hint: "Rename or merge duplicate speakers.",
-            });
-        }
-        if (speakerId)
-            speakerIds.add(speakerId);
-        if (!SPEAKER_SOURCE_KINDS.has(sourceKind)) {
-            issues.push({
-                code: "ENUM_SPEAKER_SOURCE_KIND",
-                severity: "error",
-                summary: `speaker.source_kind invalid: ${sourceKind || "<empty>"}`,
-                repair_hint: "Use actor/location/prop/system/broadcast/group/other.",
-            });
-        }
-        if (sourceKind === "actor" && !actorIds.has(strOf(sourceId))) {
-            issues.push({
-                code: "DANGLING_SPEAKER_SOURCE_REF",
-                severity: "error",
-                summary: `Speaker actor source not found: ${sourceId}`,
-                repair_hint: "Patch source_id or source_kind.",
-            });
-        }
-        if (sourceKind === "location" && !locationIds.has(strOf(sourceId))) {
-            issues.push({
-                code: "DANGLING_SPEAKER_SOURCE_REF",
-                severity: "error",
-                summary: `Speaker location source not found: ${sourceId}`,
-                repair_hint: "Patch source_id or source_kind.",
-            });
-        }
-        if (sourceKind === "prop" && !propIds.has(strOf(sourceId))) {
-            issues.push({
-                code: "DANGLING_SPEAKER_SOURCE_REF",
-                severity: "error",
-                summary: `Speaker prop source not found: ${sourceId}`,
-                repair_hint: "Patch source_id or source_kind.",
-            });
-        }
-    }
-    const planPath = path.join(dd, "episode_plan.json");
-    if (exists(planPath)) {
-        const plan = readJson(planPath);
-        if (plan["boundary_confidence"] === "low") {
-            issues.push({
-                code: "LOW_CONFIDENCE_EPISODE_PLAN",
-                severity: "warning",
-                summary: "Episode plan used a single-episode fallback.",
-                repair_hint: "Inspect the initial script and adjust structure with patch if needed.",
-            });
-        }
-    }
-    const episodes = asList(script["episodes"]);
-    if (episodes.length === 0) {
-        issues.push({ code: "NO_EPISODES", severity: "warning", incomplete_ok: true, summary: "No episodes in script.", repair_hint: "Add episodes with add-episode (an empty script is publishable but renders to nothing)." });
-    }
-    let totalScenes = 0;
-    let totalActions = 0;
-    let lastSceneNum = 0;
-    for (const ep of episodes) {
-        const epTitle = strOf(ep["title"]).trim();
-        if (!epTitle || isTechnicalEpisodeTitle(epTitle)) {
-            issues.push({
-                code: "EPISODE_TITLE_INVALID",
-                severity: "warning",
-                episode: ep["episode_id"],
-                summary: `Episode title is missing or technical: ${epTitle || "<empty>"}`,
-                repair_hint: 'Rerun `direct init` to regenerate, or `script patch episode <episode_id> --field title --value "第N集：短标题"`.',
-            });
-        }
-        const scenes = asList(ep["scenes"]);
-        if (scenes.length === 0) {
-            issues.push({
-                code: "EPISODE_WITHOUT_SCENES",
-                severity: "warning",
-                incomplete_ok: true,
-                episode: ep["episode_id"],
-                summary: "Episode has no scenes.",
-                repair_hint: "Add scenes with insert (an empty episode is publishable but renders to nothing).",
-            });
-        }
-        for (const scene of scenes) {
-            totalScenes += 1;
-            const rawSceneId = strOf(scene["scene_id"]);
-            const match = /^scn_(\d+)$/.exec(rawSceneId);
-            if (match) {
-                const sceneNum = parseInt(match[1], 10);
-                if (sceneNum <= lastSceneNum) {
-                    issues.push({
-                        code: "REF_SCENE_ID_NONMONO",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: rawSceneId,
-                        summary: `scene_id must increase globally: ${rawSceneId}`,
-                        repair_hint: "Rerun init or patch scene ids to a global monotonic sequence.",
-                    });
-                }
-                lastSceneNum = Math.max(lastSceneNum, sceneNum);
-            }
-            else {
-                issues.push({
-                    code: "REF_SCENE_ID_INVALID",
-                    severity: "error",
-                    episode: ep["episode_id"],
-                    scene: rawSceneId || null,
-                    summary: "scene_id must use scn_### format.",
-                    repair_hint: "Patch scene_id to scn_###.",
-                });
-            }
-            const ctx = sceneContext(scene);
-            const ctxLocations = asList(ctx["locations"]);
-            if (ctxLocations.length === 0) {
-                issues.push({
-                    code: "SCENE_WITHOUT_LOCATION",
-                    severity: "warning",
-                    incomplete_ok: true,
-                    episode: ep["episode_id"],
-                    scene: scene["scene_id"],
-                    summary: "Scene has no location.",
-                    repair_hint: "Set a location with context (an unlocated scene is publishable but cannot render).",
-                });
-            }
-            for (const ref of ctxLocations) {
-                const locationId = strOf(ref["location_id"]);
-                const stateId = strOf(ref["state_id"]);
-                if (!locationIds.has(locationId)) {
-                    issues.push({
-                        code: "DANGLING_LOCATION_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Location ref not found: ${locationId || "<empty>"}`,
-                        repair_hint: "Patch scene location to an existing location_id.",
-                    });
-                }
-                if (stateId && !(stateIdsByAsset.get(locationId) ?? new Set()).has(stateId)) {
-                    issues.push({
-                        code: "DANGLING_LOCATION_STATE_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Location state ref not found: ${stateId}`,
-                        repair_hint: "Patch location state_id or asset states.",
-                    });
-                }
-            }
-            for (const ref of asList(ctx["actors"])) {
-                const actorId = strOf(ref["actor_id"]);
-                const stateId = strOf(ref["state_id"]);
-                if (!actorIds.has(actorId)) {
-                    issues.push({
-                        code: "DANGLING_ACTOR_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Actor ref not found: ${actorId || "<empty>"}`,
-                        repair_hint: "Patch scene actor refs to existing actor_id.",
-                    });
-                }
-                if (stateId && !(stateIdsByAsset.get(actorId) ?? new Set()).has(stateId)) {
-                    issues.push({
-                        code: "DANGLING_ACTOR_STATE_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Actor state ref not found: ${stateId}`,
-                        repair_hint: "Patch actor state_id or asset states.",
-                    });
-                }
-            }
-            for (const ref of asList(ctx["props"])) {
-                const propId = strOf(ref["prop_id"]);
-                const stateId = strOf(ref["state_id"]);
-                if (!propIds.has(propId)) {
-                    issues.push({
-                        code: "DANGLING_PROP_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Prop ref not found: ${propId || "<empty>"}`,
-                        repair_hint: "Patch scene prop refs to existing prop_id.",
-                    });
-                }
-                if (stateId && !(stateIdsByAsset.get(propId) ?? new Set()).has(stateId)) {
-                    issues.push({
-                        code: "DANGLING_PROP_STATE_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        summary: `Prop state ref not found: ${stateId}`,
-                        repair_hint: "Patch prop state_id or asset states.",
-                    });
-                }
-            }
-            const actionsArr = asList(scene["actions"]);
-            if (actionsArr.length === 0) {
-                issues.push({
-                    code: "SCENE_WITHOUT_ACTIONS",
-                    severity: "warning",
-                    incomplete_ok: true,
-                    episode: ep["episode_id"],
-                    scene: scene["scene_id"],
-                    summary: "Scene has no actions.",
-                    repair_hint: "Add actions with insert (an empty scene is publishable but renders to nothing).",
-                });
-            }
-            for (let actionIndex = 0; actionIndex < actionsArr.length; actionIndex++) {
-                const action = actionsArr[actionIndex];
-                totalActions += 1;
-                const kind = strOf(action["type"]).trim();
-                if (!ACTION_TYPE_VALUES.has(kind)) {
-                    issues.push({
-                        code: "ENUM_ACTION_TYPE",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        action_index: actionIndex,
-                        summary: `action.type invalid: ${kind || "<empty>"}`,
-                        repair_hint: "Patch action.type to dialogue, inner_thought, or action.",
-                    });
-                }
-                const content = strOf(action["content"]).trim();
-                const hasOverlapLines = action["delivery"] === "overlap" && isList(action["lines"]) && action["lines"].length > 0;
-                if (!content && !hasOverlapLines) {
-                    issues.push({
-                        code: "EMPTY_ACTION_CONTENT",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        action_index: actionIndex,
-                        summary: "Action content is empty.",
-                        repair_hint: "Patch content from a source span.",
-                    });
-                }
-                if (content && contentHasSpeakerPrefix(content, speakerDisplayNames)) {
-                    issues.push({
-                        code: "DIALOGUE_CONTENT_SPEAKER_PREFIX",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        action_index: actionIndex,
-                        summary: "Dialogue content appears to contain speaker prefixes.",
-                        repair_hint: "Move speaker labels into speaker_id/speakers/lines and keep content as spoken text only.",
-                    });
-                }
-                if (action["type"] === "dialogue") {
-                    const delivery = strOf(action["delivery"] || "single");
-                    if (!DELIVERY_VALUES.has(delivery)) {
-                        issues.push({
-                            code: "ENUM_DIALOGUE_DELIVERY",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: `dialogue.delivery invalid: ${delivery}`,
-                            repair_hint: "Use single, simultaneous, overlap, or group.",
-                        });
-                    }
-                    if (delivery === "overlap") {
-                        const lines = asList(action["lines"]);
-                        if (lines.length === 0) {
-                            issues.push({
-                                code: "DIALOGUE_OVERLAP_LINES_EMPTY",
-                                severity: "error",
-                                episode: ep["episode_id"],
-                                scene: scene["scene_id"],
-                                action_index: actionIndex,
-                                summary: "Overlapping dialogue has no lines.",
-                                repair_hint: "Add lines with speaker_id and content.",
-                            });
-                        }
-                        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-                            const line = lines[lineIdx] ?? {};
-                            const sid = strOf(line["speaker_id"]);
-                            const lineContent = strOf(line["content"]).trim();
-                            if (!speakerIds.has(sid)) {
-                                issues.push({
-                                    code: "DANGLING_DIALOGUE_SPEAKER_REF",
-                                    severity: "error",
-                                    episode: ep["episode_id"],
-                                    scene: scene["scene_id"],
-                                    action_index: actionIndex,
-                                    summary: `Overlap line speaker not found: ${sid || "<empty>"}`,
-                                    repair_hint: "Patch speaker_id or add a speaker.",
-                                });
-                            }
-                            if (!lineContent) {
-                                issues.push({
-                                    code: "EMPTY_DIALOGUE_LINE",
-                                    severity: "error",
-                                    episode: ep["episode_id"],
-                                    scene: scene["scene_id"],
-                                    action_index: actionIndex,
-                                    summary: `Overlap line ${lineIdx} content is empty.`,
-                                    repair_hint: "Patch line content.",
-                                });
-                            }
-                            else if (contentHasSpeakerPrefix(lineContent, speakerDisplayNames)) {
-                                issues.push({
-                                    code: "DIALOGUE_CONTENT_SPEAKER_PREFIX",
-                                    severity: "error",
-                                    episode: ep["episode_id"],
-                                    scene: scene["scene_id"],
-                                    action_index: actionIndex,
-                                    summary: `Overlap line ${lineIdx} content contains a speaker prefix.`,
-                                    repair_hint: "Keep each overlap line content as spoken text only.",
-                                });
-                            }
-                        }
-                    }
-                    else if (action["speakers"]) {
-                        const speakersInAction = asList(action["speakers"]);
-                        if (speakersInAction.length === 0) {
-                            issues.push({
-                                code: "DIALOGUE_SPEAKERS_INVALID",
-                                severity: "error",
-                                episode: ep["episode_id"],
-                                scene: scene["scene_id"],
-                                action_index: actionIndex,
-                                summary: "dialogue.speakers must be an array.",
-                                repair_hint: "Patch speakers list.",
-                            });
-                        }
-                        for (const speaker of speakersInAction) {
-                            const sid = strOf(speaker["speaker_id"]);
-                            if (!speakerIds.has(sid)) {
-                                issues.push({
-                                    code: "DANGLING_DIALOGUE_SPEAKER_REF",
-                                    severity: "error",
-                                    episode: ep["episode_id"],
-                                    scene: scene["scene_id"],
-                                    action_index: actionIndex,
-                                    summary: `Dialogue speaker not found: ${sid || "<empty>"}`,
-                                    repair_hint: "Patch speaker_id or add a speaker.",
-                                });
-                            }
-                        }
-                    }
-                    else if (action["speaker_id"]) {
-                        const sid = strOf(action["speaker_id"]);
-                        if (!speakerIds.has(sid)) {
-                            issues.push({
-                                code: "DANGLING_DIALOGUE_SPEAKER_REF",
-                                severity: "error",
-                                episode: ep["episode_id"],
-                                scene: scene["scene_id"],
-                                action_index: actionIndex,
-                                summary: `Dialogue speaker not found: ${sid}`,
-                                repair_hint: "Patch speaker_id or add a speaker.",
-                            });
-                        }
-                    }
-                    else if (!action["actor_id"]) {
-                        issues.push({
-                            code: "DIALOGUE_WITHOUT_SPEAKER",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: "Dialogue has no speaker.",
-                            repair_hint: "Patch speaker_id, speakers, lines, or legacy actor_id.",
-                        });
-                    }
-                }
-                if (action["type"] === "inner_thought") {
-                    const sid = strOf(action["speaker_id"]);
-                    if (sid && !speakerIds.has(sid)) {
-                        issues.push({
-                            code: "DANGLING_DIALOGUE_SPEAKER_REF",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: `Inner thought speaker not found: ${sid}`,
-                            repair_hint: "Patch speaker_id or add a speaker.",
-                        });
-                    }
-                    if (!action["actor_id"] && !sid) {
-                        issues.push({
-                            code: "DIALOGUE_WITHOUT_ACTOR",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: "Inner thought has no actor_id or speaker_id.",
-                            repair_hint: "Patch actor_id, speaker_id, or speaker registry.",
-                        });
-                    }
-                }
-                if (action["actor_id"] && !actorIds.has(strOf(action["actor_id"]))) {
-                    issues.push({
-                        code: "DANGLING_ACTION_ACTOR_REF",
-                        severity: "error",
-                        episode: ep["episode_id"],
-                        scene: scene["scene_id"],
-                        action_index: actionIndex,
-                        summary: `Action actor_id not found: ${action["actor_id"]}`,
-                        repair_hint: "Patch action actor_id to an existing actor.",
-                    });
-                }
-                for (const change of asList(action["state_changes"])) {
-                    const targetKind = strOf(change["target_kind"]);
-                    const targetId = strOf(change["target_id"]);
-                    const fromStateId = strOf(change["from_state_id"]);
-                    const toStateId = strOf(change["to_state_id"]);
-                    const effectiveFrom = strOf(change["effective_from"] || "after_action");
-                    if (!SCRIPT_TARGET_KINDS.has(targetKind)) {
-                        issues.push({
-                            code: "STATE_CHANGE_TARGET_KIND_INVALID",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: `state_changes target_kind invalid: ${targetKind || "<empty>"}`,
-                            repair_hint: "Use actor, location, or prop.",
-                        });
-                        continue;
-                    }
-                    const validIds = { actor: actorIds, location: locationIds, prop: propIds }[targetKind];
-                    if (!validIds.has(targetId)) {
-                        issues.push({
-                            code: "DANGLING_STATE_CHANGE_TARGET_REF",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: `State change target not found: ${targetKind}:${targetId}`,
-                            repair_hint: "Patch target_id.",
-                        });
-                    }
-                    for (const [label, sid] of [["from_state_id", fromStateId], ["to_state_id", toStateId]]) {
-                        if (sid && !(stateIdsByAsset.get(targetId) ?? new Set()).has(sid)) {
-                            issues.push({
-                                code: "DANGLING_STATE_CHANGE_STATE_REF",
-                                severity: "error",
-                                episode: ep["episode_id"],
-                                scene: scene["scene_id"],
-                                action_index: actionIndex,
-                                summary: `State change ${label} not found: ${sid}`,
-                                repair_hint: "Patch state change or asset states.",
-                            });
-                        }
-                    }
-                    if (!EFFECTIVE_FROM_VALUES.has(effectiveFrom)) {
-                        issues.push({
-                            code: "ENUM_STATE_CHANGE_EFFECTIVE_FROM",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: `effective_from invalid: ${effectiveFrom}`,
-                            repair_hint: "Use before_action or after_action.",
-                        });
-                    }
-                }
-                const transition = action["transition_prompt"];
-                if (transition !== null && transition !== undefined) {
-                    if (!isDict(transition)) {
-                        issues.push({
-                            code: "TRANSITION_PROMPT_INVALID",
-                            severity: "error",
-                            episode: ep["episode_id"],
-                            scene: scene["scene_id"],
-                            action_index: actionIndex,
-                            summary: "transition_prompt must be an object.",
-                            repair_hint: "Patch or clear transition_prompt.",
-                        });
-                    }
-                    else {
-                        const targetKind = strOf(transition["target_kind"]);
-                        const targetId = strOf(transition["target_id"]);
-                        if (!SCRIPT_TARGET_KINDS.has(targetKind)) {
-                            issues.push({
-                                code: "TRANSITION_PROMPT_TARGET_KIND_INVALID",
-                                severity: "error",
-                                episode: ep["episode_id"],
-                                scene: scene["scene_id"],
-                                action_index: actionIndex,
-                                summary: `transition target_kind invalid: ${targetKind || "<empty>"}`,
-                                repair_hint: "Use actor, location, or prop.",
-                            });
-                        }
-                        else {
-                            const validIds = { actor: actorIds, location: locationIds, prop: propIds }[targetKind];
-                            if (!validIds.has(targetId)) {
-                                issues.push({
-                                    code: "DANGLING_TRANSITION_TARGET_REF",
-                                    severity: "error",
-                                    episode: ep["episode_id"],
-                                    scene: scene["scene_id"],
-                                    action_index: actionIndex,
-                                    summary: `Transition target not found: ${targetKind}:${targetId}`,
-                                    repair_hint: "Patch transition target.",
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    const hasBlocking = issues.some((it) => it["severity"] === "blocking");
-    const hasErrors = issues.some((it) => it["severity"] === "error");
-    const validation = {
-        passed: !hasBlocking && !hasErrors,
-        has_blocking: hasBlocking,
-        issues,
-        stats: {
-            episodes: episodes.length,
-            scenes: totalScenes,
-            actions: totalActions,
-            actors: asList(script["actors"]).length,
-            locations: asList(script["locations"]).length,
-            props: asList(script["props"]).length,
-            speakers: asList(script["speakers"]).length,
-        },
-        script_path: opts.scriptData !== undefined ? "<in-memory>" : (scriptPath ?? path.join(dd, "script.initial.json")),
-        validated_at: new Date().toISOString().replace(/\.\d+Z$/, "Z"),
-    };
-    // persist defaults to true (direct/write flows write validation.json into
-    // directDir); callers that want a side-effect-free check (e.g. `parse`) pass
-    // persist:false so no direct artifacts are created.
-    if (opts.persist !== false)
-        writeJson(path.join(dd, "validation.json"), validation);
-    return validation;
-}
-// ---------------------------------------------------------------------------
-// Resolve/lookup helpers
-// ---------------------------------------------------------------------------
-function resolveAsset(items, idKey, nameKey, raw) {
-    for (const item of items) {
-        if (raw === item[idKey] || raw === item[nameKey])
-            return item;
-    }
-    return null;
-}
-const ASSET_KEY_MAP = {
-    actor: ["actors", "actor_id", "actor_name"],
-    location: ["locations", "location_id", "location_name"],
-    prop: ["props", "prop_id", "prop_name"],
-};
-export function assetKeys(assetType) {
-    const entry = ASSET_KEY_MAP[assetType];
-    if (!entry) {
-        throw new CliError("PATCH BLOCKED: Asset type invalid", "Asset type invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["asset_type: actor, location, or prop"],
-            received: [`asset_type: ${assetType}`],
-            nextSteps: ["Fix the patch operation and rerun patch."],
-        });
-    }
-    return entry;
-}
-function resolvePatchAsset(script, op, assetType = null) {
-    const kind = strOf(assetType || op["asset_type"]);
-    const [key, idKey, nameKey] = assetKeys(kind);
-    const raw = op[idKey] ?? op["id"] ?? op["name"] ?? op[nameKey];
-    const asset = resolveAsset(asList(script[key]), idKey, nameKey, strOf(raw));
-    if (!asset) {
-        throw new CliError("PATCH BLOCKED: Asset not found", "Asset not found.", {
-            exitCode: EXIT_USAGE,
-            required: [`existing ${idKey} or ${nameKey}`],
-            received: [JSON.stringify(op)],
-            nextSteps: ["Inspect assets and fix the patch."],
-        });
-    }
-    return [asset, idKey, nameKey];
-}
-function nextStateId(script) {
-    const ids = [];
-    for (const key of ["actors", "locations", "props"]) {
-        for (const asset of asList(script[key])) {
-            for (const state of asList(asset["states"]))
-                ids.push(state["state_id"]);
-        }
-    }
-    return nextSeqId(ids, "st");
-}
-function normalizeStates(script, rawStates, assetKind = "") {
-    if (!isList(rawStates)) {
-        throw new CliError("PATCH BLOCKED: States invalid", "States invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["states: array of state names or {state_id,state_name} objects"],
-            received: [typeof rawStates],
-            nextSteps: ["Fix the patch operation and rerun patch."],
-        });
-    }
-    let maxSeen = 0;
-    for (const key of ["actors", "locations", "props"]) {
-        for (const asset of asList(script[key])) {
-            for (const state of asList(asset["states"])) {
-                const m = /^st_(\d+)$/.exec(strOf(state["state_id"]));
-                if (m)
-                    maxSeen = Math.max(maxSeen, parseInt(m[1], 10));
-            }
-        }
-    }
-    const states = [];
-    const seenNames = new Set();
-    for (const raw of rawStates) {
-        let name = "";
-        let sid = "";
-        if (typeof raw === "string") {
-            name = raw.trim();
-            maxSeen += 1;
-            sid = fmtId("st", maxSeen);
-        }
-        else if (isDict(raw)) {
-            name = strOf(raw["state_name"] || raw["name"]).trim();
-            sid = strOf(raw["state_id"] || raw["id"]).trim();
-            if (!sid) {
-                maxSeen += 1;
-                sid = fmtId("st", maxSeen);
-            }
-        }
-        else
-            continue;
-        if (!name || seenNames.has(name))
-            continue;
-        if (assetKind === "actor") {
-            const reason = stateLabelError(name);
-            if (reason) {
-                throw new CliError("PATCH BLOCKED: State label invalid", "State label invalid.", {
-                    exitCode: EXIT_USAGE,
-                    required: ["one clear state label"],
-                    received: [name],
-                    nextSteps: ["Do not combine multiple states into one label."],
-                    errorCode: "STATE_LABEL_INVALID",
-                });
-            }
-        }
-        seenNames.add(name);
-        states.push({ state_id: sid, state_name: name });
-    }
-    return states;
-}
-export function ensureRefId(script, assetType, rawId, opts = {}) {
-    const allowNone = opts.allowNone ?? false;
-    if (rawId === null && allowNone)
-        return null;
-    const value = strOf(rawId).trim();
-    if (!value && allowNone)
-        return null;
-    const [key, idKey] = assetKeys(assetType);
-    const valid = new Set();
-    for (const item of asList(script[key]))
-        valid.add(strOf(item[idKey]));
-    if (!valid.has(value)) {
-        throw new CliError("PATCH BLOCKED: Reference target not found", "Reference target not found.", {
-            exitCode: EXIT_USAGE,
-            required: [`existing ${idKey}`],
-            received: [`${idKey}: ${value || "<empty>"}`],
-            nextSteps: ["Inspect assets and fix the patch."],
-        });
-    }
-    return value;
-}
-function idKeyForKind(kind) {
-    const map = { actor: "actor_id", location: "location_id", prop: "prop_id" };
-    return map[kind];
-}
-function pluralForKind(kind) {
-    const map = { actor: "actors", location: "locations", prop: "props" };
-    return map[kind];
-}
-export function parseAssetTarget(raw) {
-    const value = strOf(raw).trim();
-    if (!value.includes(":")) {
-        throw new CliError("SCRIPT OP BLOCKED: Target invalid", "Target invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["target: actor:<id>, location:<id>, or prop:<id>"],
-            received: [value || "<empty>"],
-            nextSteps: ["Use a concrete asset target."],
-            errorCode: "TARGET_INVALID",
-        });
-    }
-    const idx = value.indexOf(":");
-    const kind = value.slice(0, idx).trim();
-    const targetId = value.slice(idx + 1).trim();
-    if (!SCRIPT_TARGET_KINDS.has(kind) || !targetId) {
-        throw new CliError("SCRIPT OP BLOCKED: Target invalid", "Target invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["target: actor:<id>, location:<id>, or prop:<id>"],
-            received: [value],
-            nextSteps: ["Use actor, location, or prop with a non-empty id."],
-            errorCode: "TARGET_INVALID",
-        });
-    }
-    return [kind, targetId];
-}
-export function parseStateTarget(raw) {
-    const value = strOf(raw).trim();
-    if (!value.includes("/")) {
-        throw new CliError("SCRIPT OP BLOCKED: State target invalid", "State target invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["state target: actor:<id>/<state_id>"],
-            received: [value || "<empty>"],
-            nextSteps: ["Use a concrete state target."],
-            errorCode: "STATE_TARGET_INVALID",
-        });
-    }
-    const lastSlash = value.lastIndexOf("/");
-    const assetRaw = value.slice(0, lastSlash);
-    const stateId = value.slice(lastSlash + 1).trim();
-    const [kind, targetId] = parseAssetTarget(assetRaw);
-    if (!stateId) {
-        throw new CliError("SCRIPT OP BLOCKED: State target invalid", "State target invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["state_id after '/'"],
-            received: [value],
-            nextSteps: ["Use a non-empty state_id."],
-            errorCode: "STATE_TARGET_INVALID",
-        });
-    }
-    return [kind, targetId, stateId];
-}
-export function parseSceneRef(raw) {
-    const value = strOf(raw).trim();
-    if (!value.includes("/")) {
-        throw new CliError("SCRIPT OP BLOCKED: Scene ref invalid", "Scene ref invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["scene ref: ep_001/scn_001"],
-            received: [value || "<empty>"],
-            nextSteps: ["Use ep_id/scn_id."],
-            errorCode: "SCENE_REF_INVALID",
-        });
-    }
-    const idx = value.indexOf("/");
-    return [value.slice(0, idx).trim(), value.slice(idx + 1).trim()];
-}
-export function parseActionRef(raw) {
-    const value = strOf(raw).trim();
-    if (!value.includes("#")) {
-        throw new CliError("SCRIPT OP BLOCKED: Action ref invalid", "Action ref invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["action ref: ep_001/scn_001#4"],
-            received: [value || "<empty>"],
-            nextSteps: ["Use ep_id/scn_id#action_index."],
-            errorCode: "ACTION_REF_INVALID",
-        });
-    }
-    const lastHash = value.lastIndexOf("#");
-    const sceneRaw = value.slice(0, lastHash);
-    const indexRaw = value.slice(lastHash + 1);
-    const [epId, sceneId] = parseSceneRef(sceneRaw);
-    const actionIndex = parseInt(indexRaw, 10);
-    if (Number.isNaN(actionIndex)) {
-        throw new CliError("SCRIPT OP BLOCKED: Action index invalid", "Action index invalid.", {
-            exitCode: EXIT_USAGE,
-            required: ["integer action index after '#'"],
-            received: [value],
-            nextSteps: ["Use a zero-based action index."],
-            errorCode: "ACTION_INDEX_INVALID",
-        });
-    }
-    return [epId, sceneId, actionIndex];
-}
-function resolveAssetByTarget(script, kind, targetId) {
-    const [key, idKey] = assetKeys(kind);
-    for (const item of asList(script[key])) {
-        if (strOf(item[idKey]) === targetId)
-            return item;
-    }
-    throw new CliError("SCRIPT OP BLOCKED: Asset not found", "Asset not found.", {
-        exitCode: EXIT_USAGE,
-        required: [`existing ${kind} id`],
-        received: [`${kind}:${targetId}`],
-        nextSteps: ["Inspect assets and fix the target."],
-        errorCode: "ASSET_NOT_FOUND",
-    });
-}
-function resolveState(script, kind, targetId, stateId) {
-    const asset = resolveAssetByTarget(script, kind, targetId);
-    for (const state of asList(asset["states"])) {
-        if (strOf(state["state_id"]) === stateId)
-            return state;
-    }
-    throw new CliError("SCRIPT OP BLOCKED: State not found", "State not found.", {
-        exitCode: EXIT_USAGE,
-        required: ["existing state_id on the target asset"],
-        received: [`${kind}:${targetId}/${stateId}`],
-        nextSteps: ["Inspect states and fix the target."],
-        errorCode: "STATE_NOT_FOUND",
-    });
-}
-function validateStateForTarget(script, kind, targetId, stateId) {
-    const value = strOf(stateId).trim();
-    if (!value)
-        return null;
-    resolveState(script, kind, targetId, value);
-    return value;
-}
-function nextSpeakerId(script, sourceKind, sourceId = null) {
-    const existing = new Set();
-    for (const item of asList(script["speakers"]))
-        existing.add(strOf(item["speaker_id"]));
-    if (sourceKind === "actor" && sourceId) {
-        const candidate = `spk_${sourceId}`;
-        if (!existing.has(candidate))
-            return candidate;
-    }
-    let maxSeen = 0;
-    const prefix = `spk_${sourceKind}_`;
-    for (const id of existing) {
-        if (id.startsWith(prefix)) {
-            const m = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\d+)$`).exec(id);
-            if (m)
-                maxSeen = Math.max(maxSeen, parseInt(m[1], 10));
-        }
-    }
-    return `${prefix}${String(maxSeen + 1).padStart(3, "0")}`;
-}
-function speakerSourceActorId(script, speakerId) {
-    for (const speaker of asList(script["speakers"])) {
-        if (strOf(speaker["speaker_id"]) === speakerId && speaker["source_kind"] === "actor") {
-            return strOf(speaker["source_id"]).trim() || null;
-        }
-    }
-    return null;
-}
-function ensureSpeakerId(script, speakerId) {
-    const value = strOf(speakerId).trim();
-    const valid = new Set();
-    for (const item of asList(script["speakers"]))
-        valid.add(strOf(item["speaker_id"]));
-    if (!valid.has(value)) {
-        throw new CliError("SCRIPT OP BLOCKED: Speaker not found", "Speaker not found.", {
-            exitCode: EXIT_USAGE,
-            required: ["existing speaker_id"],
-            received: [value || "<empty>"],
-            nextSteps: ["Add a speaker first, or fix the dialogue patch."],
-            errorCode: "SPEAKER_NOT_FOUND",
-        });
-    }
-    return value;
-}
-function contextRefsForKind(context, kind) {
-    return asList(context[pluralForKind(kind)]);
-}
-function findContextRef(context, kind, targetId) {
-    const idKey = idKeyForKind(kind);
-    for (const ref of contextRefsForKind(context, kind)) {
-        if (strOf(ref[idKey]) === targetId)
-            return ref;
-    }
-    return null;
-}
-function setContextState(script, epId, sceneId, kind, targetId, stateId) {
-    ensureRefId(script, kind, targetId);
-    const normalizedState = validateStateForTarget(script, kind, targetId, stateId);
-    const scene = findScene(script, epId, sceneId);
-    const ctx = sceneContext(scene);
-    const idKey = idKeyForKind(kind);
-    // location is single-valued per scene by direct-init invariant; the legacy
-    // set_scene_location_ref op replaced the whole locations[] array to preserve
-    // that. Mirror it here: for location kind, context.set REPLACES (one entry
-    // total). actor/prop stay upsert because multi-actor / multi-prop per scene
-    // is intentional.
-    if (kind === "location") {
-        ctx[pluralForKind(kind)] = [{ [idKey]: targetId, state_id: normalizedState }];
-        setSceneContext(scene, ctx);
-        return;
-    }
-    const refs = [...contextRefsForKind(ctx, kind)];
-    const existing = refs.find((ref) => strOf(ref[idKey]) === targetId);
-    if (existing) {
-        existing["state_id"] = normalizedState;
-    }
-    else {
-        refs.push({ [idKey]: targetId, state_id: normalizedState });
-    }
-    ctx[pluralForKind(kind)] = refs;
-    setSceneContext(scene, ctx);
-}
-function inferStateBeforeAction(script, epId, sceneId, actionIndex, kind, targetId) {
-    const scene = findScene(script, epId, sceneId);
-    const ctx = sceneContext(scene);
-    let current = null;
-    const ref = findContextRef(ctx, kind, targetId);
-    if (ref)
-        current = strOf(ref["state_id"]).trim() || null;
-    const actions = asList(scene["actions"]);
-    for (let i = 0; i < actionIndex && i < actions.length; i++) {
-        for (const change of asList(actions[i]["state_changes"])) {
-            if (strOf(change["target_kind"]) === kind && strOf(change["target_id"]) === targetId) {
-                const toState = strOf(change["to_state_id"]).trim();
-                if (toState)
-                    current = toState;
-            }
-        }
-    }
-    return current;
-}
-function stateRefSummary(kind, targetId, stateId, location, role) {
-    return { target: `${kind}:${targetId}/${stateId}`, location, role };
-}
-export function collectStateRefs(script, kind, targetId, stateId) {
-    const refs = [];
-    const idKey = idKeyForKind(kind);
-    for (const ep of asList(script["episodes"])) {
-        const epId = strOf(ep["episode_id"]);
-        for (const scene of asList(ep["scenes"])) {
-            const sceneId = strOf(scene["scene_id"]);
-            const ctx = sceneContext(scene);
-            const refsList = contextRefsForKind(ctx, kind);
-            for (let idx = 0; idx < refsList.length; idx++) {
-                const ref = refsList[idx];
-                if (strOf(ref[idKey]) === targetId && strOf(ref["state_id"]) === stateId) {
-                    refs.push(stateRefSummary(kind, targetId, stateId, `${epId}/${sceneId}.context.${pluralForKind(kind)}[${idx}]`, "scene_initial_state"));
-                }
-            }
-            const actions = asList(scene["actions"]);
-            for (let actionIdx = 0; actionIdx < actions.length; actionIdx++) {
-                const changes = asList(actions[actionIdx]["state_changes"]);
-                for (let changeIdx = 0; changeIdx < changes.length; changeIdx++) {
-                    const change = changes[changeIdx];
-                    if (strOf(change["target_kind"]) !== kind || strOf(change["target_id"]) !== targetId)
-                        continue;
-                    if (strOf(change["from_state_id"]) === stateId) {
-                        refs.push(stateRefSummary(kind, targetId, stateId, `${epId}/${sceneId}#${actionIdx}.state_changes[${changeIdx}].from_state_id`, "state_change_from"));
-                    }
-                    if (strOf(change["to_state_id"]) === stateId) {
-                        refs.push(stateRefSummary(kind, targetId, stateId, `${epId}/${sceneId}#${actionIdx}.state_changes[${changeIdx}].to_state_id`, "state_change_to"));
-                    }
-                }
-            }
-        }
-    }
-    return refs;
-}
-// Try each format in order. The order matters: action (has `#`) is checked
-// before scene (just `/`), and asset+state (has `:`) is checked before scene.
-// Episode and speaker are bare ids (no separators) distinguished by prefix.
-export function parseAnyAddress(raw) {
-    const value = strOf(raw).trim();
-    if (!value) {
-        throw new CliError("ADDRESS BLOCKED: Address empty", "Address empty.", {
-            exitCode: EXIT_USAGE,
-            required: ["one of the supported address formats"],
-            received: ["<empty>"],
-            nextSteps: ["Pass an address like ep_001/scn_001#3, ep_001/scn_001, actor:act_001, actor:act_001/st_001, ep_001, or spk_001."],
-            errorCode: "ADDRESS_EMPTY",
-        });
-    }
-    if (value.includes("#")) {
-        const [episodeId, sceneId, actionIndex] = parseActionRef(value);
-        return { kind: "action", episodeId, sceneId, actionIndex };
-    }
-    if (value.includes(":")) {
-        if (value.slice(value.indexOf(":") + 1).includes("/")) {
-            const [assetKind, assetId, stateId] = parseStateTarget(value);
-            return { kind: "state", assetKind, assetId, stateId };
-        }
-        const [assetKind, assetId] = parseAssetTarget(value);
-        return { kind: "asset", assetKind, assetId };
-    }
-    if (value.includes("/")) {
-        const [episodeId, sceneId] = parseSceneRef(value);
-        return { kind: "scene", episodeId, sceneId };
-    }
-    if (/^ep_/.test(value)) {
-        return { kind: "episode", episodeId: value };
-    }
-    if (/^spk_/.test(value)) {
-        return { kind: "speaker", speakerId: value };
-    }
-    throw new CliError("ADDRESS BLOCKED: Address invalid", "Address invalid.", {
-        exitCode: EXIT_USAGE,
-        required: [
-            "address: ep_NNN/scn_NNN#idx (action) | ep_NNN/scn_NNN (scene) | actor|location|prop:id (asset) | actor|location|prop:id/state_id (state) | ep_NNN (episode) | spk_XXX (speaker)",
-        ],
-        received: [value],
-        nextSteps: ["Use a recognized address format."],
-        errorCode: "ADDRESS_INVALID",
-    });
-}
-// Reverse lookup for asset / speaker references. Parallel to collectStateRefs
-// but tracks where an actor/location/prop/speaker is mentioned rather than
-// where a specific state is mentioned. Returns one `{target, location, role}`
-// entry per reference site. Walks the same edges the validator does
-// (script-core.ts validateScript) so coverage is complete:
-//   - scene.context.{actors|locations|props}[]
-//   - action.actor_id (actor only)
-//   - action.speaker_id + action.speakers[] + action.lines[].speaker_id (speaker only)
-//   - action.state_changes[].target_{kind,id}
-//   - action.transition_prompt.target_{kind,id}
-//   - script.speakers[].source_{kind,id} (for actor/location/prop reverse)
-export function collectAssetRefs(script, kind, targetId) {
-    const refs = [];
-    const isSpeaker = kind === "speaker";
-    const target = isSpeaker ? `speaker:${targetId}` : `${kind}:${targetId}`;
-    const idKey = isSpeaker ? null : idKeyForKind(kind);
-    for (const ep of asList(script["episodes"])) {
-        const epId = strOf(ep["episode_id"]);
-        for (const scene of asList(ep["scenes"])) {
-            const sceneId = strOf(scene["scene_id"]);
-            if (!isSpeaker) {
-                const ctx = sceneContext(scene);
-                const refsList = contextRefsForKind(ctx, kind);
-                for (let i = 0; i < refsList.length; i++) {
-                    if (strOf(refsList[i][idKey]) === targetId) {
-                        refs.push({
-                            target,
-                            location: `${epId}/${sceneId}.context.${pluralForKind(kind)}[${i}]`,
-                            role: `scene_${pluralForKind(kind)}`,
-                        });
-                    }
-                }
-            }
-            const actions = asList(scene["actions"]);
-            for (let actionIdx = 0; actionIdx < actions.length; actionIdx++) {
-                const action = actions[actionIdx];
-                if (kind === "actor" && strOf(action["actor_id"]) === targetId) {
-                    refs.push({
-                        target,
-                        location: `${epId}/${sceneId}#${actionIdx}.actor_id`,
-                        role: "action_actor",
-                    });
-                }
-                if (isSpeaker) {
-                    if (strOf(action["speaker_id"]) === targetId) {
-                        refs.push({
-                            target,
-                            location: `${epId}/${sceneId}#${actionIdx}.speaker_id`,
-                            role: "action_speaker",
-                        });
-                    }
-                    const speakers = asList(action["speakers"]);
-                    for (let i = 0; i < speakers.length; i++) {
-                        if (strOf(speakers[i]["speaker_id"]) === targetId) {
-                            refs.push({
-                                target,
-                                location: `${epId}/${sceneId}#${actionIdx}.speakers[${i}]`,
-                                role: "dialogue_speaker",
-                            });
-                        }
-                    }
-                    const lines = asList(action["lines"]);
-                    for (let i = 0; i < lines.length; i++) {
-                        if (strOf(lines[i]["speaker_id"]) === targetId) {
-                            refs.push({
-                                target,
-                                location: `${epId}/${sceneId}#${actionIdx}.lines[${i}].speaker_id`,
-                                role: "overlap_line_speaker",
-                            });
-                        }
-                    }
-                }
-                if (!isSpeaker) {
-                    const changes = asList(action["state_changes"]);
-                    for (let i = 0; i < changes.length; i++) {
-                        const change = changes[i];
-                        if (strOf(change["target_kind"]) === kind && strOf(change["target_id"]) === targetId) {
-                            refs.push({
-                                target,
-                                location: `${epId}/${sceneId}#${actionIdx}.state_changes[${i}]`,
-                                role: "state_change_target",
-                            });
-                        }
-                    }
-                    const transition = action["transition_prompt"];
-                    if (isDict(transition) && strOf(transition["target_kind"]) === kind && strOf(transition["target_id"]) === targetId) {
-                        refs.push({
-                            target,
-                            location: `${epId}/${sceneId}#${actionIdx}.transition_prompt`,
-                            role: "transition_target",
-                        });
-                    }
-                }
-            }
-        }
-    }
-    // Speaker registrations pointing at this asset (actor/location/prop only).
-    // A speaker.source_id ties an actor/location/prop to a speaker entity; the
-    // speaker entry itself counts as a reference, so deleting / merging the
-    // asset must surface it.
-    if (!isSpeaker) {
-        const speakers = asList(script["speakers"]);
-        for (let i = 0; i < speakers.length; i++) {
-            const s = speakers[i];
-            if (strOf(s["source_kind"]) === kind && strOf(s["source_id"]) === targetId) {
-                refs.push({
-                    target,
-                    location: `speakers[${i}]`,
-                    role: "speaker_source",
-                });
-            }
-        }
-    }
-    return refs;
-}
-// Asset id prefixes. props use `prp_` (not `prop_`); mirrors direct-init output.
-const ASSET_ID_PREFIX = { actor: "act", location: "loc", prop: "prp" };
-// Next free `<prefix>_NNN` id given the existing ids in a collection. Scans for
-// the max NNN so a manually-chosen id (e.g. act_007) never collides with a later
-// auto-id. The single id-allocation routine behind nextScene/Asset/Episode/State.
-function nextSeqId(existingIds, prefix) {
-    const re = new RegExp(`^${prefix}_(\\d+)$`);
-    let maxSeen = 0;
-    for (const raw of existingIds) {
-        const m = re.exec(strOf(raw));
-        if (m)
-            maxSeen = Math.max(maxSeen, parseInt(m[1], 10));
-    }
-    return fmtId(prefix, maxSeen + 1);
-}
-function nextSceneId(script) {
-    const ids = asList(script["episodes"]).flatMap((ep) => asList(ep["scenes"]).map((s) => s["scene_id"]));
-    return nextSeqId(ids, "scn");
-}
-function nextAssetId(script, kind) {
-    const [key, idKey] = assetKeys(kind);
-    return nextSeqId(asList(script[key]).map((item) => item[idKey]), ASSET_ID_PREFIX[kind]);
-}
-function nextEpisodeId(script) {
-    return nextSeqId(asList(script["episodes"]).map((ep) => ep["episode_id"]), "ep");
-}
-function sceneIdExists(script, sceneId) {
-    for (const ep of asList(script["episodes"])) {
-        for (const scene of asList(ep["scenes"])) {
-            if (scene["scene_id"] === sceneId)
-                return true;
-        }
-    }
-    return false;
-}
-// Shared body for actor.add / location.add / prop.add: validate the name,
-// allocate or accept an id, reject duplicates, and append a minimal entity
-// ({id, name, description, states:[]}). The caller layers on kind-specific
-// fields (actor role_type/aliases). Returns the pushed entity so the caller can
-// extend it. description defaults to "" — an empty description is a completeness
-// warning, not a hard error, so you can register an asset now and describe it
-// later.
-function pushAsset(script, kind, op) {
-    const [collKey, idKey, nameKey] = assetKeys(kind);
-    const name = strOf(op["name"] ?? op[nameKey]).trim();
-    if (!name) {
-        throw opErr("SCRIPT OP BLOCKED: Asset name empty", "Asset name empty.", {
-            required: ["name"], received: [JSON.stringify(op)],
-            nextSteps: [`Provide a ${kind} name.`], op: `${kind}.add`, errorCode: "ASSET_NAME_EMPTY",
-        });
-    }
-    // name is already whitespace-trimmed; cleanName additionally strips trailing/
-    // leading punctuation (：，、…) and embedded 【】（） state annotations. Reuse the
-    // same errorCode validateScript uses for this rule (ASSET_NAME_HAS_STATE_ANNOTATION)
-    // so op-time and validate-time speak one vocabulary; the message stays accurate
-    // for the punctuation-only case too. Suggest the canonical form when there is one
-    // (a name that is entirely punctuation/annotation reduces to "").
-    const canonical = cleanName(name);
-    if (canonical !== name) {
-        const suggestion = canonical
-            ? `Use "${canonical}", and register durable looks with state-add instead of putting them in the name.`
-            : "Provide a real name (this one is only punctuation/annotation); register durable looks with state-add.";
-        throw opErr("SCRIPT OP BLOCKED: Asset name not canonical", "Asset name is not canonical (trailing/leading punctuation or an embedded state annotation).", {
-            required: [canonical ? `canonical name, e.g. "${canonical}"` : "a canonical name without punctuation/annotation"],
-            received: [name],
-            nextSteps: [suggestion], op: `${kind}.add`, errorCode: "ASSET_NAME_HAS_STATE_ANNOTATION",
-        });
-    }
-    const id = strOf(op[idKey] ?? op["id"]).trim() || nextAssetId(script, kind);
-    if (!isList(script[collKey]))
-        script[collKey] = [];
-    const coll = script[collKey];
-    if (coll.some((a) => strOf(a[idKey]) === id)) {
-        throw opErr("SCRIPT OP BLOCKED: Asset id exists", "Asset id exists.", {
-            required: ["unused id"], received: [id],
-            nextSteps: ["Use another --id or omit it to auto-allocate."], op: `${kind}.add`, errorCode: "ASSET_ID_EXISTS",
-        });
-    }
-    const entity = { [idKey]: id, [nameKey]: name, description: strOf(op["description"]).trim(), states: [] };
-    coll.push(entity);
-    return entity;
-}
-function renumberSceneIds(script) {
-    let counter = 0;
-    for (const ep of asList(script["episodes"])) {
-        for (const scene of asList(ep["scenes"])) {
-            counter += 1;
-            scene["scene_id"] = fmtId("scn", counter);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// apply_patch_operations
-// ---------------------------------------------------------------------------
-function opErr(title, message, opts = {}) {
-    return new CliError(title, message, {
-        exitCode: opts.exitCode ?? EXIT_USAGE,
-        required: opts.required,
-        received: opts.received,
-        nextSteps: opts.nextSteps,
-        op: opts.op,
-        errorCode: opts.errorCode,
-    });
-}
-export const PATCH_OP_SCHEMA = {
-    // meta
-    "meta.worldview.set": { required: ["worldview"], optional: ["worldview_raw"], description: "Set the script.worldview enum." },
-    // state
-    "state.add": { required: ["target", "name"], optional: ["description", "state_id"], description: "Add a state to an asset's states[]." },
-    "state.rename": { required: ["target", "name"], optional: [], description: "Rename an asset state." },
-    "state.describe": { required: ["target", "description"], optional: [], description: "Set a state's description." },
-    "state.delete": { required: ["target", "strategy"], optional: ["replacement"], description: "Delete a state. strategy: replace|remove." },
-    // asset
-    "actor.add": { required: ["name"], optional: ["actor_id", "role_type", "description", "aliases"], description: "Register a new actor (human/character). role_type: 主角|配角." },
-    "location.add": { required: ["name"], optional: ["location_id", "description"], description: "Register a new location." },
-    "prop.add": { required: ["name"], optional: ["prop_id", "description"], description: "Register a new prop." },
-    "episode.add": { required: [], optional: ["episode_id", "title"], description: "Append a new empty episode (no scenes)." },
-    "asset.rename": { required: ["target", "name"], optional: [], description: "Rename an asset (actor / location / prop)." },
-    "asset.describe": { required: ["target", "description"], optional: [], description: "Set asset description." },
-    "asset.alias.set": { required: ["target", "aliases"], optional: [], description: "Bulk replace aliases[]." },
-    "asset.alias.add": { required: ["target", "alias"], optional: [], description: "Append alias(es)." },
-    "asset.alias.remove": { required: ["target", "alias"], optional: [], description: "Remove alias(es)." },
-    "asset.states.set": { required: ["target", "states"], optional: ["asset_type"], description: "Bulk replace states[]." },
-    "asset.role.set": { required: ["target", "role_type"], optional: [], description: "Set actor role_type (主角|配角)." },
-    "asset.merge": { required: ["from", "into"], optional: [], description: "Merge from asset into another; from disappears." },
-    "asset.delete": { required: ["target"], optional: ["strategy", "replacement"], description: "Delete an asset. strategy: replace|remove (required if refs exist)." },
-    // action
-    "action.type.set": { required: ["at", "type"], optional: [], description: "Set action.type (dialogue|action|inner_thought)." },
-    "action.actor.set": { required: ["at"], optional: ["actor_id"], description: "Set/clear action.actor_id." },
-    "action.content.replace": { required: ["at", "from"], optional: ["to", "all"], description: "Literal substring replace in action.content." },
-    "action.state.change": { required: ["at", "target", "to"], optional: ["from", "effective"], description: "Add/update a state_change on an action." },
-    "action.state.remove": { required: ["at", "target"], optional: [], description: "Remove a state_change from an action." },
-    "action.transition.set": { required: ["at", "target", "process", "contrast"], optional: [], description: "Set transition_prompt." },
-    "action.transition.clear": { required: ["at", "target"], optional: [], description: "Clear transition_prompt." },
-    "action.delete": { required: ["at"], optional: [], description: "Remove an action; later indices shift." },
-    "action.insert": { required: ["at", "type"], optional: ["content", "at_index", "before", "after", "actor_id", "speaker_id"], description: "Insert an action into a scene." },
-    "action.move": { required: ["at", "to"], optional: [], description: "Move an action (within or across scenes)." },
-    // scene
-    "scene.split": { required: ["at", "at_index"], optional: ["new_scene_id"], description: "Split a scene at an action boundary." },
-    "scene.merge": { required: ["from", "into"], optional: [], description: "Merge two scenes within the same episode." },
-    "scene.delete": { required: ["at"], optional: ["force"], description: "Delete a scene; empty by default, force=true for non-empty." },
-    "scene.move": { required: ["at", "to"], optional: ["at_index"], description: "Move a scene to another episode." },
-    "scene.insert": { required: ["at", "location"], optional: ["time", "space", "at_index", "before", "after", "scene_id"], description: "Insert a new empty scene." },
-    // context
-    "context.set": { required: ["at", "target"], optional: ["state", "state_id"], description: "Upsert (actor/prop) or replace (location) scene context ref + state." },
-    "context.clear": { required: ["at", "target"], optional: [], description: "Keep ref, clear state_id." },
-    "context.ref.remove": { required: ["at", "target"], optional: [], description: "Remove the ref entirely from scene context." },
-    // dialogue / speaker
-    "dialogue.speakers": { required: ["at", "speakers"], optional: ["delivery"], description: "Set dialogue speakers; delivery: single|simultaneous|group." },
-    "dialogue.overlap": { required: ["at", "lines"], optional: [], description: "Set overlap dialogue lines[]." },
-    "speaker.add": { required: ["kind", "name"], optional: ["source_id", "voice_desc", "speaker_id"], description: "Register a new speaker." },
-    "speaker.delete": { required: ["target"], optional: ["strategy", "replacement"], description: "Delete a speaker. strategy: replace|remove (required if refs exist)." },
-};
-export function applyPatchOperations(script, sourceText, operations) {
-    const applied = [];
-    for (const op of operations) {
-        const kind = strOf(op["op"]);
-        if (kind === "state.add") {
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, targetKind, targetId);
-            const name = strOf(op["name"] || op["state_name"]).trim();
-            const description = strOf(op["description"]).trim();
-            const stateId = strOf(op["state_id"]).trim() || nextStateId(script);
-            if (!name) {
-                throw opErr("SCRIPT OP BLOCKED: State name empty", "State name empty.", {
-                    required: ["name"], received: [JSON.stringify(op)],
-                    nextSteps: ["Provide a state name."], op: kind, errorCode: "STATE_NAME_EMPTY",
-                });
-            }
-            const reason = stateRejectionReason(targetKind, name);
-            if (reason) {
-                throw opErr("SCRIPT OP BLOCKED: State label invalid", "State label invalid.", {
-                    required: ["one clear state label"], received: [name],
-                    nextSteps: ["Do not combine multiple states into one label."], op: kind, errorCode: "STATE_LABEL_INVALID",
-                });
-            }
-            if (!isList(asset["states"]))
-                asset["states"] = [];
-            const existingStates = asset["states"];
-            if (existingStates.some((s) => strOf(s["state_id"]) === stateId)) {
-                throw opErr("SCRIPT OP BLOCKED: State id exists", "State id exists.", { required: ["unused state_id"], received: [stateId], nextSteps: ["Use another state_id or edit the existing state."], op: kind, errorCode: "STATE_ID_EXISTS" });
-            }
-            if (existingStates.some((s) => strOf(s["state_name"] || s["name"]) === name)) {
-                throw opErr("SCRIPT OP BLOCKED: State name exists", "State name exists.", { required: ["unused state name"], received: [name], nextSteps: ["Rename the existing state or choose another name."], op: kind, errorCode: "STATE_NAME_EXISTS" });
-            }
-            const state = { state_id: stateId, state_name: name };
-            if (description)
-                state["description"] = description;
-            existingStates.push(state);
-            op["state_id"] = stateId;
-            applied.push(kind);
-        }
-        else if (kind === "state.rename") {
-            const [targetKind, targetId, stateId] = parseStateTarget(op["target"]);
-            const state = resolveState(script, targetKind, targetId, stateId);
-            const name = strOf(op["name"] || op["state_name"]).trim();
-            if (!name) {
-                throw opErr("SCRIPT OP BLOCKED: State name empty", "State name empty.", { required: ["name"], received: [JSON.stringify(op)], nextSteps: ["Provide a state name."], op: kind, errorCode: "STATE_NAME_EMPTY" });
-            }
-            const reason = stateRejectionReason(targetKind, name);
-            if (reason) {
-                throw opErr("SCRIPT OP BLOCKED: State label invalid", "State label invalid.", { required: ["one clear state label"], received: [name], nextSteps: ["Do not combine multiple states into one label."], op: kind, errorCode: "STATE_LABEL_INVALID" });
-            }
-            state["state_name"] = name;
-            applied.push(kind);
-        }
-        else if (kind === "state.describe") {
-            const [targetKind, targetId, stateId] = parseStateTarget(op["target"]);
-            const state = resolveState(script, targetKind, targetId, stateId);
-            state["description"] = strOf(op["description"]).trim();
-            applied.push(kind);
-        }
-        else if (kind === "state.delete") {
-            const [targetKind, targetId, stateId] = parseStateTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, targetKind, targetId);
-            resolveState(script, targetKind, targetId, stateId);
-            const strategy = strOf(op["strategy"]).trim();
-            const replacement = strOf(op["replacement"]).trim();
-            if (strategy !== "replace" && strategy !== "remove") {
-                throw opErr("SCRIPT OP BLOCKED: Delete strategy invalid", "Delete strategy invalid.", { required: ["strategy: replace or remove"], received: [strategy || "<empty>"], nextSteps: ["Choose replace with --replacement, or remove."], op: kind, errorCode: "DELETE_STRATEGY_INVALID" });
-            }
-            if (strategy === "replace") {
-                if (!replacement) {
-                    throw opErr("SCRIPT OP BLOCKED: Replacement missing", "Replacement missing.", { required: ["replacement state_id"], received: ["<empty>"], nextSteps: ["Pass --replacement with an existing state_id."], op: kind, errorCode: "REPLACEMENT_MISSING" });
-                }
-                validateStateForTarget(script, targetKind, targetId, replacement);
-            }
-            const contextField = pluralForKind(targetKind);
-            const idKey = idKeyForKind(targetKind);
-            for (const ep of asList(script["episodes"])) {
-                for (const scene of asList(ep["scenes"])) {
-                    const ctx = sceneContext(scene);
-                    for (const ref of contextRefsForKind(ctx, targetKind)) {
-                        if (strOf(ref[idKey]) === targetId && strOf(ref["state_id"]) === stateId) {
-                            ref["state_id"] = strategy === "replace" ? replacement : null;
-                        }
-                    }
-                    ctx[contextField] = contextRefsForKind(ctx, targetKind);
-                    setSceneContext(scene, ctx);
-                    for (const action of asList(scene["actions"])) {
-                        const nextChanges = [];
-                        for (const change of asList(action["state_changes"])) {
-                            if (strOf(change["target_kind"]) === targetKind && strOf(change["target_id"]) === targetId) {
-                                let touched = false;
-                                for (const stateField of ["from_state_id", "to_state_id"]) {
-                                    if (strOf(change[stateField]) === stateId) {
-                                        touched = true;
-                                        if (strategy === "replace")
-                                            change[stateField] = replacement;
-                                    }
-                                }
-                                if (strategy === "remove" && touched)
-                                    continue;
-                            }
-                            nextChanges.push(change);
-                        }
-                        if (action["state_changes"] !== undefined && action["state_changes"] !== null) {
-                            if (nextChanges.length > 0)
-                                action["state_changes"] = nextChanges;
-                            else
-                                delete action["state_changes"];
-                        }
-                    }
-                }
-            }
-            asset["states"] = asList(asset["states"]).filter((s) => strOf(s["state_id"]) !== stateId);
-            applied.push(kind);
-        }
-        else if (kind === "context.set") {
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            setContextState(script, epId, sceneId, targetKind, targetId, strOf(op["state"] || op["state_id"]).trim());
-            applied.push(kind);
-        }
-        else if (kind === "context.clear") {
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            setContextState(script, epId, sceneId, targetKind, targetId, null);
-            applied.push(kind);
-        }
-        else if (kind === "action.state.change") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            ensureRefId(script, targetKind, targetId);
-            const toState = validateStateForTarget(script, targetKind, targetId, strOf(op["to"] || op["to_state_id"]).trim());
-            if (!toState) {
-                throw opErr("SCRIPT OP BLOCKED: Target state missing", "Target state missing.", { required: ["to state_id"], received: [JSON.stringify(op)], nextSteps: ["Pass --to with an existing state_id."], op: kind, errorCode: "TO_STATE_MISSING" });
-            }
-            const fromStateExplicit = strOf(op["from"] || op["from_state_id"]).trim();
-            const fromState = fromStateExplicit || inferStateBeforeAction(script, epId, sceneId, actionIndex, targetKind, targetId);
-            if (!fromState) {
-                throw opErr("SCRIPT OP BLOCKED: From state ambiguous", "Unable to infer current state before this action.", { required: ["scene initial state or --from"], received: [`${op["at"]} ${op["target"]}`], nextSteps: ["Set scene context first, or pass --from explicitly.", "先设置场景初始状态，或修复前序状态变化。"], op: kind, errorCode: "FROM_STATE_AMBIGUOUS" });
-            }
-            validateStateForTarget(script, targetKind, targetId, fromState);
-            const effective = strOf(op["effective"] || op["effective_from"] || "after").trim();
-            const effectiveFrom = effective === "after" ? "after_action" : effective === "before" ? "before_action" : effective;
-            if (!EFFECTIVE_FROM_VALUES.has(effectiveFrom)) {
-                throw opErr("SCRIPT OP BLOCKED: Effective invalid", "Effective invalid.", { required: ["effective: after or before"], received: [effective], nextSteps: ["Use after or before."], op: kind, errorCode: "EFFECTIVE_INVALID" });
-            }
-            const action = findAction(script, epId, sceneId, actionIndex);
-            const changes = asList(action["state_changes"]).filter((c) => !(strOf(c["target_kind"]) === targetKind && strOf(c["target_id"]) === targetId));
-            changes.push({
-                target_kind: targetKind,
-                target_id: targetId,
-                from_state_id: fromState,
-                to_state_id: toState,
-                effective_from: effectiveFrom,
-            });
-            action["state_changes"] = changes;
-            applied.push(kind);
-        }
-        else if (kind === "action.state.remove") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            const action = findAction(script, epId, sceneId, actionIndex);
-            const changes = asList(action["state_changes"]).filter((c) => !(strOf(c["target_kind"]) === targetKind && strOf(c["target_id"]) === targetId));
-            if (changes.length > 0)
-                action["state_changes"] = changes;
-            else
-                delete action["state_changes"];
-            applied.push(kind);
-        }
-        else if (kind === "action.transition.set") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            ensureRefId(script, targetKind, targetId);
-            const process = strOf(op["process"]).trim();
-            const contrast = strOf(op["contrast"]).trim();
-            if (!process || !contrast) {
-                throw opErr("SCRIPT OP BLOCKED: Transition prompt incomplete", "Transition prompt incomplete.", { required: ["process and contrast"], received: [JSON.stringify(op)], nextSteps: ["Provide both process and contrast."], op: kind, errorCode: "TRANSITION_PROMPT_INCOMPLETE" });
-            }
-            const action = findAction(script, epId, sceneId, actionIndex);
-            action["transition_prompt"] = { target_kind: targetKind, target_id: targetId, process, contrast };
-            applied.push(kind);
-        }
-        else if (kind === "action.transition.clear") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            const action = findAction(script, epId, sceneId, actionIndex);
-            const transition = action["transition_prompt"];
-            if (isDict(transition) && strOf(transition["target_kind"]) === targetKind && strOf(transition["target_id"]) === targetId) {
-                delete action["transition_prompt"];
-            }
-            applied.push(kind);
-        }
-        else if (kind === "action.content.replace") {
-            // Literal substring replace on action.content. Designed for "find this
-            // phrase and edit it" — the script-stage equivalent of
-            // set_action_content_from_span, but without needing source.txt (the DB-
-            // backed script doesn't ship source). Refuses ambiguous matches by
-            // default so an off-by-one edit can't silently rewrite the wrong copy.
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const from = strOf(op["from"]);
-            const to = strOf(op["to"]);
-            const all = Boolean(op["all"]);
-            if (!from) {
-                throw opErr("SCRIPT OP BLOCKED: From text empty", "From text empty.", {
-                    required: ["from: non-empty string"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Pass --from with the literal substring to replace."],
-                    op: kind,
-                    errorCode: "FROM_TEXT_EMPTY",
-                });
-            }
-            const action = findAction(script, epId, sceneId, actionIndex);
-            if (strOf(action["type"]) === "dialogue" && strOf(action["delivery"]) === "overlap") {
-                throw opErr("SCRIPT OP BLOCKED: Overlap dialogue not supported", "action.content.replace cannot edit overlap dialogue lines.", {
-                    required: ["non-overlap action"],
-                    received: [`${op["at"]} delivery=overlap`],
-                    nextSteps: ["Use `script dialogue overlap` to rewrite the lines."],
-                    op: kind,
-                    errorCode: "OVERLAP_DIALOGUE_UNSUPPORTED",
-                });
-            }
-            const current = strOf(action["content"]);
-            let count = 0;
-            let cursor = 0;
-            while (true) {
-                const i = current.indexOf(from, cursor);
-                if (i < 0)
-                    break;
-                count += 1;
-                cursor = i + from.length;
-            }
-            if (count === 0) {
-                throw opErr("SCRIPT OP BLOCKED: From text not found", "From text not found in action content.", {
-                    required: ["from substring present in action.content"],
-                    received: [`${op["at"]} from=${JSON.stringify(from)}`],
-                    nextSteps: ["Inspect the action with `scriptctl actions --in <addr> --grep` and adjust --from."],
-                    op: kind,
-                    errorCode: "FROM_TEXT_NOT_FOUND",
-                });
-            }
-            if (count > 1 && !all) {
-                throw opErr("SCRIPT OP BLOCKED: From text ambiguous", `From text matches ${count} times in this action.`, {
-                    required: ["unique substring, or pass all=true to replace every occurrence"],
-                    received: [`${op["at"]} matches=${count}`],
-                    nextSteps: ["Use a longer/more specific --from, or pass --all."],
-                    op: kind,
-                    errorCode: "FROM_TEXT_AMBIGUOUS",
-                });
-            }
-            if (all) {
-                action["content"] = current.split(from).join(to);
-            }
-            else {
-                const i = current.indexOf(from);
-                action["content"] = current.slice(0, i) + to + current.slice(i + from.length);
-            }
-            applied.push(kind);
-        }
-        else if (kind === "speaker.add") {
-            const sourceKind = strOf(op["kind"] || op["source_kind"]).trim();
-            if (!SPEAKER_SOURCE_KINDS.has(sourceKind)) {
-                throw opErr("SCRIPT OP BLOCKED: Speaker kind invalid", "Speaker kind invalid.", { required: ["kind: actor/location/prop/system/broadcast/group/other"], received: [sourceKind || "<empty>"], nextSteps: ["Use a supported speaker kind."], op: kind, errorCode: "SPEAKER_KIND_INVALID" });
-            }
-            const name = strOf(op["name"] || op["display_name"]).trim();
-            if (!name) {
-                throw opErr("SCRIPT OP BLOCKED: Speaker name empty", "Speaker name empty.", { required: ["name"], received: [JSON.stringify(op)], nextSteps: ["Provide display name."], op: kind, errorCode: "SPEAKER_NAME_EMPTY" });
-            }
-            const sourceId = strOf(op["source_id"]).trim() || null;
-            if (SCRIPT_TARGET_KINDS.has(sourceKind)) {
-                if (!sourceId) {
-                    throw opErr("SCRIPT OP BLOCKED: Speaker source missing", "Speaker source missing.", { required: ["source_id for actor/location/prop speakers"], received: ["<empty>"], nextSteps: ["Pass --source-id."], op: kind, errorCode: "SPEAKER_SOURCE_MISSING" });
-                }
-                ensureRefId(script, sourceKind, sourceId);
-            }
-            const speakerId = strOf(op["speaker_id"]).trim() || nextSpeakerId(script, sourceKind, sourceId);
-            if (asList(script["speakers"]).some((s) => strOf(s["speaker_id"]) === speakerId)) {
-                throw opErr("SCRIPT OP BLOCKED: Speaker id exists", "Speaker id exists.", { required: ["unused speaker_id"], received: [speakerId], nextSteps: ["Use another speaker_id."], op: kind, errorCode: "SPEAKER_ID_EXISTS" });
-            }
-            if (!isList(script["speakers"]))
-                script["speakers"] = [];
-            script["speakers"].push({
-                speaker_id: speakerId,
-                display_name: name,
-                source_kind: sourceKind,
-                source_id: sourceId,
-                voice_desc: strOf(op["voice_desc"]).trim(),
-            });
-            applied.push(kind);
-        }
-        else if (kind === "dialogue.speakers") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const delivery = strOf(op["delivery"] || "simultaneous").trim();
-            if (delivery !== "single" && delivery !== "simultaneous" && delivery !== "group") {
-                throw opErr("SCRIPT OP BLOCKED: Delivery invalid", "Delivery invalid.", { required: ["delivery: single, simultaneous, or group"], received: [delivery], nextSteps: ["Use a supported delivery."], op: kind, errorCode: "DELIVERY_INVALID" });
-            }
-            let rawSpeakers = op["speakers"] ?? op["speaker"] ?? [];
-            if (typeof rawSpeakers === "string")
-                rawSpeakers = [rawSpeakers];
-            if (!isList(rawSpeakers) || rawSpeakers.length === 0) {
-                throw opErr("SCRIPT OP BLOCKED: Speakers empty", "Speakers empty.", { required: ["speaker list"], received: [JSON.stringify(op)], nextSteps: ["Pass at least one --speaker."], op: kind, errorCode: "SPEAKERS_EMPTY" });
-            }
-            const speakerIds = rawSpeakers.map((sid) => ensureSpeakerId(script, strOf(sid)));
-            const action = findAction(script, epId, sceneId, actionIndex);
-            action["type"] = "dialogue";
-            action["delivery"] = delivery;
-            action["speakers"] = speakerIds.map((sid) => ({ speaker_id: sid }));
-            delete action["lines"];
-            const actorId = speakerIds.length === 1 ? speakerSourceActorId(script, speakerIds[0]) : null;
-            if (actorId) {
-                action["actor_id"] = actorId;
-                action["speaker_id"] = speakerIds[0];
-            }
-            else {
-                delete action["actor_id"];
-                delete action["speaker_id"];
-            }
-            applied.push(kind);
-        }
-        else if (kind === "dialogue.overlap") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            let rawLines = op["lines"] ?? op["line"] ?? [];
-            if (typeof rawLines === "string")
-                rawLines = [rawLines];
-            if (!isList(rawLines) || rawLines.length === 0) {
-                throw opErr("SCRIPT OP BLOCKED: Lines empty", "Lines empty.", { required: ["line list"], received: [JSON.stringify(op)], nextSteps: ["Pass at least one --line speaker_id:content."], op: kind, errorCode: "LINES_EMPTY" });
-            }
-            const lines = [];
-            for (const line of rawLines) {
-                let speakerId;
-                let content;
-                if (isDict(line)) {
-                    speakerId = ensureSpeakerId(script, strOf(line["speaker_id"]));
-                    content = strOf(line["content"]).trim();
-                }
-                else {
-                    const rawLine = strOf(line);
-                    if (!rawLine.includes(":") && !rawLine.includes("：")) {
-                        throw opErr("SCRIPT OP BLOCKED: Line invalid", "Line invalid.", { required: ["speaker_id:content"], received: [rawLine], nextSteps: ["Use --line spk_xxx:对白."], op: kind, errorCode: "LINE_INVALID" });
-                    }
-                    const m = /^([^:：]+)[:：](.*)$/.exec(rawLine);
-                    if (!m) {
-                        throw opErr("SCRIPT OP BLOCKED: Line invalid", "Line invalid.", { required: ["speaker_id:content"], received: [rawLine], nextSteps: ["Use --line spk_xxx:对白."], op: kind, errorCode: "LINE_INVALID" });
-                    }
-                    speakerId = ensureSpeakerId(script, m[1]);
-                    content = m[2].trim();
-                }
-                if (!content) {
-                    throw opErr("SCRIPT OP BLOCKED: Line content empty", "Line content empty.", { required: ["non-empty line content"], received: [JSON.stringify(line)], nextSteps: ["Provide line content."], op: kind, errorCode: "LINE_CONTENT_EMPTY" });
-                }
-                lines.push({ speaker_id: speakerId, content });
-            }
-            const action = findAction(script, epId, sceneId, actionIndex);
-            action["type"] = "dialogue";
-            action["delivery"] = "overlap";
-            action["lines"] = lines;
-            action["content"] = lines.map((l) => l["content"]).join(" / ");
-            delete action["speakers"];
-            delete action["actor_id"];
-            delete action["speaker_id"];
-            applied.push(kind);
-        }
-        else if (kind === "actor.add") {
-            const name = strOf(op["name"] ?? op["actor_name"]).trim();
-            // Reject non-human speakers as actors up front (validate would flag
-            // NONHUMAN_AS_ACTOR otherwise) — system/broadcast/prop voices belong in
-            // speakers[], not actors[].
-            if (name && inferNonActorSpeakerKind(name) !== "actor") {
-                throw opErr("SCRIPT OP BLOCKED: Non-human as actor", "Non-human speaker registered as actor.", {
-                    required: ["a human/character name"], received: [name],
-                    nextSteps: ["Register non-human voices with add-speaker (kind system/broadcast/prop/group/other)."],
-                    op: kind, errorCode: "NONHUMAN_AS_ACTOR",
-                });
-            }
-            const entity = pushAsset(script, "actor", op);
-            const roleType = strOf(op["role_type"] ?? op["role"]).trim();
-            if (roleType) {
-                if (!ROLE_TYPE_VALUES.includes(roleType)) {
-                    throw opErr("SCRIPT OP BLOCKED: Role type invalid", "Role type invalid.", {
-                        required: ["role_type: 主角 or 配角"], received: [roleType],
-                        nextSteps: ["Use a supported actor role_type, or omit to leave it unset."],
-                        op: kind, errorCode: "ROLE_TYPE_INVALID",
-                    });
-                }
-                entity["role_type"] = roleType;
-            }
-            // Only stamp aliases when there's at least one — keeps the entity shape
-            // identical to direct/parse-produced actors (which omit the key when empty).
-            const aliases = isList(op["aliases"]) ? op["aliases"].map((a) => strOf(a).trim()).filter(Boolean) : [];
-            if (aliases.length)
-                entity["aliases"] = aliases;
-            applied.push(kind);
-        }
-        else if (kind === "location.add") {
-            pushAsset(script, "location", op);
-            applied.push(kind);
-        }
-        else if (kind === "prop.add") {
-            pushAsset(script, "prop", op);
-            applied.push(kind);
-        }
-        else if (kind === "episode.add") {
-            // Append an empty episode. Scenes/actions are added afterwards with
-            // scene.insert / action.insert. episode_id auto-allocates as ep_NNN.
-            const epId = strOf(op["episode_id"] ?? op["id"]).trim() || nextEpisodeId(script);
-            if (!/^ep_\d+$/.test(epId)) {
-                throw opErr("SCRIPT OP BLOCKED: Episode id invalid", "Episode id must use ep_NNN format.", {
-                    required: ["episode_id: ep_NNN"], received: [epId],
-                    nextSteps: ["Pass --id ep_004 or omit to auto-allocate."],
-                    op: kind, errorCode: "EPISODE_ID_INVALID",
-                });
-            }
-            if (!isList(script["episodes"]))
-                script["episodes"] = [];
-            const eps = script["episodes"];
-            if (eps.some((e) => strOf(e["episode_id"]) === epId)) {
-                throw opErr("SCRIPT OP BLOCKED: Episode id exists", "Episode id exists.", {
-                    required: ["unused episode_id"], received: [epId],
-                    nextSteps: ["Use another --id or omit it to auto-allocate."],
-                    op: kind, errorCode: "EPISODE_ID_EXISTS",
-                });
-            }
-            eps.push({ episode_id: epId, title: strOf(op["title"]).trim(), scenes: [] });
-            applied.push(kind);
-        }
-        else if (kind === "meta.worldview.set") {
-            // 0.6.0 dot-style equivalent of the legacy `set_worldview` op.
-            const worldview = strOf(op["worldview"] ?? op["value"]).trim();
-            if (!WORLDVIEW_VALUES.includes(worldview)) {
-                throw opErr("SCRIPT OP BLOCKED: Worldview invalid", "Worldview invalid.", {
-                    required: [`worldview: one of ${WORLDVIEW_VALUES.join(", ")}`],
-                    received: [worldview || "<empty>"],
-                    nextSteps: ["Use a supported worldview enum."],
-                    op: kind,
-                    errorCode: "WORLDVIEW_INVALID",
-                });
-            }
-            script["worldview"] = worldview;
-            if ("worldview_raw" in op)
-                script["worldview_raw"] = strOf(op["worldview_raw"]).trim();
-            applied.push(kind);
-        }
-        else if (kind === "asset.role.set") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            if (assetKind !== "actor") {
-                throw opErr("SCRIPT OP BLOCKED: Role only on actors", "Role applies to actor only.", {
-                    required: ["actor:<id>"],
-                    received: [strOf(op["target"])],
-                    nextSteps: ["Use an actor target."],
-                    op: kind,
-                    errorCode: "ROLE_TARGET_INVALID",
-                });
-            }
-            const asset = resolveAssetByTarget(script, "actor", assetId);
-            const roleType = strOf(op["role_type"] ?? op["role"]).trim();
-            if (!ROLE_TYPE_VALUES.includes(roleType)) {
-                throw opErr("SCRIPT OP BLOCKED: Role type invalid", "Role type invalid.", {
-                    required: ["role_type: 主角 or 配角"],
-                    received: [roleType || "<empty>"],
-                    nextSteps: ["Use a supported actor role_type."],
-                    op: kind,
-                    errorCode: "ROLE_TYPE_INVALID",
-                });
-            }
-            asset["role_type"] = roleType;
-            applied.push(kind);
-        }
-        else if (kind === "asset.rename") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            const newName = strOf(op["name"] ?? op["new_name"]).trim();
-            if (!newName) {
-                throw opErr("SCRIPT OP BLOCKED: Name empty", "Name empty.", {
-                    required: ["name"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Provide a non-empty name."],
-                    op: kind,
-                    errorCode: "NAME_EMPTY",
-                });
-            }
-            const [, , nameKey] = assetKeys(assetKind);
-            asset[nameKey] = newName;
-            applied.push(kind);
-        }
-        else if (kind === "asset.describe") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            const description = strOf(op["description"]).trim();
-            if (!description) {
-                throw opErr("SCRIPT OP BLOCKED: Description empty", "Description empty.", {
-                    required: ["description"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Provide a concise grounded description."],
-                    op: kind,
-                    errorCode: "DESCRIPTION_EMPTY",
-                });
-            }
-            asset["description"] = description;
-            applied.push(kind);
-        }
-        else if (kind === "asset.alias.set") {
-            // Bulk replace. Rare; primarily for migration tools.
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            const aliases = op["aliases"];
-            if (!isList(aliases) || aliases.some((it) => typeof it !== "string")) {
-                throw opErr("SCRIPT OP BLOCKED: Aliases invalid", "Aliases invalid.", {
-                    required: ["aliases: array of strings"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Pass a string array."],
-                    op: kind,
-                    errorCode: "ALIASES_INVALID",
-                });
-            }
-            const seen = new Set();
-            const cleaned = [];
-            for (const item of aliases) {
-                const trimmed = item.trim();
-                if (trimmed && !seen.has(trimmed)) {
-                    seen.add(trimmed);
-                    cleaned.push(trimmed);
-                }
-            }
-            asset["aliases"] = cleaned;
-            applied.push(kind);
-        }
-        else if (kind === "asset.alias.add") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            const rawAdd = op["alias"] ?? op["aliases"];
-            const toAdd = isList(rawAdd)
-                ? rawAdd.map((v) => strOf(v).trim()).filter((v) => v)
-                : strOf(rawAdd).trim() ? [strOf(rawAdd).trim()] : [];
-            if (toAdd.length === 0) {
-                throw opErr("SCRIPT OP BLOCKED: Alias empty", "Alias empty.", {
-                    required: ["alias: non-empty string or array"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Pass --add <alias> at least once."],
-                    op: kind,
-                    errorCode: "ALIAS_EMPTY",
-                });
-            }
-            const existing = asList(asset["aliases"]).map((s) => strOf(s));
-            const seen = new Set(existing);
-            for (const alias of toAdd) {
-                if (!seen.has(alias)) {
-                    existing.push(alias);
-                    seen.add(alias);
-                }
-            }
-            asset["aliases"] = existing;
-            applied.push(kind);
-        }
-        else if (kind === "asset.alias.remove") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            const rawRemove = op["alias"] ?? op["aliases"];
-            const toRemove = new Set(isList(rawRemove)
-                ? rawRemove.map((v) => strOf(v).trim()).filter((v) => v)
-                : strOf(rawRemove).trim() ? [strOf(rawRemove).trim()] : []);
-            if (toRemove.size === 0) {
-                throw opErr("SCRIPT OP BLOCKED: Alias empty", "Alias empty.", {
-                    required: ["alias: non-empty string or array"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Pass --remove <alias> at least once."],
-                    op: kind,
-                    errorCode: "ALIAS_EMPTY",
-                });
-            }
-            asset["aliases"] = asList(asset["aliases"]).map((s) => strOf(s)).filter((a) => !toRemove.has(a));
-            applied.push(kind);
-        }
-        else if (kind === "asset.states.set") {
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            const asset = resolveAssetByTarget(script, assetKind, assetId);
-            asset["states"] = normalizeStates(script, op["states"], assetKind);
-            applied.push(kind);
-        }
-        else if (kind === "asset.merge") {
-            // Direction is explicit: `from` disappears, `into` keeps everything.
-            const fromRaw = op["from"] ?? op["source"];
-            const intoRaw = op["into"] ?? op["target"];
-            const [fromKind, fromId] = parseAssetTarget(fromRaw);
-            const [intoKind, intoId] = parseAssetTarget(intoRaw);
-            if (fromKind !== intoKind) {
-                throw opErr("SCRIPT OP BLOCKED: Merge kind mismatch", "Merge source and target must be the same kind.", {
-                    required: ["same kind on both sides (actor/actor, location/location, prop/prop)"],
-                    received: [`${fromKind}:${fromId} → ${intoKind}:${intoId}`],
-                    nextSteps: ["Use a same-kind target."],
-                    op: kind,
-                    errorCode: "MERGE_KIND_MISMATCH",
-                });
-            }
-            const [key, idKey] = assetKeys(fromKind);
-            // Verify both exist.
-            resolveAssetByTarget(script, fromKind, fromId);
-            resolveAssetByTarget(script, intoKind, intoId);
-            // Pre-flight: refuse merge if any scene context already references BOTH
-            // from and into with conflicting state_ids. Silently picking one (the
-            // array-order-first) was a quiet data-loss bug — we'd rather make the
-            // user resolve the state divergence explicitly.
-            for (const ep of asList(script["episodes"])) {
-                for (const scene of asList(ep["scenes"])) {
-                    const ctx = sceneContext(scene);
-                    const refList = contextRefsForKind(ctx, fromKind);
-                    const fromRef = refList.find((ref) => strOf(ref[idKey]) === fromId);
-                    const intoRef = refList.find((ref) => strOf(ref[idKey]) === intoId);
-                    if (fromRef && intoRef) {
-                        const fromState = strOf(fromRef["state_id"]);
-                        const intoState = strOf(intoRef["state_id"]);
-                        if (fromState !== intoState) {
-                            throw opErr("SCRIPT OP BLOCKED: Merge state conflict", "Merge has conflicting state_ids in a shared scene.", {
-                                required: ["from and into agree on state_id in every scene where both appear"],
-                                received: [`${ep["episode_id"]}/${scene["scene_id"]}: ${fromId}=${fromState || "null"}, ${intoId}=${intoState || "null"}`],
-                                nextSteps: ["Resolve the state divergence (run `scriptctl context <scene> <kind>:<into-id> --state <state>`) then retry merge."],
-                                op: kind,
-                                errorCode: "MERGE_STATE_CONFLICT",
-                            });
-                        }
-                    }
-                }
-            }
-            // Drop source from the asset list.
-            script[key] = asList(script[key]).filter((it) => strOf(it[idKey]) !== fromId);
-            // Rewrite refs: scene.context, action.actor_id (actor only), state_changes targets, transition targets, speaker.source_id.
-            for (const ep of asList(script["episodes"])) {
-                for (const scene of asList(ep["scenes"])) {
-                    const ctx = sceneContext(scene);
-                    const refList = contextRefsForKind(ctx, fromKind);
-                    for (const ref of refList) {
-                        if (strOf(ref[idKey]) === fromId)
-                            ref[idKey] = intoId;
-                    }
-                    // After rewrite, dedupe (intoId may now appear twice). State_id was
-                    // pre-validated to agree above, so first-seen wins is safe.
-                    const seen = new Set();
-                    ctx[pluralForKind(fromKind)] = refList.filter((ref) => {
-                        const key2 = strOf(ref[idKey]);
-                        if (seen.has(key2))
-                            return false;
-                        seen.add(key2);
-                        return true;
-                    });
-                    setSceneContext(scene, ctx);
-                    for (const action of asList(scene["actions"])) {
-                        if (fromKind === "actor" && strOf(action["actor_id"]) === fromId)
-                            action["actor_id"] = intoId;
-                        for (const change of asList(action["state_changes"])) {
-                            if (strOf(change["target_kind"]) === fromKind && strOf(change["target_id"]) === fromId) {
-                                change["target_id"] = intoId;
-                            }
-                        }
-                        const transition = action["transition_prompt"];
-                        if (isDict(transition) && strOf(transition["target_kind"]) === fromKind && strOf(transition["target_id"]) === fromId) {
-                            transition["target_id"] = intoId;
-                        }
-                    }
-                }
-            }
-            // Speakers anchored to the source actor get reattached to the target.
-            for (const sp of asList(script["speakers"])) {
-                if (strOf(sp["source_kind"]) === fromKind && strOf(sp["source_id"]) === fromId) {
-                    sp["source_id"] = intoId;
-                }
-            }
-            applied.push(kind);
-        }
-        else if (kind === "asset.delete") {
-            // Refs are walked via collectAssetRefs. Default: refuse if any refs exist.
-            // strategy=replace → rewrite refs to a replacement asset, then delete.
-            // strategy=remove → rewrite refs to null/clean and delete (leaves dangling
-            // pointers cleaned by per-edge logic; validation will still surface anything
-            // still wrong).
-            const [assetKind, assetId] = parseAssetTarget(op["target"]);
-            resolveAssetByTarget(script, assetKind, assetId);
-            const refs = collectAssetRefs(script, assetKind, assetId);
-            const strategy = strOf(op["strategy"]).trim();
-            if (refs.length > 0 && !strategy) {
-                throw opErr("SCRIPT OP BLOCKED: Asset has refs", `Asset is referenced ${refs.length} time(s).`, {
-                    required: ["--strategy replace|remove"],
-                    received: [`refs=${refs.length}`],
-                    nextSteps: ["Use --strategy replace --replacement <addr> to remap, or --strategy remove to scrub refs."],
-                    op: kind,
-                    errorCode: "ASSET_HAS_REFS",
-                });
-            }
-            if (strategy === "replace") {
-                const replacementRaw = op["replacement"] ?? op["into"];
-                const [replacementKind, replacementId] = parseAssetTarget(replacementRaw);
-                if (replacementKind !== assetKind) {
-                    throw opErr("SCRIPT OP BLOCKED: Replacement kind mismatch", "Replacement must be same kind.", {
-                        required: ["replacement same kind as target"],
-                        received: [`${assetKind} vs ${replacementKind}`],
-                        nextSteps: ["Pass a same-kind replacement."],
-                        op: kind,
-                        errorCode: "REPLACEMENT_KIND_MISMATCH",
-                    });
-                }
-                resolveAssetByTarget(script, replacementKind, replacementId);
-                // Delegate ref rewrite to asset.merge logic by reusing the same traversal.
-                applyPatchOperations(script, sourceText, [
-                    { op: "asset.merge", from: op["target"], into: replacementRaw },
-                ]);
-                applied.push(kind);
-            }
-            else if (strategy === "remove" || refs.length === 0) {
-                // Scrub refs (actor_id → undefined, state_changes/transition refs removed, scene.context entries removed, speakers' source_id cleared).
-                const [key, idKey] = assetKeys(assetKind);
-                script[key] = asList(script[key]).filter((it) => strOf(it[idKey]) !== assetId);
-                for (const ep of asList(script["episodes"])) {
-                    for (const scene of asList(ep["scenes"])) {
-                        const ctx = sceneContext(scene);
-                        ctx[pluralForKind(assetKind)] = contextRefsForKind(ctx, assetKind).filter((ref) => strOf(ref[idKey]) !== assetId);
-                        setSceneContext(scene, ctx);
-                        for (const action of asList(scene["actions"])) {
-                            if (assetKind === "actor" && strOf(action["actor_id"]) === assetId)
-                                delete action["actor_id"];
-                            const changes = asList(action["state_changes"]).filter((c) => !(strOf(c["target_kind"]) === assetKind && strOf(c["target_id"]) === assetId));
-                            if (changes.length > 0)
-                                action["state_changes"] = changes;
-                            else
-                                delete action["state_changes"];
-                            const transition = action["transition_prompt"];
-                            if (isDict(transition) && strOf(transition["target_kind"]) === assetKind && strOf(transition["target_id"]) === assetId) {
-                                delete action["transition_prompt"];
-                            }
-                        }
-                    }
-                }
-                for (const sp of asList(script["speakers"])) {
-                    if (strOf(sp["source_kind"]) === assetKind && strOf(sp["source_id"]) === assetId) {
-                        sp["source_id"] = null;
-                    }
-                }
-                applied.push(kind);
-            }
-            else {
-                throw opErr("SCRIPT OP BLOCKED: Strategy invalid", "Strategy invalid.", {
-                    required: ["strategy: replace or remove"],
-                    received: [strategy],
-                    nextSteps: ["Use replace (with --replacement) or remove."],
-                    op: kind,
-                    errorCode: "DELETE_STRATEGY_INVALID",
-                });
-            }
-        }
-        else if (kind === "action.type.set") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const actionType = strOf(op["type"] ?? op["action_type"]).trim();
-            if (!ACTION_TYPE_VALUES.has(actionType)) {
-                throw opErr("SCRIPT OP BLOCKED: Action type invalid", "Action type invalid.", {
-                    required: ["type: dialogue, inner_thought, or action"],
-                    received: [actionType || "<empty>"],
-                    nextSteps: ["Use a supported action type."],
-                    op: kind,
-                    errorCode: "ACTION_TYPE_INVALID",
-                });
-            }
-            const action = findAction(script, epId, sceneId, actionIndex);
-            action["type"] = actionType;
-            applied.push(kind);
-        }
-        else if (kind === "action.actor.set") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const rawActor = op["actor_id"] ?? op["actor"];
-            const isNone = rawActor === null || strOf(rawActor).trim() === "" || strOf(rawActor).trim() === "none";
-            const actorId = isNone ? null : ensureRefId(script, "actor", rawActor);
-            const action = findAction(script, epId, sceneId, actionIndex);
-            if (actorId === null)
-                delete action["actor_id"];
-            else
-                action["actor_id"] = actorId;
-            applied.push(kind);
-        }
-        else if (kind === "action.delete") {
-            const [epId, sceneId, actionIndex] = parseActionRef(op["at"]);
-            const scene = findScene(script, epId, sceneId);
-            const actions = asList(scene["actions"]);
-            if (actionIndex < 0 || actionIndex >= actions.length) {
-                throw opErr("SCRIPT OP BLOCKED: Action index out of range", "Action index out of range.", {
-                    required: [`0 <= action_index < ${actions.length}`],
-                    received: [String(actionIndex)],
-                    nextSteps: ["Inspect actions in the scene and use a valid index."],
-                    op: kind,
-                    errorCode: "ACTION_INDEX_OUT_OF_RANGE",
-                });
-            }
-            actions.splice(actionIndex, 1);
-            scene["actions"] = actions;
-            applied.push(kind);
-        }
-        else if (kind === "action.insert") {
-            // <at> is a scene ref (ep_xxx/scn_xxx). Position resolved from
-            // --at <idx> | --before <action-ref> | --after <action-ref> | default-append.
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const scene = findScene(script, epId, sceneId);
-            const actions = asList(scene["actions"]);
-            const actionType = strOf(op["type"]).trim();
-            if (!ACTION_TYPE_VALUES.has(actionType)) {
-                throw opErr("SCRIPT OP BLOCKED: Action type invalid", "Action type invalid.", {
-                    required: ["type: dialogue, inner_thought, or action"],
-                    received: [actionType || "<empty>"],
-                    nextSteps: ["Use a supported action type."],
-                    op: kind,
-                    errorCode: "ACTION_TYPE_INVALID",
-                });
-            }
-            const content = strOf(op["content"]);
-            let insertIndex;
-            if (op["before"]) {
-                const [bEp, bScn, bIdx] = parseActionRef(op["before"]);
-                if (bEp !== epId || bScn !== sceneId) {
-                    throw opErr("SCRIPT OP BLOCKED: before address mismatch", "--before must point at the same scene.", {
-                        required: [`${epId}/${sceneId}#<idx>`],
-                        received: [strOf(op["before"])],
-                        nextSteps: ["Use a sibling action address."],
-                        op: kind,
-                        errorCode: "INSERT_REF_MISMATCH",
-                    });
-                }
-                insertIndex = bIdx;
-            }
-            else if (op["after"]) {
-                const [aEp, aScn, aIdx] = parseActionRef(op["after"]);
-                if (aEp !== epId || aScn !== sceneId) {
-                    throw opErr("SCRIPT OP BLOCKED: after address mismatch", "--after must point at the same scene.", {
-                        required: [`${epId}/${sceneId}#<idx>`],
-                        received: [strOf(op["after"])],
-                        nextSteps: ["Use a sibling action address."],
-                        op: kind,
-                        errorCode: "INSERT_REF_MISMATCH",
-                    });
-                }
-                insertIndex = aIdx + 1;
-            }
-            else if (op["at_index"] !== undefined && op["at_index"] !== null) {
-                const n = Number(op["at_index"]);
-                if (!Number.isInteger(n) || n < 0 || n > actions.length) {
-                    throw opErr("SCRIPT OP BLOCKED: at_index out of range", "at_index out of range.", {
-                        required: [`0..${actions.length}`],
-                        received: [String(op["at_index"])],
-                        nextSteps: ["Use a valid integer index."],
-                        op: kind,
-                        errorCode: "AT_INDEX_OUT_OF_RANGE",
-                    });
-                }
-                insertIndex = n;
-            }
-            else {
-                // Default: append at end.
-                insertIndex = actions.length;
-            }
-            const newAction = { type: actionType, content };
-            if (op["actor_id"])
-                newAction["actor_id"] = ensureRefId(script, "actor", op["actor_id"]);
-            if (op["speaker_id"])
-                newAction["speaker_id"] = ensureSpeakerId(script, strOf(op["speaker_id"]));
-            actions.splice(insertIndex, 0, newAction);
-            scene["actions"] = actions;
-            applied.push(kind);
-        }
-        else if (kind === "action.move") {
-            const [fromEp, fromScn, fromIdx] = parseActionRef(op["at"] ?? op["from"]);
-            const [toEp, toScn, toIdx] = parseActionRef(op["to"]);
-            const fromScene = findScene(script, fromEp, fromScn);
-            const fromActions = asList(fromScene["actions"]);
-            if (fromIdx < 0 || fromIdx >= fromActions.length) {
-                throw opErr("SCRIPT OP BLOCKED: Action index out of range", "Source action index out of range.", {
-                    required: [`0 <= idx < ${fromActions.length}`],
-                    received: [String(fromIdx)],
-                    nextSteps: ["Inspect actions and use a valid index."],
-                    op: kind,
-                    errorCode: "ACTION_INDEX_OUT_OF_RANGE",
-                });
-            }
-            const [moved] = fromActions.splice(fromIdx, 1);
-            fromScene["actions"] = fromActions;
-            const toScene = (fromEp === toEp && fromScn === toScn) ? fromScene : findScene(script, toEp, toScn);
-            const toActions = asList(toScene["actions"]);
-            // After removing the source, when target is the same scene and idx is past
-            // the removed slot, the agent's intended index is already correct (no
-            // shift needed in the destination); otherwise clamp.
-            let dest = toIdx;
-            if (dest < 0)
-                dest = 0;
-            if (dest > toActions.length)
-                dest = toActions.length;
-            toActions.splice(dest, 0, moved);
-            toScene["actions"] = toActions;
-            applied.push(kind);
-        }
-        else if (kind === "scene.insert") {
-            // Insert a new empty scene into an episode. Position resolved from
-            // --at <idx> | --before <ep/scn> | --after <ep/scn> | default-append.
-            // Requires --location to anchor the scene's locations[] context (matches
-            // direct-init's assumption that every scene names at least one location).
-            const epId = strOf(op["at"] ?? op["episode_id"]);
-            const ep = findEpisode(script, epId);
-            const scenes = asList(ep["scenes"]);
-            const locationId = strOf(op["location"] ?? op["location_id"]).trim();
-            if (!locationId) {
-                throw opErr("SCRIPT OP BLOCKED: location required", "Scene insert requires --location.", {
-                    required: ["location: existing location_id"],
-                    received: ["<empty>"],
-                    nextSteps: ["Pass --location <loc_id>."],
-                    op: kind,
-                    errorCode: "SCENE_LOCATION_MISSING",
-                });
-            }
-            ensureRefId(script, "location", locationId);
-            let insertIndex;
-            if (op["before"]) {
-                const [bEp, bScn] = parseSceneRef(op["before"]);
-                if (bEp !== epId) {
-                    throw opErr("SCRIPT OP BLOCKED: before address mismatch", "--before must point at the same episode.", {
-                        required: [`${epId}/<scn>`],
-                        received: [strOf(op["before"])],
-                        nextSteps: ["Use a sibling scene address."],
-                        op: kind,
-                        errorCode: "INSERT_REF_MISMATCH",
-                    });
-                }
-                insertIndex = scenes.findIndex((s) => strOf(s["scene_id"]) === bScn);
-                if (insertIndex < 0) {
-                    throw opErr("SCRIPT OP BLOCKED: before scene not found", "before scene not found.", {
-                        required: ["existing scene_id"],
-                        received: [bScn],
-                        nextSteps: ["Inspect scenes."],
-                        op: kind,
-                        errorCode: "SCENE_NOT_FOUND",
-                    });
-                }
-            }
-            else if (op["after"]) {
-                const [aEp, aScn] = parseSceneRef(op["after"]);
-                if (aEp !== epId) {
-                    throw opErr("SCRIPT OP BLOCKED: after address mismatch", "--after must point at the same episode.", {
-                        required: [`${epId}/<scn>`],
-                        received: [strOf(op["after"])],
-                        nextSteps: ["Use a sibling scene address."],
-                        op: kind,
-                        errorCode: "INSERT_REF_MISMATCH",
-                    });
-                }
-                const found = scenes.findIndex((s) => strOf(s["scene_id"]) === aScn);
-                if (found < 0) {
-                    throw opErr("SCRIPT OP BLOCKED: after scene not found", "after scene not found.", {
-                        required: ["existing scene_id"],
-                        received: [aScn],
-                        nextSteps: ["Inspect scenes."],
-                        op: kind,
-                        errorCode: "SCENE_NOT_FOUND",
-                    });
-                }
-                insertIndex = found + 1;
-            }
-            else if (op["at_index"] !== undefined && op["at_index"] !== null) {
-                const n = Number(op["at_index"]);
-                if (!Number.isInteger(n) || n < 0 || n > scenes.length) {
-                    throw opErr("SCRIPT OP BLOCKED: at_index out of range", "at_index out of range.", {
-                        required: [`0..${scenes.length}`],
-                        received: [String(op["at_index"])],
-                        nextSteps: ["Use a valid integer index."],
-                        op: kind,
-                        errorCode: "AT_INDEX_OUT_OF_RANGE",
-                    });
-                }
-                insertIndex = n;
-            }
-            else {
-                insertIndex = scenes.length;
-            }
-            const newSceneId = strOf(op["scene_id"]).trim() || nextSceneId(script);
-            if (sceneIdExists(script, newSceneId)) {
-                throw opErr("SCRIPT OP BLOCKED: New scene id exists", "New scene id exists.", {
-                    required: ["unused scene_id"],
-                    received: [newSceneId],
-                    nextSteps: ["Pass --scene-id <unused> or omit."],
-                    op: kind,
-                    errorCode: "NEW_SCENE_ID_EXISTS",
-                });
-            }
-            const time = strOf(op["time"]).trim() || "day";
-            const space = strOf(op["space"]).trim() || "interior";
-            const newScene = {
-                scene_id: newSceneId,
-                environment: { time, space },
-                context: {
-                    locations: [{ location_id: locationId, state_id: null }],
-                    actors: [],
-                    props: [],
-                },
-                locations: [{ location_id: locationId, state_id: null }],
-                actors: [],
-                props: [],
-                actions: [],
-            };
-            scenes.splice(insertIndex, 0, newScene);
-            ep["scenes"] = scenes;
-            applied.push(kind);
-        }
-        else if (kind === "scene.split") {
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const splitAt = op["at_index"] ?? op["action_index"];
-            if (typeof splitAt !== "number" || !Number.isInteger(splitAt)) {
-                throw opErr("SCRIPT OP BLOCKED: Split index invalid", "Split index invalid.", {
-                    required: ["at_index: integer between existing actions"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Inspect actions and use a valid index."],
-                    op: kind,
-                    errorCode: "SPLIT_INDEX_INVALID",
-                });
-            }
-            const ep = findEpisode(script, epId);
-            const scenes = asList(ep["scenes"]);
-            const index = scenes.findIndex((s) => s["scene_id"] === sceneId);
-            if (index < 0) {
-                throw opErr("SCRIPT OP BLOCKED: Scene not found", "Scene not found.", {
-                    required: ["existing scene_id"],
-                    received: [sceneId],
-                    nextSteps: ["Inspect scenes and fix the address."],
-                    op: kind,
-                    errorCode: "SCENE_NOT_FOUND",
-                });
-            }
-            const scene = scenes[index];
-            const actions = asList(scene["actions"]);
-            if (splitAt <= 0 || splitAt >= actions.length) {
-                throw opErr("SCRIPT OP BLOCKED: Split index invalid", "Split index out of bounds.", {
-                    required: [`0 < at_index < ${actions.length}`],
-                    received: [String(splitAt)],
-                    nextSteps: ["Choose an action boundary inside the scene."],
-                    op: kind,
-                    errorCode: "SPLIT_INDEX_INVALID",
-                });
-            }
-            const newSceneId = strOf(op["new_scene_id"]) || nextSceneId(script);
-            if (sceneIdExists(script, newSceneId)) {
-                throw opErr("SCRIPT OP BLOCKED: New scene id exists", "New scene id exists.", {
-                    required: ["unused new_scene_id"],
-                    received: [newSceneId],
-                    nextSteps: ["Choose an unused scene id or omit new_scene_id."],
-                    op: kind,
-                    errorCode: "NEW_SCENE_ID_EXISTS",
-                });
-            }
-            const ctx = sceneContext(scene);
-            const newScene = {
-                scene_id: newSceneId,
-                environment: { ...(isDict(scene["environment"]) ? scene["environment"] : {}) },
-                context: ctx,
-                locations: [...asList(ctx["locations"])],
-                actors: [...asList(ctx["actors"])],
-                props: [...asList(ctx["props"])],
-                actions: actions.slice(splitAt),
-            };
-            scene["actions"] = actions.slice(0, splitAt);
-            scenes.splice(index + 1, 0, newScene);
-            applied.push(kind);
-        }
-        else if (kind === "scene.merge") {
-            // 0.6.0 uses {from, into} (source disappears, into keeps). The legacy op
-            // used {keep_scene_id, remove_scene_id}; payload still accepted for back-
-            // compat during transition.
-            const fromRaw = op["from"] ?? op["remove_scene_id"];
-            const intoRaw = op["into"] ?? op["keep_scene_id"];
-            // from can be either ep/scn or just scn (legacy). Normalize.
-            let fromEp, fromScn, intoEp, intoScn;
-            if (typeof fromRaw === "string" && fromRaw.includes("/")) {
-                [fromEp, fromScn] = parseSceneRef(fromRaw);
-            }
-            else {
-                // Legacy: needs episode_id from op.
-                fromEp = strOf(op["episode_id"]);
-                fromScn = strOf(fromRaw);
-            }
-            if (typeof intoRaw === "string" && intoRaw.includes("/")) {
-                [intoEp, intoScn] = parseSceneRef(intoRaw);
-            }
-            else {
-                intoEp = strOf(op["episode_id"]);
-                intoScn = strOf(intoRaw);
-            }
-            if (fromEp !== intoEp) {
-                throw opErr("SCRIPT OP BLOCKED: Merge cross-episode", "Scene merge must be within one episode.", {
-                    required: ["same episode_id on both sides"],
-                    received: [`${fromEp}/${fromScn} → ${intoEp}/${intoScn}`],
-                    nextSteps: ["Move one scene first, or merge same-episode scenes."],
-                    op: kind,
-                    errorCode: "MERGE_CROSS_EPISODE",
-                });
-            }
-            const ep = findEpisode(script, fromEp);
-            const scenes = asList(ep["scenes"]);
-            const intoScene = scenes.find((s) => s["scene_id"] === intoScn);
-            const fromScene = scenes.find((s) => s["scene_id"] === fromScn);
-            if (!intoScene || !fromScene) {
-                throw opErr("SCRIPT OP BLOCKED: Scene not found", "Scene not found.", {
-                    required: ["existing scene_id on both sides"],
-                    received: [`from=${fromScn}, into=${intoScn}`],
-                    nextSteps: ["Inspect scenes and fix the address."],
-                    op: kind,
-                    errorCode: "SCENE_NOT_FOUND",
-                });
-            }
-            intoScene["actions"].push(...asList(fromScene["actions"]));
-            const intoCtx = sceneContext(intoScene);
-            const fromCtx = sceneContext(fromScene);
-            for (const [field, idKey] of [["actors", "actor_id"], ["locations", "location_id"], ["props", "prop_id"]]) {
-                const existingIds = new Set();
-                for (const ref of asList(intoCtx[field]))
-                    existingIds.add(ref[idKey]);
-                for (const ref of asList(fromCtx[field])) {
-                    if (!existingIds.has(ref[idKey])) {
-                        if (!isList(intoCtx[field]))
-                            intoCtx[field] = [];
-                        intoCtx[field].push(ref);
-                    }
-                }
-            }
-            setSceneContext(intoScene, intoCtx);
-            ep["scenes"] = scenes.filter((s) => s !== fromScene);
-            applied.push(kind);
-        }
-        else if (kind === "scene.delete") {
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const ep = findEpisode(script, epId);
-            const scenes = asList(ep["scenes"]);
-            const scene = scenes.find((s) => s["scene_id"] === sceneId);
-            if (!scene) {
-                throw opErr("SCRIPT OP BLOCKED: Scene not found", "Scene not found.", {
-                    required: ["existing scene_id"],
-                    received: [`${epId}/${sceneId}`],
-                    nextSteps: ["Inspect scenes."],
-                    op: kind,
-                    errorCode: "SCENE_NOT_FOUND",
-                });
-            }
-            const actions = asList(scene["actions"]);
-            const force = Boolean(op["force"]);
-            if (actions.length > 0 && !force) {
-                throw opErr("SCRIPT OP BLOCKED: Scene non-empty", `Scene has ${actions.length} action(s).`, {
-                    required: ["empty scene, or force=true"],
-                    received: [`actions=${actions.length}`],
-                    nextSteps: ["Pass --force to delete with actions, or move/delete actions first."],
-                    op: kind,
-                    errorCode: "SCENE_NON_EMPTY",
-                });
-            }
-            ep["scenes"] = scenes.filter((s) => s !== scene);
-            applied.push(kind);
-        }
-        else if (kind === "scene.move") {
-            const [fromEp, fromScn] = parseSceneRef(op["at"] ?? op["from"]);
-            const toEpRaw = strOf(op["to"]);
-            // `to` accepts either bare `ep_NNN` (append) or `ep_NNN/scn_NNN` (insert before that scene).
-            // `--at <idx>` overrides positioning.
-            let toEp;
-            let toAnchorScn = null;
-            if (toEpRaw.includes("/")) {
-                const [a, b] = parseSceneRef(toEpRaw);
-                toEp = a;
-                toAnchorScn = b;
-            }
-            else {
-                toEp = toEpRaw;
-            }
-            if (!toEp) {
-                throw opErr("SCRIPT OP BLOCKED: to address invalid", "to address invalid.", {
-                    required: ["to: ep_NNN or ep_NNN/scn_NNN"],
-                    received: [toEpRaw],
-                    nextSteps: ["Pass a target episode id."],
-                    op: kind,
-                    errorCode: "SCENE_MOVE_TO_INVALID",
-                });
-            }
-            const fromEpisode = findEpisode(script, fromEp);
-            const fromScenes = asList(fromEpisode["scenes"]);
-            const sourceIdx = fromScenes.findIndex((s) => s["scene_id"] === fromScn);
-            if (sourceIdx < 0) {
-                throw opErr("SCRIPT OP BLOCKED: Scene not found", "Source scene not found.", {
-                    required: ["existing scene_id"],
-                    received: [`${fromEp}/${fromScn}`],
-                    nextSteps: ["Inspect scenes."],
-                    op: kind,
-                    errorCode: "SCENE_NOT_FOUND",
-                });
-            }
-            const [moved] = fromScenes.splice(sourceIdx, 1);
-            fromEpisode["scenes"] = fromScenes;
-            const toEpisode = findEpisode(script, toEp);
-            const toScenes = asList(toEpisode["scenes"]);
-            let destIdx;
-            if (op["at_index"] !== undefined && op["at_index"] !== null) {
-                const n = Number(op["at_index"]);
-                if (!Number.isInteger(n) || n < 0 || n > toScenes.length) {
-                    throw opErr("SCRIPT OP BLOCKED: at_index out of range", "at_index out of range.", {
-                        required: [`0..${toScenes.length}`],
-                        received: [String(op["at_index"])],
-                        nextSteps: ["Use a valid integer index."],
-                        op: kind,
-                        errorCode: "AT_INDEX_OUT_OF_RANGE",
-                    });
-                }
-                destIdx = n;
-            }
-            else if (toAnchorScn) {
-                const found = toScenes.findIndex((s) => s["scene_id"] === toAnchorScn);
-                if (found < 0) {
-                    throw opErr("SCRIPT OP BLOCKED: Target scene not found", "Target scene not found.", {
-                        required: ["existing scene_id in target episode"],
-                        received: [`${toEp}/${toAnchorScn}`],
-                        nextSteps: ["Inspect the target episode."],
-                        op: kind,
-                        errorCode: "SCENE_NOT_FOUND",
-                    });
-                }
-                destIdx = found;
-            }
-            else {
-                destIdx = toScenes.length;
-            }
-            toScenes.splice(destIdx, 0, moved);
-            toEpisode["scenes"] = toScenes;
-            applied.push(kind);
-        }
-        else if (kind === "speaker.delete") {
-            // Mirror of asset.delete for speakers: refs scrub or replace via
-            // --strategy. Speaker refs live in action.speaker_id /
-            // action.speakers[] / action.lines[].speaker_id only — no scene
-            // context entries to handle.
-            const speakerId = strOf(op["target"] ?? op["speaker_id"]).trim();
-            if (!speakerId) {
-                throw opErr("SCRIPT OP BLOCKED: Speaker id missing", "Speaker id missing.", {
-                    required: ["target speaker id"],
-                    received: [JSON.stringify(op)],
-                    nextSteps: ["Pass a spk_id."],
-                    op: kind,
-                    errorCode: "SPEAKER_ID_MISSING",
-                });
-            }
-            const refs = collectAssetRefs(script, "speaker", speakerId);
-            const strategy = strOf(op["strategy"]).trim();
-            if (refs.length > 0 && !strategy) {
-                throw opErr("SCRIPT OP BLOCKED: Speaker has refs", `Speaker is referenced ${refs.length} time(s).`, {
-                    required: ["--strategy replace|remove"],
-                    received: [`refs=${refs.length}`],
-                    nextSteps: ["Use --strategy replace --replacement <spk_id> to remap, or --strategy remove to scrub refs."],
-                    op: kind,
-                    errorCode: "SPEAKER_HAS_REFS",
-                });
-            }
-            const replacement = strOf(op["replacement"]).trim();
-            if (strategy === "replace") {
-                if (!replacement) {
-                    throw opErr("SCRIPT OP BLOCKED: Replacement missing", "Replacement missing.", {
-                        required: ["replacement speaker id"],
-                        received: ["<empty>"],
-                        nextSteps: ["Pass --replacement <spk_id>."],
-                        op: kind,
-                        errorCode: "REPLACEMENT_MISSING",
-                    });
-                }
-                // Verify replacement exists.
-                if (!asList(script["speakers"]).some((s) => strOf(s["speaker_id"]) === replacement)) {
-                    throw opErr("SCRIPT OP BLOCKED: Replacement speaker not found", "Replacement speaker not found.", {
-                        required: ["existing speaker id"],
-                        received: [replacement],
-                        nextSteps: ["Add the speaker first or use a different replacement."],
-                        op: kind,
-                        errorCode: "SPEAKER_NOT_FOUND",
-                    });
-                }
-                for (const ep of asList(script["episodes"])) {
-                    for (const scene of asList(ep["scenes"])) {
-                        for (const action of asList(scene["actions"])) {
-                            if (strOf(action["speaker_id"]) === speakerId)
-                                action["speaker_id"] = replacement;
-                            const speakers = asList(action["speakers"]);
-                            for (const sp of speakers) {
-                                if (strOf(sp["speaker_id"]) === speakerId)
-                                    sp["speaker_id"] = replacement;
-                            }
-                            // Dedupe action.speakers[] in case the action already referenced
-                            // the replacement: an unconditional rewrite + no dedupe would
-                            // leave [spk_replacement, spk_replacement], breaking overlap/
-                            // simultaneous delivery counts downstream.
-                            if (action["speakers"] !== undefined) {
-                                const seen = new Set();
-                                action["speakers"] = speakers.filter((s) => {
-                                    const id = strOf(s["speaker_id"]);
-                                    if (seen.has(id))
-                                        return false;
-                                    seen.add(id);
-                                    return true;
-                                });
-                            }
-                            const lines = asList(action["lines"]);
-                            for (const line of lines) {
-                                if (strOf(line["speaker_id"]) === speakerId)
-                                    line["speaker_id"] = replacement;
-                            }
-                            // lines[] semantically represents distinct overlapping lines
-                            // (a speaker can legitimately overlap with themselves), so we do
-                            // NOT dedupe lines — preserve overlap-with-self if it existed.
-                        }
-                    }
-                }
-            }
-            else if (strategy === "remove" || refs.length === 0) {
-                for (const ep of asList(script["episodes"])) {
-                    for (const scene of asList(ep["scenes"])) {
-                        for (const action of asList(scene["actions"])) {
-                            if (strOf(action["speaker_id"]) === speakerId)
-                                delete action["speaker_id"];
-                            const speakers = asList(action["speakers"]).filter((s) => strOf(s["speaker_id"]) !== speakerId);
-                            if (action["speakers"] !== undefined) {
-                                if (speakers.length > 0)
-                                    action["speakers"] = speakers;
-                                else
-                                    delete action["speakers"];
-                            }
-                            const lines = asList(action["lines"]).filter((l) => strOf(l["speaker_id"]) !== speakerId);
-                            if (action["lines"] !== undefined) {
-                                if (lines.length > 0)
-                                    action["lines"] = lines;
-                                else
-                                    delete action["lines"];
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                throw opErr("SCRIPT OP BLOCKED: Strategy invalid", "Strategy invalid.", {
-                    required: ["strategy: replace or remove"],
-                    received: [strategy],
-                    nextSteps: ["Use replace (with --replacement) or remove."],
-                    op: kind,
-                    errorCode: "DELETE_STRATEGY_INVALID",
-                });
-            }
-            script["speakers"] = asList(script["speakers"]).filter((s) => strOf(s["speaker_id"]) !== speakerId);
-            applied.push(kind);
-        }
-        else if (kind === "context.ref.remove") {
-            const [epId, sceneId] = parseSceneRef(op["at"]);
-            const [targetKind, targetId] = parseAssetTarget(op["target"]);
-            const scene = findScene(script, epId, sceneId);
-            const ctx = sceneContext(scene);
-            const idKey = idKeyForKind(targetKind);
-            ctx[pluralForKind(targetKind)] = contextRefsForKind(ctx, targetKind).filter((ref) => strOf(ref[idKey]) !== targetId);
-            setSceneContext(scene, ctx);
-            applied.push(kind);
-        }
-        else {
-            throw opErr("PATCH BLOCKED: Unsupported operation", "Unsupported patch operation.", {
-                required: [
-                    "dot-style op: meta.worldview.set / asset.{rename,describe,alias.set,alias.add,alias.remove,states.set,role.set,merge,delete} / state.{add,rename,describe,delete} / context.{set,clear,ref.remove} / action.{type.set,actor.set,delete,insert,move,state.change,state.remove,transition.set,transition.clear,content.replace} / scene.{split,merge,delete,move} / dialogue.{speakers,overlap} / speaker.add",
-                ],
-                received: [kind],
-                nextSteps: [
-                    "Use a supported dot-style patch operation.",
-                    "Legacy snake-style ops (set_worldview / rename_actor / set_action_type / merge_scenes / split_scene / set_scene_*_ref / set_action_actor / set_asset_aliases / set_asset_states / set_action_content_from_span etc.) were removed in 0.6.0; use the new dot-style equivalents.",
-                ],
-                errorCode: "OP_UNSUPPORTED",
-            });
-        }
-    }
-    renumberSceneIds(script);
-    return applied;
-}
-//# sourceMappingURL=script-core.js.map