@lingjingai/scriptctl 0.60.13 → 0.61.1

package/dist/review-agent.js

@@ -0,0 +1,2956 @@
+// packages/screenplay/dist/model.js
+import * as fs from "node:fs";
+
+// packages/screenplay/dist/trace.js
+var sink = null;
+var t0 = 0;
+function step(fn, note) {
+  if (sink)
+    sink.push({ fn, note, ms: Math.round((performance.now() - t0) * 100) / 100 });
+}
+
+// packages/screenplay/dist/schema/types.js
+var ACTION_TYPES = ["action", "dialogue", "inner_thought", "transition"];
+var ACTION_TYPE_SET = new Set(ACTION_TYPES);
+var NON_ACTOR_SPEAKER_KINDS = ["system", "broadcast", "offscreen", "group"];
+var NON_ACTOR_SPEAKER_KIND_SET = new Set(NON_ACTOR_SPEAKER_KINDS);
+var IMPORTANCE_TIERS = ["featured", "background"];
+var IMPORTANCE_TIER_SET = new Set(IMPORTANCE_TIERS);
+var ROLE_TYPES = ["\u4E3B\u89D2", "\u914D\u89D2"];
+var ROLE_TYPE_SET = new Set(ROLE_TYPES);
+var SCENE_TIME_VALUES = ["day", "night", "dawn", "dusk"];
+var SCENE_TIME_SET = new Set(SCENE_TIME_VALUES);
+function isSceneTime(value) {
+  return typeof value === "string" && SCENE_TIME_SET.has(value);
+}
+var SCENE_SPACE_VALUES = ["interior", "exterior"];
+var SCENE_SPACE_SET = new Set(SCENE_SPACE_VALUES);
+
+// packages/screenplay/dist/schema/names.js
+function canonicalNameKey(name) {
+  return name.normalize("NFKC").toLowerCase();
+}
+
+// packages/screenplay/dist/schema/issues.js
+function issueKey(issue) {
+  return JSON.stringify([issue.code, issue.path, issue.message]);
+}
+function issueCounts(issues2) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const issue of issues2) {
+    const key = issueKey(issue);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function issuesIntroduced(baseline2, current) {
+  const budget = issueCounts(baseline2);
+  const fresh = [];
+  for (const issue of current) {
+    const key = issueKey(issue);
+    const left = budget.get(key) ?? 0;
+    if (left > 0)
+      budget.set(key, left - 1);
+    else
+      fresh.push(issue);
+  }
+  return fresh;
+}
+
+// packages/screenplay/dist/schema/ids.js
+import { customAlphabet } from "nanoid";
+var V4_ID_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var V4_ID_RANDOM_LENGTH = 6;
+var V4_ID_PREFIXES = {
+  episode: "ep",
+  scene: "scn",
+  action: "ac",
+  actor: "act",
+  location: "loc",
+  prop: "prp",
+  state: "st"
+};
+var randomSuffix = customAlphabet(V4_ID_ALPHABET, V4_ID_RANDOM_LENGTH);
+var alphabetClass = `[${V4_ID_ALPHABET}]`;
+var V4_ID_PATTERNS = Object.fromEntries(Object.entries(V4_ID_PREFIXES).map(([kind, prefix]) => [
+  kind,
+  new RegExp(`^${prefix}${alphabetClass}{${V4_ID_RANDOM_LENGTH}}$`)
+]));
+function isV4Id(kind, value) {
+  return typeof value === "string" && V4_ID_PATTERNS[kind].test(value);
+}
+var ID_SPACE_EXHAUSTED = "ID_SPACE_EXHAUSTED";
+function generateV4Id(kind, existing = /* @__PURE__ */ new Set(), generateSuffix = randomSuffix) {
+  const prefix = V4_ID_PREFIXES[kind];
+  for (let attempt = 0; attempt < 128; attempt++) {
+    const candidate = `${prefix}${generateSuffix()}`;
+    if (!existing.has(candidate))
+      return candidate;
+  }
+  throw Object.assign(new Error(`Could not generate an unused ${kind} ID after 128 attempts.`), { code: ID_SPACE_EXHAUSTED });
+}
+
+// packages/screenplay/dist/schema/timestamp.js
+var TimestampParseError = class extends Error {
+  input;
+  constructor(input, message) {
+    super(message);
+    this.input = input;
+    this.name = "TimestampParseError";
+  }
+};
+var MINUTE_SECOND_RE = /^(\d+):(\d{2})(?:\.(\d{1,3}))?$/;
+var HOUR_MINUTE_SECOND_RE = /^(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/;
+function fractionMilliseconds(raw) {
+  return raw ? Number(raw.padEnd(3, "0")) : 0;
+}
+function requireSafeMilliseconds(raw, milliseconds) {
+  if (!Number.isSafeInteger(milliseconds)) {
+    throw new TimestampParseError(raw, "Timestamp exceeds the supported numeric range.");
+  }
+  return milliseconds;
+}
+function canonicalTimestamp(milliseconds, fraction) {
+  const totalSeconds = Math.floor(milliseconds / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds2 = totalSeconds % 60;
+  const fractionPart = fraction ? `.${fraction}` : "";
+  if (hours > 0) {
+    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds2).padStart(2, "0")}${fractionPart}`;
+  }
+  return `${String(minutes).padStart(2, "0")}:${String(seconds2).padStart(2, "0")}${fractionPart}`;
+}
+function parseTimestamp(raw) {
+  const input = raw.trim();
+  if (!input) {
+    throw new TimestampParseError(raw, "Timestamp must not be empty.");
+  }
+  const hourMatch = input.match(HOUR_MINUTE_SECOND_RE);
+  if (hourMatch) {
+    const hours = Number(hourMatch[1]);
+    const minutes2 = Number(hourMatch[2]);
+    const seconds3 = Number(hourMatch[3]);
+    const fraction2 = hourMatch[4];
+    if (minutes2 > 59) {
+      throw new TimestampParseError(raw, "Hour-form timestamps require minutes between 00 and 59.");
+    }
+    if (seconds3 > 59) {
+      throw new TimestampParseError(raw, "Timestamp seconds must be between 00 and 59.");
+    }
+    const milliseconds2 = requireSafeMilliseconds(raw, ((hours * 60 + minutes2) * 60 + seconds3) * 1e3 + fractionMilliseconds(fraction2));
+    return {
+      canonical: canonicalTimestamp(milliseconds2, fraction2),
+      milliseconds: milliseconds2,
+      fractionDigits: fraction2?.length ?? 0
+    };
+  }
+  const minuteMatch = input.match(MINUTE_SECOND_RE);
+  if (!minuteMatch) {
+    throw new TimestampParseError(raw, "Use M:SS, MM:SS, or H:MM:SS with an optional 1-3 digit fraction.");
+  }
+  const minutes = Number(minuteMatch[1]);
+  const seconds2 = Number(minuteMatch[2]);
+  const fraction = minuteMatch[3];
+  if (seconds2 > 59) {
+    throw new TimestampParseError(raw, "Timestamp seconds must be between 00 and 59.");
+  }
+  const milliseconds = requireSafeMilliseconds(raw, (minutes * 60 + seconds2) * 1e3 + fractionMilliseconds(fraction));
+  return {
+    canonical: canonicalTimestamp(milliseconds, fraction),
+    milliseconds,
+    fractionDigits: fraction?.length ?? 0
+  };
+}
+function timestampOfAction(action) {
+  if (typeof action !== "object" || action === null || Array.isArray(action))
+    return void 0;
+  const extend = action.extend;
+  if (typeof extend !== "object" || extend === null || Array.isArray(extend))
+    return void 0;
+  return extend.timestamp;
+}
+function validateActionTimestampOrder(actions, actionsPath, issue) {
+  let previous = null;
+  actions.forEach((action, actionIndex) => {
+    const rawTimestamp = timestampOfAction(action);
+    if (rawTimestamp === void 0)
+      return;
+    const timestampPath = `${actionsPath}[${actionIndex}].extend.timestamp`;
+    if (typeof rawTimestamp !== "string") {
+      issue("timestamp_invalid", timestampPath, "timestamp must be a string in M:SS, MM:SS, or H:MM:SS form");
+      return;
+    }
+    let timestamp;
+    try {
+      timestamp = parseTimestamp(rawTimestamp);
+    } catch (error) {
+      if (!(error instanceof TimestampParseError))
+        throw error;
+      issue("timestamp_invalid", timestampPath, error.message);
+      return;
+    }
+    if (previous !== null && timestamp.milliseconds < previous.timestamp.milliseconds) {
+      issue("timestamp_out_of_order", timestampPath, `timestamp ${timestamp.canonical} is earlier than Action ${previous.actionIndex + 1} timestamp ${previous.timestamp.canonical}; equal timestamps are allowed`);
+    }
+    previous = { actionIndex, timestamp };
+  });
+}
+
+// packages/screenplay/dist/schema/v3.js
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isArr = (v) => Array.isArray(v);
+var isStr = (v) => typeof v === "string";
+var ACTION_LEGACY = ["state_changes", "actor_id", "speakers", "lines"];
+function validateScriptV3(doc) {
+  const errors = [];
+  const warnings = [];
+  const err = (code, path4, message, repairHint) => errors.push({ code, path: path4, message, ...repairHint ? { repair_hint: repairHint } : {} });
+  const warn = (code, path4, message) => warnings.push({ code, path: path4, message });
+  if (!isObj(doc))
+    return { ok: false, errors: [{ code: "not_object", path: "$", message: "script must be an object" }], warnings };
+  if (doc.version !== 3)
+    err("version", "$.version", "version must be 3");
+  for (const key of ["title", "worldview", "style"])
+    if (!isStr(doc[key]))
+      err("field", `$.${key}`, `${key} must be a string`);
+  const stateIds = /* @__PURE__ */ new Map();
+  const idKind = /* @__PURE__ */ new Map();
+  const actorNames = /* @__PURE__ */ new Map();
+  const collect = (list, kind, idField, nameField, path4) => {
+    if (!isArr(list)) {
+      err("field", path4, `${path4} must be an array`);
+      return;
+    }
+    list.forEach((raw, i) => {
+      const p = `${path4}[${i}]`;
+      if (!isObj(raw)) {
+        err("asset", p, "asset must be an object");
+        return;
+      }
+      const id = raw[idField];
+      if (!isStr(id)) {
+        err("asset_id", `${p}.${idField}`, `${idField} required`);
+        return;
+      }
+      if (idKind.has(id))
+        err("dup_id", `${p}.${idField}`, `duplicate id ${id}`);
+      idKind.set(id, kind);
+      if (!isStr(raw[nameField]))
+        err("asset_name", `${p}.${nameField}`, `${nameField} required`);
+      else if (kind === "actor") {
+        const nameKey = canonicalNameKey(raw[nameField]);
+        const existingId = actorNames.get(nameKey);
+        if (existingId !== void 0) {
+          err("dup_actor_name", `${p}.${nameField}`, `actor name ${raw[nameField]} already belongs to ${existingId}`);
+        } else {
+          actorNames.set(nameKey, id);
+        }
+      }
+      if (!isStr(raw.importance) || !IMPORTANCE_TIERS.includes(raw.importance))
+        err("importance", `${p}.importance`, `importance must be one of ${IMPORTANCE_TIERS.join("|")}`);
+      if (!isStr(raw.description))
+        err("asset_desc", `${p}.description`, "description must be a string");
+      const ids = /* @__PURE__ */ new Set();
+      const names = /* @__PURE__ */ new Set();
+      let defaults = 0;
+      if (!isArr(raw.states) || raw.states.length === 0)
+        err("states", `${p}.states`, "states must be a non-empty array");
+      else
+        raw.states.forEach((st, j) => {
+          const sp = `${p}.states[${j}]`;
+          if (!isObj(st) || !isStr(st.state_id)) {
+            err("state_id", sp, "state_id required");
+            return;
+          }
+          if (ids.has(st.state_id))
+            err("dup_state", sp, `duplicate state_id ${st.state_id}`);
+          ids.add(st.state_id);
+          if (st.state_id === "default")
+            defaults++;
+          if (!isStr(st.state_name))
+            err("state_name", `${sp}.state_name`, "state_name required");
+          else {
+            if (names.has(st.state_name))
+              err("dup_state_name", `${sp}.state_name`, `duplicate state_name ${st.state_name}`);
+            names.add(st.state_name);
+          }
+        });
+      if (isArr(raw.states) && defaults !== 1)
+        err("default_state", `${p}.states`, `exactly one 'default' state required, found ${defaults}`);
+      stateIds.set(id, ids);
+    });
+  };
+  collect(doc.actors, "actor", "actor_id", "actor_name", "$.actors");
+  collect(doc.locations, "location", "location_id", "location_name", "$.locations");
+  collect(doc.props, "prop", "prop_id", "prop_name", "$.props");
+  const refState = (assetId, stateId, kind, path4) => {
+    if (idKind.get(assetId) !== kind) {
+      err("ref", path4, `${kind} ${assetId} not found`);
+      return;
+    }
+    if (stateId !== void 0 && (!isStr(stateId) || !stateIds.get(assetId)?.has(stateId)))
+      err("state_ref", path4, `state ${String(stateId)} not materialized on ${assetId}`);
+  };
+  const checkEntityList = (list, kind, idField, path4) => {
+    if (list === void 0) {
+      err("field", path4, `${path4} required (may be empty array)`);
+      return;
+    }
+    if (!isArr(list)) {
+      err("field", path4, `${path4} must be an array`);
+      return;
+    }
+    list.forEach((ref2, i) => {
+      if (!isObj(ref2) || !isStr(ref2[idField])) {
+        err("ref", `${path4}[${i}]`, `${idField} required`);
+        return;
+      }
+      refState(ref2[idField], ref2.state_id, kind, `${path4}[${i}]`);
+    });
+  };
+  const checkAction = (action, path4, sceneActorIds, sceneAddress) => {
+    if (!isObj(action)) {
+      err("action", path4, "action must be an object");
+      return;
+    }
+    for (const bad of ACTION_LEGACY)
+      if (bad in action)
+        err("legacy_field", `${path4}.${bad}`, `v3 forbids action.${bad}`);
+    const type = action.type;
+    if (!isStr(type) || !ACTION_TYPES.includes(type))
+      err("action_type", `${path4}.type`, `invalid action type ${String(type)}`);
+    if (!isStr(action.content))
+      err("content", `${path4}.content`, "content must be a plain-text string");
+    if (type === "dialogue" || type === "inner_thought") {
+      const sp = action.speaker;
+      if (!isObj(sp))
+        err("speaker", `${path4}.speaker`, "dialogue/inner_thought needs a speaker");
+      else if ("kind" in sp) {
+        if (!isStr(sp.kind) || !NON_ACTOR_SPEAKER_KINDS.includes(sp.kind))
+          err("speaker_kind", `${path4}.speaker.kind`, "invalid non-actor speaker kind");
+      } else if (isStr(sp.actor_id)) {
+        refState(sp.actor_id, sp.state_id, "actor", `${path4}.speaker`);
+        if (!sceneActorIds.has(sp.actor_id)) {
+          const ownedStates = stateIds.get(sp.actor_id);
+          const requestedState = isStr(sp.state_id) && ownedStates?.has(sp.state_id) ? sp.state_id : ownedStates?.has("default") ? "default" : ownedStates?.values().next().value;
+          const repairHint = sceneAddress && requestedState ? `scriptctl scene-ref ${sceneAddress} actor:${sp.actor_id} --state ${requestedState} -p "$SCRIPT"` : void 0;
+          err("actor_not_in_scene", `${path4}.speaker.actor_id`, `actor ${sp.actor_id} is not referenced by this scene`, repairHint);
+        }
+      } else
+        err("speaker", `${path4}.speaker`, "speaker needs actor_id or kind");
+    }
+  };
+  const episodes = doc.episodes;
+  if (!isArr(episodes))
+    err("episodes", "$.episodes", "episodes must be an array");
+  else
+    episodes.forEach((ep, ei) => {
+      const ep_p = `$.episodes[${ei}]`;
+      if (!isObj(ep) || !isStr(ep.episode_id)) {
+        err("episode_id", ep_p, "episode_id required");
+        return;
+      }
+      if (!isArr(ep.scenes)) {
+        err("scenes", `${ep_p}.scenes`, "scenes must be an array");
+        return;
+      }
+      ep.scenes.forEach((sc, si) => {
+        const sc_p = `${ep_p}.scenes[${si}]`;
+        if (!isObj(sc)) {
+          err("scene", sc_p, "scene must be an object");
+          return;
+        }
+        if ("context" in sc)
+          err("legacy_field", `${sc_p}.context`, "v3 forbids scene.context");
+        if (!isStr(sc.scene_id))
+          err("scene_id", sc_p, "scene_id required");
+        const environment = sc.environment;
+        if (environment === void 0 || isObj(environment) && (!isStr(environment.time) || environment.time.trim() === "")) {
+          warn("scene_time_missing", `${sc_p}.environment.time`, "scene time is required for production review");
+        } else if (!isObj(environment) || environment.space !== void 0 && !isStr(environment.space) || !isStr(environment.time)) {
+          err("environment", `${sc_p}.environment`, "environment must contain optional string space and a time string");
+        } else if (!isSceneTime(environment.time)) {
+          err("scene_time", `${sc_p}.environment.time`, "scene time must be day|night|dawn|dusk");
+        }
+        const loc = sc.location;
+        if (loc !== null) {
+          if (!isObj(loc) || !isStr(loc.location_id))
+            err("location", `${sc_p}.location`, "location must be null or {location_id}");
+          else
+            refState(loc.location_id, loc.state_id, "location", `${sc_p}.location`);
+        }
+        checkEntityList(sc.actors, "actor", "actor_id", `${sc_p}.actors`);
+        checkEntityList(sc.props, "prop", "prop_id", `${sc_p}.props`);
+        if (isArr(sc.props)) {
+          const propIds = /* @__PURE__ */ new Set();
+          sc.props.forEach((ref2, i) => {
+            if (!isObj(ref2) || !isStr(ref2.prop_id))
+              return;
+            if (propIds.has(ref2.prop_id))
+              err("dup_prop_ref", `${sc_p}.props[${i}]`, `duplicate prop ref ${ref2.prop_id}`);
+            propIds.add(ref2.prop_id);
+          });
+        }
+        const sceneActorIds = new Set(isArr(sc.actors) ? sc.actors.filter((ref2) => isObj(ref2)).map((ref2) => ref2.actor_id).filter((id) => isStr(id)) : []);
+        if (!isArr(sc.actions))
+          err("actions", `${sc_p}.actions`, "actions must be an array");
+        else {
+          const sceneAddress = isStr(sc.scene_id) ? `${ep.episode_id}/${sc.scene_id}` : void 0;
+          sc.actions.forEach((a, ai) => checkAction(a, `${sc_p}.actions[${ai}]`, sceneActorIds, sceneAddress));
+          validateActionTimestampOrder(sc.actions, `${sc_p}.actions`, err);
+        }
+      });
+    });
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+// packages/screenplay/dist/schema/v4.js
+var isObj2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStr2 = (value) => typeof value === "string";
+var isArr2 = (value) => Array.isArray(value);
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJsonValue);
+  return isObj2(value) && Object.values(value).every(isJsonValue);
+}
+function validateExtend(value, path4, err) {
+  if (value !== void 0 && (!isObj2(value) || !Object.values(value).every(isJsonValue))) {
+    err("extend", path4, "extend must be an object containing JSON values");
+  }
+}
+function isSorted(values) {
+  for (let index = 1; index < values.length; index++) {
+    if (values[index - 1] > values[index])
+      return false;
+  }
+  return true;
+}
+function validateScriptV4(doc) {
+  const errors = [];
+  const warnings = [];
+  const err = (code, path4, message, repairHint) => errors.push({ code, path: path4, message, ...repairHint ? { repair_hint: repairHint } : {} });
+  const warn = (code, path4, message, repairHint) => warnings.push({ code, path: path4, message, ...repairHint ? { repair_hint: repairHint } : {} });
+  if (!isObj2(doc)) {
+    return {
+      ok: false,
+      errors: [{ code: "not_object", path: "$", message: "script must be an object" }],
+      warnings
+    };
+  }
+  if (doc.version !== 4)
+    err("version", "$.version", "version must be 4");
+  for (const key of ["title", "worldview", "style"]) {
+    if (!isStr2(doc[key]))
+      err("field", `$.${key}`, `${key} must be a string`);
+  }
+  for (const key of ["worldview_raw", "synopsis", "logline", "theme"]) {
+    if (doc[key] !== void 0 && !isStr2(doc[key]))
+      err("field", `$.${key}`, `${key} must be a string`);
+  }
+  if (doc.main_characters !== void 0 && (!isArr2(doc.main_characters) || !doc.main_characters.every((item) => isObj2(item) && isStr2(item.name) && isStr2(item.role)))) {
+    err("main_characters", "$.main_characters", "main_characters must contain {name, role} string records");
+  }
+  validateExtend(doc.extend, "$.extend", err);
+  const assetKinds = /* @__PURE__ */ new Map();
+  const stateIds = /* @__PURE__ */ new Map();
+  const actorNames = /* @__PURE__ */ new Set();
+  const collectAssets = (list, kind, idField, nameField, path4) => {
+    if (!isArr2(list)) {
+      err("field", path4, `${path4} must be an array`);
+      return;
+    }
+    const ids = /* @__PURE__ */ new Set();
+    list.forEach((raw, index) => {
+      const itemPath = `${path4}[${index}]`;
+      if (!isObj2(raw)) {
+        err("asset", itemPath, "asset must be an object");
+        return;
+      }
+      const id = raw[idField];
+      if (!isV4Id(kind, id)) {
+        err("asset_id", `${itemPath}.${idField}`, `${idField} must be ${kind} ID`);
+        return;
+      }
+      if (ids.has(id))
+        err("dup_id", `${itemPath}.${idField}`, `duplicate ${idField} ${id}`);
+      ids.add(id);
+      assetKinds.set(id, kind);
+      if (!isStr2(raw[nameField]) || raw[nameField].trim() === "") {
+        err("asset_name", `${itemPath}.${nameField}`, `${nameField} must be a non-empty string`);
+      } else if (kind === "actor") {
+        const nameKey = raw[nameField].trim().toLocaleLowerCase();
+        if (actorNames.has(nameKey)) {
+          err("dup_actor_name", `${itemPath}.${nameField}`, `duplicate actor name ${raw[nameField]}`);
+        }
+        actorNames.add(nameKey);
+      }
+      if (!isStr2(raw.importance) || !IMPORTANCE_TIERS.includes(raw.importance)) {
+        err("importance", `${itemPath}.importance`, `importance must be ${IMPORTANCE_TIERS.join("|")}`);
+      }
+      if (kind === "actor" && raw.role_type !== void 0 && (!isStr2(raw.role_type) || !ROLE_TYPES.includes(raw.role_type))) {
+        err("role_type", `${itemPath}.role_type`, `role_type must be ${ROLE_TYPES.join("|")}`);
+      }
+      if (!isStr2(raw.description))
+        err("asset_desc", `${itemPath}.description`, "description must be a string");
+      if (raw.aliases !== void 0 && (!isArr2(raw.aliases) || !raw.aliases.every(isStr2))) {
+        err("aliases", `${itemPath}.aliases`, "aliases must be an array of strings");
+      } else if (isArr2(raw.aliases) && raw.aliases.every(isStr2)) {
+        const seenAliases = /* @__PURE__ */ new Set();
+        const assetName2 = isStr2(raw[nameField]) ? raw[nameField] : "";
+        raw.aliases.forEach((alias, aliasIndex) => {
+          if (alias === "") {
+            err("alias_empty", `${itemPath}.aliases[${aliasIndex}]`, "alias must not be empty");
+          }
+          if (alias === assetName2) {
+            err("alias_equals_name", `${itemPath}.aliases[${aliasIndex}]`, "alias must differ from the asset name");
+          }
+          if (seenAliases.has(alias)) {
+            err("dup_alias", `${itemPath}.aliases[${aliasIndex}]`, `duplicate alias ${alias}`);
+          }
+          seenAliases.add(alias);
+        });
+      }
+      validateExtend(raw.extend, `${itemPath}.extend`, err);
+      const ownerStates = /* @__PURE__ */ new Set();
+      const ownerStateNames = /* @__PURE__ */ new Set();
+      let defaults = 0;
+      if (!isArr2(raw.states) || raw.states.length === 0) {
+        err("states", `${itemPath}.states`, "states must be a non-empty array");
+      } else {
+        raw.states.forEach((state2, stateIndex) => {
+          const statePath = `${itemPath}.states[${stateIndex}]`;
+          if (!isObj2(state2)) {
+            err("state", statePath, "state must be an object");
+            return;
+          }
+          const stateId = state2.state_id;
+          if (stateId !== "default" && !isV4Id("state", stateId)) {
+            err("state_id", `${statePath}.state_id`, "state_id must be default or st plus six Base58 characters");
+            return;
+          }
+          if (ownerStates.has(stateId))
+            err("dup_state", `${statePath}.state_id`, `duplicate state_id ${stateId}`);
+          ownerStates.add(stateId);
+          if (stateId === "default")
+            defaults++;
+          if (!isStr2(state2.state_name) || state2.state_name.trim() === "") {
+            err("state_name", `${statePath}.state_name`, "state_name must be a non-empty string");
+          } else {
+            if (ownerStateNames.has(state2.state_name)) {
+              err("dup_state_name", `${statePath}.state_name`, `duplicate state_name ${state2.state_name}`);
+            }
+            ownerStateNames.add(state2.state_name);
+          }
+          if (!isStr2(state2.description))
+            err("state_description", `${statePath}.description`, "description must be a string");
+          validateExtend(state2.extend, `${statePath}.extend`, err);
+        });
+      }
+      if (defaults !== 1) {
+        err("default_state", `${itemPath}.states`, `exactly one default state required, found ${defaults}`);
+      }
+      stateIds.set(id, ownerStates);
+    });
+  };
+  collectAssets(doc.actors, "actor", "actor_id", "actor_name", "$.actors");
+  collectAssets(doc.locations, "location", "location_id", "location_name", "$.locations");
+  collectAssets(doc.props, "prop", "prop_id", "prop_name", "$.props");
+  const validateStateSet = (assetId, rawStateIds, path4) => {
+    if (!isArr2(rawStateIds) || rawStateIds.length === 0 || !rawStateIds.every(isStr2)) {
+      err("state_ids", path4, "state_ids must be a non-empty array of strings");
+      return [];
+    }
+    const ids = rawStateIds;
+    const seen = /* @__PURE__ */ new Set();
+    ids.forEach((stateId, index) => {
+      if (seen.has(stateId))
+        err("dup_state_ref", `${path4}[${index}]`, `duplicate state_id ${stateId}`);
+      seen.add(stateId);
+      if (!stateIds.get(assetId)?.has(stateId)) {
+        err("state_ref", `${path4}[${index}]`, `state ${stateId} not found on ${assetId}`);
+      }
+    });
+    if (!isSorted(ids))
+      err("state_ids_order", path4, "state_ids must be sorted lexically");
+    return ids;
+  };
+  const episodeIds = /* @__PURE__ */ new Set();
+  const sceneIds = /* @__PURE__ */ new Set();
+  const actionIds = /* @__PURE__ */ new Set();
+  if (!isArr2(doc.episodes)) {
+    err("episodes", "$.episodes", "episodes must be an array");
+  } else {
+    doc.episodes.forEach((episode, episodeIndex) => {
+      const episodePath = `$.episodes[${episodeIndex}]`;
+      if (!isObj2(episode)) {
+        err("episode", episodePath, "episode must be an object");
+        return;
+      }
+      if (!isV4Id("episode", episode.episode_id)) {
+        err("episode_id", `${episodePath}.episode_id`, "episode_id must be ep plus six Base58 characters");
+      } else {
+        if (episodeIds.has(episode.episode_id)) {
+          err("dup_episode_id", `${episodePath}.episode_id`, `duplicate episode_id ${episode.episode_id}`);
+        }
+        episodeIds.add(episode.episode_id);
+      }
+      for (const key of ["title", "synopsis"]) {
+        if (episode[key] !== void 0 && !isStr2(episode[key])) {
+          err("field", `${episodePath}.${key}`, `${key} must be a string`);
+        }
+      }
+      validateExtend(episode.extend, `${episodePath}.extend`, err);
+      if (!isArr2(episode.scenes)) {
+        err("scenes", `${episodePath}.scenes`, "scenes must be an array");
+        return;
+      }
+      episode.scenes.forEach((scene, sceneIndex) => {
+        const scenePath = `${episodePath}.scenes[${sceneIndex}]`;
+        if (!isObj2(scene)) {
+          err("scene", scenePath, "scene must be an object");
+          return;
+        }
+        if (!isV4Id("scene", scene.scene_id)) {
+          err("scene_id", `${scenePath}.scene_id`, "scene_id must be scn plus six Base58 characters");
+        } else {
+          if (sceneIds.has(scene.scene_id)) {
+            err("dup_scene_id", `${scenePath}.scene_id`, `duplicate scene_id ${scene.scene_id}`);
+          }
+          sceneIds.add(scene.scene_id);
+        }
+        validateExtend(scene.extend, `${scenePath}.extend`, err);
+        if (scene.environment === void 0 || isObj2(scene.environment) && (!isStr2(scene.environment.time) || scene.environment.time.trim() === "")) {
+          warn("scene_time_missing", `${scenePath}.environment.time`, "scene time is required for production review");
+        } else if (!isObj2(scene.environment) || scene.environment.space !== void 0 && !isStr2(scene.environment.space) || !isStr2(scene.environment.time)) {
+          err("environment", `${scenePath}.environment`, "environment must contain optional string space and a time string");
+        } else if (!isSceneTime(scene.environment.time)) {
+          err("scene_time", `${scenePath}.environment.time`, "scene time must be day|night|dawn|dusk");
+        }
+        if (scene.location !== null) {
+          if (!isObj2(scene.location) || !isV4Id("location", scene.location.location_id)) {
+            err("location", `${scenePath}.location`, "location must be null or a typed v4 location reference");
+          } else {
+            if ("state_id" in scene.location) {
+              err("v3_field", `${scenePath}.location.state_id`, "Script v4 scene references use state_ids");
+            }
+            if (assetKinds.get(scene.location.location_id) !== "location") {
+              err("location_ref", `${scenePath}.location.location_id`, `location ${scene.location.location_id} not found`);
+            }
+            validateStateSet(scene.location.location_id, scene.location.state_ids, `${scenePath}.location.state_ids`);
+          }
+        }
+        const sceneActorStates = /* @__PURE__ */ new Map();
+        const validateRefs = (refs, kind, idField, path4) => {
+          if (!isArr2(refs)) {
+            err("field", path4, `${path4} must be an array`);
+            return;
+          }
+          const seen = /* @__PURE__ */ new Set();
+          refs.forEach((ref2, refIndex) => {
+            const refPath = `${path4}[${refIndex}]`;
+            if (!isObj2(ref2) || !isV4Id(kind, ref2[idField])) {
+              err("ref", refPath, `${idField} must be a typed v4 ID`);
+              return;
+            }
+            const assetId = ref2[idField];
+            if ("state_id" in ref2) {
+              err("v3_field", `${refPath}.state_id`, "Script v4 scene references use state_ids");
+            }
+            if (seen.has(assetId))
+              err("dup_asset_ref", `${refPath}.${idField}`, `duplicate ${kind} ref ${assetId}`);
+            seen.add(assetId);
+            if (assetKinds.get(assetId) !== kind) {
+              err("asset_ref", `${refPath}.${idField}`, `${kind} ${assetId} not found`);
+            }
+            const ids = validateStateSet(assetId, ref2.state_ids, `${refPath}.state_ids`);
+            if (kind === "actor")
+              sceneActorStates.set(assetId, new Set(ids));
+          });
+        };
+        validateRefs(scene.actors, "actor", "actor_id", `${scenePath}.actors`);
+        validateRefs(scene.props, "prop", "prop_id", `${scenePath}.props`);
+        if (!isArr2(scene.actions)) {
+          err("actions", `${scenePath}.actions`, "actions must be an array");
+          return;
+        }
+        scene.actions.forEach((action, actionIndex) => {
+          const actionPath = `${scenePath}.actions[${actionIndex}]`;
+          if (!isObj2(action)) {
+            err("action", actionPath, "action must be an object");
+            return;
+          }
+          if (!isV4Id("action", action.action_id)) {
+            err("action_id", `${actionPath}.action_id`, "action_id must be ac plus six Base58 characters");
+          } else {
+            if (actionIds.has(action.action_id)) {
+              err("dup_action_id", `${actionPath}.action_id`, `duplicate action_id ${action.action_id}`);
+            }
+            actionIds.add(action.action_id);
+          }
+          if (!isStr2(action.type) || !ACTION_TYPES.includes(action.type)) {
+            err("action_type", `${actionPath}.type`, `invalid action type ${String(action.type)}`);
+          }
+          if (!isStr2(action.content))
+            err("content", `${actionPath}.content`, "content must be a string");
+          if ("emotion" in action)
+            err("v3_field", `${actionPath}.emotion`, "Script v4 does not allow emotion");
+          validateExtend(action.extend, `${actionPath}.extend`, err);
+          const speaking = action.type === "dialogue" || action.type === "inner_thought";
+          if (speaking) {
+            if (action.parenthetical !== void 0 && !isStr2(action.parenthetical)) {
+              err("parenthetical", `${actionPath}.parenthetical`, "parenthetical must be a string");
+            }
+            if (!isObj2(action.speaker)) {
+              err("speaker", `${actionPath}.speaker`, "dialogue/inner_thought requires a speaker");
+            } else if (isStr2(action.speaker.actor_id)) {
+              if ("kind" in action.speaker || "label" in action.speaker) {
+                err("speaker_shape", `${actionPath}.speaker`, "actor speaker cannot contain non-actor speaker fields");
+              }
+              const actorId = action.speaker.actor_id;
+              if (!isV4Id("actor", actorId) || assetKinds.get(actorId) !== "actor") {
+                err("speaker_actor", `${actionPath}.speaker.actor_id`, `actor ${actorId} not found`);
+              }
+              const sceneStates = sceneActorStates.get(actorId);
+              const ownedStates = stateIds.get(actorId);
+              const speakerState = isStr2(action.speaker.state_id) && ownedStates?.has(action.speaker.state_id) ? action.speaker.state_id : void 0;
+              const defaultState = ownedStates?.has("default") ? "default" : ownedStates?.values().next().value;
+              const repairStates = speakerState ? [speakerState] : defaultState ? [defaultState] : [];
+              const sceneRefRepair = isV4Id("scene", scene.scene_id) && isV4Id("actor", actorId) && repairStates.length > 0 ? `scriptctl scene-ref ${scene.scene_id} ${actorId} ${repairStates.map((id) => `--state ${id}`).join(" ")} -p "$SCRIPT"` : void 0;
+              if (!sceneStates) {
+                err("actor_not_in_scene", `${actionPath}.speaker.actor_id`, `actor ${actorId} is not referenced by this scene`, sceneRefRepair);
+              }
+              if (action.speaker.state_id !== void 0 && (!isStr2(action.speaker.state_id) || !sceneStates?.has(action.speaker.state_id))) {
+                const nextStates = speakerState ? [.../* @__PURE__ */ new Set([...sceneStates ?? [], speakerState])].sort() : [];
+                const stateRepair = isV4Id("scene", scene.scene_id) && isV4Id("actor", actorId) && nextStates.length > 0 ? `scriptctl scene-ref ${scene.scene_id} ${actorId} ${nextStates.map((id) => `--state ${id}`).join(" ")} -p "$SCRIPT"` : sceneRefRepair;
+                err("speaker_state", `${actionPath}.speaker.state_id`, `speaker state ${String(action.speaker.state_id)} is not in this scene's actor state_ids`, stateRepair);
+              }
+            } else if (isStr2(action.speaker.kind)) {
+              if ("actor_id" in action.speaker || "state_id" in action.speaker) {
+                err("speaker_shape", `${actionPath}.speaker`, "non-actor speaker cannot contain actor speaker fields");
+              }
+              if (!NON_ACTOR_SPEAKER_KINDS.includes(action.speaker.kind)) {
+                err("speaker_kind", `${actionPath}.speaker.kind`, "invalid non-actor speaker kind");
+              }
+              if (action.speaker.label !== void 0 && !isStr2(action.speaker.label)) {
+                err("speaker_label", `${actionPath}.speaker.label`, "speaker label must be a string");
+              }
+            } else {
+              err("speaker", `${actionPath}.speaker`, "speaker needs actor_id or kind");
+            }
+          } else {
+            if ("parenthetical" in action) {
+              err("parenthetical_type", `${actionPath}.parenthetical`, "parenthetical only belongs to speaking actions");
+            }
+            if ("speaker" in action) {
+              err("speaker_type", `${actionPath}.speaker`, "speaker only belongs to speaking actions");
+            }
+          }
+          if (action.transition_prompt !== void 0) {
+            const prompt = action.transition_prompt;
+            if (!isObj2(prompt) || !isStr2(prompt.target) || !isStr2(prompt.process) || prompt.process === "" || !isStr2(prompt.contrast) || prompt.contrast === "") {
+              err("transition_prompt", `${actionPath}.transition_prompt`, "transition_prompt requires non-empty target/process/contrast");
+            } else if (!assetKinds.has(prompt.target)) {
+              err("transition_target", `${actionPath}.transition_prompt.target`, `asset ${prompt.target} not found`);
+            }
+          }
+        });
+        validateActionTimestampOrder(scene.actions, `${scenePath}.actions`, err);
+      });
+    });
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+// packages/screenplay/dist/model.js
+var KINDS = [
+  ["actor", "actors", "actor"],
+  ["location", "locations", "location"],
+  ["prop", "props", "prop"]
+];
+function arr(v) {
+  return Array.isArray(v) ? v : [];
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function put(map, key, value, dupes) {
+  if (!key)
+    return;
+  if (map.has(key) && map.get(key) !== value) {
+    dupes.add(key);
+    return;
+  }
+  map.set(key, value);
+}
+function parse(raw, path4 = "") {
+  const version = raw?.version;
+  if (version !== 3 && version !== 4) {
+    throw new Error(`Unsupported script.version: ${JSON.stringify(version)} (expected 3 or 4)`);
+  }
+  const doc = {
+    version,
+    path: path4,
+    raw,
+    episodes: [],
+    assets: [],
+    byId: /* @__PURE__ */ new Map(),
+    eps: /* @__PURE__ */ new Map(),
+    scenes: /* @__PURE__ */ new Map(),
+    actions: /* @__PURE__ */ new Map()
+  };
+  for (const [kind, field, idKey] of KINDS) {
+    for (const a of arr(raw[field])) {
+      const asset = {
+        id: str(a[`${idKey}_id`]),
+        kind,
+        name: str(a[`${idKey}_name`]),
+        aliases: arr(a.aliases).map(str).filter(Boolean),
+        importance: str(a.importance),
+        desc: str(a.description),
+        states: arr(a.states).map((s) => ({
+          id: str(s.state_id),
+          name: str(s.state_name),
+          desc: str(s.description)
+        })),
+        raw: a,
+        label: ""
+      };
+      doc.assets.push(asset);
+      doc.byId.set(asset.id, asset);
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const a of doc.assets)
+    for (const n of [a.name, ...a.aliases])
+      seen.set(n, (seen.get(n) ?? 0) + 1);
+  for (const a of doc.assets) {
+    a.label = [a.name, ...a.aliases].filter((n) => seen.get(n) === 1).sort((x, y) => x.length - y.length)[0] ?? a.name;
+  }
+  const dupes = /* @__PURE__ */ new Set();
+  let gScene = 0, gAction = 0;
+  arr(raw.episodes).forEach((eRaw, ei) => {
+    const ep = {
+      anchor: String(ei + 1),
+      id: str(eRaw.episode_id),
+      no: ei + 1,
+      title: str(eRaw.title) || void 0,
+      synopsis: str(eRaw.synopsis) || void 0,
+      scenes: [],
+      raw: eRaw
+    };
+    arr(eRaw.scenes).forEach((sRaw, si) => {
+      gScene++;
+      const scene = {
+        anchor: version === 4 ? str(sRaw.scene_id) : `${ei + 1}-${si + 1}`,
+        id: str(sRaw.scene_id),
+        no: si + 1,
+        gno: gScene,
+        env: sRaw.environment ?? {},
+        location: refOf(sRaw.location, "location_id"),
+        actors: arr(sRaw.actors).map((r) => refOf(r, "actor_id")).filter(Boolean),
+        props: arr(sRaw.props).map((r) => refOf(r, "prop_id")).filter(Boolean),
+        actions: [],
+        raw: sRaw,
+        ep
+      };
+      arr(sRaw.actions).forEach((aRaw, ai) => {
+        gAction++;
+        const action = {
+          anchor: version === 4 ? str(aRaw.action_id) : `${ei + 1}-${si + 1}-${ai + 1}`,
+          no: ai + 1,
+          gno: gAction,
+          type: str(aRaw.type) || "action",
+          content: str(aRaw.content),
+          speaker: speakerOf(aRaw.speaker),
+          paren: typeof aRaw.parenthetical === "string" ? aRaw.parenthetical : typeof aRaw.emotion === "string" ? aRaw.emotion : void 0,
+          ts: str(aRaw.extend?.timestamp) || void 0,
+          raw: aRaw,
+          scene
+        };
+        scene.actions.push(action);
+        put(doc.actions, action.anchor, action, dupes);
+        put(doc.actions, `${ei + 1}-${si + 1}-${ai + 1}`, action, dupes);
+        if (version === 3)
+          put(doc.actions, `${ep.id}/${scene.id}#${ai}`, action, dupes);
+      });
+      ep.scenes.push(scene);
+      put(doc.scenes, scene.anchor, scene, dupes);
+      put(doc.scenes, `${ei + 1}-${si + 1}`, scene, dupes);
+      put(doc.scenes, `${ep.id}/${scene.id}`, scene, dupes);
+      put(doc.scenes, scene.id, scene, dupes);
+    });
+    doc.episodes.push(ep);
+    put(doc.eps, String(ei + 1), ep, dupes);
+    put(doc.eps, ep.id, ep, dupes);
+  });
+  for (const k of dupes) {
+    doc.actions.delete(k);
+    doc.scenes.delete(k);
+    doc.eps.delete(k);
+  }
+  step(path4 ? "model.load" : "model.parse", `v${version} \xB7 ${doc.episodes.length} ep \xB7 ${doc.scenes.size} scene keys \xB7 ${doc.actions.size} action keys \xB7 ${doc.assets.length} assets \xB7 ${dupes.size} ambiguous keys dropped`);
+  return doc;
+}
+function refOf(r, idKey) {
+  if (!r || typeof r !== "object")
+    return null;
+  const id = str(r[idKey]);
+  if (!id)
+    return null;
+  const states = Array.isArray(r.state_ids) ? r.state_ids.map(str) : r.state_id ? [str(r.state_id)] : [];
+  return { id, states, raw: r };
+}
+function speakerOf(s) {
+  if (!s || typeof s !== "object")
+    return void 0;
+  if (s.actor_id)
+    return { id: str(s.actor_id), state: str(s.state_id) || void 0 };
+  if (s.kind)
+    return { kind: str(s.kind), label: str(s.label) || void 0 };
+  return void 0;
+}
+function resolve(doc, addr) {
+  const q = addr.trim();
+  if (!q)
+    return { t: "script", doc };
+  const slash = q.indexOf("/");
+  if (slash > 0 && !doc.scenes.has(q)) {
+    const left = q.slice(0, slash), right = q.slice(slash + 1);
+    const owner = doc.byId.get(left) ?? assetByName(doc, left);
+    if (owner) {
+      const hit = owner.states.filter((st) => st.id === right || st.name === right);
+      if (hit.length === 1) {
+        step("resolve", `"${q}" -> state ${owner.id}/${hit[0].id} "${hit[0].name}"`);
+        return { t: "state", asset: owner, state: hit[0] };
+      }
+      if (hit.length > 1) {
+        throw new Error(`${owner.name} has ${hit.length} states named "${right}"; address it by state id`);
+      }
+      throw new Error(`${owner.name} has no state "${right}" (has: ${owner.states.map((st) => `${st.id}(${st.name})`).join(", ")})`);
+    }
+  }
+  const a = doc.actions.get(q);
+  if (a) {
+    step("resolve", `"${q}" -> action map hit -> ${a.anchor}`);
+    return { t: "action", action: a };
+  }
+  const s = doc.scenes.get(q);
+  if (s) {
+    step("resolve", `"${q}" -> scene map hit -> ${s.anchor}`);
+    return { t: "scene", scene: s };
+  }
+  const e = doc.eps.get(q);
+  if (e) {
+    step("resolve", `"${q}" -> episode map hit -> ${e.id}`);
+    return { t: "ep", ep: e };
+  }
+  const byId = doc.byId.get(q);
+  if (byId) {
+    step("resolve", `"${q}" -> asset id hit -> ${byId.name}`);
+    return { t: "asset", asset: byId };
+  }
+  const hits = doc.assets.filter((x) => x.name === q || x.aliases.includes(q));
+  if (hits.length === 1) {
+    step("resolve", `"${q}" -> exact name/alias -> ${hits[0].id} ${hits[0].name}`);
+    return { t: "asset", asset: hits[0] };
+  }
+  if (hits.length > 1) {
+    throw new Error(`Ambiguous name "${q}": ${hits.map((h) => `${h.id}(${h.name})`).join(", ")}`);
+  }
+  const loose = doc.assets.filter((x) => x.name.includes(q) || x.aliases.some((al) => al.includes(q)));
+  if (loose.length === 1) {
+    step("resolve", `"${q}" -> substring name match -> ${loose[0].id} ${loose[0].name}`);
+    return { t: "asset", asset: loose[0] };
+  }
+  throw new Error(`Unknown address "${q}". Use an ordinal (3 / 3-2 / 3-2-5), a canonical ID, or an asset name.` + (loose.length ? ` Did you mean: ${loose.slice(0, 5).map((h) => h.name).join(", ")}?` : ""));
+}
+function assetByName(doc, q) {
+  const exact = doc.assets.filter((x) => x.name === q || x.aliases.includes(q));
+  if (exact.length === 1)
+    return exact[0];
+  if (exact.length > 1)
+    return void 0;
+  const loose = doc.assets.filter((x) => x.name.includes(q) || x.aliases.some((a) => a.includes(q)));
+  return loose.length === 1 ? loose[0] : void 0;
+}
+function assetName(doc, id) {
+  return doc.byId.get(id)?.label || id;
+}
+function stateName(doc, assetId, stateId) {
+  const st = doc.byId.get(assetId)?.states.find((s) => s.id === stateId);
+  return st?.name || stateId;
+}
+function allActions(doc) {
+  return doc.episodes.flatMap((e) => e.scenes.flatMap((s) => s.actions));
+}
+var KIND_OF = {
+  ep: "episode",
+  scn: "scene",
+  ac: "action",
+  act: "actor",
+  loc: "location",
+  prp: "prop",
+  st: "state"
+};
+function newId(prefix, taken) {
+  const id = generateV4Id(KIND_OF[prefix], taken);
+  taken.add(id);
+  step("newId", `${id} (collision-checked against ${taken.size - 1} live ids)`);
+  return id;
+}
+function save(doc) {
+  if (!doc.path) {
+    step("save", "skipped: document is not bound to a file");
+    return;
+  }
+  commit(doc, doc.path);
+}
+function commit(doc, path4 = doc.path) {
+  if (!path4)
+    throw new Error("commit needs a path: this document is not bound to a file");
+  const tmp = `${path4}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(doc.raw, null, 2) + "\n");
+  fs.renameSync(tmp, path4);
+  doc.path = path4;
+  step("commit", `${fs.statSync(path4).size} bytes -> ${path4} (tmp + atomic rename)`);
+}
+
+// packages/screenplay/dist/text.js
+var NON_ACTOR = {
+  system: "\u65C1\u767D",
+  broadcast: "\u5E7F\u64AD",
+  offscreen: "\u753B\u5916",
+  group: "\u7FA4\u58F0"
+};
+var THOUGHT = "\u5FC3\u58F0";
+function speakerLabel(doc, sp) {
+  if (sp.kind)
+    return NON_ACTOR[sp.kind] ?? sp.kind;
+  const name = assetName(doc, sp.id);
+  return sp.state ? `${name}\xB7${stateName(doc, sp.id, sp.state)}` : name;
+}
+function formatAction(doc, a, gutter, opts = {}) {
+  const pad = (opts.plain ? "" : a.anchor).padEnd(gutter);
+  const ts = !opts.plain && a.ts ? `${a.ts} ` : "";
+  const body = (() => {
+    if (a.type === "transition")
+      return `\u2192 ${a.content}`;
+    if (a.type === "dialogue" || a.type === "inner_thought") {
+      const who = a.speaker ? speakerLabel(doc, a.speaker) : "?";
+      const notes = [a.type === "inner_thought" ? THOUGHT : "", a.paren ?? ""].filter(Boolean);
+      const label = a.speaker?.kind && a.speaker.label ? `${who}\xB7${a.speaker.label}` : who;
+      return `${label}${notes.length ? `(${notes.join("/")})` : ""}\uFF1A${a.content}`;
+    }
+    return a.content;
+  })();
+  return `${pad}${pad ? "  " : ""}${ts}${body}`.replace(/\n/g, "\\n");
+}
+function refText(doc, r) {
+  const name = assetName(doc, r.id);
+  if (r.states.length === 1 && r.states[0] === "default")
+    return name;
+  return `${name}(${r.states.map((x) => stateName(doc, r.id, x)).join("+")})`;
+}
+function formatSceneHead(doc, s) {
+  const env = [s.env?.space, s.env?.time].filter(Boolean).join("/").toUpperCase();
+  const where = s.location ? refText(doc, s.location) : "\u2014";
+  const head = `## ${s.ep.no}-${s.no}  ${s.anchor === `${s.ep.no}-${s.no}` ? s.id : s.anchor}  ${env || "\u2014"}  ${where}  ${s.actions.length} actions`;
+  const cast = s.actors.map((r) => refText(doc, r)).join(", ");
+  const props = s.props.map((r) => refText(doc, r)).join(", ");
+  const meta = [cast && `cast: ${cast}`, props && `props: ${props}`].filter(Boolean).join("  ");
+  return meta ? `${head}
+#  ${meta}` : head;
+}
+function formatScene(doc, s, opts = {}) {
+  const gutter = opts.plain ? 0 : Math.max(0, ...s.actions.map((a) => a.anchor.length));
+  step("formatScene", `${s.anchor}: ${s.actions.length} actions, gutter=${gutter}`);
+  return [formatSceneHead(doc, s), ...s.actions.map((a) => formatAction(doc, a, gutter, opts))].join("\n");
+}
+
+// packages/screenplay/dist/span.js
+function fail(message, detail) {
+  throw Object.assign(new Error(message), detail);
+}
+function spanPoints(doc) {
+  return doc.episodes.flatMap((ep) => ep.scenes.flatMap((scene) => scene.actions.map((a, index) => ({
+    address: doc.version === 4 ? a.anchor : `${ep.id}/${scene.id}#${index}`,
+    episodeId: ep.id,
+    episodeNo: ep.no,
+    timestamp: a.ts
+  }))));
+}
+function stamp(point) {
+  try {
+    return parseTimestamp(point.timestamp ?? "");
+  } catch (error) {
+    if (!(error instanceof TimestampParseError))
+      throw error;
+    return fail(`Action ${point.address} has an invalid stored timestamp.`, {
+      code: "ACTION_SPAN_TIMESTAMP_INVALID",
+      hint: `Fix it with \`scriptctl timestamp ${point.address} --set <time>\` or remove it.`,
+      data: {
+        expected: ["valid action.extend.timestamp"],
+        actual: [`${point.address}: ${JSON.stringify(point.timestamp ?? "")}`]
+      }
+    });
+  }
+}
+function nonMonotonic(previous, current) {
+  return fail("Action timestamps run backward within the selected episode.", {
+    code: "ACTION_SPAN_TIMESTAMP_NON_MONOTONIC",
+    hint: "Fix the stored timestamps so they do not move backward in document order, then rerun `actions --span`.",
+    data: { actual: [`${previous.address}: ${previous.timestamp}`, `${current.address}: ${current.timestamp}`] }
+  });
+}
+function resolveSpan(timeline, selectedAddresses) {
+  if (selectedAddresses.length === 0) {
+    fail("The action selection matched nothing.", {
+      code: "ACTION_SPAN_NO_MATCH",
+      hint: "Check the selector with `scriptctl actions` and rerun with `--span`.",
+      data: { actual: ["0 matched actions"] }
+    });
+  }
+  const wanted = new Set(selectedAddresses);
+  const selected = timeline.filter((point) => wanted.has(point.address));
+  if (selected.length !== wanted.size) {
+    fail("The resolved action selection is inconsistent with the script timeline.", {
+      code: "ACTION_SPAN_SELECTION_INCONSISTENT",
+      data: {
+        expected: [`${wanted.size} timeline actions`],
+        actual: [`${selected.length} timeline actions`]
+      }
+    });
+  }
+  const episodeIds = new Set(selected.map((point) => point.episodeId));
+  if (episodeIds.size !== 1) {
+    fail("An action timestamp span must stay within one episode.", {
+      code: "ACTION_SPAN_CROSSES_EPISODES",
+      hint: "Split the selector into one `actions --span` call per episode.",
+      data: { actual: [...episodeIds] }
+    });
+  }
+  const first = selected[0], last = selected[selected.length - 1];
+  if (!first.timestamp) {
+    fail(`The first selected Action ${first.address} has no timestamp.`, {
+      code: "ACTION_SPAN_START_TIMESTAMP_MISSING",
+      hint: `Set it with \`scriptctl timestamp ${first.address} --set <time>\`, then rerun.`,
+      data: { actual: [first.address] }
+    });
+  }
+  const start = stamp(first);
+  let prevPoint = first, prev = start, lastSelected = "";
+  for (const point of selected) {
+    if (!point.timestamp)
+      continue;
+    const ts = stamp(point);
+    if (ts.milliseconds < prev.milliseconds)
+      nonMonotonic(prevPoint, point);
+    prevPoint = point;
+    prev = ts;
+    if (point.address === last.address)
+      lastSelected = ts.canonical;
+  }
+  const lastIndex = timeline.findIndex((point) => point.address === last.address);
+  let boundary;
+  let boundaryTs;
+  for (let i = lastIndex + 1; i < timeline.length; i += 1) {
+    const candidate = timeline[i];
+    if (candidate.episodeId !== first.episodeId)
+      break;
+    if (!candidate.timestamp)
+      continue;
+    const ts = stamp(candidate);
+    if (ts.milliseconds < prev.milliseconds)
+      nonMonotonic(prevPoint, candidate);
+    if (ts.milliseconds === prev.milliseconds)
+      continue;
+    boundary = candidate;
+    boundaryTs = ts;
+    break;
+  }
+  step("span", `${first.episodeId} ${start.canonical}..${boundaryTs?.canonical ?? "(open)"} over ${selected.length} action(s)`);
+  return {
+    episode_id: first.episodeId,
+    ep_no: first.episodeNo,
+    start_timestamp: start.canonical,
+    last_selected_timestamp: lastSelected,
+    end_timestamp: boundaryTs?.canonical ?? "",
+    end_open: boundaryTs === void 0,
+    end_exclusive: true,
+    start_action: first.address,
+    last_action: last.address,
+    end_boundary_action: boundary?.address ?? "",
+    matched_actions: selected.length
+  };
+}
+var SPAN_COLUMNS = [
+  "episode_id",
+  "ep_no",
+  "start_timestamp",
+  "last_selected_timestamp",
+  "end_timestamp",
+  "end_open",
+  "end_exclusive",
+  "start_action",
+  "last_action",
+  "end_boundary_action",
+  "matched_actions"
+];
+function spanAddresses(doc, actions) {
+  return actions.map((a) => {
+    if (doc.version === 4)
+      return a.anchor;
+    const index = a.scene.actions.indexOf(a);
+    return `${a.scene.ep.id}/${a.scene.id}#${index}`;
+  });
+}
+
+// packages/screenplay/dist/tools.js
+var NON_ACTOR_KIND = {
+  \u65C1\u767D: "system",
+  \u5E7F\u64AD: "broadcast",
+  \u753B\u5916: "offscreen",
+  \u7FA4\u58F0: "group"
+};
+function read(doc, addr = "", opts = {}) {
+  const node = resolve(doc, addr);
+  step("read", `dispatch on node kind "${node.t}"`);
+  switch (node.t) {
+    case "script":
+      return scriptCard(doc);
+    case "ep":
+      return readEpisode(doc, node.ep, opts);
+    case "scene":
+      return formatScene(doc, node.scene, opts);
+    case "asset":
+      return assetCard(doc, node.asset);
+    case "state":
+      return stateCard(doc, node.asset, node.state);
+    case "action": {
+      const n = opts.context ?? 3;
+      const all = node.action.scene.actions;
+      const i = all.indexOf(node.action);
+      const slice = all.slice(Math.max(0, i - n), i + n + 1);
+      const gutter = opts.plain ? 0 : Math.max(...slice.map((a) => a.anchor.length));
+      const tp = node.action.raw.transition_prompt;
+      const extra = Object.entries(node.action.raw.extend ?? {}).filter(([k]) => k !== "timestamp");
+      return [
+        formatSceneHead(doc, node.action.scene),
+        ...slice.map((a) => (a === node.action ? "> " : "  ") + formatAction(doc, a, gutter, opts)),
+        // Fields that have no place on the prose line still have to be visible
+        // somewhere, or "editable" is a lie.
+        tp ? `transition: ${assetName(doc, tp.target)} | ${tp.process} | ${tp.contrast}` : "",
+        extra.length ? `extend: ${extra.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ")}` : ""
+      ].filter(Boolean).join("\n");
+    }
+  }
+}
+function chars(s) {
+  return s.actions.reduce((n, a) => n + a.content.length, 0);
+}
+function scriptCard(doc) {
+  const r = doc.raw;
+  const scenes = doc.episodes.reduce((n, e) => n + e.scenes.length, 0);
+  const actions = doc.episodes.reduce((n, e) => n + e.scenes.reduce((m, s) => m + s.actions.length, 0), 0);
+  const out = [
+    `${r.title || "(untitled)"}  v${doc.version}  ${doc.episodes.length} ep \xB7 ${scenes} scenes \xB7 ${actions} actions`
+  ];
+  for (const k of ["logline", "theme", "synopsis", "worldview", "style"]) {
+    if (r[k])
+      out.push(`${k}: ${clip(String(r[k]), 300)}`);
+  }
+  if (Array.isArray(r.main_characters) && r.main_characters.length) {
+    out.push(`main: ${r.main_characters.map((m) => `${m.name}=${m.role}`).join(", ")}`);
+  }
+  for (const kind of ["actor", "location", "prop"]) {
+    const list = doc.assets.filter((a) => a.kind === kind);
+    if (!list.length)
+      continue;
+    out.push("", `${kind}s (${list.length})`);
+    for (const a of list.slice(0, 40)) {
+      const al = a.aliases.length ? `  ~${a.aliases.join(",")}` : "";
+      const imp = a.importance ? ` [${a.importance}]` : "";
+      out.push(`  ${a.id}  ${a.name}${imp}  ${a.states.length}st${al}`);
+    }
+    if (list.length > 40)
+      out.push(`  \u2026 ${list.length - 40} more`);
+  }
+  out.push("", "episodes");
+  for (const e of doc.episodes) {
+    const c = e.scenes.reduce((n, s) => n + chars(s), 0);
+    out.push(`  ${e.no}  ${e.id}  ${e.scenes.length} scenes  ${c} chars${e.title ? `  ${e.title}` : ""}` + (e.synopsis ? `  ${clip(e.synopsis, 120)}` : ""));
+  }
+  return out.join("\n");
+}
+function readEpisode(doc, ep, opts) {
+  const head = `# EP${String(ep.no).padStart(2, "0")}  ${ep.id}  ${ep.scenes.length} scenes` + (ep.title ? `  ${ep.title}` : "");
+  if (opts.depth === "outline") {
+    return [head, ...ep.scenes.map((s) => formatSceneHead(doc, s))].join("\n");
+  }
+  return [head, ...ep.scenes.map((s) => formatScene(doc, s, opts))].join("\n\n");
+}
+function assetCard(doc, a) {
+  const role = a.raw.role_type ? `  <${a.raw.role_type}>` : "";
+  const out = [`${a.id}  ${a.name}  ${a.kind}${a.importance ? `  [${a.importance}]` : ""}${role}`];
+  if (a.aliases.length)
+    out.push(`aliases: ${a.aliases.join(", ")}`);
+  if (a.desc)
+    out.push(a.desc);
+  out.push(`states (${a.states.length})`);
+  for (const s of a.states)
+    out.push(`  ${s.id}  ${s.name}  ${clip(s.desc, 160)}`);
+  const hits = [];
+  const byState = /* @__PURE__ */ new Map();
+  for (const ep of doc.episodes)
+    for (const s of ep.scenes) {
+      const ref2 = [s.location, ...s.actors, ...s.props].find((r) => r && r.id === a.id);
+      if (!ref2)
+        continue;
+      hits.push(s);
+      for (const st of ref2.states)
+        byState.set(st, (byState.get(st) ?? 0) + 1);
+    }
+  if (hits.length) {
+    const eps = [...new Set(hits.map((s) => s.ep.no))];
+    out.push(`appears: ${hits.length} scenes across ${eps.length} ep  first ${hits[0].ep.no}-${hits[0].no}  last ${hits.at(-1).ep.no}-${hits.at(-1).no}`);
+    out.push(`state usage: ${[...byState].map(([k, v]) => `${stateName(doc, a.id, k)}\xD7${v}`).join(", ")}`);
+    const unused = a.states.filter((s) => !byState.has(s.id));
+    if (unused.length)
+      out.push(`unused states: ${unused.map((s) => `${s.id}(${s.name})`).join(", ")}`);
+  } else {
+    out.push("appears: never referenced");
+  }
+  return out.join("\n");
+}
+function stateCard(doc, a, st) {
+  const scenes = [];
+  for (const ep of doc.episodes)
+    for (const s of ep.scenes) {
+      const ref2 = [s.location, ...s.actors, ...s.props].find((r) => r && r.id === a.id);
+      if (ref2?.states.includes(st.id))
+        scenes.push(s);
+    }
+  const speakers = allActions(doc).filter((x) => x.speaker?.id === a.id && x.speaker.state === st.id);
+  return [
+    `${a.id}/${st.id}  ${st.name}  (${a.kind} ${a.name})`,
+    st.desc,
+    scenes.length ? `bound in ${scenes.length} scene(s): ${scenes.slice(0, 12).map((s) => `${s.ep.no}-${s.no}`).join(", ")}` + (scenes.length > 12 ? ` \u2026` : "") : "bound in no scene",
+    speakers.length ? `named by ${speakers.length} speaker reference(s)` : ""
+  ].filter(Boolean).join("\n");
+}
+function clip(s, n) {
+  return s.length > n ? s.slice(0, n) + "\u2026" : s;
+}
+function filterActions(doc, opts) {
+  let pool2 = allActions(doc);
+  step("find", `pool = all actions (${pool2.length})`);
+  if (opts.in) {
+    const node = resolve(doc, opts.in);
+    if (node.t === "ep")
+      pool2 = node.ep.scenes.flatMap((s) => s.actions);
+    else if (node.t === "scene")
+      pool2 = node.scene.actions;
+    else if (node.t === "action")
+      pool2 = [node.action];
+    else
+      throw new Error(`--in must address an episode, scene or action (got ${node.t})`);
+    step("find", `--in ${opts.in} narrows pool to ${pool2.length}`);
+  }
+  if (opts.type) {
+    pool2 = pool2.filter((a) => a.type === opts.type);
+    step("find", `--type ${opts.type} -> ${pool2.length}`);
+  }
+  if (opts.speaker) {
+    const who = resolve(doc, opts.speaker);
+    if (who.t !== "asset")
+      throw new Error(`--speaker must name an actor`);
+    pool2 = pool2.filter((a) => a.speaker?.id === who.asset.id);
+    step("find", `--speaker ${opts.speaker} -> ${who.asset.id} -> ${pool2.length}`);
+  }
+  return pool2;
+}
+function find(doc, query, opts = {}) {
+  const pool2 = filterActions(doc, opts);
+  const re = query ? new RegExp(query, "u") : null;
+  const hits = pool2.filter((a) => !re || re.test(a.content));
+  step("find", `regex /${query}/ -> ${hits.length} hits`);
+  const limit = opts.limit ?? 40;
+  const w = opts.window ?? 16;
+  const shown = hits.slice(0, limit);
+  const gutter = Math.max(0, ...shown.map((a) => a.anchor.length));
+  const head = `${hits.length} hit${hits.length === 1 ? "" : "s"}` + (query ? ` for /${query}/` : "") + (hits.length > shown.length ? `  (showing ${shown.length})` : "");
+  const lines = shown.map((a) => {
+    const ord = `${a.scene.ep.no}-${a.scene.no}-${a.no}`;
+    const pos = ord === a.anchor ? "" : ord.padEnd(8) + "  ";
+    const who = a.speaker?.id ? assetName(doc, a.speaker.id) + "\uFF1A" : "";
+    const body = opts.full || !re ? a.content : windowed(a.content, re, w);
+    return `${a.anchor.padEnd(gutter)}  ${pos}${who}${body}`;
+  });
+  return [head, ...lines].join("\n");
+}
+function windowed(text, re, w) {
+  const m = text.match(re);
+  if (!m || m.index === void 0)
+    return clip(text, w * 2);
+  const a = Math.max(0, m.index - w), b = Math.min(text.length, m.index + m[0].length + w);
+  return (a > 0 ? "\u2026" : "") + text.slice(a, b) + (b < text.length ? "\u2026" : "");
+}
+function span(doc, range) {
+  const pool2 = filterActions(doc, { in: range });
+  const row = resolveSpan(spanPoints(doc), spanAddresses(doc, pool2));
+  return SPAN_COLUMNS.map((c) => `${c}=${row[c]}`).join("  ");
+}
+var ACTION_FIELDS = ["content", "paren", "speaker", "ts", "type", "transition"];
+var ASSET_FIELDS = ["name", "desc", "importance", "aliases", "role"];
+var STATE_FIELDS = ["name", "desc"];
+var EPISODE_FIELDS = ["title", "synopsis"];
+var SCENE_FIELDS = ["space", "time"];
+var SCRIPT_FIELDS = ["title", "worldview", "style", "synopsis", "logline", "theme", "main"];
+function only(at, kind, fields, allowed) {
+  const given = Object.keys(fields).filter((k) => fields[k] !== void 0);
+  if (!given.length)
+    throw new Error(`Nothing to change on ${at}; pass at least one field`);
+  const bad = given.filter((k) => !allowed.includes(k));
+  if (bad.length) {
+    const art = /^[aeiou]/.test(kind) ? "an" : "a";
+    throw new Error(`${at} is ${art} ${kind}; it has no ${bad.join(", ")} \u2014 ${art} ${kind} takes ${allowed.join(", ")}`);
+  }
+  return given;
+}
+function edit(doc, at, fields) {
+  const node = resolve(doc, at);
+  if (node.t === "asset")
+    return editAsset(doc, at, node.asset, fields);
+  if (node.t === "state")
+    return editState(doc, at, node.asset, node.state, fields);
+  if (node.t === "script")
+    return editPlain(doc, at || "script", "script", node.doc.raw, fields, SCRIPT_FIELDS);
+  if (node.t === "ep")
+    return editPlain(doc, at, "episode", node.ep.raw, fields, EPISODE_FIELDS);
+  if (node.t === "scene")
+    return editScene(doc, at, node.scene, fields);
+  const a = node.action;
+  const raw = a.raw;
+  const changed = only(a.anchor, "action", fields, ACTION_FIELDS);
+  const base = baseline(doc);
+  step("edit", `${a.anchor}: ${changed.join(", ")}`);
+  if (fields.type !== void 0)
+    raw.type = oneOf("type", fields.type, ACTION_TYPE_SET, ACTION_TYPES);
+  if (fields.content !== void 0)
+    raw.content = fields.content;
+  if (fields.paren !== void 0)
+    setParen(doc, raw, fields.paren);
+  if (fields.speaker !== void 0)
+    raw.speaker = speakerJson(doc, fields.speaker);
+  if (fields.ts !== void 0)
+    setTs(raw, fields.ts);
+  if (fields.transition !== void 0) {
+    if (fields.transition === null)
+      delete raw.transition_prompt;
+    else {
+      const [target, process2, contrast] = fields.transition.split("|").map((x) => x.trim());
+      if (!target || !process2 || !contrast) {
+        throw new Error(`transition takes "target|process|contrast" (got "${fields.transition}")`);
+      }
+      const t = resolve(doc, target);
+      if (t.t !== "asset")
+        throw new Error(`transition target must be an asset (got ${target})`);
+      raw.transition_prompt = { target: t.asset.id, process: process2, contrast };
+    }
+  }
+  save(doc);
+  return `${a.anchor}  ${changed.join("+")}  ${preview(raw)}` + since(doc, base);
+}
+function editPlain(doc, at, kind, raw, fields, allowed) {
+  const changed = only(at, kind, fields, allowed);
+  const base = baseline(doc);
+  for (const k of changed) {
+    if (k === "main") {
+      raw.main_characters = fields.main.split(",").map((pair) => {
+        const [name, role] = pair.split("=").map((x) => x.trim());
+        if (!name || !role)
+          throw new Error(`main takes "\u540D\u5B57=\u89D2\u8272\u5B9A\u4F4D,\u2026" (got "${pair}")`);
+        return { name, role };
+      });
+    } else if (k === "aliases" || k === "role") {
+      throw new Error(`${at} is ${kind}; it has no ${k}`);
+    } else {
+      raw[k] = fields[k];
+    }
+  }
+  step("edit", `${kind} ${at}: ${changed.join(", ")}`);
+  save(doc);
+  return `${at}  ${changed.join("+")}` + since(doc, base);
+}
+function editScene(doc, at, scene, fields) {
+  const changed = only(at, "scene", fields, SCENE_FIELDS);
+  const base = baseline(doc);
+  const env = { ...scene.raw.environment ?? {} };
+  if (fields.space !== void 0)
+    env.space = oneOf("space", fields.space, SCENE_SPACE_SET, SCENE_SPACE_VALUES);
+  if (fields.time !== void 0)
+    env.time = oneOf("time", fields.time, SCENE_TIME_SET, SCENE_TIME_VALUES);
+  scene.raw.environment = env;
+  step("edit", `scene ${scene.anchor}: ${changed.join(", ")}`);
+  save(doc);
+  return `${scene.anchor}  ${changed.join("+")}  ${[env.space, env.time].filter(Boolean).join("/")}` + since(doc, base);
+}
+function editAsset(doc, at, a, fields) {
+  const changed = only(at, "asset", fields, ASSET_FIELDS);
+  const base = baseline(doc);
+  if (fields.name !== void 0) {
+    const clash = doc.assets.find((x) => x !== a && (x.name === fields.name || x.aliases.includes(fields.name)));
+    if (clash)
+      throw new Error(`"${fields.name}" already names ${clash.kind} ${clash.id}`);
+    a.raw[`${a.kind}_name`] = fields.name;
+  }
+  if (fields.desc !== void 0)
+    a.raw.description = fields.desc;
+  if (fields.importance !== void 0)
+    a.raw.importance = checkImportance(fields.importance);
+  if (fields.role !== void 0) {
+    if (a.kind !== "actor")
+      throw new Error(`role only applies to actors (${a.name} is a ${a.kind})`);
+    if (fields.role)
+      a.raw.role_type = oneOf("role", fields.role, ROLE_TYPE_SET, ROLE_TYPES);
+    else
+      delete a.raw.role_type;
+  }
+  if (fields.aliases !== void 0) {
+    if (fields.aliases.length)
+      a.raw.aliases = fields.aliases;
+    else
+      delete a.raw.aliases;
+  }
+  step("edit", `asset ${a.id}: ${changed.join(", ")}`);
+  save(doc);
+  return `${a.id}  ${changed.join("+")}  ${fields.name ?? a.name}` + since(doc, base);
+}
+function editState(doc, at, a, st, fields) {
+  const changed = only(at, "state", fields, STATE_FIELDS);
+  const base = baseline(doc);
+  const raw = a.raw.states.find((x) => x.state_id === st.id);
+  if (fields.name !== void 0) {
+    if (a.states.some((x) => x.id !== st.id && x.name === fields.name)) {
+      throw new Error(`${a.name} already has a state named "${fields.name}"`);
+    }
+    raw.state_name = fields.name;
+  }
+  if (fields.desc !== void 0)
+    raw.description = fields.desc;
+  step("edit", `state ${a.id}/${st.id}: ${changed.join(", ")}`);
+  save(doc);
+  return `${a.id}/${st.id}  ${changed.join("+")}  ${fields.name ?? st.name}` + since(doc, base);
+}
+function insert(doc, at, where, type, content, speaker, paren) {
+  const node = resolve(doc, at);
+  if (node.t !== "action")
+    throw new Error(`${at} is a ${node.t}; insert needs a sibling action`);
+  const anchor = node.action;
+  const base = baseline(doc);
+  const raw = { type: oneOf("type", type, ACTION_TYPE_SET, ACTION_TYPES), content };
+  if (doc.version === 4)
+    raw.action_id = newId("ac", new Set(doc.actions.keys()));
+  if (type === "dialogue" || type === "inner_thought") {
+    if (!speaker)
+      throw new Error(`a ${type} needs a speaker`);
+    raw.speaker = speakerJson(doc, speaker);
+    if (paren !== void 0)
+      setParen(doc, raw, paren);
+  } else if (speaker || paren) {
+    throw new Error(`a ${type} takes neither speaker nor paren`);
+  }
+  const list = anchor.scene.raw.actions;
+  const index = list.indexOf(anchor.raw) + (where === "before" ? 0 : 1);
+  list.splice(index, 0, raw);
+  step("insert", `${raw.action_id ?? `${anchor.scene.anchor}#${index}`} ${where} ${anchor.anchor}`);
+  save(doc);
+  return `${raw.action_id ?? `${anchor.scene.anchor}#${index}`}  ${where} ${anchor.anchor}  ${preview(raw)}` + since(doc, base);
+}
+function move(doc, at, to, where = "after") {
+  const src = resolve(doc, at);
+  if (src.t !== "action")
+    throw new Error(`${at} is a ${src.t}; move targets one action`);
+  const dst = resolve(doc, to);
+  if (dst.t !== "action")
+    throw new Error(`${to} is a ${dst.t}; move --to takes a sibling action`);
+  if (src.action === dst.action)
+    throw new Error(`${at} cannot move relative to itself`);
+  const base = baseline(doc);
+  const from = src.action.scene.raw.actions;
+  from.splice(from.indexOf(src.action.raw), 1);
+  const into = dst.action.scene.raw.actions;
+  into.splice(into.indexOf(dst.action.raw) + (where === "before" ? 0 : 1), 0, src.action.raw);
+  step("move", `${src.action.scene.anchor} -> ${dst.action.scene.anchor}, identity ${src.action.anchor} preserved`);
+  save(doc);
+  return `${src.action.anchor}  ${where} ${dst.action.anchor}  (${src.action.scene.anchor} -> ${dst.action.scene.anchor})` + since(doc, base);
+}
+function setParen(doc, raw, v) {
+  const key = doc.version === 4 ? "parenthetical" : "emotion";
+  if (v === null)
+    delete raw[key];
+  else
+    raw[key] = v;
+}
+function setTs(raw, v) {
+  if (v === null) {
+    if (raw.extend)
+      delete raw.extend.timestamp;
+    return;
+  }
+  let canonical;
+  try {
+    canonical = parseTimestamp(v).canonical;
+  } catch (error) {
+    if (!(error instanceof TimestampParseError))
+      throw error;
+    throw new Error(`${error.message} (got ${JSON.stringify(v)})`);
+  }
+  raw.extend = { ...raw.extend ?? {}, timestamp: canonical };
+}
+function speakerJson(doc, name) {
+  const whole = doc.assets.find((a) => a.name === name || a.aliases.includes(name));
+  const [base, qual] = whole ? [name, void 0] : splitOnce(name, "\xB7");
+  const kind = NON_ACTOR_KIND[base];
+  if (kind)
+    return qual ? { kind, label: qual } : { kind };
+  const n = resolve(doc, base);
+  if (n.t !== "asset" || n.asset.kind !== "actor")
+    throw new Error(`Not an actor: ${name}`);
+  const out = { actor_id: n.asset.id };
+  if (qual) {
+    const st = n.asset.states.find((s) => s.name === qual || s.id === qual);
+    if (!st)
+      throw new Error(`Unknown state "${qual}" on ${n.asset.name}`);
+    out.state_id = st.id;
+  }
+  return out;
+}
+function splitOnce(v, sep) {
+  const i = v.indexOf(sep);
+  return i < 0 ? [v, void 0] : [v.slice(0, i), v.slice(i + sep.length)];
+}
+function preview(raw) {
+  return clip(String(raw.content ?? ""), 40);
+}
+function ref(doc, sceneAddr, assetAddr, states, remove = false) {
+  const node = resolve(doc, sceneAddr);
+  if (node.t !== "scene")
+    throw new Error(`${sceneAddr} is a ${node.t}; ref targets one scene`);
+  const scene = node.scene;
+  const target = resolve(doc, assetAddr);
+  if (target.t !== "asset")
+    throw new Error(`${assetAddr} is a ${target.t}; ref takes an actor, location or prop`);
+  const a = target.asset;
+  const field = a.kind === "actor" ? "actors" : a.kind === "prop" ? "props" : "location";
+  const base = baseline(doc);
+  if (remove) {
+    if (a.kind === "location") {
+      if (scene.location?.id !== a.id) {
+        throw new Error(`${scene.anchor}'s location is ${scene.location ? assetName(doc, scene.location.id) : "empty"}, not ${a.name}`);
+      }
+      scene.raw.location = null;
+    } else {
+      const list = scene.raw[field];
+      const i = list.findIndex((r) => r[`${a.kind}_id`] === a.id);
+      if (i < 0)
+        throw new Error(`${scene.anchor} does not reference ${a.name}`);
+      list.splice(i, 1);
+    }
+    step("ref", `${scene.anchor} -= ${a.id}`);
+    save(doc);
+    return `${scene.anchor}  removed ${a.name}` + since(doc, base);
+  }
+  if (!states.length) {
+    throw new Error(`ref needs at least one state for ${a.name} (has: ${a.states.map((st) => st.name).join(", ")}) \u2014 nothing is implied, not even default`);
+  }
+  const ids = [...new Set(states.map((sn) => {
+    const hit = a.states.filter((st) => st.name === sn || st.id === sn);
+    if (!hit.length) {
+      throw new Error(`${a.name} has no state "${sn}" (has: ${a.states.map((x) => x.name).join(", ")})`);
+    }
+    if (hit.length > 1)
+      throw new Error(`${a.name} has ${hit.length} states named "${sn}"; use the state id`);
+    return hit[0].id;
+  }))].sort();
+  const key = `${a.kind}_id`;
+  const entry = doc.version === 4 ? { [key]: a.id, state_ids: ids } : { [key]: a.id, state_id: ids[0] };
+  if (doc.version === 3 && ids.length > 1) {
+    throw new Error(`Script v3 holds one state per reference; pass a single state`);
+  }
+  let verb;
+  if (a.kind === "location") {
+    verb = scene.location ? scene.location.id === a.id ? "restated" : "replaced" : "set";
+    scene.raw.location = entry;
+  } else {
+    const list = scene.raw[field];
+    const i = list.findIndex((r) => r[key] === a.id);
+    if (i < 0) {
+      list.push(entry);
+      verb = "added";
+    } else {
+      list[i] = entry;
+      verb = "restated";
+    }
+  }
+  step("ref", `${scene.anchor} ${verb} ${a.id} = [${ids.join(", ")}]`);
+  save(doc);
+  return `${scene.anchor}  ${verb} ${a.name}(${ids.map((i2) => stateName(doc, a.id, i2)).join("+")})` + since(doc, base);
+}
+function replace(doc, query, to, opts = {}) {
+  if (!query)
+    throw new Error("replace needs a pattern; an empty one would rewrite every action");
+  const re = new RegExp(query, "gu");
+  const base = baseline(doc);
+  const pool2 = filterActions(doc, opts);
+  const hits = pool2.filter((a) => {
+    re.lastIndex = 0;
+    return re.test(a.content);
+  });
+  step("replace", `/${query}/ matched ${hits.length} of ${pool2.length} actions in scope`);
+  if (!hits.length)
+    return `0 hits for /${query}/ \u2014 nothing to do`;
+  const gutter = Math.max(...hits.map((a) => a.anchor.length));
+  const lines = hits.map((a) => {
+    const next = a.content.replace(re, to);
+    return `${a.anchor.padEnd(gutter)}  ${a.scene.ep.no}-${a.scene.no}-${a.no}
+${" ".repeat(gutter)}  - ${a.content}
+${" ".repeat(gutter)}  + ${next}`;
+  });
+  if (!opts.apply) {
+    return `${hits.length} action(s) would change (dry run \u2014 pass apply to write)
+` + lines.join("\n");
+  }
+  for (const a of hits) {
+    re.lastIndex = 0;
+    a.raw.content = a.content.replace(re, to);
+  }
+  save(doc);
+  step("replace", `wrote ${hits.length} actions`);
+  return `${hits.length} action(s) changed` + since(doc, base) + "\n" + lines.join("\n");
+}
+function oneOf(what, v, set, allowed) {
+  if (!set.has(v))
+    throw new Error(`${what} must be one of ${allowed.join(" | ")} (got "${v}")`);
+  return v;
+}
+function checkImportance(v) {
+  return oneOf("importance", v, IMPORTANCE_TIER_SET, IMPORTANCE_TIERS);
+}
+function validateDoc(doc) {
+  return doc.version === 4 ? validateScriptV4(doc.raw) : validateScriptV3(doc.raw);
+}
+function validate(doc) {
+  const r = validateDoc(doc);
+  const head = `${doc.episodes.length} episodes / ${doc.scenes.size ? [...new Set(doc.episodes.flatMap((e) => e.scenes))].length : 0} scenes / ${allActions(doc).length} actions \u2014 ${r.ok ? "ok" : `${r.errors.length} error(s)`}` + (r.warnings.length ? `, ${r.warnings.length} warning(s)` : "");
+  return [head, ...fmtIssues([
+    ...r.errors.map((i) => ["error", i]),
+    ...r.warnings.map((i) => ["warning", i])
+  ])].join("\n");
+}
+function issues(doc, opts = {}) {
+  const r = validateDoc(doc);
+  let rows = [
+    ...r.errors.map((i) => ["error", i]),
+    ...r.warnings.map((i) => ["warning", i])
+  ];
+  if (opts.severity)
+    rows = rows.filter(([s]) => s === opts.severity);
+  if (opts.code)
+    rows = rows.filter(([, i]) => i.code === opts.code);
+  step("issues", `${rows.length} matching issue(s)`);
+  return rows.length ? fmtIssues(rows).join("\n") : "No issues.";
+}
+function fmtIssues(rows) {
+  return rows.map(([sev, i]) => `${sev} ${i.code}  ${i.path}  ${i.message}` + (i.repair_hint ? `
+      fix: ${i.repair_hint}` : ""));
+}
+function baseline(doc) {
+  return validateDoc(doc);
+}
+function since(doc, base) {
+  const now = validateDoc(doc);
+  const fresh = [
+    ...issuesIntroduced(base.errors, now.errors).map((i) => ["error", i]),
+    ...issuesIntroduced(base.warnings, now.warnings).map((i) => ["warning", i])
+  ];
+  if (!fresh.length)
+    return "";
+  step("check", `${fresh.length} issue(s) introduced by this edit`);
+  return `
+introduced ${fresh.length} issue(s):
+  ` + fmtIssues(fresh).join("\n  ");
+}
+var ASSET_FIELD = { actor: "actors", location: "locations", prop: "props" };
+function state(doc, assetName2, name, desc) {
+  const n = resolve(doc, assetName2);
+  if (n.t !== "asset")
+    throw new Error(`${assetName2} is a ${n.t}; state targets an asset`);
+  const base = baseline(doc);
+  if (n.asset.states.some((s) => s.name === name)) {
+    throw new Error(`${n.asset.name} already has a state named "${name}"`);
+  }
+  const id = doc.version === 4 ? newId("st", new Set(n.asset.states.map((s) => s.id))) : `st_${String(n.asset.states.length).padStart(3, "0")}`;
+  n.asset.raw.states.push({ state_id: id, state_name: name, description: desc });
+  step("state", `${n.asset.id} + ${id} "${name}"`);
+  save(doc);
+  return `${n.asset.id}/${id}  ${name}  (${n.asset.name} now has ${n.asset.states.length + 1} states)` + since(doc, base);
+}
+function del(doc, addr, opts = {}) {
+  const n = resolve(doc, addr);
+  const base = baseline(doc);
+  if (n.t === "action") {
+    const list = n.action.scene.raw.actions;
+    list.splice(list.indexOf(n.action.raw), 1);
+    step("del", `action ${n.action.anchor} from ${n.action.scene.anchor}`);
+    save(doc);
+    return `deleted ${n.action.anchor}  ${preview(n.action.raw)}` + since(doc, base);
+  }
+  if (n.t === "scene") {
+    if (n.scene.actions.length && !opts.force) {
+      throw new Error(`${n.scene.anchor} still holds ${n.scene.actions.length} action(s) \u2014 pass --force to delete the scene and everything in it`);
+    }
+    const list = n.scene.ep.raw.scenes;
+    list.splice(list.indexOf(n.scene.raw), 1);
+    step("del", `scene ${n.scene.anchor} (${n.scene.actions.length} actions)`);
+    save(doc);
+    return `deleted scene ${n.scene.anchor} with ${n.scene.actions.length} action(s)` + since(doc, base);
+  }
+  if (n.t === "ep") {
+    const acts = n.ep.scenes.reduce((m, s) => m + s.actions.length, 0);
+    if (n.ep.scenes.length && !opts.force) {
+      throw new Error(`episode ${n.ep.no} still holds ${n.ep.scenes.length} scene(s) / ${acts} action(s) \u2014 pass --force to delete the episode and everything in it`);
+    }
+    const list = doc.raw.episodes;
+    list.splice(list.indexOf(n.ep.raw), 1);
+    step("del", `episode ${n.ep.no}`);
+    save(doc);
+    return `deleted episode ${n.ep.no} (${n.ep.id}) with ${n.ep.scenes.length} scene(s) / ${acts} action(s)`;
+  }
+  if (n.t === "asset")
+    return delAsset(doc, n.asset, opts) + since(doc, base);
+  if (n.t === "state")
+    return delState(doc, n.asset, n.state, opts) + since(doc, base);
+  throw new Error(`del takes an action, scene, episode, asset or state (got ${n.t})`);
+}
+function assetUses(doc, id) {
+  const scenes = [];
+  for (const ep of doc.episodes)
+    for (const s of ep.scenes) {
+      if ([s.location, ...s.actors, ...s.props].some((r) => r && r.id === id))
+        scenes.push(s);
+    }
+  return { scenes, speakers: allActions(doc).filter((a) => a.speaker?.id === id) };
+}
+function delAsset(doc, a, opts) {
+  const { scenes, speakers } = assetUses(doc, a.id);
+  const used = scenes.length + speakers.length;
+  if (used && !opts.replacement && !opts.force) {
+    throw new Error(`${a.name} is still referenced by ${scenes.length} scene(s) and ${speakers.length} speaker(s) \u2014 merge it into another asset with \`merge ${a.id} <other>\`, or pass --force to strip every reference`);
+  }
+  if (opts.replacement)
+    return merge(doc, a.id, opts.replacement);
+  for (const s of scenes) {
+    if (s.raw.location?.[`${a.kind}_id`] === a.id)
+      s.raw.location = null;
+    for (const f of ["actors", "props"]) {
+      const list2 = s.raw[f];
+      if (!list2)
+        continue;
+      const i = list2.findIndex((r) => r[`${a.kind}_id`] === a.id);
+      if (i >= 0)
+        list2.splice(i, 1);
+    }
+  }
+  for (const act of speakers)
+    delete act.raw.speaker;
+  const field = ASSET_FIELD[a.kind];
+  const list = doc.raw[field];
+  list.splice(list.indexOf(a.raw), 1);
+  step("del", `asset ${a.id}, stripped ${scenes.length} scene refs + ${speakers.length} speakers`);
+  save(doc);
+  return `deleted ${a.kind} ${a.id} ${a.name}` + (used ? `
+stripped ${scenes.length} scene reference(s) and ${speakers.length} speaker(s)` : "");
+}
+function delState(doc, a, st, opts) {
+  if (st.id === "default")
+    throw new Error(`every asset keeps its default state; delete the asset instead`);
+  const scenes = doc.episodes.flatMap((e) => e.scenes).filter((s) => [s.location, ...s.actors, ...s.props].some((r) => r && r.id === a.id && r.states.includes(st.id)));
+  const speakers = allActions(doc).filter((x) => x.speaker?.id === a.id && x.speaker.state === st.id);
+  const used = scenes.length + speakers.length;
+  let rewired = "";
+  if (used) {
+    if (!opts.replacement && !opts.force) {
+      throw new Error(`${a.name}/${st.name} is bound in ${scenes.length} scene(s) and named by ${speakers.length} speaker(s) \u2014 pass --replacement <state> to rewire them, or --force to drop the bindings`);
+    }
+    let to;
+    if (opts.replacement) {
+      const hit = a.states.filter((x) => x.id === opts.replacement || x.name === opts.replacement);
+      if (hit.length !== 1)
+        throw new Error(`${a.name} has no single state "${opts.replacement}"`);
+      if (hit[0].id === st.id)
+        throw new Error(`replacement must differ from the state being deleted`);
+      to = hit[0].id;
+    }
+    for (const s of scenes) {
+      for (const r of [s.raw.location, ...s.raw.actors ?? [], ...s.raw.props ?? []]) {
+        if (!r || r[`${a.kind}_id`] !== a.id)
+          continue;
+        if (doc.version === 4) {
+          const next = new Set(r.state_ids.filter((x) => x !== st.id));
+          if (to)
+            next.add(to);
+          if (!next.size)
+            next.add("default");
+          r.state_ids = [...next].sort();
+        } else
+          r[`state_id`] = to ?? "default";
+      }
+    }
+    for (const x of speakers) {
+      if (to)
+        x.raw.speaker.state_id = to;
+      else
+        delete x.raw.speaker.state_id;
+    }
+    rewired = `
+${to ? `rewired` : `cleared`} ${scenes.length} scene binding(s) and ${speakers.length} speaker(s)${to ? ` to ${stateName(doc, a.id, to)}` : ""}`;
+  }
+  const list = a.raw.states;
+  list.splice(list.findIndex((x) => x.state_id === st.id), 1);
+  step("del", `state ${a.id}/${st.id}`);
+  save(doc);
+  return `deleted state ${a.id}/${st.id} ${st.name}` + rewired;
+}
+function merge(doc, srcAddr, dstAddr) {
+  const s = resolve(doc, srcAddr), d = resolve(doc, dstAddr);
+  if (s.t !== "asset" || d.t !== "asset")
+    throw new Error(`merge takes two assets`);
+  if (s.asset === d.asset)
+    throw new Error(`cannot merge ${s.asset.name} into itself`);
+  if (s.asset.kind !== d.asset.kind) {
+    throw new Error(`cannot merge a ${s.asset.kind} into a ${d.asset.kind}`);
+  }
+  const base = baseline(doc);
+  const src = s.asset, dst = d.asset;
+  const kindKey = `${src.kind}_id`;
+  const taken = new Set(dst.states.map((x) => x.id));
+  const map = /* @__PURE__ */ new Map();
+  for (const st of src.states) {
+    const same = dst.states.find((x) => x.name === st.name);
+    if (same) {
+      map.set(st.id, same.id);
+      continue;
+    }
+    if (st.id === "default") {
+      map.set(st.id, "default");
+      continue;
+    }
+    const id = doc.version === 4 ? newId("st", taken) : `st_${String(dst.states.length + map.size).padStart(3, "0")}`;
+    dst.raw.states.push({ state_id: id, state_name: st.name, description: st.desc });
+    map.set(st.id, id);
+  }
+  const { scenes, speakers } = assetUses(doc, src.id);
+  for (const scene of scenes) {
+    for (const field of ["location", "actors", "props"]) {
+      const slot = scene.raw[field];
+      const list2 = field === "location" ? slot ? [slot] : [] : slot ?? [];
+      for (const r of list2) {
+        if (r[kindKey] !== src.id)
+          continue;
+        r[kindKey] = dst.id;
+        if (doc.version === 4) {
+          r.state_ids = [...new Set(r.state_ids.map((x) => map.get(x) ?? "default"))].sort();
+        } else
+          r.state_id = map.get(r.state_id) ?? "default";
+      }
+      if (field !== "location" && Array.isArray(slot)) {
+        const merged = [];
+        for (const r of slot) {
+          const prev = merged.find((x) => x[kindKey] === r[kindKey]);
+          if (!prev) {
+            merged.push(r);
+            continue;
+          }
+          if (doc.version === 4) {
+            prev.state_ids = [.../* @__PURE__ */ new Set([...prev.state_ids, ...r.state_ids])].sort();
+          }
+        }
+        scene.raw[field] = merged;
+      }
+    }
+  }
+  for (const a of speakers) {
+    a.raw.speaker.actor_id = dst.id;
+    if (a.raw.speaker.state_id)
+      a.raw.speaker.state_id = map.get(a.raw.speaker.state_id) ?? "default";
+  }
+  const list = doc.raw[ASSET_FIELD[src.kind]];
+  list.splice(list.indexOf(src.raw), 1);
+  step("merge", `${src.id} -> ${dst.id}: ${scenes.length} scenes, ${speakers.length} speakers`);
+  save(doc);
+  return `merged ${src.id} ${src.name} into ${dst.id} ${dst.name}
+moved ${scenes.length} scene reference(s), ${speakers.length} speaker(s), ${[...map].filter(([k, v]) => k !== v).length} state mapping(s)` + since(doc, base);
+}
+
+// packages/review-agent/src/finding.ts
+import { z } from "zod";
+var CATEGORIES = [
+  "scene-reference",
+  "actor-identity",
+  "wardrobe",
+  "asset",
+  "dialogue-action",
+  "scene-boundary",
+  "timeline",
+  "other"
+];
+var OUTCOMES = ["fixed", "unchanged", "unresolved"];
+var CONFIDENCES = ["high", "medium", "low"];
+var SUBJECT_KINDS = ["actor", "state", "location", "prop", "action", "scene"];
+var EVIDENCE_KINDS = ["scriptctl", "video", "gemini", "frame", "structure"];
+var FINDING_INPUT = z.object({
+  category: z.enum(CATEGORIES),
+  title: z.string().min(1).describe("\u4E00\u53E5\u8BDD\u6807\u9898"),
+  issue: z.string().min(1).describe("\u95EE\u9898\u662F\u4EC0\u4E48"),
+  impact: z.string().min(1).describe("\u4E0D\u4FEE\u4F1A\u5F71\u54CD\u4EC0\u4E48"),
+  resolution: z.string().min(1).describe("\u505A\u4E86\u4EC0\u4E48\uFF0C\u6216\u4E3A\u4EC0\u4E48\u4E0D\u505A"),
+  outcome: z.enum(OUTCOMES),
+  confidence: z.enum(CONFIDENCES),
+  at: z.string().min(1).describe("\u5B9A\u4F4D\u5730\u5740\uFF1A\u96C6 `3`\u3001\u573A `3-2`\u3001\u5355\u6761 `3-2-5`\u3001\u6B63\u5F0F ID\u3001\u6216 `<\u8D44\u4EA7>/<\u72B6\u6001>`"),
+  subject: z.string().optional().describe("\u6D89\u53CA\u7684\u8D44\u4EA7\u540D\u6216 ID\uFF0C\u4F8B\u5982 `\u5411\u5317` \u6216 `actQYEeTr/default`"),
+  before: z.string().optional(),
+  after: z.string().optional(),
+  unresolved_reason: z.string().optional().describe("outcome=unresolved \u65F6\u5FC5\u586B"),
+  evidence: z.array(z.string()).optional().describe("\u6BCF\u6761\u5199\u6210 `kind|label|detail`\uFF0Ckind \u2208 scriptctl|video|gemini|frame|structure")
+});
+var EMPTY_ANCHOR = (episode) => ({
+  episode_number: episode,
+  episode_id: null,
+  scene_number: null,
+  scene_id: null,
+  action_id: null,
+  timestamp: null,
+  end_timestamp: null
+});
+function anchorOf(doc, at, episode) {
+  const anchor = EMPTY_ANCHOR(episode);
+  let node;
+  try {
+    node = resolve(doc, at);
+  } catch {
+    return anchor;
+  }
+  if (node.t === "ep") {
+    return { ...anchor, episode_number: node.ep.no, episode_id: node.ep.id };
+  }
+  if (node.t === "scene") {
+    const first = node.scene.actions.find((a) => a.ts);
+    const last = [...node.scene.actions].reverse().find((a) => a.ts);
+    return {
+      ...anchor,
+      episode_number: node.scene.ep.no,
+      episode_id: node.scene.ep.id,
+      scene_number: node.scene.no,
+      scene_id: node.scene.id,
+      timestamp: first?.ts ?? null,
+      end_timestamp: last?.ts ?? null
+    };
+  }
+  if (node.t === "action") {
+    const a = node.action;
+    return {
+      ...anchor,
+      episode_number: a.scene.ep.no,
+      episode_id: a.scene.ep.id,
+      scene_number: a.scene.no,
+      scene_id: a.scene.id,
+      action_id: doc.version === 4 ? a.anchor : null,
+      timestamp: a.ts ?? null,
+      end_timestamp: null
+    };
+  }
+  return anchor;
+}
+function subjectOf(doc, raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const node = resolve(doc, raw);
+    if (node.t === "asset") return { kind: node.asset.kind, id: node.asset.id, name: node.asset.name };
+    if (node.t === "state") {
+      return { kind: "state", id: `${node.asset.id}/${node.state.id}`, name: node.state.name };
+    }
+    if (node.t === "action") return { kind: "action", id: node.action.anchor, name: raw };
+    if (node.t === "scene") return { kind: "scene", id: node.scene.id, name: raw };
+  } catch {
+  }
+  return { kind: "actor", id: null, name: raw };
+}
+function evidenceOf(lines) {
+  return (lines ?? []).map((line) => {
+    const [rawKind, label, ...rest] = line.split("|");
+    const kind = EVIDENCE_KINDS.includes(rawKind?.trim()) ? rawKind.trim() : "structure";
+    return {
+      kind,
+      label: (label ?? rawKind ?? "").trim() || "evidence",
+      detail: rest.join("|").trim() || (label ?? "").trim(),
+      timestamp: null,
+      end_timestamp: null,
+      evidence_id: null
+    };
+  });
+}
+function toFinding(doc, input, episode, seq) {
+  return {
+    id: `episode-${episode}-${String(seq).padStart(3, "0")}-${input.category}`,
+    category: input.category,
+    title: input.title,
+    issue: input.issue,
+    impact: input.impact,
+    resolution: input.resolution,
+    outcome: input.outcome,
+    confidence: input.confidence,
+    anchor: anchorOf(doc, input.at, episode),
+    subject: subjectOf(doc, input.subject),
+    before: input.before ?? null,
+    after: input.after ?? null,
+    unresolved_reason: input.unresolved_reason ?? null,
+    evidence: evidenceOf(input.evidence)
+  };
+}
+
+// packages/review-agent/src/media/clip.ts
+import { spawn } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var CLIP_FPS = 2;
+var MAX_WINDOW_S = 15;
+function seconds(value) {
+  const raw = value.trim().replace(/s$/, "");
+  if (!raw) throw new Error("timestamp is empty");
+  const parts = raw.split(":");
+  if (parts.length > 3) throw new Error(`unparseable timestamp: ${value}`);
+  return parts.map((p) => {
+    const n = Number(p);
+    if (!Number.isFinite(n) || n < 0) throw new Error(`unparseable timestamp: ${value}`);
+    return n;
+  }).reduce((total, n) => total * 60 + n, 0);
+}
+function ffmpegArgs(src, from, to, out) {
+  return [
+    "-y",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-ss",
+    String(seconds(from)),
+    "-to",
+    String(seconds(to)),
+    "-i",
+    src,
+    "-map",
+    "0:v:0",
+    "-map",
+    "0:a:0?",
+    "-vf",
+    `fps=${CLIP_FPS},scale=-2:min(360\\,ih),setsar=1`,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "30",
+    "-pix_fmt",
+    "yuv420p",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "48k",
+    "-ar",
+    "24000",
+    "-ac",
+    "1",
+    "-movflags",
+    "+faststart",
+    out
+  ];
+}
+async function cutClip(src, from, to) {
+  const span2 = seconds(to) - seconds(from);
+  if (span2 <= 0) throw new Error(`window end must follow its start (${from}..${to})`);
+  if (span2 > MAX_WINDOW_S) {
+    throw new Error(`window ${from}..${to} is ${span2.toFixed(1)}s; a media check covers at most ${MAX_WINDOW_S}s \u2014 split it into overlapping windows`);
+  }
+  if (!fs2.existsSync(src)) throw new Error(`source video not found: ${src}`);
+  const dir = fs2.mkdtempSync(path.join(os.tmpdir(), "review-clip-"));
+  const out = path.join(dir, "evidence.mp4");
+  const cleanup = () => fs2.rmSync(dir, { recursive: true, force: true });
+  try {
+    await run("ffmpeg", ffmpegArgs(src, from, to, out));
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+  if (!fs2.existsSync(out) || fs2.statSync(out).size === 0) {
+    cleanup();
+    throw new Error(`ffmpeg produced no output for ${from}..${to}`);
+  }
+  return { path: out, bytes: fs2.statSync(out).size, cleanup };
+}
+async function grabFrame(src, at, out) {
+  if (!fs2.existsSync(src)) throw new Error(`source video not found: ${src}`);
+  fs2.mkdirSync(path.dirname(out), { recursive: true });
+  await run("ffmpeg", [
+    "-y",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-ss",
+    String(seconds(at)),
+    "-i",
+    src,
+    "-frames:v",
+    "1",
+    "-vf",
+    "scale=-2:min(480\\,ih)",
+    "-q:v",
+    "3",
+    "-f",
+    "image2",
+    out
+  ]);
+  if (!fs2.existsSync(out) || fs2.statSync(out).size === 0) throw new Error(`no frame at ${at}`);
+  return out;
+}
+function run(bin, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => reject(new Error(`${bin} failed to start: ${error.message}`)));
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${bin} exited ${code}: ${stderr.trim().slice(0, 300)}`)));
+  });
+}
+
+// packages/review-agent/src/media/watch.ts
+import * as crypto from "node:crypto";
+import * as fs3 from "node:fs";
+
+// packages/review-agent/src/media/net.ts
+import { ProxyAgent } from "undici";
+var cached;
+function proxyUrl() {
+  for (const name of ["https_proxy", "HTTPS_PROXY", "http_proxy", "HTTP_PROXY"]) {
+    const value = (process.env[name] ?? "").trim();
+    if (value && /^https?:\/\//i.test(value)) return value;
+  }
+  return void 0;
+}
+function dispatcher() {
+  if (cached === void 0) {
+    const url = proxyUrl();
+    cached = url ? new ProxyAgent(url) : null;
+  }
+  return cached ?? void 0;
+}
+async function post(url, body, timeoutMs = 18e4) {
+  return fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+    ...dispatcher() ? { dispatcher: dispatcher() } : {}
+  });
+}
+
+// packages/review-agent/src/media/watch.ts
+var SYSTEM = "\u4F60\u662F\u5267\u672C\u5BA1\u6838\u7684\u89C6\u9891\u8BC1\u636E\u6838\u5BF9\u5668\u3002\u53EA\u62A5\u544A\u89C6\u9891\u7A97\u53E3\u4E2D\u53EF\u76F4\u63A5\u89C2\u5BDF\u6216\u542C\u5230\u7684\u4E8B\u5B9E\uFF1B\u65E0\u6CD5\u786E\u8BA4\u65F6\u660E\u786E\u8BF4\u660E\uFF0C\u4E0D\u63A8\u6D4B\u5267\u60C5\u3002";
+function traceKey(video, window, model, question) {
+  return "watch:" + crypto.createHash("sha256").update([video, window, model, question].join("\n")).digest("hex");
+}
+async function watchWindow(video, from, to, question, opts) {
+  const model = opts.model ?? "gemini-3.7-flash";
+  const base = opts.baseUrl ?? "https://generativelanguage.googleapis.com";
+  const clip2 = await cutClip(video, from, to);
+  const started = Date.now();
+  try {
+    const body = {
+      contents: [{
+        role: "user",
+        parts: [
+          {
+            inline_data: { mime_type: "video/mp4", data: fs3.readFileSync(clip2.path, "base64") },
+            video_metadata: { fps: CLIP_FPS }
+          },
+          { text: question }
+        ]
+      }],
+      systemInstruction: { parts: [{ text: SYSTEM }] },
+      generationConfig: {
+        temperature: 0.1,
+        maxOutputTokens: 2048,
+        responseMimeType: "application/json",
+        responseSchema: {
+          type: "object",
+          properties: { answer: { type: "string" } },
+          required: ["answer"]
+        }
+      }
+    };
+    const response = await post(
+      `${base}/v1beta/models/${model}:generateContent?key=${opts.apiKey}`,
+      body
+    );
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload?.error) {
+      throw new Error(`media check failed (${response.status}): ` + String(payload?.error?.message ?? "unknown").slice(0, 200));
+    }
+    const text = payload?.candidates?.[0]?.content?.parts?.map((p) => p?.text).filter(Boolean).join("") ?? "";
+    let answer = text.trim();
+    try {
+      const parsed = JSON.parse(answer);
+      if (typeof parsed?.answer === "string") answer = parsed.answer;
+    } catch {
+    }
+    if (!answer) throw new Error("media check returned no answer");
+    const meta = payload?.usageMetadata ?? {};
+    return {
+      answer,
+      usage: {
+        call_key: opts.callKey,
+        trace_key: traceKey(video, `${from}..${to}`, model, question),
+        provider: "google-gemini",
+        model,
+        input_tokens: Number(meta.promptTokenCount ?? 0),
+        cached_input_tokens: Number(meta.cachedContentTokenCount ?? 0),
+        output_tokens: Number(meta.candidatesTokenCount ?? 0),
+        reasoning_tokens: Number(meta.thoughtsTokenCount ?? 0),
+        clip_bytes: clip2.bytes,
+        wall_ms: Date.now() - started
+      }
+    };
+  } finally {
+    clip2.cleanup();
+  }
+}
+
+// packages/review-agent/src/prompt.ts
+var DOCTRINE = `
+## \u804C\u8D23
+
+\u53EA\u505A\u5FE0\u5B9E\u5EA6\u4E0E\u7ED3\u6784\u6821\u51C6\u3002\u4E0D\u8BC4\u4EF7\u5267\u60C5\u8D28\u91CF\uFF0C\u4E0D\u6DA6\u8272\uFF0C\u4E0D\u8865\u6897\u6982\u6216\u4EBA\u7269\u63CF\u8FF0\u3002
+
+## \u4E0D\u53D8\u91CF
+
+- \u89C6\u9891\u753B\u9762\u4E0E\u539F\u58F0\u662F\u5FE0\u5B9E\u5EA6\u7684\u4E8B\u5B9E\u6E90\uFF1B\u5267\u672C\u4E0A\u4E0B\u6587\u53EA\u7528\u4E8E**\u53D1\u73B0**\u98CE\u9669\uFF0C\u4E0D\u7528\u4E8E\u786E\u8BA4\u3002
+- \u9AD8\u3001\u4E2D\u7F6E\u4FE1\u4E14\u901A\u8FC7\u8BC1\u636E\u51C6\u5165\u7684\u95EE\u9898\u624D\u53EF\u4EE5\u4FEE\uFF1B\u4F4E\u7F6E\u4FE1\u3001\u5A92\u4F53\u7F3A\u5931\u6216\u8BC1\u636E\u51B2\u7A81\u4E00\u5F8B\u4FDD\u6301\u539F\u6837\u3002
+- \u540C\u503C\u65F6\u95F4\u6233\u5408\u6CD5\u3002\u53EA\u6709\u5012\u5E8F\u3001\u7F3A\u5931\u3001\u8D85\u51FA\u89C6\u9891\u65F6\u957F\u6216\u8D85\u8FC7 15 \u79D2\u7684\u65E0\u4E8B\u4EF6\u7A7A\u6863\u7B97\u65F6\u95F4\u8F74\u98CE\u9669\u3002
+- \u6BCF\u6279\u4FEE\u6539\u4E4B\u540E\u8C03\u7528 validate \u8BFB\u56DE\u3002
+- **\u96F6\u4FEE\u6539\u662F\u5408\u683C\u7ED3\u679C\u3002** \u6CA1\u53D1\u73B0\u95EE\u9898\u5C31\u5982\u5B9E\u8BB0 unchanged\uFF0C\u4E0D\u8981\u4E3A\u4E86\u4EA4\u5DEE\u5236\u9020\u4FEE\u6539\u3002
+
+## \u8BC1\u636E\u51C6\u5165
+
+\u53EA\u6709\u6EE1\u8DB3\u5176\u4E00\u624D\u5141\u8BB8\u4FEE\u6539\uFF1A
+
+1. \u65E0\u6B67\u4E49\u7684\u5185\u90E8\u7ED3\u6784\u4E8B\u5B9E\uFF08\u8BF4\u8BDD\u4EBA\u672A\u88AB\u672C\u573A\u5F15\u7528\u3001\u65F6\u95F4\u6233\u5012\u5E8F\u3001\u60AC\u7A7A\u5F15\u7528\uFF09\u3002
+2. \u4E00\u4E2A\u77ED\u539F\u7247\u7A97\u53E3\u6E05\u695A\u8BC1\u660E\u4E86\u5B9E\u9645\u8BF4\u8BDD\u4EBA / \u51FA\u573A\u8005 / \u9020\u578B / \u52A8\u4F5C / \u5730\u70B9 / \u9053\u5177\u3002
+3. \u591A\u4E2A\u76F8\u4E92\u72EC\u7ACB\u4E14\u4E00\u81F4\u7684\u8BC1\u636E\uFF0C\u4E14\u6CA1\u6709\u540C\u7B49\u5F3A\u5EA6\u7684\u53CD\u8BC1\u3002
+
+\u8EAB\u4EFD\u5224\u5B9A\u5FC5\u987B\u5148\u8BB0\u5F55**\u53EF\u89C2\u5BDF\u7684**\u5916\u89C2\u3001\u4F4D\u7F6E\u548C\u58F0\u97F3\uFF0C\u518D\u901A\u8FC7\u72EC\u7ACB\u951A\u70B9\u6620\u5C04\u5230\u4EBA\u7269\u540D\u3002
+**\u5F53\u524D\u90A3\u4E2A\uFF08\u53EF\u80FD\u662F\u9519\u7684\uFF09\u6807\u7B7E\u6C38\u8FDC\u4E0D\u80FD\u5F53\u951A\u70B9\u3002** \u753B\u9762\u91CC\u7684\u4EBA\u786E\u8BA4\u4E86\u4F46\u65E0\u6CD5\u53EF\u9760\u6620\u5C04\u5230\u540D\u5B57 \u2192 unresolved\u3002
+
+\u7F6E\u4FE1\u5EA6\uFF1Ahigh = \u76F4\u63A5\u65E0\u6B67\u4E49\uFF1Bmedium = \u82E5\u5E72\u4E00\u81F4\u7684\u95F4\u63A5\u8BC1\u636E\uFF1Blow = \u5355\u4E00\u5F31\u7EBF\u7D22\u6216\u5B58\u5728\u53CD\u8BC1\u3002
+
+## \u56FA\u5B9A\u68C0\u67E5
+
+- Scene \u4EBA\u7269\u3001\u72B6\u6001\u3001\u8BF4\u8BDD\u4EBA\u4E0E Action \u4E3B\u4F53\u662F\u5426\u4E00\u81F4\u3002
+- \u4EBA\u7269\u8EAB\u4EFD\u3001\u58F0\u97F3\u6765\u6E90\u3001\u9020\u578B\u3001\u5730\u70B9\u3001\u9053\u5177\u662F\u5426\u8BEF\u5EFA\u3001\u91CD\u590D\u6216\u9519\u6302\u3002
+- \u5BF9\u767D\u662F\u5426\u9010\u5B57\u5FE0\u5B9E\u4E8E\u539F\u58F0\uFF0C\u52A8\u4F5C\u662F\u5426\u5FE0\u5B9E\u4E8E\u53EF\u89C1\u4E8B\u5B9E\uFF1B\u6709\u65E0\u9057\u6F0F\u3001\u91CD\u590D\u6216\u5E7B\u89C9\u3002
+- \u573A\u754C\u662F\u5426\u5BF9\u5E94\u771F\u5B9E\u7684\u65F6\u7A7A\u5207\u6362\u3002
+- \u65F6\u95F4\u6233\u662F\u5426\u7F3A\u5931\u3001\u5012\u5E8F\u3001\u8D8A\u754C\u6216\u4EA7\u751F\u8D85\u8FC7 15 \u79D2\u7684\u7A7A\u6863\uFF08\u76F8\u90BB\u540C\u503C\u5408\u6CD5\uFF09\u3002
+- \u591A\u72B6\u6001\u4EBA\u7269\u7684\u76F8\u4F3C\u9020\u578B\u5FC5\u987B\u53D6\u5F97\u4EE3\u8868\u6027\u89C6\u9891\u7A97\u53E3\u540E\u518D\u5224\u65AD\uFF0C\u4E0D\u51ED\u540D\u79F0\u76F4\u63A5\u5408\u5E76\u3002
+
+## \u4FEE\u590D\u89C4\u5219
+
+- \u4EBA\u7269\u8BB0\u5F55\u91CD\u590D \u2192 \u5408\u5E76\u753B\u50CF\u4E0E\u5F15\u7528\uFF0C\u518D\u5220\u6389\u5DF2\u65E0\u5F15\u7528\u7684\u90A3\u4E2A\uFF0C\u4FDD\u7559\u66F4\u7A33\u5B9A/\u5F15\u7528\u66F4\u591A\u7684 ID\u3002
+- \u4E24\u4E2A\u4E0D\u540C\u4EBA\u7269\u4E4B\u95F4\u7684\u90E8\u5206\u8BEF\u8BA4 \u2192 \u4E24\u4E2A Actor \u90FD\u7559\u4E0B\uFF0C\u53EA\u4FEE\u9519\u7684\u90A3\u4E00\u96C6/\u90A3\u4E00\u573A\u7684\u8BF4\u8BDD\u4EBA\u3001\u6B63\u6587\u4E0E\u5F15\u7528\u3002
+- \u58F0\u97F3\u6765\u6E90\u88AB\u8BEF\u5EFA\u6210\u4EBA\u7269 \u2192 \u628A\u5BF9\u767D\u6307\u56DE\u6B63\u786E\u7684\u8BF4\u8BDD\u4EBA\u7C7B\u522B\u6216\u771F\u5B9E\u4EBA\u7269\uFF0C\u5F15\u7528\u6E05\u7A7A\u540E\u518D\u5220\u7A7A\u58F3\u3002
+- \u9020\u578B\u72B6\u6001\u91CD\u590D \u2192 \u628A\u5F15\u7528\u8FC1\u79FB\u5230\u6709\u8BC1\u636E\u652F\u6301\u7684\u90A3\u4E2A\u72B6\u6001\uFF0C\u518D\u5220\u91CD\u590D\u7684\u3002
+- Scene \u7F3A\u4EBA\u7269\u5F15\u7528 \u2192 \u53EA\u6709\u8BE5\u4EBA\u7269\u786E\u5B9E\u51FA\u573A\u6216\u5F00\u53E3\u624D\u8865\uFF1B\u6B63\u6587\u91CC\u88AB\u63D0\u5230\u4E0D\u6784\u6210\u4F9D\u636E\u3002
+- \u7F3A\u5931\u7684 Action / \u5BF9\u767D \u2192 \u53EA\u5728\u539F\u7247\u660E\u786E\u7684\u65F6\u95F4\u70B9\u63D2\u5165\uFF1B\u4E0D\u5F97\u6539\u5199\u539F\u58F0\uFF0C\u4E0D\u5F97\u51ED\u7A7A\u8865\u4E0D\u53EF\u89C1\u7684\u4E8B\u5B9E\u3002
+`.trim();
+var MEDIA = `
+## \u5A92\u4F53\u8BC1\u636E
+
+\u53EA\u5728\u6587\u672C\u548C\u7ED3\u6784\u8BC1\u636E\u4E0D\u80FD\u6536\u53E3\u65F6\u624D\u52A8\u5A92\u4F53\u5DE5\u5177\u3002
+
+- \`span\` \u628A action \u6362\u7B97\u6210\u89C6\u9891\u7A97\u53E3\uFF0C\u5148\u7528\u5B83\u5B9A\u4F4D\u518D\u770B\u7247\u3002
+- \`watch\` \u770B\u5E26\u58F0\u97F3\u7684\u77ED\u7A97\u53E3\uFF0C\u6700\u8D35\uFF1A\u7A97\u53E3\u8981\u8986\u76D6\u5019\u9009\u7684\u58F0\u97F3\u6216\u52A8\u4F5C\uFF0C\u524D\u540E\u5404\u7559\u6700\u591A 3 \u79D2\uFF0C
+  \u5355\u6B21\u4E0D\u8D85\u8FC7 15 \u79D2\uFF1B\u4E00\u53E5\u53F0\u8BCD\u8986\u76D6\u4E0D\u5B8C\u5C31\u62C6\u6210\u91CD\u53E0\u7A97\u53E3\u3002
+- \`frames\` \u62BD\u9759\u5E27\u76F4\u63A5\u8FDB\u4F60\u7684\u4E0A\u4E0B\u6587\uFF0C\u4FBF\u5B9C\u4E14\u7CBE\u786E\uFF0C\u9002\u5408\u6838\u5BF9\u9020\u578B\u3001\u4EBA\u6570\u3001\u573A\u666F\uFF0C\u4F46\u6CA1\u6709\u58F0\u97F3\u3002
+
+\u5A92\u4F53\u9884\u7B97\u7528\u5B8C\u6216\u4E00\u6B21\u6838\u5BF9\u4ECD\u4E0D\u8DB3 \u2192 \u8BB0 unresolved \u5E76\u8BF4\u660E\u539F\u56E0\uFF0C\u4E0D\u8981\u53CD\u590D\u8BD5\u3002
+`.trim();
+var NO_MEDIA = `
+## \u6CA1\u6709\u539F\u89C6\u9891
+
+\u672C\u6B21\u6CA1\u6709\u63D0\u4F9B\u539F\u7247\uFF0C\u5A92\u4F53\u5DE5\u5177\u672A\u6CE8\u518C\u3002\u56E0\u6B64**\u4E0D\u5F97\u58F0\u79F0\u4EFB\u4F55\u89C6\u9891\u8BC1\u636E**\uFF1A
+\u53EA\u80FD\u4F9D\u636E\u65E0\u6B67\u4E49\u7684\u5185\u90E8\u7ED3\u6784\u4E8B\u5B9E\u4FEE\u6539\uFF08\u8BF4\u8BDD\u4EBA\u672A\u88AB\u672C\u573A\u5F15\u7528\u3001\u65F6\u95F4\u6233\u5012\u5E8F\u3001\u60AC\u7A7A\u5F15\u7528\u7B49\uFF09\u3002
+\u4EFB\u4F55\u9700\u8981\u770B\u753B\u9762\u6216\u542C\u58F0\u97F3\u624D\u80FD\u5224\u5B9A\u7684\u5019\u9009\uFF0C\u4E00\u5F8B\u8BB0 unresolved\uFF0C\u539F\u56E0\u5199"\u65E0\u539F\u7247"\u3002
+`.trim();
+function systemPrompt(input) {
+  return [
+    "\u4F60\u6B63\u5728\u6267\u884C\u65E0\u4EBA\u503C\u5B88\u7684\u5267\u672C\u5BA1\u6838\u4E0E\u4FEE\u590D\u3002",
+    DOCTRINE,
+    input.video ? MEDIA : NO_MEDIA,
+    "## \u5168\u5267\u8BBE\u5B9A\uFF08\u6BCF\u96C6\u76F8\u540C\uFF09",
+    input.seriesCard
+  ].join("\n\n");
+}
+function episodeTask(input) {
+  if (input.episode === 0) {
+    return [
+      "## \u672C\u6B21\u4EFB\u52A1\uFF1A\u5168\u5267\u6536\u655B",
+      "\u53EA\u5904\u7406\u8DE8\u96C6\u4E00\u81F4\u6027\uFF1A\u4EBA\u7269\u8EAB\u4EFD\u91CD\u590D\u3001\u9020\u578B\u72B6\u6001\u91CD\u590D\u3001\u5730\u70B9/\u9053\u5177\u91CD\u590D\u3001\u6B8B\u4F59\u5F15\u7528\u3002",
+      "\u4E0D\u8981\u91CD\u590D\u9010\u96C6\u5185\u5BB9\u5BA1\u6838\u3002\u672C\u9636\u6BB5\u53EF\u4EE5\u4F7F\u7528 merge \u4E0E\u8D44\u4EA7/\u72B6\u6001\u7EA7\u7684 edit / del\u3002",
+      "\u6BCF\u6536\u53E3\u4E00\u4E2A\u95EE\u9898\u8C03\u7528\u4E00\u6B21 finding\uFF0C\u6700\u540E\u8DD1\u4E00\u6B21 validate\u3002"
+    ].join("\n");
+  }
+  return [
+    `## \u672C\u6B21\u4EFB\u52A1\uFF1A\u7B2C ${input.episode} \u96C6`,
+    input.video ? `\u539F\u89C6\u9891\uFF1A${input.video}` : "\uFF08\u65E0\u539F\u89C6\u9891\uFF09",
+    input.video ? `\u5A92\u4F53\u6838\u5BF9\u9884\u7B97\uFF1A${input.mediaBudget} \u6B21` : "",
+    "",
+    "\u5148 scan \u672C\u96C6\u5EFA\u7ACB\u4E0A\u4E0B\u6587\uFF0C\u518D\u9010\u6761\u68C0\u67E5 Dialogue\u3001inner thought \u4E0E Action\u3002",
+    "\u5148\u5EFA\u7ACB\u4EBA\u7269\u76EE\u6807\u3001\u5DF2\u77E5\u4FE1\u606F\u3001\u5173\u7CFB\u548C\u76F8\u90BB\u884C\u4E3A\u7684\u56E0\u679C\uFF0C\u518D\u5224\u65AD\u5355\u6761\u662F\u5426\u5FE0\u5B9E\u3002",
+    input.neighbours ? `
+\u76F8\u90BB\u96C6\u6897\u6982\uFF08\u53EA\u7528\u4E8E\u7406\u89E3\u56E0\u679C\uFF09\uFF1A
+${input.neighbours}` : "",
+    "",
+    "\u6BCF\u6536\u53E3\u4E00\u4E2A\u95EE\u9898\u5C31\u8C03\u7528\u4E00\u6B21 finding\uFF0C\u4E0D\u8981\u6512\u5230\u6700\u540E\u3002\u6539\u5B8C\u8BFB\u56DE\u5E76\u8DD1 validate\u3002"
+  ].filter((line) => line !== "").join("\n");
+}
+
+// packages/review-agent/src/tools.ts
+import * as fs4 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+import { createTool } from "@mastra/core/tools";
+import { z as z2 } from "zod";
+var ADDR = "\u5730\u5740\uFF1A\u96C6 `3`\u3001\u573A `3-2`\u3001\u5355\u6761 `3-2-5`\u3001\u6B63\u5F0F ID\uFF08`acB4xR8p`/`scnQ7mN2v`\uFF09\u3001\u8D44\u4EA7\u540D\u3001\u6216 `<\u8D44\u4EA7>/<\u72B6\u6001>`";
+function newContext(init) {
+  return {
+    ...init,
+    findings: [],
+    usage: [],
+    mediaCalls: 0,
+    frameDir: fs4.mkdtempSync(path2.join(os2.tmpdir(), "review-frames-"))
+  };
+}
+function scanEpisode(doc, episode) {
+  const addr = String(episode);
+  const outline = read(doc, addr, { depth: "outline" });
+  const body = read(doc, addr);
+  const problems = issues(doc, {});
+  return [
+    `## \u573A\u7ED3\u6784
+${outline}`,
+    `## \u6B63\u6587
+${body}`,
+    `## \u5F53\u524D\u6821\u9A8C\u95EE\u9898\uFF08\u5168\u5267\uFF09
+${problems}`
+  ].join("\n\n");
+}
+function buildTools(ctx) {
+  const tools = {};
+  tools.scan = createTool({
+    id: "scan",
+    description: "\u8BFB\u4E00\u96C6\u7684\u5B8C\u6574\u4E0A\u4E0B\u6587\uFF1A\u573A\u7ED3\u6784 + \u5168\u90E8\u6B63\u6587 + \u5F53\u524D\u6821\u9A8C\u95EE\u9898\u3002\u5F00\u59CB\u5BA1\u6838\u4E00\u96C6\u65F6\u5148\u8C03\u7528\u5B83\u3002",
+    inputSchema: z2.object({ episode: z2.number().int().min(1).describe("\u96C6\u53F7\uFF0C\u4ECE 1 \u5F00\u59CB") }),
+    execute: async ({ episode }) => scanEpisode(ctx.doc, episode)
+  });
+  tools.read = createTool({
+    id: "read",
+    description: `\u8BFB\u4EFB\u610F\u8282\u70B9\u3002${ADDR}\u3002\u4E0D\u4F20\u5730\u5740\u8FD4\u56DE\u5267\u672C\u5361\uFF08\u9898\u6750/\u8D44\u4EA7\u8868/\u6BCF\u96C6\u4E00\u884C\uFF09\u3002\u8D44\u4EA7\u5730\u5740\u8FD4\u56DE\u4EBA\u7269\u5361\uFF08\u63CF\u8FF0 + \u5168\u90E8\u72B6\u6001 + \u51FA\u573A\u7EDF\u8BA1 + \u672A\u4F7F\u7528\u72B6\u6001\uFF09\u3002`,
+    inputSchema: z2.object({
+      addr: z2.string().optional().describe(ADDR),
+      context: z2.number().int().min(0).max(20).optional().describe("\u5355\u6761 action \u524D\u540E\u5404\u5E26\u51E0\u6761\uFF0C\u9ED8\u8BA4 3")
+    }),
+    execute: async ({ addr, context }) => read(ctx.doc, addr ?? "", context === void 0 ? {} : { context })
+  });
+  tools.find = createTool({
+    id: "find",
+    description: "\u6309\u6B63\u6587\u6B63\u5219 / \u8BF4\u8BDD\u4EBA / \u7C7B\u578B\u5B9A\u4F4D action\uFF0C\u8FD4\u56DE\u951A\u70B9 + \u4F4D\u7F6E + \u547D\u4E2D\u7A97\u53E3\u3002",
+    inputSchema: z2.object({
+      query: z2.string().describe("\u6B63\u5219\uFF1B\u53EA\u6309 speaker/type \u8FC7\u6EE4\u65F6\u4F20\u7A7A\u4E32"),
+      in: z2.string().optional().describe(`\u9650\u5236\u8303\u56F4\uFF0C${ADDR}`),
+      speaker: z2.string().optional().describe("\u4EBA\u7269\u540D\u6216 actor id"),
+      type: z2.enum(["action", "dialogue", "inner_thought", "transition"]).optional(),
+      limit: z2.number().int().min(1).max(200).optional()
+    }),
+    execute: async (input) => find(ctx.doc, input.query, {
+      ...input.in ? { in: input.in } : {},
+      ...input.speaker ? { speaker: input.speaker } : {},
+      ...input.type ? { type: input.type } : {},
+      ...input.limit ? { limit: input.limit } : {}
+    })
+  });
+  tools.span = createTool({
+    id: "span",
+    description: "\u628A\u4E00\u6BB5 action \u6362\u7B97\u6210\u96C6\u5185\u89C6\u9891\u65F6\u95F4\u7A97\u53E3\uFF08\u534A\u5F00\u533A\u95F4\uFF09\uFF0C\u9009 watch/frames \u7684\u7A97\u53E3\u9760\u5B83\u3002",
+    inputSchema: z2.object({ range: z2.string().describe(`${ADDR}\uFF0C\u6216 \`\u8D77ID..\u6B62ID\``) }),
+    execute: async ({ range }) => span(ctx.doc, range)
+  });
+  tools.issues = createTool({
+    id: "issues",
+    description: "\u5217\u5F53\u524D\u6821\u9A8C\u95EE\u9898\uFF0C\u53EF\u6309 severity / code \u8FC7\u6EE4\u3002",
+    inputSchema: z2.object({
+      severity: z2.enum(["error", "warning"]).optional(),
+      code: z2.string().optional()
+    }),
+    execute: async (input) => issues(ctx.doc, input)
+  });
+  tools.validate = createTool({
+    id: "validate",
+    description: "\u8DD1\u6574\u672C\u6821\u9A8C\u3002\u6BCF\u6279\u4FEE\u6539\u4E4B\u540E\u5FC5\u987B\u8C03\u7528\u4E00\u6B21\u3002",
+    inputSchema: z2.object({}),
+    execute: async () => validate(ctx.doc)
+  });
+  const editFields = {
+    content: z2.string().optional().describe("**\u6574\u6761\u8986\u5199** action \u6B63\u6587\uFF1A\u4F20\u5165\u7684\u5B57\u7B26\u4E32\u4F1A\u6210\u4E3A\u8FD9\u6761 action \u7684\u5168\u90E8\u5185\u5BB9\uFF0C\u539F\u6587\u88AB\u4E22\u5F03\u3002\u53EA\u60F3\u6539\u5176\u4E2D\u4E00\u4E2A\u8BCD\u6216\u4E00\u6BB5\uFF0C\u7528 `replace`\uFF0C\u4E0D\u8981\u7528\u8FD9\u4E2A\u5B57\u6BB5\u3002"),
+    paren: z2.string().nullable().optional().describe("\u8868\u6F14\u63D0\u793A\uFF1Bnull \u5220\u9664\u8BE5\u5B57\u6BB5"),
+    speaker: z2.string().optional().describe("\u4EBA\u7269\u540D\u6216 `\u540D\u5B57\xB7\u72B6\u6001`\uFF1B\u65C1\u767D/\u5E7F\u64AD/\u753B\u5916/\u7FA4\u58F0\u4EA6\u53EF"),
+    ts: z2.string().nullable().optional().describe("\u65F6\u95F4\u6233\uFF1Bnull \u5220\u9664"),
+    type: z2.enum(["action", "dialogue", "inner_thought", "transition"]).optional(),
+    space: z2.enum(["interior", "exterior"]).optional().describe("\u573A\u5730\u5740\uFF1A\u5185\u5916\u666F"),
+    time: z2.enum(["day", "night", "dawn", "dusk"]).optional().describe("\u573A\u5730\u5740\uFF1A\u65E5\u591C")
+  };
+  const assetFields = {
+    name: z2.string().optional(),
+    desc: z2.string().optional(),
+    importance: z2.enum(["featured", "background"]).optional(),
+    role: z2.enum(["\u4E3B\u89D2", "\u914D\u89D2"]).optional()
+  };
+  tools.edit = createTool({
+    id: "edit",
+    description: ctx.phase === "converge" ? `\u6539\u4E00\u4E2A\u8282\u70B9\u7684\u5B57\u6BB5\u3002${ADDR}\uFF1B\u5730\u5740\u51B3\u5B9A\u54EA\u4E9B\u5B57\u6BB5\u5408\u6CD5\uFF08action / \u573A / \u8D44\u4EA7 / \u72B6\u6001\uFF09\u3002` : `\u6539\u4E00\u6761 action \u6216\u4E00\u4E2A\u573A\u7684\u5B57\u6BB5\u3002${ADDR}\u3002\u8D44\u4EA7\u548C\u72B6\u6001\u672C\u8EAB\u7559\u7ED9\u5168\u5267\u6536\u655B\u9636\u6BB5\u3002`,
+    inputSchema: z2.object({
+      at: z2.string().describe(ADDR),
+      ...editFields,
+      ...ctx.phase === "converge" ? assetFields : {}
+    }),
+    execute: async ({ at, ...fields }) => {
+      const clean = Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== void 0));
+      return edit(ctx.doc, at, clean);
+    }
+  });
+  tools.replace = createTool({
+    id: "replace",
+    description: "\u628A\u4E00\u6BB5\u6587\u672C\u6362\u6210\u53E6\u4E00\u6BB5\uFF0C\u53EA\u52A8\u5339\u914D\u5230\u7684\u90E8\u5206\uFF0C\u6B63\u6587\u5176\u4F59\u5185\u5BB9\u4E0D\u53D8\u3002\u6539\u4EBA\u540D\u3001\u5730\u540D\u3001\u79F0\u8C13\u8FD9\u7C7B\u300E\u4E00\u4E2A\u8BCD\u9519\u4E86\u300F\u7684\u95EE\u9898\u7528\u5B83\uFF0C\u4E0D\u8981\u7528 edit \u6574\u6761\u8986\u5199\u3002 \u8FC7\u6EE4\u53C2\u6570\u4E0E find \u76F8\u540C\uFF0C\u53EF\u7528 in \u9650\u5B9A\u5230\u67D0\u96C6\u6216\u67D0\u573A\u3002",
+    inputSchema: z2.object({
+      pattern: z2.string().describe("\u8981\u88AB\u66FF\u6362\u6389\u7684\u6587\u672C\uFF08\u6B63\u5219\uFF09"),
+      to: z2.string().describe("\u66FF\u6362\u6210\u4EC0\u4E48"),
+      in: z2.string().optional().describe(`\u9650\u5236\u8303\u56F4\uFF0C${ADDR}\uFF1B\u4E0D\u4F20\u5219\u6574\u672C`),
+      speaker: z2.string().optional().describe("\u53EA\u6539\u67D0\u4EBA\u7269\u7684\u53F0\u8BCD"),
+      type: z2.enum(["action", "dialogue", "inner_thought", "transition"]).optional(),
+      apply: z2.boolean().optional().describe("false \u6216\u7701\u7565\u53EA\u8FD4\u56DE\u9010\u884C before/after \u9884\u89C8\uFF1Btrue \u624D\u771F\u7684\u5199\u5165")
+    }),
+    execute: async ({ pattern, to, apply, ...filters }) => replace(ctx.doc, pattern, to, {
+      ...Object.fromEntries(Object.entries(filters).filter(([, v]) => v !== void 0)),
+      ...apply ? { apply: true } : {}
+    })
+  });
+  tools.ref = createTool({
+    id: "ref",
+    description: "\u6539\u4E00\u4E2A\u573A\u5BF9\u67D0\u8D44\u4EA7\u7684\u5F15\u7528\u3002states \u662F\u5B8C\u6574\u72B6\u6001\u96C6\u5408\u800C\u975E\u8FFD\u52A0\uFF0C`default` \u4E5F\u8981\u663E\u5F0F\u5199\u3002",
+    inputSchema: z2.object({
+      scene: z2.string().describe("\u573A\u5730\u5740"),
+      asset: z2.string().describe("\u4EBA\u7269 / \u5730\u70B9 / \u9053\u5177\u7684\u540D\u5B57\u6216 ID"),
+      states: z2.array(z2.string()).optional().describe("\u5B8C\u6574\u72B6\u6001\u96C6\u5408\uFF08\u540D\u5B57\u6216 ID\uFF09"),
+      remove: z2.boolean().optional().describe("true \u5220\u9664\u6574\u6761\u5F15\u7528")
+    }),
+    execute: async ({ scene, asset, states, remove }) => ref(ctx.doc, scene, asset, states ?? [], remove ?? false)
+  });
+  tools.insert = createTool({
+    id: "insert",
+    description: "\u5728\u67D0\u6761 action \u524D/\u540E\u63D2\u5165\u4E00\u6761\u65B0 action\uFF0C\u7528\u4E8E\u8865\u539F\u7247\u6709\u4F46\u5267\u672C\u6F0F\u6389\u7684\u5185\u5BB9\u3002",
+    inputSchema: z2.object({
+      at: z2.string().describe("\u76F8\u90BB action \u7684\u5730\u5740"),
+      where: z2.enum(["before", "after"]),
+      type: z2.enum(["action", "dialogue", "inner_thought", "transition"]),
+      content: z2.string(),
+      speaker: z2.string().optional(),
+      paren: z2.string().optional(),
+      ts: z2.string().optional()
+    }),
+    execute: async ({ at, where, type, content, speaker, paren, ts }) => {
+      const out = insert(ctx.doc, at, where, type, content, speaker, paren);
+      if (ts) {
+        const anchor = out.match(/\b(ac[1-9A-HJ-NP-Za-km-z]{6}|\d+-\d+-\d+)\b/)?.[1];
+        if (anchor) edit(ctx.doc, anchor, { ts });
+      }
+      return out;
+    }
+  });
+  tools.move = createTool({
+    id: "move",
+    description: "\u628A\u4E00\u6761 action \u632A\u5230\u53E6\u4E00\u6761\u65C1\u8FB9\uFF1B\u8DE8\u573A\u4E5F\u4FDD\u6301\u5B83\u7684 action_id\u3002",
+    inputSchema: z2.object({
+      at: z2.string(),
+      to: z2.string().describe("\u76EE\u6807\u90BB\u5C45 action"),
+      where: z2.enum(["before", "after"]).optional()
+    }),
+    execute: async ({ at, to, where }) => move(ctx.doc, at, to, where ?? "after")
+  });
+  tools.del = createTool({
+    id: "del",
+    description: ctx.phase === "converge" ? "\u5220\u9664\u8282\u70B9\uFF1Aaction / \u573A / \u8D44\u4EA7 / \u72B6\u6001\u3002\u88AB\u5F15\u7528\u7684\u8D44\u4EA7\u6216\u72B6\u6001\u9700\u8981 replacement \u6539\u5199\u6216 force\u3002" : "\u5220\u9664\u4E00\u6761 action\uFF0C\u6216\u4E00\u4E2A\u7A7A\u573A\u3002\u8D44\u4EA7\u548C\u72B6\u6001\u7684\u5220\u9664\u7559\u7ED9\u5168\u5267\u6536\u655B\u9636\u6BB5\u3002",
+    inputSchema: z2.object({
+      addr: z2.string().describe(ADDR),
+      replacement: ctx.phase === "converge" ? z2.string().optional().describe("\u5220\u72B6\u6001\u65F6\u628A\u5F15\u7528\u6539\u5199\u5230\u8FD9\u4E2A\u72B6\u6001") : z2.undefined().optional(),
+      force: z2.boolean().optional()
+    }),
+    execute: async ({ addr, replacement, force }) => {
+      if (ctx.phase !== "converge") {
+        const node = resolve(ctx.doc, addr);
+        if (node.t === "asset" || node.t === "state") {
+          throw new Error("\u8D44\u4EA7\u4E0E\u72B6\u6001\u7684\u5220\u9664\u53EA\u5728\u5168\u5267\u6536\u655B\u9636\u6BB5\u53EF\u7528\uFF1B\u672C\u96C6\u53EA\u5904\u7406 action \u4E0E\u573A\u3002");
+        }
+      }
+      return del(ctx.doc, addr, {
+        ...replacement ? { replacement } : {},
+        ...force ? { force } : {}
+      });
+    }
+  });
+  if (ctx.phase === "converge") {
+    tools.merge = createTool({
+      id: "merge",
+      description: "\u628A\u4E00\u4E2A\u8D44\u4EA7\u5E76\u5165\u53E6\u4E00\u4E2A\uFF1A\u5168\u90E8\u573A\u666F\u5F15\u7528\u4E0E speaker \u6539\u5199\u8FC7\u53BB\uFF0C\u540C\u540D\u72B6\u6001\u81EA\u52A8\u5BF9\u9F50\u3002",
+      inputSchema: z2.object({ src: z2.string(), dst: z2.string() }),
+      execute: async ({ src, dst }) => merge(ctx.doc, src, dst)
+    });
+    tools.state = createTool({
+      id: "state",
+      description: "\u7ED9\u5DF2\u6709\u8D44\u4EA7\u52A0\u4E00\u4E2A\u72B6\u6001\uFF08\u9020\u578B\u6863\u4F4D\uFF09\u3002",
+      inputSchema: z2.object({ asset: z2.string(), name: z2.string(), desc: z2.string() }),
+      execute: async ({ asset, name, desc }) => state(ctx.doc, asset, name, desc)
+    });
+  }
+  if (ctx.video && ctx.geminiKey) {
+    tools.watch = createTool({
+      id: "watch",
+      description: `\u770B\u539F\u7247\u7684\u4E00\u4E2A\u77ED\u7A97\u53E3\uFF08\u6709\u58F0\u97F3\uFF09\uFF0C\u6838\u5BF9\u8BF4\u8BDD\u4EBA / \u8EAB\u4EFD / \u9020\u578B / \u52A8\u4F5C / \u8D44\u4EA7\u4E8B\u5B9E\u3002 \u5355\u6B21\u7A97\u53E3\u4E0D\u8D85\u8FC7 15 \u79D2\uFF1B\u672C\u96C6\u9884\u7B97 ${ctx.mediaBudget} \u6B21\u3002\u53EA\u5728\u6587\u672C\u548C\u7ED3\u6784\u8BC1\u636E\u4E0D\u80FD\u6536\u53E3\u65F6\u7528\u3002`,
+      inputSchema: z2.object({
+        from: z2.string().describe("\u7A97\u53E3\u8D77\u70B9\uFF0C`M:SS` \u6216 `H:MM:SS`"),
+        to: z2.string().describe("\u7A97\u53E3\u7EC8\u70B9\uFF1B\u8986\u76D6\u5019\u9009\u58F0\u97F3\u6216\u52A8\u4F5C\uFF0C\u524D\u540E\u5404\u7559\u6700\u591A 3 \u79D2"),
+        question: z2.string().describe("\u8981\u6838\u5BF9\u4EC0\u4E48\u3002\u8981\u6C42\u5B83\u53EA\u62A5\u53EF\u76F4\u63A5\u770B\u5230/\u542C\u5230\u7684\u4E8B\u5B9E")
+      }),
+      execute: async ({ from, to, question }) => {
+        if (ctx.mediaCalls >= ctx.mediaBudget) {
+          return `\u5A92\u4F53\u6838\u5BF9\u9884\u7B97\u5DF2\u7528\u5B8C\uFF08${ctx.mediaBudget} \u6B21\uFF09\u3002\u8BC1\u636E\u4E0D\u8DB3\u7684\u5019\u9009\u8BB0\u4E3A unresolved\u3002`;
+        }
+        ctx.mediaCalls += 1;
+        const result = await watchWindow(ctx.video, from, to, question, {
+          apiKey: ctx.geminiKey,
+          model: ctx.mediaModel,
+          callKey: `review:ep${ctx.episode}:watch:${ctx.mediaCalls}`
+        });
+        ctx.usage.push(result.usage);
+        return result.answer;
+      }
+    });
+    tools.frames = createTool({
+      id: "frames",
+      description: "\u62BD\u53D6\u539F\u7247\u82E5\u5E72\u65F6\u523B\u7684\u9759\u5E27\uFF0C\u76F4\u63A5\u8FDB\u4F60\u7684\u4E0A\u4E0B\u6587\u4F9B\u4F60\u81EA\u5DF1\u770B\u3002\u6CA1\u6709\u58F0\u97F3\uFF0C\u4F46\u7CBE\u786E\u4E14\u4FBF\u5B9C\u3002",
+      inputSchema: z2.object({
+        timestamps: z2.array(z2.string()).min(1).max(6).describe("\u65F6\u523B\u5217\u8868\uFF0C`M:SS`"),
+        note: z2.string().optional().describe("\u4F60\u60F3\u5728\u8FD9\u4E9B\u5E27\u91CC\u786E\u8BA4\u4EC0\u4E48")
+      }),
+      // The frames themselves reach the model through toModelOutput; the plain
+      // return value is only what a transcript reader sees.
+      execute: async ({ timestamps, note }) => {
+        const images = [];
+        const failed = [];
+        for (const at of timestamps) {
+          try {
+            const out = path2.join(ctx.frameDir, `${ctx.episode}-${at.replace(/[:.]/g, "_")}.jpg`);
+            await grabFrame(ctx.video, at, out);
+            images.push({ at, data: fs4.readFileSync(out).toString("base64") });
+          } catch (error) {
+            failed.push(`${at}: ${error.message}`);
+          }
+        }
+        return { images, failed, note: note ?? "" };
+      },
+      toModelOutput: ({ images, failed, note }) => ({
+        type: "content",
+        value: [
+          { type: "text", text: `\u539F\u7247\u9759\u5E27 ${images.map((i) => i.at).join(", ")}` + (note ? `\uFF08${note}\uFF09` : "") + (failed.length ? `
+\u62BD\u5E27\u5931\u8D25\uFF1A${failed.join("; ")}` : "") },
+          ...images.map((image) => ({
+            type: "image-data",
+            data: image.data,
+            mimeType: "image/jpeg"
+          }))
+        ]
+      })
+    });
+  }
+  tools.finding = createTool({
+    id: "finding",
+    description: "\u8BB0\u5F55\u4E00\u6761\u5BA1\u6838\u7ED3\u8BBA\u3002\u6BCF\u6536\u53E3\u4E00\u4E2A\u95EE\u9898\u5C31\u8C03\u7528\u4E00\u6B21\uFF0C\u4E0D\u8981\u6512\u5230\u6700\u540E\u3002 outcome=fixed \u8868\u793A\u5DF2\u7ECF\u6539\u5B8C\u5E76\u8BFB\u56DE\uFF1Bunchanged \u8868\u793A\u6838\u5BF9\u540E\u65E0\u9700\u4FEE\u6539\uFF1B unresolved \u8868\u793A\u8BC1\u636E\u4E0D\u8DB3\u3001\u4FDD\u6301\u539F\u6837\u5E76\u8BF4\u660E\u539F\u56E0\u3002",
+    inputSchema: FINDING_INPUT,
+    execute: async (input) => {
+      if (input.outcome === "fixed" && input.confidence === "low") {
+        return "\u4F4E\u7F6E\u4FE1\u4E0D\u5F97\u81EA\u52A8\u4FEE\u6539\u3002\u8981\u4E48\u8865\u8DB3\u8BC1\u636E\u628A\u7F6E\u4FE1\u63D0\u5230 medium \u4EE5\u4E0A\uFF0C\u8981\u4E48\u628A\u8FD9\u6761\u8BB0\u4E3A unresolved\u3002";
+      }
+      if (input.outcome === "unresolved" && !input.unresolved_reason?.trim()) {
+        return "unresolved \u5FC5\u987B\u5199 unresolved_reason\u3002";
+      }
+      const finding = toFinding(ctx.doc, input, ctx.episode, ctx.findings.length + 1);
+      ctx.findings.push(finding);
+      return `\u5DF2\u8BB0\u5F55 ${finding.id}\uFF08\u951A\u70B9 ${finding.anchor.episode_id ?? "?"}${finding.anchor.action_id ? "/" + finding.anchor.action_id : ""}\uFF09\u3002\u672C\u96C6\u5DF2\u8BB0 ${ctx.findings.length} \u6761\u3002`;
+    }
+  });
+  return tools;
+}
+
+// packages/review-agent/src/agent.ts
+import { Agent } from "@mastra/core/agent";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { z as z3 } from "zod";
+function seriesCard(doc) {
+  return read(doc, "").split("\nepisodes\n")[0].trim();
+}
+function neighbourSynopses(doc, episode) {
+  return doc.episodes.filter((ep) => Math.abs(ep.no - episode) <= 1 && ep.synopsis).map((ep) => `\u7B2C ${ep.no} \u96C6\uFF1A${ep.synopsis}`).join("\n");
+}
+function timeoutFinding(episode, minutes) {
+  return {
+    id: `episode-${episode}-timeout`,
+    category: "other",
+    title: "\u5BA1\u6838\u8D85\u65F6",
+    issue: `\u7B2C ${episode} \u96C6\u5BA1\u6838\u8D85\u8FC7 ${minutes} \u5206\u949F`,
+    impact: "\u672C\u96C6\u53EF\u80FD\u4ECD\u6709\u672A\u6536\u53E3\u7684\u5019\u9009",
+    resolution: "\u5DF2\u4E2D\u65AD\u5E76\u4FDD\u7559\u6B64\u524D\u7ED3\u8BBA",
+    outcome: "unresolved",
+    confidence: "low",
+    anchor: {
+      episode_number: episode,
+      episode_id: null,
+      scene_number: null,
+      scene_id: null,
+      action_id: null,
+      timestamp: null,
+      end_timestamp: null
+    },
+    subject: null,
+    before: null,
+    after: null,
+    unresolved_reason: `\u5355\u96C6\u5BA1\u6838\u8D85\u8FC7 ${minutes} \u5206\u949F\u786C\u8D85\u65F6`,
+    evidence: []
+  };
+}
+async function reviewUnit(doc, episode, video, config) {
+  const started = Date.now();
+  const ctx = newContext({
+    doc,
+    episode,
+    phase: episode === 0 ? "converge" : "episode",
+    ...video ? { video, geminiKey: config.apiKey } : {},
+    mediaModel: config.mediaModel,
+    mediaBudget: config.mediaBudget
+  });
+  const google = createGoogleGenerativeAI({
+    apiKey: config.apiKey,
+    ...config.baseUrl ? { baseURL: config.baseUrl } : {},
+    fetch: ((url, init) => fetch(url, {
+      ...init,
+      ...dispatcher() ? { dispatcher: dispatcher() } : {}
+    }))
+  });
+  const input = {
+    seriesCard: seriesCard(doc),
+    episode,
+    ...video ? { video } : {},
+    mediaBudget: config.mediaBudget,
+    neighbours: neighbourSynopses(doc, episode)
+  };
+  const agent = new Agent({
+    id: `review-ep${episode}`,
+    name: `Script review \xB7 episode ${episode}`,
+    instructions: systemPrompt(input),
+    model: google(config.model),
+    tools: buildTools(ctx)
+  });
+  let state2 = "completed";
+  let message = "";
+  let error = null;
+  let steps = 0;
+  const usage = [];
+  const minutes = Math.round(config.timeoutMs / 6e4);
+  try {
+    const response = await agent.generate(episodeTask(input), {
+      maxSteps: config.maxSteps,
+      modelSettings: { temperature: 0, timeout: { totalMs: config.timeoutMs } },
+      structuredOutput: {
+        schema: z3.object({ message: z3.string().describe("\u4E00\u4E24\u53E5\u8BDD\u603B\u7ED3\u672C\u96C6\u5BA1\u6838\u7ED3\u679C") }),
+        errorStrategy: "warn"
+      }
+    });
+    steps = response?.steps?.length ?? 0;
+    message = response?.object?.message || response?.text?.trim() || `\u7B2C ${episode} \u96C6\u5BA1\u6838\u5B8C\u6210`;
+    const u = response?.usage ?? {};
+    usage.push({
+      call_key: `review:ep${episode}:agent`,
+      provider: "google-gemini",
+      model: config.model,
+      input_tokens: Number(u.inputTokens ?? u.promptTokens ?? 0),
+      cached_input_tokens: Number(u.cachedInputTokens ?? 0),
+      output_tokens: Number(u.outputTokens ?? u.completionTokens ?? 0),
+      reasoning_tokens: Number(u.reasoningTokens ?? 0)
+    });
+  } catch (thrown) {
+    const detail = thrown instanceof Error ? thrown.message : String(thrown);
+    const timedOut = /timeout|aborted|AbortError/i.test(detail);
+    state2 = timedOut ? "completed" : "failed";
+    error = detail.slice(0, 300);
+    message = timedOut ? `\u5BA1\u6838\u5728 ${minutes} \u5206\u949F\u8D85\u65F6\u540E\u4E2D\u65AD\uFF0C\u5DF2\u4FDD\u7559\u6B64\u524D\u7ED3\u8BBA` : `\u7B2C ${episode} \u96C6\u5BA1\u6838\u5931\u8D25`;
+    if (timedOut) ctx.findings.push(timeoutFinding(episode, minutes));
+  }
+  for (const media of ctx.usage) {
+    usage.push({
+      call_key: media.call_key,
+      provider: media.provider,
+      model: media.model,
+      input_tokens: media.input_tokens,
+      cached_input_tokens: media.cached_input_tokens,
+      output_tokens: media.output_tokens,
+      reasoning_tokens: media.reasoning_tokens
+    });
+  }
+  return {
+    episode_number: episode,
+    state: state2,
+    message,
+    error,
+    findings: ctx.findings,
+    wall_ms: Date.now() - started,
+    steps,
+    media_calls: ctx.mediaCalls,
+    usage
+  };
+}
+
+// packages/review-agent/src/review.ts
+import * as fs5 from "node:fs";
+import * as path3 from "node:path";
+function episodeVideos(source, count) {
+  if (!source) return Array.from({ length: count }, () => void 0);
+  const stat = fs5.statSync(source);
+  if (stat.isFile()) return Array.from({ length: count }, () => source);
+  const files = fs5.readdirSync(source).filter((name) => /\.(mp4|mov|mkv|m4v)$/i.test(name)).sort().map((name) => path3.join(source, name));
+  if (files.length < count) {
+    throw new Error(`${source} holds ${files.length} videos for ${count} episodes`);
+  }
+  return files.slice(0, count);
+}
+function statistics(units) {
+  const findings = units.flatMap((unit) => unit.findings);
+  return {
+    fixed: findings.filter((f) => f.outcome === "fixed").length,
+    unchanged: findings.filter((f) => f.outcome === "unchanged").length,
+    unresolved: findings.filter((f) => f.outcome === "unresolved").length,
+    failed_episodes: units.filter((u) => u.state === "failed" && u.episode_number > 0).length
+  };
+}
+async function pool(items, limit, run2) {
+  const queue = [...items];
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, queue.length)) }, async () => {
+    for (; ; ) {
+      const item = queue.shift();
+      if (item === void 0) return;
+      await run2(item);
+    }
+  });
+  await Promise.all(workers);
+}
+async function reviewScript(opts) {
+  const started = Date.now();
+  const doc = parse(JSON.parse(fs5.readFileSync(opts.scriptPath, "utf8")));
+  const config = {
+    apiKey: opts.apiKey,
+    model: opts.model ?? "gemini-3.8-flash",
+    mediaModel: opts.mediaModel ?? opts.model ?? "gemini-3.8-flash",
+    ...opts.baseUrl ? { baseUrl: opts.baseUrl } : {},
+    maxSteps: opts.maxSteps ?? 60,
+    mediaBudget: opts.mediaBudget ?? 1,
+    timeoutMs: opts.episodeTimeoutMs ?? 8 * 6e4
+  };
+  const all = doc.episodes.map((ep) => ep.no);
+  const selected = opts.episodes?.length ? opts.episodes.filter((n) => all.includes(n)) : all;
+  const videos = opts.videos?.length ? opts.videos : episodeVideos(opts.source, doc.episodes.length);
+  const events = [];
+  const emit = (event) => {
+    events.push(event);
+    opts.onEvent?.(event);
+  };
+  const units = [];
+  await pool(selected, opts.concurrency ?? 5, async (episode) => {
+    const unit = await reviewUnit(doc, episode, videos[episode - 1], config);
+    units.push(unit);
+    emit({ type: "episode", ...unit });
+  });
+  if (opts.converge !== false) {
+    const unit = await reviewUnit(doc, 0, void 0, config);
+    units.push(unit);
+    emit({ type: "global", ...unit });
+  }
+  commit(doc, opts.scriptPath);
+  const usage_total = units.flatMap((unit) => unit.usage);
+  emit({
+    type: "done",
+    statistics: statistics(units),
+    usage_total,
+    wall_ms: Date.now() - started
+  });
+  return events;
+}
+export {
+  CATEGORIES,
+  CLIP_FPS,
+  CONFIDENCES,
+  EVIDENCE_KINDS,
+  FINDING_INPUT,
+  MAX_WINDOW_S,
+  OUTCOMES,
+  SUBJECT_KINDS,
+  anchorOf,
+  buildTools,
+  cutClip,
+  dispatcher,
+  episodeTask,
+  episodeVideos,
+  ffmpegArgs,
+  grabFrame,
+  neighbourSynopses,
+  newContext,
+  post,
+  proxyUrl,
+  reviewScript,
+  reviewUnit,
+  seconds,
+  seriesCard,
+  systemPrompt,
+  toFinding,
+  traceKey,
+  watchWindow
+};
+//# sourceMappingURL=review-agent.js.map