editorbrain 0.10.0 → 0.12.0

package/bin/editorbrain.mjs

@@ -30,6 +30,307 @@ function resolveMemory(files, p) {
   return { confirmed: entries.filter((e) => e.status === "confirmed"), pending: entries.filter((e) => e.status === "suggested").map(({ id, scope, scopeId }) => ({ id, scope, scopeId })), policy: "Apply only relevant confirmed preferences. Conditions and prose conflicts require agent judgment. Project-specific guidance precedes brand then style; required tokens still govern. Suggestions are not instructions. Provenance is a claim, not proof of human confirmation." };
 }
 
+// packages/core/src/style-authoring.ts
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nonempty = (value) => typeof value === "string" && !!value.trim();
+var identifier = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+var digest = /^[a-f0-9]{64}$/;
+var kinds = ["font", "audio", "image", "video", "editable", "script", "other"];
+var forbiddenText = /(?:\b[a-z][a-z0-9+.-]*:\/\/|\b(?:data|file|mailto):|\b(?:authorization|api[_ -]?key|access[_ -]?token|client[_ -]?secret|password)\s*[:=]|\bBearer\s+\S+|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
+function safeStyleResourcePath(path) {
+  if (typeof path !== "string" || !path || path.length > 400 || path !== path.trim() || /[\\\x00-\x1f\x7f%:?#]/.test(path) || path.startsWith("/") || path.startsWith("~")) throw new Error("Resource path must be a safe workspace-relative path");
+  const parts = path.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".." || part.length > 100 || /[. ]$/.test(part) || ["__proto__", "prototype", "constructor"].includes(part) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) throw new Error("Unsafe or nonportable resource path segment");
+  if (parts.some((part) => /^\.env(?:\.|$)/i.test(part) || /^(?:\.?credentials|secrets?|service[-_]account)(?:\.|$)/i.test(part) || [".git", ".ssh", ".aws", ".gnupg", ".sync.json", "id_rsa", "id_ed25519"].includes(part.toLowerCase()))) throw new Error("Credential and private configuration paths cannot be style resources");
+  return path;
+}
+function validateStyleResources(value, expectedId) {
+  const path = `.editorbrain/styles/${expectedId}/resources.json`;
+  const issues = [];
+  const add = (message) => issues.push({ path, message });
+  const fields = (entry, allowed, label) => {
+    if (Object.keys(entry).some((key) => !allowed.includes(key))) add(`${label} has unsupported fields; do not include URLs, credentials or hidden resource sources`);
+  };
+  const text2 = (value2, label) => {
+    if (!nonempty(value2)) add(`${label} must be nonempty text`);
+    else if (forbiddenText.test(value2) || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value2)) add(`${label} cannot contain URLs, credentials or control characters`);
+  };
+  if (!object(value)) return { valid: false, issues: [{ path, message: "Style resources must be a JSON object" }] };
+  fields(value, ["schemaVersion", "id", "resources"], "Style resources");
+  if (value.schemaVersion !== 1) add("schemaVersion must be 1");
+  if (!identifier.test(expectedId) || value.id !== expectedId) add(`Style resource id must match path: ${expectedId}`);
+  if (!Array.isArray(value.resources)) add("Style resources requires a resources array");
+  else {
+    const ids = /* @__PURE__ */ new Set();
+    for (const [index, resource] of value.resources.entries()) {
+      const label = `Resource ${index + 1}`;
+      if (!object(resource)) {
+        add(`${label} must be an object`);
+        continue;
+      }
+      fields(resource, ["id", "kind", "purpose", "required", "source"], label);
+      if (typeof resource.id !== "string" || !identifier.test(resource.id) || ["constructor", "prototype"].includes(resource.id)) add(`${label} requires a valid identifier`);
+      else if (ids.has(resource.id)) add(`Duplicate resource id: ${resource.id}`);
+      else ids.add(resource.id);
+      if (!kinds.includes(resource.kind)) add(`${label} has an invalid kind`);
+      text2(resource.purpose, `${label} purpose`);
+      if (typeof resource.required !== "boolean") add(`${label} required must be boolean`);
+      const source = resource.source;
+      if (!object(source)) {
+        add(`${label} source must be local, asset or requirement`);
+        continue;
+      }
+      if (source.type === "local") {
+        fields(source, ["type", "path", "sha256"], `${label} local source`);
+        try {
+          safeStyleResourcePath(source.path);
+        } catch (error) {
+          add(`${label}: ${error.message}`);
+        }
+        if (source.sha256 !== void 0 && (typeof source.sha256 !== "string" || !digest.test(source.sha256))) add(`${label} sha256 must be a 64-character lowercase hexadecimal digest`);
+      } else if (source.type === "asset") {
+        fields(source, ["type", "assetId"], `${label} asset source`);
+        if (typeof source.assetId !== "string" || !digest.test(source.assetId)) add(`${label} assetId must be a 64-character lowercase hexadecimal digest`);
+      } else if (source.type === "requirement") {
+        fields(source, ["type", "description"], `${label} requirement source`);
+        text2(source.description, `${label} requirement description`);
+      } else add(`${label} source must be local, asset or requirement`);
+    }
+  }
+  return { valid: issues.length === 0, issues };
+}
+function createStyle(options) {
+  const id = assertIdentifier(options.id);
+  const base = `.editorbrain/styles/${id}`;
+  safeDocumentPath(`${base}/style.json`);
+  const name = options.name ?? id;
+  if (!nonempty(name)) throw new Error("Style name must be nonempty text");
+  const style = { schemaVersion: 1, id, name, tokens: {}, references: [], components: [{ id: "editorial-mechanism", status: "concept" }] };
+  const resources = { schemaVersion: 1, id, resources: [] };
+  return {
+    [`${base}/style.json`]: stableJson(style),
+    [`${base}/style.md`]: `# ${name}
+
+STYLE_DRAFT
+
+Este documento es un borrador. Sustituye las preguntas por decisiones y evidencia; los componentes comienzan como concept.
+
+## Prop\xF3sito y encaje
+
+Describe qu\xE9 funci\xF3n cumple el estilo, para qu\xE9 material y audiencia encaja, qu\xE9 necesita y cu\xE1ndo no conviene usarlo.
+
+## Mecanismos que lo definen
+
+Explica c\xF3mo interact\xFAan narrativa, composici\xF3n, tipograf\xEDa, ritmo y sonido. Define qu\xE9 debe conservarse para reconocer el estilo y qu\xE9 se adapta a la marca, el guion y el footage real. No heredes una paleta, fuente o identidad personal por defecto.
+
+## T\xE9cnicas adaptables
+
+Para cada t\xE9cnica registra su funci\xF3n, requisitos, ancla de timing (voz, acci\xF3n, lectura o beat), par\xE1metros adaptables, cu\xE1ndo omitirla y c\xF3mo verificarla en el render. Los timestamps del piloto son evidencia localizada, no tiempos fijos para otro video. Detalla movimiento, estados y cobertura cuando sean relevantes.
+
+## Pilotos y evidencia
+
+Registra pilotos propios o referencias autorizadas en examples.json y referencias expl\xEDcitas en style.json. Separa observaci\xF3n, propuesta e inferencia; distingue revisi\xF3n de agente de revisi\xF3n humana. Documenta qu\xE9 mecanismo se prob\xF3, el material de destino, el resultado y las limitaciones. Una declaraci\xF3n transfer_tested no demuestra la prueba.
+
+## Recursos y l\xEDmites
+
+Declara recursos en resources.json con su prop\xF3sito, si son necesarios y una ruta relativa al workspace, un assetId permanente o un requisito pendiente. Describe permisos y sustitutos. No guardes URLs temporales ni credenciales. Un scaffold o chequeo estructural no valida calidad editorial ni disponibilidad remota.
+`,
+    [`${base}/examples.json`]: stableJson({ schemaVersion: 1, id, examples: [] }),
+    [`${base}/effects.md`]: "# Efectos y movimiento\n\nSTYLE_DRAFT\n\nPara cada t\xE9cnica define funci\xF3n, requisitos y evidencia del piloto; ancla entradas, estados, duraci\xF3n y salida a voz, acci\xF3n o tiempo de lectura del material real. Especifica qu\xE9 conservar, qu\xE9 adaptar, cu\xE1ndo omitir y c\xF3mo verificar movimiento, legibilidad y cobertura en el render. Separa lo observado de lo propuesto; no copies timestamps del piloto ni impongas efectos en cada beat. No deduzcas SFX a partir de im\xE1genes.\n",
+    [`${base}/music.md`]: "# M\xFAsica y sonido\n\nSTYLE_DRAFT\n\nDescribe funci\xF3n, energ\xEDa, instrumentaci\xF3n y uso del silencio seg\xFAn el relato. Ancla cambios a voz, acci\xF3n y beats reales; define cu\xE1ndo omitir m\xFAsica o SFX y c\xF3mo verificar inteligibilidad y mezcla escuchando el render. Separa sonidos corroborados de candidatos. Declara los recursos necesarios en resources.json y documenta su procedencia, licencia y sustitutos: una referencia no concede derechos de reutilizaci\xF3n.\n",
+    [`${base}/resources.json`]: stableJson(resources)
+  };
+}
+function checkStyle(files, id) {
+  const issues = [];
+  const warnings = [];
+  const manualChecks = [
+    "Review purpose, fit, defining mechanisms, what stays and what adapts against the actual destination material.",
+    "Inspect pilot evidence and its coverage; distinguish observations, proposals, agent review and human verification.",
+    "Preview the implemented edit: verify timing anchors, movement, legibility, audio and when each technique should be omitted.",
+    "Verify resource availability, local bytes, remote workspace authorization, provenance and reuse rights. Structural validation does not certify these."
+  ];
+  const finish2 = (documents2) => ({ valid: issues.length === 0, issues, warnings, documents: documents2, manualChecks });
+  const base = `.editorbrain/styles/${id}/`;
+  try {
+    assertIdentifier(id);
+    safeDocumentPath(`${base}style.json`);
+  } catch (error) {
+    issues.push({ path: base, message: error.message });
+    return finish2([]);
+  }
+  let selected;
+  try {
+    selected = canonicalFiles(Object.fromEntries(Object.entries(files).filter(([path]) => canonicalDocumentPath(path).startsWith(base))));
+  } catch (error) {
+    issues.push({ path: base, message: error.message });
+    return finish2([]);
+  }
+  const documents = Object.keys(selected).sort();
+  for (const name of ["style.json", "style.md", "examples.json"]) {
+    if (!own(selected, base + name)) issues.push({ path: base + name, message: "Missing required style document" });
+  }
+  for (const name of ["effects.md", "music.md"]) if (!own(selected, base + name)) warnings.push(`${base + name}: Optional guide is absent; document the relevant treatment before using this style.`);
+  for (const path of documents) {
+    const content = selected[path];
+    const result = validateDocument(path, content);
+    issues.push(...result.issues);
+    if (typeof content !== "string") continue;
+    if (!content.trim()) warnings.push(`${path}: Document is empty.`);
+    if (/^\s*(?:STYLE_DRAFT|DRAFT|TODO(?::[^\n]*)?)\s*$/m.test(content)) warnings.push(`${path}: Draft markers remain; complete the authored guidance before claiming readiness.`);
+    if (!result.valid || !path.endsWith(".json")) continue;
+    const doc = JSON.parse(content);
+    if (path === base + "examples.json") {
+      if (!Array.isArray(doc.examples)) issues.push({ path, message: "Style examples requires an examples array" });
+      else if (!doc.examples.length) warnings.push(`${path}: No pilot examples are recorded; evidence and transfer have not been assessed.`);
+      else warnings.push(`${path}: Example entries are preserved as descriptive data; this check cannot assess their evidence, review claims or transfer quality.`);
+    }
+    if (path === base + "style.json" && Array.isArray(doc.components)) {
+      for (const component of doc.components) {
+        if (component.status === "concept") warnings.push(`${path}: Component ${component.id} remains concept; implementation is pending.`);
+        if (component.status === "transfer_tested") warnings.push(`${path}: Component ${component.id} declares transfer_tested; the declaration is not proof of a tested transfer.`);
+      }
+    }
+    if (path === base + "resources.json") {
+      const resources = doc;
+      for (const resource of resources.resources) if (resource.source.type === "requirement") warnings.push(`${path}: Resource ${resource.id} is a requirement; availability has not been verified.`);
+    }
+  }
+  return finish2(documents);
+}
+
+// packages/core/src/production-plan.ts
+var record = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+var nonnegative = (v) => v === 0 || positive(v);
+var hash = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
+var text = (v) => typeof v === "string" && v.trim().length > 0 && v.length <= 2e3;
+var range = (v) => record(v) && nonnegative(v.startSeconds) && positive(v.endSeconds) && v.endSeconds > v.startSeconds;
+var MAX_ENTRIES = 2e3;
+function validateProductionPlan(value) {
+  const issues = [];
+  if (!record(value) || value.schemaVersion !== 1 || value.kind !== "editorbrain.production-plan") return { valid: false, issues: ["Expected schemaVersion 1 and kind editorbrain.production-plan."] };
+  if (Object.keys(value).some((key) => !["schemaVersion", "kind", "inspections", "uses"].includes(key))) issues.push("Unknown plan fields; keep editorial notes in direction.md and use the documented plan schema.");
+  if (!Array.isArray(value.inspections) || value.inspections.length > MAX_ENTRIES) issues.push("inspections must be an array of at most 2000 observations.");
+  else value.inspections.forEach((item, index) => {
+    const label = `inspections[${index}]`;
+    if (!record(item) || !hash(item.sourceSha256) || !["visual", "motion", "audio"].includes(String(item.modality)) || !["sampled_frames", "playback", "listening"].includes(String(item.method))) {
+      issues.push(`${label}: invalid source hash, modality or method.`);
+      return;
+    }
+    if (Object.keys(item).some((key) => !["sourceSha256", "modality", "method", "intervals", "sampledSeconds", "note"].includes(key))) issues.push(`${label}: unsupported field.`);
+    if (item.note !== void 0 && !text(item.note)) issues.push(`${label}: note must be nonempty text of at most 2000 characters.`);
+    if (item.method === "sampled_frames") {
+      if (item.modality !== "visual" || item.intervals !== void 0 || !Array.isArray(item.sampledSeconds) || !item.sampledSeconds.length || item.sampledSeconds.length > MAX_ENTRIES || !item.sampledSeconds.every(nonnegative)) issues.push(`${label}: sampled_frames requires visual modality and sampledSeconds; snapshots never establish continuous interval coverage.`);
+    } else {
+      if (item.sampledSeconds !== void 0 || !Array.isArray(item.intervals) || !item.intervals.length || item.intervals.length > MAX_ENTRIES || !item.intervals.every(range)) issues.push(`${label}: playback/listening requires valid intervals, not sampledSeconds.`);
+      if (item.method === "listening" && item.modality !== "audio" || item.method === "playback" && item.modality === "audio") issues.push(`${label}: listening covers audio; playback covers visual or motion. Record separately what was actually inspected.`);
+    }
+  });
+  if (!Array.isArray(value.uses) || value.uses.length > MAX_ENTRIES) issues.push("uses must be an array of at most 2000 source uses.");
+  else {
+    const ids = /* @__PURE__ */ new Set();
+    value.uses.forEach((item, index) => {
+      const label = `uses[${index}]`;
+      if (!record(item) || typeof item.id !== "string" || !/^[a-zA-Z0-9_-]{1,80}$/.test(item.id) || !hash(item.sourceSha256) || !range(item.source) || !range(item.timeline)) {
+        issues.push(`${label}: requires ID, source hash, source and timeline intervals.`);
+        return;
+      }
+      if (ids.has(item.id)) issues.push(`${label}: duplicate use ID ${item.id}.`);
+      ids.add(item.id);
+      if (Object.keys(item).some((key) => !["id", "sourceSha256", "source", "timeline", "purpose", "reuseReason"].includes(key))) issues.push(`${label}: unsupported field.`);
+      for (const key of ["purpose", "reuseReason"]) if (item[key] !== void 0 && !text(item[key])) issues.push(`${label}: ${key} must be nonempty text of at most 2000 characters.`);
+    });
+  }
+  return { valid: !issues.length, issues };
+}
+function mergeProductionIntervals(intervals) {
+  const merged = [];
+  for (const interval of [...intervals].sort((a, b) => a.startSeconds - b.startSeconds)) {
+    const last = merged.at(-1);
+    if (last && interval.startSeconds <= last.endSeconds) last.endSeconds = Math.max(last.endSeconds, interval.endSeconds);
+    else merged.push({ ...interval });
+  }
+  return merged;
+}
+function checkProductionPlan(inventory, value) {
+  const checked = validateProductionPlan(value);
+  const findings = checked.issues.map((message) => ({ code: "INVALID_PLAN", severity: "error", message }));
+  const sources = /* @__PURE__ */ new Map();
+  let inventoryComplete = true;
+  if (!record(inventory) || inventory.schemaVersion !== 1 || inventory.kind !== "editorbrain.media-inventory" || inventory.summary === true || typeof inventory.complete !== "boolean" || !Array.isArray(inventory.assets) || inventory.assets.length > 1e4) {
+    inventoryComplete = false;
+    findings.push({ code: "INVALID_INVENTORY", severity: "error", message: "Use the full schemaVersion 1 media inventory saved with --out, not compact stdout. It must declare complete." });
+  } else {
+    if (inventory.complete === false || Array.isArray(inventory.failures) && inventory.failures.length) {
+      inventoryComplete = false;
+      findings.push({ code: "INVENTORY_INCOMPLETE", severity: "warning", message: "Inventory traversal or probing was incomplete. This plan check covers only recorded assets." });
+    }
+    for (const asset of inventory.assets) {
+      if (!record(asset) || !hash(asset.sha256) || !(asset.durationSeconds === null || nonnegative(asset.durationSeconds)) || asset.streams !== void 0 && (!Array.isArray(asset.streams) || asset.streams.some((s) => !record(s) || typeof s.type !== "string"))) {
+        findings.push({ code: "INVALID_INVENTORY", severity: "error", message: "Inventory assets need a source hash, nonnegative duration or null, and valid optional streams." });
+        continue;
+      }
+      const existing = sources.get(asset.sha256);
+      if (existing && existing.durationSeconds !== asset.durationSeconds) findings.push({ code: "INVENTORY_CONFLICT", severity: "error", message: "The same content hash has conflicting durations.", sourceSha256: asset.sha256 });
+      sources.set(asset.sha256, asset);
+    }
+  }
+  if (findings.some((f) => f.severity === "error")) return { schemaVersion: 1, kind: "editorbrain.production-plan-check", valid: false, inventoryComplete, findings, coverage: [], sourceFilesReverified: false, quality: "not_assessed", observations: "agent_declared" };
+  const plan = value;
+  const sourceFor = (sourceSha256) => {
+    const source = sources.get(sourceSha256);
+    if (!source) findings.push({ code: "UNKNOWN_SOURCE", severity: "error", message: "A source hash is absent from the selected inventory. Refresh the inventory after changing media.", sourceSha256 });
+    return source;
+  };
+  const inBounds = (end, source) => source.durationSeconds === null || end <= source.durationSeconds + 1e-3;
+  for (const inspection of plan.inspections) {
+    const source = sourceFor(inspection.sourceSha256);
+    if (!source) continue;
+    if (source.streams && !source.streams.some((s) => s.type === (inspection.modality === "audio" ? "audio" : "video") && (inspection.modality !== "motion" || !s.attachedPicture))) findings.push({ code: "MODALITY_ABSENT", severity: "error", message: `Declared ${inspection.modality} inspection has no matching stream.`, sourceSha256: source.sha256 });
+    if ([...inspection.sampledSeconds ?? [], ...(inspection.intervals ?? []).map((r) => r.endSeconds)].some((end) => !inBounds(end, source))) findings.push({ code: "INSPECTION_OUT_OF_BOUNDS", severity: "error", message: "Inspection extends past the source duration.", sourceSha256: source.sha256 });
+  }
+  const validUses = [];
+  for (const use of plan.uses) {
+    const source = sourceFor(use.sourceSha256);
+    if (!source) continue;
+    if (!inBounds(use.source.endSeconds, source)) findings.push({ code: "USE_OUT_OF_BOUNDS", severity: "error", message: "Source interval extends past the source duration.", sourceSha256: source.sha256, useIds: [use.id], interval: use.source });
+    else validUses.push(use);
+  }
+  for (const use of validUses) {
+    const source = sources.get(use.sourceSha256);
+    const audioOnly = source.streams?.some((s) => s.type === "audio") && !source.streams.some((s) => s.type === "video" && !s.attachedPicture);
+    const inspected = mergeProductionIntervals(plan.inspections.filter((i) => i.sourceSha256 === source.sha256 && (audioOnly ? i.modality === "audio" : i.modality === "visual" || i.modality === "motion")).flatMap((i) => i.intervals ?? []).filter((r) => inBounds(r.endSeconds, source)));
+    const covered = inspected.reduce((sum, r) => sum + Math.max(0, Math.min(use.source.endSeconds, r.endSeconds) - Math.max(use.source.startSeconds, r.startSeconds)), 0);
+    const missing = use.source.endSeconds - use.source.startSeconds - covered;
+    if (missing > 1e-3) findings.push({ code: "USED_RANGE_COVERAGE_GAP", severity: source.durationSeconds === null ? "info" : "warning", message: `${Math.round(missing * 1e3) / 1e3}s of this source use lack declared continuous ${audioOnly ? "audio" : "visual/motion"} inspection. Review relevant content when needed; snapshots do not establish interval coverage. This is not a requirement to inspect every unused source.`, sourceSha256: source.sha256, useIds: [use.id], interval: use.source });
+  }
+  let repeatedPairs = 0;
+  for (let i = 0; i < validUses.length; i++) for (let j = i + 1; j < validUses.length; j++) {
+    const a = validUses[i], b = validUses[j];
+    if (a.sourceSha256 !== b.sourceSha256) continue;
+    const startSeconds = Math.max(a.source.startSeconds, b.source.startSeconds), endSeconds = Math.min(a.source.endSeconds, b.source.endSeconds);
+    if (endSeconds - startSeconds <= 1e-3) continue;
+    repeatedPairs++;
+    if (repeatedPairs <= 200) findings.push({ code: b.reuseReason ? "SOURCE_REUSE_EXPLAINED" : "SOURCE_REUSE_REVIEW", severity: b.reuseReason ? "info" : "warning", message: b.reuseReason ? `Declared reuse: ${b.reuseReason}` : "These uses overlap the same source interval. Review whether the callback, comparison or repeated action serves the edit.", sourceSha256: a.sourceSha256, useIds: [a.id, b.id], interval: { startSeconds, endSeconds } });
+  }
+  if (repeatedPairs > 200) findings.push({ code: "REUSE_DETAILS_LIMIT", severity: "info", message: `${repeatedPairs} repeated pairs detected; only the first 200 are detailed.` });
+  const coverage = [...sources.values()].map((source) => {
+    const byModality = ["visual", "motion", "audio"].map((modality) => {
+      const observations = plan.inspections.filter((i) => i.sourceSha256 === source.sha256 && i.modality === modality);
+      const intervals = mergeProductionIntervals(observations.flatMap((i) => i.intervals ?? []).filter((r) => inBounds(r.endSeconds, source)));
+      const seconds = intervals.reduce((sum, i) => sum + i.endSeconds - i.startSeconds, 0);
+      return { modality, intervals, seconds, fraction: !source.durationSeconds ? null : seconds / source.durationSeconds, sampledSeconds: [...new Set(observations.flatMap((i) => i.sampledSeconds ?? []))].sort((a, b) => a - b) };
+    });
+    const sourceUses = validUses.filter((use) => use.sourceSha256 === source.sha256);
+    if (!plan.inspections.some((i) => i.sourceSha256 === source.sha256)) findings.push({ code: sourceUses.length ? "USED_SOURCE_UNINSPECTED" : "SOURCE_UNINSPECTED", severity: sourceUses.length ? "warning" : "info", message: sourceUses.length ? "Used source has no declared content inspection; metadata is not content review." : "Source has no declared content inspection. Using every source is not required.", sourceSha256: source.sha256 });
+    if (source.durationSeconds === null) findings.push({ code: "DURATION_UNKNOWN", severity: "info", message: "Duration unknown; interval bounds and coverage fraction cannot be verified for this source.", sourceSha256: source.sha256 });
+    return { sourceSha256: source.sha256, durationSeconds: source.durationSeconds, uses: sourceUses.length, byModality };
+  });
+  return { schemaVersion: 1, kind: "editorbrain.production-plan-check", valid: !findings.some((f) => f.severity === "error"), inventoryComplete, findings, coverage, repeatedPairs, sourceFilesReverified: false, quality: "not_assessed", observations: "agent_declared" };
+}
+
 // packages/core/src/index.ts
 var SCHEMA_VERSION = 1;
 var MAX_DOCUMENT_BYTES = 128 * 1024;
@@ -41,15 +342,15 @@ var ValidationError = class extends Error {
   }
   issues;
 };
-var identifier = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+var identifier2 = /^[a-z0-9][a-z0-9_-]{0,79}$/;
 var tokenName = /^[a-z][a-z0-9_.-]{0,79}$/;
-var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-var nonempty = (value) => typeof value === "string" && value.trim().length > 0;
+var own2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var object2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nonempty2 = (value) => typeof value === "string" && value.trim().length > 0;
 var finite = (value) => typeof value === "number" && Number.isFinite(value);
 var tokenValue = (value) => typeof value === "string" || typeof value === "boolean" || finite(value) || Array.isArray(value) && value.every((v) => typeof v === "string");
 function assertIdentifier(value) {
-  if (!identifier.test(value)) throw new Error(`Invalid identifier: ${value}. Use lowercase letters, numbers, _ or - (max 80).`);
+  if (!identifier2.test(value)) throw new Error(`Invalid identifier: ${value}. Use lowercase letters, numbers, _ or - (max 80).`);
   return value;
 }
 function safeDocumentPath(path) {
@@ -61,13 +362,13 @@ function safeDocumentPath(path) {
   return path;
 }
 function checkRules(value, add) {
-  if (!object(value)) {
+  if (!object2(value)) {
     add("tokens must be an object");
     return;
   }
   for (const [key, rule] of Object.entries(value)) {
     if (!tokenName.test(key) || ["__proto__", "constructor", "prototype"].includes(key)) add(`Invalid semantic token ${key}`);
-    if (!object(rule) || !tokenValue(rule.value) || !["required", "preferred", "example"].includes(String(rule.strength))) add(`Token ${key} requires value and strength required/preferred/example`);
+    if (!object2(rule) || !tokenValue(rule.value) || !["required", "preferred", "example"].includes(String(rule.strength))) add(`Token ${key} requires value and strength required/preferred/example`);
   }
 }
 function checkEvidence(value, add) {
@@ -76,7 +377,7 @@ function checkEvidence(value, add) {
     return;
   }
   for (const ref of value) {
-    if (!object(ref) || !nonempty(ref.videoId) || !["reference_only", "licensed_asset", "owned_asset"].includes(String(ref.relationship))) add("Evidence must include videoId and explicit relationship");
+    if (!object2(ref) || !nonempty2(ref.videoId) || !["reference_only", "licensed_asset", "owned_asset"].includes(String(ref.relationship))) add("Evidence must include videoId and explicit relationship");
     else {
       if (ref.timestampSeconds !== void 0 && (!finite(ref.timestampSeconds) || ref.timestampSeconds < 0)) add("Evidence timestamp must be nonnegative seconds");
       if (ref.reviewStatus !== void 0 && !["unreviewed", "agent_reviewed", "human_verified"].includes(String(ref.reviewStatus))) add("Invalid evidence reviewStatus");
@@ -105,7 +406,7 @@ function validateDocument(path, content) {
     add("Invalid JSON");
     return { valid: false, issues };
   }
-  if (!object(doc)) {
+  if (!object2(doc)) {
     add("JSON document must be an object");
     return { valid: false, issues };
   }
@@ -119,38 +420,39 @@ function validateDocument(path, content) {
   const isMedia = parts[0] === "videos" && parts.length === 3 && parts[2] === "media.json";
   if (isBrand || isStyle || isProject || isOutput) {
     const expected = isOutput ? parts[2].slice(0, -5) : parts[isProject ? 1 : 2];
-    if (!identifier.test(expected)) add("Invalid resource identifier in path");
+    if (!identifier2.test(expected)) add("Invalid resource identifier in path");
     if (doc.id !== void 0 && doc.id !== expected) add(`Document id must match path: ${expected}`);
   }
+  if (isStyle && parts[3] === "resources.json") for (const issue of validateStyleResources(doc, parts[2]).issues) add(issue.message);
   if (isBrand && parts[3] === "tokens.json" || isStyle && parts[3] === "style.json") {
-    if (!nonempty(doc.id)) add("id is required");
+    if (!nonempty2(doc.id)) add("id is required");
     if (isBrand || doc.tokens !== void 0) checkRules(doc.tokens, add);
     if (isStyle) {
-      if (!nonempty(doc.name)) add("Style name is required");
+      if (!nonempty2(doc.name)) add("Style name is required");
       if (doc.references !== void 0) checkEvidence(doc.references, add);
-      if (doc.components !== void 0 && (!Array.isArray(doc.components) || doc.components.some((c) => !object(c) || !nonempty(c.id) || !["concept", "implemented", "transfer_tested"].includes(String(c.status))))) add("Components need id and explicit implementation status");
+      if (doc.components !== void 0 && (!Array.isArray(doc.components) || doc.components.some((c) => !object2(c) || !nonempty2(c.id) || !["concept", "implemented", "transfer_tested"].includes(String(c.status))))) add("Components need id and explicit implementation status");
     }
   }
   if (isProject) {
-    for (const key of ["id", "brand", "style", "outputProfile"]) if (typeof doc[key] !== "string" || !identifier.test(doc[key])) add(`${key} must be a valid identifier`);
-    if (!object(doc.intent) || !nonempty(doc.intent.topic) || !nonempty(doc.intent.goal)) add("intent requires topic and goal");
+    for (const key of ["id", "brand", "style", "outputProfile"]) if (typeof doc[key] !== "string" || !identifier2.test(doc[key])) add(`${key} must be a valid identifier`);
+    if (!object2(doc.intent) || !nonempty2(doc.intent.topic) || !nonempty2(doc.intent.goal)) add("intent requires topic and goal");
     if (doc.reviewMode !== void 0 && !["direct", "directions", "sample"].includes(doc.reviewMode)) add("reviewMode must be direct, directions or sample");
     if (doc.script !== void 0 && typeof doc.script !== "string") add("script must be text");
     if (doc.overrides !== void 0) {
-      if (!object(doc.overrides)) add("overrides must be an object");
+      if (!object2(doc.overrides)) add("overrides must be an object");
       else for (const [key, rule] of Object.entries(doc.overrides)) {
         if (!tokenName.test(key) || ["__proto__", "constructor", "prototype"].includes(key)) add(`Invalid override token ${key}`);
-        if (!object(rule) || !tokenValue(rule.value) || !nonempty(rule.reason) || rule.overrideRequired !== void 0 && typeof rule.overrideRequired !== "boolean") add(`Override ${key} requires value and a reason; overrideRequired must be boolean`);
+        if (!object2(rule) || !tokenValue(rule.value) || !nonempty2(rule.reason) || rule.overrideRequired !== void 0 && typeof rule.overrideRequired !== "boolean") add(`Override ${key} requires value and a reason; overrideRequired must be boolean`);
       }
     }
   }
   if (isMedia) {
-    if (!identifier.test(parts[1])) add("Invalid project identifier in media path");
+    if (!identifier2.test(parts[1])) add("Invalid project identifier in media path");
     if (!Array.isArray(doc.assets)) add("Production media requires an assets array");
     else {
       const ids = /* @__PURE__ */ new Set();
       for (const asset of doc.assets) {
-        if (!object(asset) || typeof asset.id !== "string" || !/^[a-f0-9]{64}$/.test(asset.id) || !nonempty(asset.name) || typeof asset.mimeType !== "string" || !/^(video|image|audio)\/[a-zA-Z0-9][a-zA-Z0-9.+-]*$/.test(asset.mimeType) || !Number.isSafeInteger(asset.bytes) || Number(asset.bytes) < 1) {
+        if (!object2(asset) || typeof asset.id !== "string" || !/^[a-f0-9]{64}$/.test(asset.id) || !nonempty2(asset.name) || typeof asset.mimeType !== "string" || !/^(video|image|audio)\/[a-zA-Z0-9][a-zA-Z0-9.+-]*$/.test(asset.mimeType) || !Number.isSafeInteger(asset.bytes) || Number(asset.bytes) < 1) {
           add("Production assets require a SHA-256 id, name, media mimeType and positive integer bytes");
           continue;
         }
@@ -160,11 +462,11 @@ function validateDocument(path, content) {
     }
   }
   if (isOutput) {
-    if (!nonempty(doc.id)) add("id is required");
+    if (!nonempty2(doc.id)) add("id is required");
     for (const key of ["width", "height"]) if (!Number.isInteger(doc[key]) || Number(doc[key]) < 1 || Number(doc[key]) > 16384) add(`${key} must be an integer between 1 and 16384`);
     if (!finite(doc.fps) || doc.fps <= 0 || doc.fps > 240) add("fps must be between 0 and 240");
     if (doc.safeAreas !== void 0) {
-      if (!object(doc.safeAreas) || ["top", "right", "bottom", "left"].some((k) => !finite(doc.safeAreas[k]) || Number(doc.safeAreas[k]) < 0 || Number(doc.safeAreas[k]) >= 0.5)) add("safeAreas must have normalized fractions from 0 up to (not including) 0.5 for all four sides");
+      if (!object2(doc.safeAreas) || ["top", "right", "bottom", "left"].some((k) => !finite(doc.safeAreas[k]) || Number(doc.safeAreas[k]) < 0 || Number(doc.safeAreas[k]) >= 0.5)) add("safeAreas must have normalized fractions from 0 up to (not including) 0.5 for all four sides");
     }
   }
   return { valid: issues.length === 0, issues };
@@ -185,7 +487,7 @@ function projectSources(project) {
   ];
 }
 function optionalProjectSources(project) {
-  return [`.editorbrain/brands/${project.brand}/design.md`, `.editorbrain/styles/${project.style}/effects.md`, `.editorbrain/styles/${project.style}/music.md`, `videos/${project.id}/media.json`, memoryPath("brand", project.brand), memoryPath("style", project.style), memoryPath("project", project.id)];
+  return [`.editorbrain/brands/${project.brand}/design.md`, `.editorbrain/styles/${project.style}/effects.md`, `.editorbrain/styles/${project.style}/music.md`, `videos/${project.id}/media.json`, memoryPath("brand", project.brand), memoryPath("style", project.style), memoryPath("project", project.id), `.editorbrain/styles/${project.style}/resources.json`];
 }
 function validateWorkspace(files) {
   files = canonicalFiles(files);
@@ -194,31 +496,31 @@ function validateWorkspace(files) {
   for (const [path, content] of Object.entries(files)) {
     if (!/^videos\/[^/]+\/project\.json$/.test(path) || !validateDocument(path, content).valid) continue;
     const project = JSON.parse(content);
-    for (const required of projectSources(project)) if (!own(files, required)) issues.push({ path, message: `Missing required source ${required}` });
+    for (const required of projectSources(project)) if (!own2(files, required)) issues.push({ path, message: `Missing required source ${required}` });
   }
   return { valid: issues.length === 0, issues };
 }
 function stableJson(value) {
-  const sort = (item) => Array.isArray(item) ? item.map(sort) : object(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, sort(item[key])])) : item;
+  const sort = (item) => Array.isArray(item) ? item.map(sort) : object2(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, sort(item[key])])) : item;
   return JSON.stringify(sort(value), null, 2) + "\n";
 }
 async function sha256(content) {
   const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
-  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
-  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+  const digest2 = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+  return Array.from(new Uint8Array(digest2), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 async function resolveProject(files, projectId) {
   files = canonicalFiles(files);
   assertIdentifier(projectId);
   const path = `videos/${projectId}/project.json`;
-  if (!own(files, path)) throw new ValidationError([{ path, message: "Project does not exist" }]);
+  if (!own2(files, path)) throw new ValidationError([{ path, message: "Project does not exist" }]);
   const basic = validateDocument(path, files[path]);
   if (!basic.valid) throw new ValidationError(basic.issues);
   const project = JSON.parse(files[path]);
   const requiredPaths = projectSources(project);
   const optionalPaths = optionalProjectSources(project);
-  const sourcePaths = [...requiredPaths, ...optionalPaths.filter((p) => own(files, p))];
-  const relevant = Object.fromEntries(sourcePaths.filter((p) => own(files, p)).map((p) => [p, files[p]]));
+  const sourcePaths = [...requiredPaths, ...optionalPaths.filter((p) => own2(files, p))];
+  const relevant = Object.fromEntries(sourcePaths.filter((p) => own2(files, p)).map((p) => [p, files[p]]));
   const validation = validateWorkspace(relevant);
   if (!validation.valid) throw new ValidationError(validation.issues);
   const [brandPath, tokensPath, languagePath, assetsPath, styleMdPath, stylePath, examplesPath, outputPath, , briefPath, directionPath] = requiredPaths;
@@ -259,11 +561,12 @@ async function resolveProject(files, projectId) {
     output: output2,
     tokens,
     tokenSources,
-    editorial: { brand: files[brandPath], style: files[styleMdPath], brief: files[briefPath], direction: files[directionPath], ...Object.fromEntries(["design", "effects", "music"].flatMap((key, index) => own(files, optionalPaths[index]) ? [[key, files[optionalPaths[index]]]] : [])) },
+    editorial: { brand: files[brandPath], style: files[styleMdPath], brief: files[briefPath], direction: files[directionPath], ...Object.fromEntries(["design", "effects", "music"].flatMap((key, index) => own2(files, optionalPaths[index]) ? [[key, files[optionalPaths[index]]]] : [])) },
     language: JSON.parse(files[languagePath]),
     brandAssets: JSON.parse(files[assetsPath]),
     examples: JSON.parse(files[examplesPath]),
-    ...own(files, optionalPaths[3]) ? { media: JSON.parse(files[optionalPaths[3]]) } : {},
+    ...own2(files, optionalPaths[3]) ? { media: JSON.parse(files[optionalPaths[3]]) } : {},
+    ...own2(files, optionalPaths[7]) ? { styleResources: JSON.parse(files[optionalPaths[7]]) } : {},
     memory: resolveMemory(files, project),
     evidence: style.references ?? [],
     warnings,
@@ -282,6 +585,10 @@ ${content}` : "";
 
 \`\`\`json
 ${stableJson(resolved.media)}\`\`\``) : "";
+  const resourcesSection = resolved.styleResources ? section("Style resources", `Resolve local paths from the original workspace root; asset IDs require authorized workspace access. Availability and reuse rights must be verified before use.
+
+\`\`\`json
+${stableJson(resolved.styleResources)}\`\`\``) : "";
   if (adapter === "neutral") return { ...common, "brief.md": `# ${resolved.project.id}
 
 ${disclaimer}
@@ -298,7 +605,7 @@ ${resolved.editorial.brand}
 
 ## Style
 
-${resolved.editorial.style}${section("Design", resolved.editorial.design)}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}
+${resolved.editorial.style}${section("Design", resolved.editorial.design)}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}${resourcesSection}
 
 Exact tokens, output settings and evidence are in resolved.json.
 ` };
@@ -326,13 +633,13 @@ ${resolved.editorial.direction}
 
 ## Style intent
 
-${resolved.editorial.style}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}
+${resolved.editorial.style}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}${resourcesSection}
 
 ## Delivery
 
 ${resolved.output.width} \xD7 ${resolved.output.height}, ${resolved.output.fps} fps. Adapt composition to the actual material and safe areas in resolved.json. Implement and preview the composition in Hyperframes before claiming completion.
 ` };
-  if (adapter === "remotion") return { ...common, "remotion-plan.json": stableJson({ schemaVersion: 1, kind: "editorial_handoff", renderer: "remotion", executable: false, note: disclaimer, composition: { width: resolved.output.width, height: resolved.output.height, fps: resolved.output.fps, durationInFrames: null }, tokens: resolved.tokens, project: resolved.project, direction: resolved.editorial.direction, editorial: resolved.editorial, ...resolved.media ? { media: resolved.media } : {}, evidence: resolved.evidence, implementationTasks: ["Determine duration from the script/audio and actual cuts.", "Implement React composition and assets.", "Preview and verify typography, safe areas, motion and audio."] }) };
+  if (adapter === "remotion") return { ...common, "remotion-plan.json": stableJson({ schemaVersion: 1, kind: "editorial_handoff", renderer: "remotion", executable: false, note: disclaimer, composition: { width: resolved.output.width, height: resolved.output.height, fps: resolved.output.fps, durationInFrames: null }, tokens: resolved.tokens, project: resolved.project, direction: resolved.editorial.direction, editorial: resolved.editorial, ...resolved.media ? { media: resolved.media } : {}, ...resolved.styleResources ? { styleResources: resolved.styleResources } : {}, evidence: resolved.evidence, implementationTasks: ["Determine duration from the script/audio and actual cuts.", "Implement React composition and assets.", "Preview and verify typography, safe areas, motion and audio."] }) };
   throw new Error(`Unsupported adapter: ${adapter}`);
 }
 function createWorkspace(options = {}) {
@@ -672,11 +979,11 @@ async function pushWorkspace(client, root, files, options = {}) {
   for (const [path, content] of Object.entries(files)) {
     const validation = validateDocument(path, content);
     if (!validation.valid) throw new Error(validation.issues.map((x) => `${x.path}: ${x.message}`).join("\n"));
-    const digest = await sha256(content);
+    const digest2 = await sha256(content);
     const existing = remote.get(path);
     const base = state.documents[path];
-    if (existing?.sha256 === digest) {
-      state.documents[path] = { revision: existing.revision, sha256: digest };
+    if (existing?.sha256 === digest2) {
+      state.documents[path] = { revision: existing.revision, sha256: digest2 };
       unchanged++;
       continue;
     }
@@ -697,8 +1004,8 @@ ${conflicts.join("\n")}`, "Run push --dry-run and reconcile the reported paths."
   for (const item of pending) {
     const result = await client.put(item.path, item.content, item.expectedRevision);
     checkRemote(result);
-    const digest = await sha256(item.content);
-    if (result.path !== item.path || result.sha256 !== digest) throw new Error("Server returned inconsistent write metadata");
+    const digest2 = await sha256(item.content);
+    if (result.path !== item.path || result.sha256 !== digest2) throw new Error("Server returned inconsistent write metadata");
     state.documents[item.path] = { revision: result.revision, sha256: result.sha256 };
     uploaded.push(item.path);
     await saveSyncState(root, state);
@@ -716,14 +1023,14 @@ async function pullWorkspace(client, root, local, options = {}) {
   for (const summary of summaries) {
     checkRemote(summary);
     const content = local[summary.path];
-    const digest = content === void 0 ? void 0 : await sha256(content);
+    const digest2 = content === void 0 ? void 0 : await sha256(content);
     const base = state.documents[summary.path];
-    if (digest === summary.sha256) {
+    if (digest2 === summary.sha256) {
       state.documents[summary.path] = { revision: summary.revision, sha256: summary.sha256 };
       unchanged++;
       continue;
     }
-    if (content !== void 0 && (!base || digest !== base.sha256)) {
+    if (content !== void 0 && (!base || digest2 !== base.sha256)) {
       conflicts.push(summary.path);
       continue;
     }
@@ -809,7 +1116,7 @@ import { createHash } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { lstat as lstat2, open as open2, readdir as readdir2, rename as rename2 } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-var previousSkillHashes = { "SKILL.md": ["9df2c89deeec30ddf556c359027efe1d90e6b4e9c08717cd8827e210b38a187f", "67b157cb45cae3621e6f2c43235c1d69907ad6abd45ab6b52a3c65f236732db9", "1e2fff65a1b303b18b2d65156bef6eb2439a19d77ba2a25b37bcb1819ff009e3", "dacce1c4127f4281df6f7e1681e243444bb6f8a8e74b829e52ee0108c6672348"], "AGENTS.md": ["4f3ef860ade3a31aa7c6a6aab5cf6ec2a700850bf19ea2320324c12c2e0fbf5b", "1b07de01698a0040b47ea0eddb1b017f70a69e81acd0bf9710647ca5e02f5125", "b5ee3439ff974c668755816149fab76899d7ad9266f63978b30fbc9b7d2cd640", "bacedb7bdedab5abe75c9601717cfdb05a96208fa2e2a42af878e2dfd2ae4251"], "references/cli-mcp.md": ["5d3a79343fbd76cdae5bdbe12fb9c944d5dff4f489ac6534fd96e0cb8630b988", "8e011c31368cef2117a28ee972b39aab9535eeb0f601a4a0f9d6fc019b22c1c2", "666082653efc000f8a7cc5f1836c80bbdda5f0f57cdbbdcb393f2b84aeb93a01", "78b737796a8685b1135e0acb91b620c51845b62e31dba04eb51dd9dd38b41008", "8b2e01bfd937237919f5ade794eed01dc6e32b556ede9de3a0ccc28cbdd988d1"], "references/production-and-review.md": ["055c6df9e0f167be148b0a5c0bba5b43e108eb1f58f478d88b3536c6589ac7b3"], "references/workspace-files.md": ["e72af2871f42cd776be1bfff8009ed5562780e7f8a65b12c27887f3880631f81", "00780c64bd0244c6afb18d786b7512b43e315c376e8f88c67d6ba53d91275ccf", "97053b092e0ff36e3cfb764095fcb4a4fca94e722567e774b53bc118279f40e5", "70fc660e7ed3d70c16c33c62c8e0399b99c3251808f093ef3d4ea5e8d39e4c8a"] };
+var previousSkillHashes = { "SKILL.md": ["9df2c89deeec30ddf556c359027efe1d90e6b4e9c08717cd8827e210b38a187f", "67b157cb45cae3621e6f2c43235c1d69907ad6abd45ab6b52a3c65f236732db9", "1e2fff65a1b303b18b2d65156bef6eb2439a19d77ba2a25b37bcb1819ff009e3", "dacce1c4127f4281df6f7e1681e243444bb6f8a8e74b829e52ee0108c6672348", "09740ab4b275eada65b5040ae6000104ff39094f534a2784e67feb2afc2a59b3", "f18269ad5504fff8a4fc522d463483261f5041e56cb7f1081f9614bc67e0d96f"], "AGENTS.md": ["4f3ef860ade3a31aa7c6a6aab5cf6ec2a700850bf19ea2320324c12c2e0fbf5b", "1b07de01698a0040b47ea0eddb1b017f70a69e81acd0bf9710647ca5e02f5125", "b5ee3439ff974c668755816149fab76899d7ad9266f63978b30fbc9b7d2cd640", "bacedb7bdedab5abe75c9601717cfdb05a96208fa2e2a42af878e2dfd2ae4251", "ea3b473179857ccc07e9e4f21a6ede9e0906a09e495f4a051069d15aee1556cd", "faa2bba99ae3023be7f588d02177a4abf583d3a8a65f617b8cff7a3ceed09dfc"], "references/cli-mcp.md": ["5d3a79343fbd76cdae5bdbe12fb9c944d5dff4f489ac6534fd96e0cb8630b988", "8e011c31368cef2117a28ee972b39aab9535eeb0f601a4a0f9d6fc019b22c1c2", "666082653efc000f8a7cc5f1836c80bbdda5f0f57cdbbdcb393f2b84aeb93a01", "78b737796a8685b1135e0acb91b620c51845b62e31dba04eb51dd9dd38b41008", "8b2e01bfd937237919f5ade794eed01dc6e32b556ede9de3a0ccc28cbdd988d1", "ca88b2816a795a5ebe834074b178469367634b80ad837e3697182ea585af1c05", "490daf154b428b536d0a6f590030c854b2fc8ca6adb995c6ecd5a162f85e471e"], "references/production-and-review.md": ["055c6df9e0f167be148b0a5c0bba5b43e108eb1f58f478d88b3536c6589ac7b3"], "references/workspace-files.md": ["e72af2871f42cd776be1bfff8009ed5562780e7f8a65b12c27887f3880631f81", "00780c64bd0244c6afb18d786b7512b43e315c376e8f88c67d6ba53d91275ccf", "97053b092e0ff36e3cfb764095fcb4a4fca94e722567e774b53bc118279f40e5", "70fc660e7ed3d70c16c33c62c8e0399b99c3251808f093ef3d4ea5e8d39e4c8a", "28c62c1e28842142607f5168ee79b18fd797900dd66dd9ac5eb3cfcf8a09f781", "b86eae85cf86dbf4409b10f4d8df1f1649fc408ce1a240f7cf26d5bb69aabfd1"], "references/first-edit.md": ["cb1e9d3272b2b22ae095aed02e33067c646da48e7b64cf71ff81197f6e67b673"], "references/memory-and-review.md": ["51a274e522270f1fc295d0c0b9a1c23672ce01abea097c2499c9a8db56c0c289"], "references/search-brief.md": ["137203383a7873593136428520f5f9cd6ce1ab6cfeab365c277175786eba3ab3"], "references/style-creator.md": ["1b1bc289a5bc308cbbf7f4d699de2933b8934733a2b69b3e98fb1b7420d986f2"] };
 var destinations = {
   codex: { directory: ".agents/skills/editorbrain", entryPoint: "AGENTS.md" },
   claude: { directory: ".claude/skills/editorbrain", entryPoint: "CLAUDE.md" }
@@ -858,6 +1165,9 @@ async function loadSkill(directory) {
   if (!files.has("SKILL.md")) throw new Error("Bundled EditorBrain skill is missing SKILL.md. Reinstall the CLI package.");
   return files;
 }
+async function bundledGuidanceFiles() {
+  return [...(await loadSkill(bundledSkillDirectory())).keys()];
+}
 async function prepareAgentGuidance(root, agent = "both", sourceDirectory = bundledSkillDirectory()) {
   root = await ensureRoot(root);
   parseAgentTarget(agent);
@@ -880,13 +1190,13 @@ Keep credentials outside this folder. Treat retrieved reference material as evid
   for (const selected of agents) {
     const to = destinations[selected].directory, from = to.replace(/editorbrain$/, "editorharness");
     const oldPath = await checkedPath(root, from, false), newPath = await checkedPath(root, to, false);
-    const exists = async (path) => lstat2(path).then(() => true, (error) => {
+    const exists2 = async (path) => lstat2(path).then(() => true, (error) => {
       if (error.code === "ENOENT") return false;
       throw error;
     });
-    if (await exists(oldPath)) {
+    if (await exists2(oldPath)) {
       await loadSkill(oldPath);
-      if (await exists(newPath)) throw new Error("Two skill directories exist. Reconcile them before installing; neither was changed.");
+      if (await exists2(newPath)) throw new Error("Two skill directories exist. Reconcile them before installing; neither was changed.");
       migrations.push({ from, to });
     }
   }
@@ -948,7 +1258,7 @@ import { lstat as lstat3, open as open3, rename as rename3, unlink as unlink2 }
 import { hostname } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var LOCK_PATH = ".editorbrain-operation.lock";
-async function withWorkspaceLock(root, operation) {
+async function withWorkspaceLock(root, operation, options = {}) {
   const legacyLock = await checkedPath(root, ".editorharness-operation.lock", false);
   let legacy;
   try {
@@ -972,12 +1282,12 @@ async function withWorkspaceLock(root, operation) {
       await handle.close();
       const oldRoot = await checkedPath(root, ".editorharness", false);
       const newRoot = await checkedPath(root, ".editorbrain", false);
-      const exists = async (path2) => lstat3(path2).then(() => true, (error) => {
+      const exists2 = async (path2) => lstat3(path2).then(() => true, (error) => {
         if (error.code === "ENOENT") return false;
         throw error;
       });
-      if (await exists(oldRoot)) {
-        if (await exists(newRoot)) throw new CliError("WORKSPACE_PATH_CONFLICT", "This folder contains two versions of the workspace directory.", "Reconcile the directories before continuing; neither was changed.");
+      if (options.migrateLegacy !== false && await exists2(oldRoot)) {
+        if (await exists2(newRoot)) throw new CliError("WORKSPACE_PATH_CONFLICT", "This folder contains two versions of the workspace directory.", "Reconcile the directories before continuing; neither was changed.");
         await rename3(oldRoot, newRoot);
       }
       return await operation();
@@ -999,7 +1309,6 @@ async function cliVersion() {
   const metadata = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
   return metadata.version;
 }
-var guidanceFiles = ["SKILL.md", "AGENTS.md", "references/cli-mcp.md", "references/production-and-review.md", "references/workspace-files.md"];
 async function diagnose(options, fetcher = fetch) {
   const checks = [];
   let root;
@@ -1027,7 +1336,7 @@ async function diagnose(options, fetcher = fetch) {
       const directory = agent === "codex" ? ".agents/skills/editorbrain" : ".claude/skills/editorbrain";
       let different = false;
       try {
-        for (const file of guidanceFiles) {
+        for (const file of await bundledGuidanceFiles()) {
           const current = await readText(root, `${directory}/${file}`, false);
           const bundled = await readFile(resolve2(bundledSkillDirectory(), file), "utf8");
           if (current !== bundled) different = true;
@@ -1099,7 +1408,7 @@ async function configureMcp(agent, directory, url, noBrowser, runner = runHost)
   const version = await runner(agent, ["--version"], directory);
   if (version.code !== 0) throw new CliError("AGENT_UNAVAILABLE", `${agent} CLI is unavailable.`, "Install the official agent CLI, or use setup --skip-mcp.");
   const inspect = await runner(agent, agent === "codex" ? ["mcp", "list", "--json"] : ["mcp", "get", "editorbrain"], directory);
-  let exists = false;
+  let exists2 = false;
   if (agent === "codex") {
     if (inspect.code !== 0) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Codex MCP configuration.", "Inspect it manually; setup did not overwrite it.");
     let list;
@@ -1109,12 +1418,12 @@ async function configureMcp(agent, directory, url, noBrowser, runner = runHost)
       throw new CliError("MCP_INSPECTION_FAILED", "Codex returned an unsupported configuration format.", "Inspect MCP configuration manually.");
     }
     if (!Array.isArray(list)) throw new CliError("MCP_INSPECTION_FAILED", "Unsupported MCP configuration response.", "Inspect MCP configuration manually.");
-    exists = list.some((item) => item?.name === "editorbrain");
+    exists2 = list.some((item) => item?.name === "editorbrain");
   } else {
-    exists = inspect.code === 0;
-    if (!exists && !/^No MCP server named "editorbrain"[.\s]/.test(inspect.stderr + inspect.stdout)) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Claude MCP configuration.", "Inspect it manually; setup did not overwrite it.");
+    exists2 = inspect.code === 0;
+    if (!exists2 && !/^No MCP server named "editorbrain"[.\s]/.test(inspect.stderr + inspect.stdout)) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Claude MCP configuration.", "Inspect it manually; setup did not overwrite it.");
   }
-  if (exists) return { agent, status: "preserved", next: "An existing editorbrain server was preserved. Check its endpoint and authentication, then " + next, hostVerified: false };
+  if (exists2) return { agent, status: "preserved", next: "An existing editorbrain server was preserved. Check its endpoint and authentication, then " + next, hostVerified: false };
   const added = await runner(agent, args, directory, true);
   return { agent, status: added.code === 0 ? "registered" : "action_required", next, hostVerified: false };
 }
@@ -1169,10 +1478,10 @@ async function setup(options, runner = runHost) {
 }
 
 // packages/cli/src/index.ts
-import { chmod, lstat as lstat4, mkdir as mkdir2, open as open4 } from "node:fs/promises";
-import { constants as constants4 } from "node:fs";
+import { chmod, lstat as lstat7, mkdir as mkdir5, open as open7 } from "node:fs/promises";
+import { constants as constants7 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname as dirname2, extname, join as join2, resolve as resolve4 } from "node:path";
+import { basename as basename2, dirname as dirname6, extname as extname3, join as join3, resolve as resolve6 } from "node:path";
 
 // packages/cli/src/device-auth.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -1193,12 +1502,12 @@ function browserCommand(url, platform = process.platform) {
 }
 async function openSystemBrowser(url) {
   const { command, args } = browserCommand(url);
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve7, reject) => {
     const child = spawn2(command, args, { shell: false, stdio: "ignore", detached: true, windowsHide: true });
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve5();
+      resolve7();
     });
   });
 }
@@ -1211,7 +1520,7 @@ function expired() {
 function invalid() {
   return new DeviceLoginError("invalid_response", "The authorization server returned an invalid response. No credential was saved.");
 }
-function record(value) {
+function record2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function abortCheck(signal) {
@@ -1259,11 +1568,11 @@ async function responseJson(response) {
   }
 }
 function sessionFrom(value) {
-  if (!record(value) || typeof value.deviceCode !== "string" || !/^[a-zA-Z0-9._~-]{16,1024}$/.test(value.deviceCode) || typeof value.userCode !== "string" || !/^[A-Z0-9-]{4,32}$/.test(value.userCode) || typeof value.verificationUri !== "string" || !Number.isInteger(value.expiresIn) || Number(value.expiresIn) < 1 || Number(value.expiresIn) > 3600 || !Number.isInteger(value.interval) || Number(value.interval) < 1 || Number(value.interval) > 60) throw invalid();
+  if (!record2(value) || typeof value.deviceCode !== "string" || !/^[a-zA-Z0-9._~-]{16,1024}$/.test(value.deviceCode) || typeof value.userCode !== "string" || !/^[A-Z0-9-]{4,32}$/.test(value.userCode) || typeof value.verificationUri !== "string" || !Number.isInteger(value.expiresIn) || Number(value.expiresIn) < 1 || Number(value.expiresIn) > 3600 || !Number.isInteger(value.interval) || Number(value.interval) < 1 || Number(value.interval) > 60) throw invalid();
   return { deviceCode: value.deviceCode, userCode: value.userCode, verificationUri: verificationUrl(value.verificationUri, value.userCode, value.deviceCode), expiresIn: Number(value.expiresIn), interval: Number(value.interval) };
 }
 function authorizationFrom(value) {
-  if (!record(value) || typeof value.apiKey !== "string" || !/^eh_[a-f0-9]{64}$/.test(value.apiKey) || value.role !== "editor" || !record(value.workspace) || typeof value.workspace.id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(value.workspace.id) || typeof value.workspace.name !== "string" || !value.workspace.name.trim() || value.workspace.name.length > 100) throw invalid();
+  if (!record2(value) || typeof value.apiKey !== "string" || !/^eh_[a-f0-9]{64}$/.test(value.apiKey) || value.role !== "editor" || !record2(value.workspace) || typeof value.workspace.id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(value.workspace.id) || typeof value.workspace.name !== "string" || !value.workspace.name.trim() || value.workspace.name.length > 100) throw invalid();
   return { apiKey: value.apiKey, workspace: { id: value.workspace.id, name: value.workspace.name }, role: "editor" };
 }
 async function loginWithDevice(options, overrides = {}) {
@@ -1287,7 +1596,7 @@ async function loginWithDevice(options, overrides = {}) {
       throw new DeviceLoginError("network_error", "The authorization server could not be reached. No credential was saved.");
     }
   };
-  const parse = async (response) => {
+  const parse2 = async (response) => {
     try {
       return await responseJson(response);
     } catch (error) {
@@ -1299,7 +1608,7 @@ async function loginWithDevice(options, overrides = {}) {
   };
   const started = await post("/v1/auth/device", {});
   if (started.status !== 200 && started.status !== 201) throw new DeviceLoginError("server_error", `Could not start browser authorization (HTTP ${started.status}).`);
-  const session = sessionFrom(await parse(started));
+  const session = sessionFrom(await parse2(started));
   deadline = Math.min(deadline, runtime.now() + session.expiresIn * 1e3);
   const { deviceCode, ...challenge } = session;
   options.onChallenge?.(challenge);
@@ -1326,7 +1635,7 @@ async function loginWithDevice(options, overrides = {}) {
     if (runtime.now() >= deadline) throw expired();
     const response = await post("/v1/auth/device/token", { deviceCode });
     if (response.status === 200) {
-      const result = authorizationFrom(await parse(response));
+      const result = authorizationFrom(await parse2(response));
       abortCheck(options.signal);
       return result;
     }
@@ -1374,6 +1683,902 @@ async function prepareDirectionContext(root, client, projectId) {
   };
 }
 
+// packages/cli/src/style-authoring.ts
+import { createHash as createHash2 } from "node:crypto";
+import { constants as constants4 } from "node:fs";
+import { lstat as lstat4, mkdir as mkdir2, open as open4, readdir as readdir3, rmdir, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+function styleId(id) {
+  try {
+    return assertIdentifier(id);
+  } catch {
+    throw new CliError("INVALID_ARGUMENT", "A style ID must use lowercase letters, numbers, _ or - (1\u201380 characters).", "Use styles create <style-id> or styles check <style-id>.");
+  }
+}
+async function exists(path) {
+  try {
+    await lstat4(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function preflightCreate(root, id, files) {
+  for (const prefix of [".editorbrain", ".editorharness"]) {
+    const path = `${prefix}/styles/${id}`;
+    if (await exists(await checkedPath(root, path, false))) {
+      throw new CliError("STYLE_EXISTS", `Style ${id} already exists in this workspace.`, "Choose a new style ID or edit the existing style documents; creation never replaces a style.");
+    }
+  }
+  if (await exists(await checkedPath(root, ".editorharness", false))) {
+    throw new CliError("WORKSPACE_PATH_CONFLICT", "This workspace still has a legacy portable directory.", "Migrate it using the existing workspace pull flow, or create the style in a separate folder. No style or project was changed.");
+  }
+  for (const path of Object.keys(files)) {
+    if (!path.startsWith(`.editorbrain/styles/${id}/`)) throw new Error("Style template escaped its destination");
+    const target = await checkedPath(root, path);
+    if (await exists(target)) throw new CliError("STYLE_EXISTS", `Refusing to replace existing file: ${path}`, "Choose a new style ID.");
+  }
+}
+async function makeDirectories(root, path, created) {
+  const segments = path.split("/");
+  for (let i = 1; i <= segments.length; i++) {
+    const relative2 = segments.slice(0, i).join("/");
+    const target = await checkedPath(root, relative2, false);
+    try {
+      await mkdir2(target);
+      const info = await lstat4(target);
+      created.push({ path: relative2, dev: info.dev, ino: info.ino });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (!(await lstat4(await checkedPath(root, relative2, false))).isDirectory()) throw new Error(`Not a directory: ${relative2}`);
+    }
+  }
+}
+async function cleanCreated(root, paths, directory) {
+  for (const item of [...paths].reverse()) {
+    try {
+      const target = await checkedPath(root, item.path, false);
+      const info = await lstat4(target);
+      if (info.dev !== item.dev || info.ino !== item.ino || info.isSymbolicLink()) continue;
+      if (directory) await rmdir(target);
+      else await unlink3(target);
+    } catch {
+    }
+  }
+}
+async function createLocalStyle(options) {
+  const id = styleId(options.id);
+  if (options.name !== void 0 && (!options.name.trim() || options.name.length > 200 || /[\x00-\x1f\x7f]/.test(options.name))) {
+    throw new CliError("INVALID_ARGUMENT", "--name must contain 1\u2013200 characters without control characters.", "Use a short, descriptive style name.");
+  }
+  const files = createStyle({ id, name: options.name });
+  const root = await ensureRoot(options.directory, true);
+  await preflightCreate(root, id, files);
+  return withWorkspaceLock(root, async () => {
+    await preflightCreate(root, id, files);
+    const createdFiles = [];
+    const createdDirectories = [];
+    try {
+      for (const [path, content] of Object.entries(files)) {
+        await makeDirectories(root, dirname2(path), createdDirectories);
+        const target = await checkedPath(root, path);
+        const handle = await open4(target, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 420);
+        try {
+          const info = await handle.stat();
+          createdFiles.push({ path, dev: info.dev, ino: info.ino });
+          await handle.writeFile(content, "utf8");
+        } finally {
+          await handle.close();
+        }
+      }
+    } catch (error) {
+      await cleanCreated(root, createdFiles, false);
+      await cleanCreated(root, createdDirectories, true);
+      throw error;
+    }
+    return {
+      root,
+      id,
+      status: "draft",
+      created: Object.keys(files),
+      mediaUploaded: false,
+      next: `Read references/style-creator.md in the EditorBrain skill. Edit .editorbrain/styles/${id}/style.md, effects.md, music.md, resources.json and examples.json, and document evidence actually reviewed; then run editorbrain styles check ${id} --dir <workspace>. Assess adaptation using the actual material in the next requested edit; structural checks do not assess editorial quality.`
+    };
+  }, { migrateLegacy: false });
+}
+async function readStyle(root, id) {
+  const files = /* @__PURE__ */ Object.create(null);
+  const issues = [];
+  const directories = [];
+  for (const prefix of [".editorbrain", ".editorharness"]) {
+    const path = `${prefix}/styles/${id}`;
+    try {
+      const target = await checkedPath(root, path, false);
+      if (!await exists(target)) continue;
+      if (!(await lstat4(target)).isDirectory()) {
+        issues.push({ path, message: "Style path is not a directory." });
+        continue;
+      }
+      directories.push(path);
+      const entries = await readdir3(target, { withFileTypes: true });
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!/\.(json|md)$/.test(entry.name)) continue;
+        const document = `${path}/${entry.name}`;
+        if (!entry.isFile()) {
+          issues.push({ path: document, message: "Style document must be a regular file, not a symlink or directory." });
+          continue;
+        }
+        try {
+          files[document] = await readText(root, document);
+        } catch (error) {
+          issues.push({ path: document, message: `Cannot safely read style document: ${error.message}` });
+        }
+      }
+    } catch (error) {
+      issues.push({ path, message: `Cannot safely read style directory: ${error.message}` });
+    }
+  }
+  if (directories.length > 1) issues.push({ path: `.editorbrain/styles/${id}`, message: "Style exists in both current and legacy directories. Reconcile the duplicate before checking it." });
+  return { files, issues };
+}
+async function checkLocalResource(root, path, expected) {
+  safeStyleResourcePath(path);
+  const target = await checkedPath(root, path, false);
+  const handle = await open4(target, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile()) throw new Error("Resource is not a regular file.");
+    if (!expected) return {};
+    const hash2 = createHash2("sha256");
+    for await (const chunk of handle.createReadStream({ autoClose: false })) hash2.update(chunk);
+    const after = await handle.stat();
+    const current = await lstat4(await checkedPath(root, path, false));
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || current.dev !== before.dev || current.ino !== before.ino) {
+      throw new Error("Resource changed while its hash was being checked; check it again.");
+    }
+    return { actualSha256: hash2.digest("hex") };
+  } finally {
+    await handle.close();
+  }
+}
+async function checkLocalStyle(options) {
+  const id = styleId(options.id);
+  const root = await ensureRoot(options.directory);
+  const local = await readStyle(root, id);
+  const structural = checkStyle(local.files, id);
+  const localIssues = [...local.issues];
+  const warnings = [...structural.warnings];
+  const resources = [];
+  const resourcePath = Object.keys(local.files).find((path) => path.endsWith("/resources.json"));
+  let document;
+  if (resourcePath) {
+    try {
+      const parsed = JSON.parse(local.files[resourcePath]);
+      if (validateStyleResources(parsed, id).valid) document = parsed;
+    } catch {
+    }
+  }
+  for (const resource of document?.resources ?? []) {
+    const result = { id: resource.id, source: resource.source.type, required: resource.required, status: "unverified" };
+    resources.push(result);
+    if (resource.source.type !== "local") {
+      warnings.push(`Resource ${resource.id}: ${resource.source.type === "asset" ? "remote asset availability and access" : "installed or external requirement"} not verified by this local check.`);
+      continue;
+    }
+    result.path = resource.source.path;
+    result.expectedSha256 = resource.source.sha256;
+    let message;
+    try {
+      const checked = await checkLocalResource(root, resource.source.path, resource.source.sha256);
+      result.actualSha256 = checked.actualSha256;
+      result.status = resource.source.sha256 ? "verified" : "present";
+      if (resource.source.sha256 && checked.actualSha256 !== resource.source.sha256) {
+        result.status = "hash_mismatch";
+        message = "Resource SHA-256 does not match resources.json.";
+      } else if (!resource.source.sha256) warnings.push(`Resource ${resource.id}: local file is present, but its content hash is not pinned.`);
+    } catch (error) {
+      result.status = error.code === "ENOENT" ? "missing" : "invalid";
+      message = result.status === "missing" ? "Local resource is missing." : `Cannot safely verify resource: ${error.message}`;
+    }
+    if (message) {
+      const detail = `Resource ${resource.id}: ${message}`;
+      if (resource.required) localIssues.push({ path: resource.source.path, message: detail });
+      else warnings.push(`Optional ${detail}`);
+    }
+  }
+  const issues = [...structural.issues, ...localIssues];
+  return {
+    root,
+    id,
+    ...structural,
+    valid: issues.length === 0,
+    issues,
+    warnings,
+    localIssues,
+    resources,
+    mediaUploaded: false,
+    quality: "not_assessed"
+  };
+}
+
+// packages/cli/src/media-inventory.ts
+import { createHash as createHash4 } from "node:crypto";
+import { link, lstat as lstat6, mkdir as mkdir3, mkdtemp, opendir, readFile as readFile2, rm } from "node:fs/promises";
+import { basename, dirname as dirname4, extname as extname2, join as join2 } from "node:path";
+
+// packages/cli/src/media-runtime.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { constants as constants5 } from "node:fs";
+import { lstat as lstat5, open as open5, realpath as realpath2 } from "node:fs/promises";
+import { dirname as dirname3, extname, parse, resolve as resolve4 } from "node:path";
+var MediaToolError = class extends CliError {
+  constructor(code, message) {
+    super(code, message, code === "MEDIA_TOOL_NOT_FOUND" ? "Install FFmpeg/FFprobe separately and make them available on PATH; no account or model is needed." : "Review the local input and reported limit. An incomplete check does not validate the media.");
+    this.name = "MediaToolError";
+  }
+};
+var SUPPORTED_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".mov",
+  ".m4v",
+  ".mkv",
+  ".webm",
+  ".avi",
+  ".mpg",
+  ".mpeg",
+  ".mts",
+  ".m2ts",
+  ".ts",
+  ".ogv",
+  ".wmv",
+  ".wav",
+  ".mp3",
+  ".m4a",
+  ".aac",
+  ".flac",
+  ".ogg",
+  ".opus",
+  ".aif",
+  ".aiff",
+  ".ac3",
+  ".eac3",
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".bmp",
+  ".tif",
+  ".tiff",
+  ".gif",
+  ".avif",
+  ".heic",
+  ".heif"
+]);
+var PROTOCOLS = "file,pipe";
+var FORMATS = "mov,matroska,webm,avi,mpeg,mpegts,ogg,wav,flac,mp3,aac,aiff,ac3,eac3,asf,jpeg_pipe,png_pipe,webp_pipe,bmp_pipe,tiff_pipe,gif,heif,avif";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_OUTPUT_LIMIT = 2 * 1024 * 1024;
+function resolveLocalMediaPath(value) {
+  if (!value || value.includes("\0") || /[\r\n]/.test(value) || /^[a-z][a-z\d+.-]*:/i.test(value) && !(process.platform === "win32" && /^[a-z]:[\\/]/i.test(value)) || value.startsWith("\\\\")) {
+    throw new MediaToolError("MEDIA_LOCAL_PATH_REQUIRED", "Provide a local filesystem path, not a URL, protocol or network share.");
+  }
+  return resolve4(value);
+}
+async function assertNoMediaSymlinks(value) {
+  const path = resolveLocalMediaPath(value);
+  let cursor = path;
+  while (cursor !== parse(cursor).root) {
+    const info = await lstat5(cursor);
+    if (info.isSymbolicLink()) {
+      const systemAlias = process.platform === "darwin" && (cursor === "/tmp" || cursor === "/var") && await realpath2(cursor) === `/private${cursor}`;
+      if (!systemAlias) throw new MediaToolError("MEDIA_SYMLINK", "Symlink media paths are not followed. Use the original local path.");
+    }
+    cursor = dirname3(cursor);
+  }
+  return path;
+}
+async function assertLocalMediaFile(value) {
+  const path = await assertNoMediaSymlinks(value);
+  const info = await lstat5(path);
+  if (!info.isFile()) throw new MediaToolError("MEDIA_NOT_REGULAR", "The media input must be a regular local file.");
+  if (!SUPPORTED_MEDIA_EXTENSIONS.has(extname(path).toLowerCase())) throw new MediaToolError("MEDIA_FORMAT_UNSUPPORTED", "This file extension is not supported for local media inspection.");
+  return path;
+}
+function localInputArgs(path) {
+  return ["-protocol_whitelist", PROTOCOLS, "-format_whitelist", FORMATS, "-i", resolveLocalMediaPath(path)];
+}
+async function runMediaTool(tool, args, options = {}) {
+  if (tool !== "ffmpeg" && tool !== "ffprobe") throw new MediaToolError("MEDIA_TOOL_INVALID", "Unsupported media executable.");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_OUTPUT_LIMIT;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 10 * 6e4 || !Number.isInteger(maxOutputBytes) || maxOutputBytes < 1 || maxOutputBytes > 16 * 1024 * 1024) {
+    throw new MediaToolError("MEDIA_TOOL_LIMITS_INVALID", "Media runtime limits are outside the supported range.");
+  }
+  if (!Array.isArray(args) || args.length > 200 || args.some((arg) => typeof arg !== "string" || arg.length > 8192 || arg.includes("\0"))) {
+    throw new MediaToolError("MEDIA_TOOL_ARGUMENTS_INVALID", "Invalid media tool arguments.");
+  }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (/(?:^|[=,;\s])(?:https?|ftp|sftp|tcp|udp|rtsp|rtmp|smb|data|concat|subfile|crypto):/i.test(arg) || arg === "-safe" && args[i + 1] === "0" || arg === "-enable_drefs" && args[i + 1] !== "0") {
+      throw new MediaToolError("MEDIA_REMOTE_INPUT_FORBIDDEN", "Only self-contained local media inputs are allowed.");
+    }
+    if (arg === "-protocol_whitelist" && args[i + 1] !== PROTOCOLS || arg === "-format_whitelist" && args[i + 1] !== FORMATS) {
+      throw new MediaToolError("MEDIA_TOOL_ARGUMENTS_INVALID", "The local media allowlists cannot be widened.");
+    }
+    if (arg === "-i") {
+      await assertLocalMediaFile(args[i + 1] ?? "");
+      if (args[i - 4] !== "-protocol_whitelist" || args[i - 3] !== PROTOCOLS || args[i - 2] !== "-format_whitelist" || args[i - 1] !== FORMATS) {
+        throw new MediaToolError("MEDIA_TOOL_ARGUMENTS_INVALID", "Every media input must use localInputArgs.");
+      }
+    }
+  }
+  return new Promise((resolveResult, reject) => {
+    const stdout = [], stderr = [];
+    let size = 0, done = false;
+    const child = spawn3(tool, ["-hide_banner", ...tool === "ffmpeg" ? ["-nostdin"] : [], ...args], { shell: false, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    const fail = (error) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      child.kill("SIGKILL");
+      reject(error);
+    };
+    const timer = setTimeout(() => fail(new MediaToolError("MEDIA_TOOL_TIMEOUT", "The local media check exceeded its time limit. No complete result is available.")), timeoutMs);
+    const collect = (target) => (chunk) => {
+      if (done) return;
+      size += chunk.length;
+      if (size > maxOutputBytes) return fail(new MediaToolError("MEDIA_TOOL_OUTPUT_LIMIT", "The local media check exceeded its output limit. No complete result is available."));
+      target.push(chunk);
+    };
+    child.stdout.on("data", collect(stdout));
+    child.stderr.on("data", collect(stderr));
+    child.on("error", (error) => fail(new MediaToolError(error.code === "ENOENT" ? "MEDIA_TOOL_NOT_FOUND" : "MEDIA_TOOL_FAILED", error.code === "ENOENT" ? `${tool} is not installed or available on PATH. Install it separately to use local media checks.` : "The local media executable could not run.")));
+    child.on("close", (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (code !== 0) return reject(new MediaToolError("MEDIA_TOOL_FAILED", "The local media tool could not inspect or decode this input. No complete result is available."));
+      resolveResult({ stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+    });
+  });
+}
+var finite2 = (value) => {
+  if (typeof value !== "number" && typeof value !== "string" || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+};
+var nonnegative2 = (value) => {
+  const n = finite2(value);
+  return n !== null && n >= 0 ? n : null;
+};
+var positiveInteger = (value) => {
+  const n = finite2(value);
+  return n !== null && Number.isInteger(n) && n > 0 ? n : void 0;
+};
+var rate = (value) => {
+  if (typeof value !== "string" || !/^\d+(?:\/\d+)?$/.test(value)) return null;
+  const [n, d = "1"] = value.split("/");
+  const result = Number(n) / Number(d);
+  return Number.isFinite(result) && result > 0 ? result : null;
+};
+var sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+async function probeLocalMedia(value) {
+  const path = await assertLocalMediaFile(value);
+  const handle = await open5(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
+  try {
+    const before = await handle.stat();
+    if (!before.isFile()) throw new MediaToolError("MEDIA_NOT_REGULAR", "The media input must be a regular local file.");
+    const entries = "format=duration,start_time:stream=index,codec_type,codec_name,width,height,avg_frame_rate,sample_rate,channels,duration:stream_disposition=attached_pic";
+    const { stdout } = await runMediaTool("ffprobe", ["-v", "error", "-show_entries", entries, "-of", "json", ...localInputArgs(path)]);
+    const hash2 = createHash3("sha256");
+    for await (const chunk of handle.createReadStream({ autoClose: false })) hash2.update(chunk);
+    const after = await handle.stat();
+    await assertNoMediaSymlinks(path);
+    const current = await lstat5(path);
+    if (!sameFile(before, after) || !sameFile(after, current)) throw new MediaToolError("MEDIA_FILE_CHANGED", "The media file changed while it was being inspected. Retry with a stable source.");
+    let raw;
+    try {
+      raw = JSON.parse(stdout);
+    } catch {
+      throw new MediaToolError("MEDIA_PROBE_INVALID", "The media probe returned invalid metadata.");
+    }
+    if (!raw || !Array.isArray(raw.streams) || raw.streams.length > 256 || raw.streams.some((stream) => !stream || typeof stream !== "object" || Array.isArray(stream))) throw new MediaToolError("MEDIA_PROBE_INVALID", "The media probe returned invalid or excessive stream metadata.");
+    const streams = raw.streams.map((stream, offset) => {
+      const type = typeof stream.codec_type === "string" && /^(video|audio|subtitle|data|attachment|unknown)$/.test(stream.codec_type) ? stream.codec_type : "unknown";
+      const codec = typeof stream.codec_name === "string" && /^[a-zA-Z0-9_]{1,64}$/.test(stream.codec_name) ? stream.codec_name : null;
+      const index = finite2(stream.index);
+      return {
+        index: index !== null && Number.isInteger(index) && index >= 0 ? index : offset,
+        type,
+        codec,
+        durationSeconds: nonnegative2(stream.duration),
+        ...type === "video" ? { width: positiveInteger(stream.width), height: positiveInteger(stream.height), fps: rate(stream.avg_frame_rate), attachedPicture: stream.disposition?.attached_pic === 1 } : {},
+        ...type === "audio" ? { sampleRate: nonnegative2(stream.sample_rate), channels: positiveInteger(stream.channels) ?? null } : {}
+      };
+    });
+    return { path, sha256: hash2.digest("hex"), bytes: after.size, durationSeconds: nonnegative2(raw.format?.duration), startTimeSeconds: finite2(raw.format?.start_time), streams };
+  } finally {
+    await handle.close();
+  }
+}
+
+// packages/cli/src/media-inventory.ts
+var GENERATED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "output", "outputs", "renders", "render", "cache", "caches", "proxies", "proxy", "samples", "thumbnails", "coverage", "venv", "__pycache__"]);
+function mediaFailure(error) {
+  if (error instanceof MediaToolError) return { code: error.code, message: error.message };
+  const code = error?.code;
+  if (code === "ENOENT") return { code: "MEDIA_FILE_MISSING", message: "The local path is missing or changed during inspection." };
+  if (code === "EACCES" || code === "EPERM") return { code: "MEDIA_FILE_UNREADABLE", message: "The local path cannot be read with the current filesystem permissions." };
+  return { code: "MEDIA_INSPECTION_FAILED", message: "Local media inspection failed. No complete result is available for this path." };
+}
+async function inventoryMedia(options) {
+  const maxFiles = options.maxFiles ?? 200;
+  if (!Number.isInteger(maxFiles) || maxFiles < 1 || maxFiles > 1e3) throw new MediaToolError("MEDIA_LIMIT_INVALID", "maxFiles must be an integer between 1 and 1000.");
+  const input = resolveLocalMediaPath(options.input);
+  const report = { schemaVersion: 1, kind: "editorbrain.media-inventory", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), assets: [], failures: [], skipped: [], complete: true, scannedEntries: 0, limits: { maxFiles, maxEntries: 1e4, maxDepth: 32 }, contentReviewed: false, mediaUploaded: false };
+  const candidates = [];
+  const skip = (path, reason, incomplete = false) => {
+    report.skipped.push({ path, reason });
+    if (incomplete) report.complete = false;
+  };
+  const visit = async (path, depth, explicit = false) => {
+    if (report.scannedEntries >= report.limits.maxEntries) {
+      skip(path, "entry_limit_reached", true);
+      return;
+    }
+    report.scannedEntries++;
+    try {
+      const stat = await lstat6(path);
+      if (stat.isSymbolicLink()) {
+        if (explicit) throw new MediaToolError("MEDIA_SYMLINK", "Symlink inputs are not followed. Use the original local path.");
+        skip(path, "symlink_not_followed");
+        return;
+      }
+      if (!explicit && basename(path).startsWith(".")) {
+        skip(path, "hidden_entry");
+        return;
+      }
+      await assertNoMediaSymlinks(path);
+      if (stat.isDirectory()) {
+        if (!explicit && GENERATED_DIRECTORIES.has(basename(path).toLowerCase())) {
+          skip(path, "generated_directory");
+          return;
+        }
+        if (depth >= report.limits.maxDepth) {
+          skip(path, "depth_limit_reached", true);
+          return;
+        }
+        const directory = await opendir(path);
+        for await (const entry of directory) {
+          if (report.scannedEntries >= report.limits.maxEntries) {
+            skip(path, "remaining_entries_not_scanned", true);
+            break;
+          }
+          await visit(join2(path, entry.name), depth + 1);
+        }
+      } else if (!stat.isFile()) {
+        if (explicit) throw new MediaToolError("MEDIA_NOT_REGULAR", "The explicit media input must be a regular local file or directory.");
+        skip(path, "not_regular_file");
+      } else if (!SUPPORTED_MEDIA_EXTENSIONS.has(extname2(path).toLowerCase())) {
+        if (explicit) throw new MediaToolError("MEDIA_FORMAT_UNSUPPORTED", "This explicit input is not a supported media format.");
+        skip(path, "unsupported_extension");
+      } else if (candidates.length >= maxFiles) skip(path, "file_limit_reached", true);
+      else candidates.push(path);
+    } catch (error) {
+      report.failures.push({ path, ...mediaFailure(error) });
+      report.complete = false;
+    }
+  };
+  await visit(input, 0, true);
+  for (const path of candidates.sort()) {
+    try {
+      report.assets.push(await probeLocalMedia(path));
+    } catch (error) {
+      report.failures.push({ path, ...mediaFailure(error) });
+      report.complete = false;
+    }
+  }
+  return report;
+}
+async function sampleMedia(options) {
+  if (!Array.isArray(options.times) || options.times.length < 1 || options.times.length > 12 || options.times.some((time) => typeof time !== "number" || !Number.isFinite(time) || time < 0 || time > 86400)) {
+    throw new MediaToolError("MEDIA_SAMPLE_TIMES_INVALID", "Provide 1\u201312 sample times in seconds, between 0 and 86400.");
+  }
+  const file = await assertLocalMediaFile(options.file);
+  const source = await probeLocalMedia(file);
+  if (!source.streams.some((stream) => stream.type === "video")) throw new MediaToolError("MEDIA_VIDEO_REQUIRED", "Frame sampling requires a video or image stream.");
+  if (source.durationSeconds !== null && options.times.some((time) => time >= source.durationSeconds)) throw new MediaToolError("MEDIA_SAMPLE_OUT_OF_RANGE", "A requested sample is outside the known media duration.");
+  const outputDirectory = resolveLocalMediaPath(options.outputDirectory);
+  await assertNoMediaSymlinks(dirname4(outputDirectory));
+  try {
+    await mkdir3(outputDirectory);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  await assertNoMediaSymlinks(outputDirectory);
+  if (!(await lstat6(outputDirectory)).isDirectory()) throw new MediaToolError("MEDIA_OUTPUT_DIRECTORY_INVALID", "Frame output must be a local directory.");
+  const temp = await mkdtemp(join2(outputDirectory, ".editorbrain-samples-"));
+  const tempStat = await lstat6(temp);
+  const frames = [];
+  const created = [];
+  try {
+    for (let index = 0; index < options.times.length; index++) {
+      const time = options.times[index];
+      const filename = `${source.sha256.slice(0, 12)}-${String(index + 1).padStart(2, "0")}-${Math.round(time * 1e3)}ms.jpg`;
+      const temporary = join2(temp, filename), output2 = join2(outputDirectory, filename);
+      await runMediaTool("ffmpeg", ["-v", "error", "-n", "-ss", String(time), ...localInputArgs(file), "-map", "0:v:0", "-frames:v", "1", "-an", "-sn", "-dn", "-vf", "scale=960:960:force_original_aspect_ratio=decrease", "-q:v", "3", "-update", "1", temporary], { timeoutMs: 6e4 });
+      const bytes = await readFile2(temporary);
+      if (!bytes.length) throw new MediaToolError("MEDIA_SAMPLE_EMPTY", "The requested frame did not produce a usable image.");
+      try {
+        await link(temporary, output2);
+      } catch (error) {
+        if (error.code === "EEXIST") throw new MediaToolError("MEDIA_OUTPUT_EXISTS", "A sample output already exists. Choose a new output directory; existing files are never overwritten.");
+        throw error;
+      }
+      const outputStat = await lstat6(output2);
+      created.push({ path: output2, ino: outputStat.ino, dev: outputStat.dev, size: outputStat.size, mtimeMs: outputStat.mtimeMs, ctimeMs: outputStat.ctimeMs });
+      frames.push({ path: output2, sha256: createHash4("sha256").update(bytes).digest("hex"), bytes: bytes.length, requestedTimeSeconds: time, actualPresentationTimeSeconds: null });
+    }
+    const after = await probeLocalMedia(file);
+    if (source.sha256 !== after.sha256) throw new MediaToolError("MEDIA_FILE_CHANGED", "The source changed while frames were being sampled. Retry with a stable source.");
+    return { schemaVersion: 1, kind: "editorbrain.media-samples", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), source, frames, metadataOnly: false, contentReviewed: false, mediaUploaded: false };
+  } catch (error) {
+    for (const file2 of created) {
+      try {
+        await assertNoMediaSymlinks(file2.path);
+        const current = await lstat6(file2.path);
+        if (current.ino === file2.ino && current.dev === file2.dev && current.size === file2.size && current.mtimeMs === file2.mtimeMs && current.ctimeMs === file2.ctimeMs) await rm(file2.path, { force: true });
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    try {
+      await assertNoMediaSymlinks(temp);
+      const current = await lstat6(temp);
+      if (current.ino === tempStat.ino && current.dev === tempStat.dev) await rm(temp, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// packages/cli/src/render-check.ts
+import { resolve as resolve5 } from "node:path";
+function invalidProfile(message) {
+  throw new CliError("RENDER_PROFILE_INVALID", message, "Use a schemaVersion: 1 render profile with explicit technical requirements.");
+}
+function object3(value, path, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalidProfile(`${path} must be an object.`);
+  const result = value;
+  for (const key of Object.keys(result)) if (!keys.includes(key)) invalidProfile(`${path} contains unsupported field ${key}.`);
+  return result;
+}
+function validateRenderCheckProfile(value) {
+  const root = object3(value, "profile", ["schemaVersion", "expected", "tolerance", "audio", "silence", "black", "peak", "limits"]);
+  if (root.schemaVersion !== 1) invalidProfile("profile.schemaVersion must be 1.");
+  const expected = root.expected === void 0 ? {} : object3(root.expected, "expected", ["width", "height", "fps", "durationSeconds"]);
+  const tolerance = root.tolerance === void 0 ? {} : object3(root.tolerance, "tolerance", ["fps", "durationSeconds"]);
+  const silence = root.silence === void 0 ? {} : object3(root.silence, "silence", ["enabled", "minDurationSeconds", "thresholdDb"]);
+  const black = root.black === void 0 ? {} : object3(root.black, "black", ["enabled", "minDurationSeconds", "pixelThreshold", "pictureBlackRatio"]);
+  const peak = root.peak === void 0 ? {} : object3(root.peak, "peak", ["enabled", "thresholdDbFS"]);
+  const limits = root.limits === void 0 ? {} : object3(root.limits, "limits", ["timeoutMs", "maxOutputBytes"]);
+  const number = (v, name, min, max, fallback, integer = false) => {
+    if (v === void 0 && fallback !== void 0) return fallback;
+    if (typeof v !== "number" || !Number.isFinite(v) || v < min || v > max || integer && !Number.isInteger(v)) invalidProfile(`${name} must be ${integer ? "an integer" : "a finite number"} between ${min} and ${max}.`);
+    return v;
+  };
+  const enabled = (v, name) => {
+    if (v === void 0) return true;
+    if (typeof v !== "boolean") invalidProfile(`${name} must be a boolean.`);
+    return v;
+  };
+  if (root.audio !== void 0 && !["required", "optional", "forbidden"].includes(root.audio)) invalidProfile("audio must be required, optional or forbidden.");
+  const validatedExpected = {};
+  for (const key of ["width", "height"]) if (expected[key] !== void 0) validatedExpected[key] = number(expected[key], `expected.${key}`, 1, 32768, void 0, true);
+  if (expected.fps !== void 0) validatedExpected.fps = number(expected.fps, "expected.fps", 1e-6, 1e3);
+  if (expected.durationSeconds !== void 0) validatedExpected.durationSeconds = number(expected.durationSeconds, "expected.durationSeconds", 1e-6, 864e4);
+  return {
+    schemaVersion: 1,
+    expected: validatedExpected,
+    tolerance: { fps: number(tolerance.fps, "tolerance.fps", 0, 1e3, 0.01), durationSeconds: number(tolerance.durationSeconds, "tolerance.durationSeconds", 0, 86400, 0.1) },
+    audio: root.audio ?? "optional",
+    silence: { enabled: enabled(silence.enabled, "silence.enabled"), minDurationSeconds: number(silence.minDurationSeconds, "silence.minDurationSeconds", 1e-3, 86400, 0.75), thresholdDb: number(silence.thresholdDb, "silence.thresholdDb", -150, 0, -50) },
+    black: { enabled: enabled(black.enabled, "black.enabled"), minDurationSeconds: number(black.minDurationSeconds, "black.minDurationSeconds", 1e-3, 86400, 0.15), pixelThreshold: number(black.pixelThreshold, "black.pixelThreshold", 0, 1, 0.1), pictureBlackRatio: number(black.pictureBlackRatio, "black.pictureBlackRatio", 0, 1, 0.98) },
+    peak: { enabled: enabled(peak.enabled, "peak.enabled"), thresholdDbFS: number(peak.thresholdDbFS, "peak.thresholdDbFS", -150, 0, -0.1) },
+    limits: { timeoutMs: number(limits.timeoutMs, "limits.timeoutMs", 1, 6e5, 6e5, true), maxOutputBytes: number(limits.maxOutputBytes, "limits.maxOutputBytes", 1024, 16777216, 4194304, true) }
+  };
+}
+function errorCode(error) {
+  if (error && typeof error === "object" && "code" in error && typeof error.code === "string" && /^[A-Z_0-9]+$/.test(error.code)) return error.code;
+  return "MEDIA_CHECK_FAILED";
+}
+function addCheck(report, check) {
+  report.checks.push(check);
+}
+function addFinding(report, finding) {
+  report.findingsSummary.total++;
+  report.findingsSummary.byKind[finding.kind]++;
+  if (report.findings.length < 1e3) report.findings.push(finding);
+  else {
+    report.findingsSummary.truncated = true;
+    report.complete = false;
+  }
+  report.findingsSummary.returned = report.findings.length;
+}
+function finish(report) {
+  report.technicalStatus = report.checks.some((check) => check.status === "fail") ? "fail" : !report.complete ? "incomplete" : report.checks.some((check) => check.status === "warning") ? "warning" : "pass";
+  return report;
+}
+function checkExpected(report, probe, profile) {
+  const expected = profile.expected;
+  if (!Object.keys(expected).length) return addCheck(report, { id: "expected_format", status: "not_applicable", detail: "No target dimensions, frame rate or duration were specified." });
+  const video = probe.streams.find((stream) => stream.type === "video" && !stream.attachedPicture);
+  const mismatches = [];
+  const unknown = [];
+  for (const key of ["width", "height", "fps"]) {
+    const target = expected[key];
+    if (target === void 0) continue;
+    if (!video) {
+      mismatches.push(`Expected ${key}, but the file has no video stream.`);
+      continue;
+    }
+    const actual = video[key];
+    if (actual === void 0 || actual === null || actual <= 0) unknown.push(`Could not measure ${key}.`);
+    else if (Math.abs(actual - target) > (key === "fps" ? profile.tolerance.fps : 0)) mismatches.push(`${key}: measured ${actual}, expected ${target}.`);
+  }
+  if (expected.durationSeconds !== void 0) {
+    if (probe.durationSeconds === null) unknown.push("Could not measure container duration.");
+    else if (Math.abs(probe.durationSeconds - expected.durationSeconds) > profile.tolerance.durationSeconds) mismatches.push(`durationSeconds: measured ${probe.durationSeconds}, expected ${expected.durationSeconds}.`);
+  }
+  if (unknown.length) report.complete = false;
+  addCheck(report, { id: "expected_format", status: mismatches.length ? "fail" : unknown.length ? "not_checked" : "pass", detail: [...mismatches, ...unknown].join(" ") || "Explicit requirements matched; dimensions and reported average frame rate refer to the first video stream excluding attached cover art." });
+}
+async function toolVersion(tool) {
+  try {
+    const result = await runMediaTool(tool, ["-version"], { timeoutMs: 1e4, maxOutputBytes: 65536 });
+    return { available: true, version: new RegExp(`^${tool} version ([A-Za-z0-9._+~-]+)`, "m").exec(result.stdout)?.[1] ?? null };
+  } catch {
+    return { available: false, version: null };
+  }
+}
+function readDetectorOutput(report, stderr, audioStreams) {
+  const samples = /* @__PURE__ */ new Map();
+  for (const stream of audioStreams) samples.set(stream.index, { streamIndex: stream.index, sampleCount: null, samplePeakDbFS: null, peakState: "unavailable" });
+  const pendingSilence = /* @__PURE__ */ new Map();
+  for (const line of stderr.split("\n")) {
+    const tag = /\[(blackdetect@v|silencedetect@a|astats@a)(\d+)\s+@/.exec(line);
+    if (!tag) continue;
+    const streamIndex = Number(tag[2]);
+    if (tag[1] === "blackdetect@v") {
+      const match = /black_start:([\d.e+-]+)\s+black_end:([\d.e+-]+)\s+black_duration:([\d.e+-]+)/i.exec(line);
+      if (match && match.slice(1).every((value) => Number.isFinite(Number(value)))) addFinding(report, { kind: "black_candidate", streamIndex, startSeconds: Number(match[1]), endSeconds: Number(match[2]), durationSeconds: Number(match[3]), requiresReview: true, message: "A mostly black interval met the configured detector threshold. It may be intentional; review in context." });
+    } else if (tag[1] === "silencedetect@a") {
+      const start = /silence_start:\s*([\d.e+-]+)/i.exec(line);
+      if (start && Number.isFinite(Number(start[1]))) pendingSilence.set(streamIndex, Number(start[1]));
+      const end = /silence_end:\s*([\d.e+-]+)\s*\|\s*silence_duration:\s*([\d.e+-]+)/i.exec(line);
+      if (end && end.slice(1).every((value) => Number.isFinite(Number(value)))) {
+        addFinding(report, { kind: "silence_candidate", streamIndex, startSeconds: pendingSilence.get(streamIndex) ?? Number(end[1]) - Number(end[2]), endSeconds: Number(end[1]), durationSeconds: Number(end[2]), requiresReview: true, message: "A quiet interval met the configured detector threshold. Pauses and silent edits may be intentional." });
+        pendingSilence.delete(streamIndex);
+      }
+    } else {
+      const sample = samples.get(streamIndex);
+      if (!sample) continue;
+      const peak = /Peak level dB:\s*(-inf|[\d.e+-]+)/i.exec(line);
+      if (peak?.[1] === "-inf") sample.peakState = "negative_infinity";
+      else if (peak && Number.isFinite(Number(peak[1]))) {
+        sample.peakState = "measured";
+        sample.samplePeakDbFS = Number(peak[1]);
+      }
+      const count = /Number of samples:\s*([\d.e+-]+)/i.exec(line);
+      if (count && Number.isFinite(Number(count[1]))) sample.sampleCount = Number(count[1]);
+    }
+  }
+  report.measurements.audio = [...samples.values()];
+  if (pendingSilence.size) {
+    report.complete = false;
+    addCheck(report, { id: "silence", status: "not_checked", code: "DETECTOR_OUTPUT_INCOMPLETE", detail: "At least one detected silence interval had no closing timestamp; results are incomplete." });
+  }
+}
+async function checkRender(options) {
+  const profile = validateRenderCheckProfile(options.profile ?? { schemaVersion: 1 });
+  const report = {
+    schemaVersion: 1,
+    kind: "editorbrain.render-check",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mediaUploaded: false,
+    file: { path: resolve5(options.file), sha256: null, bytes: null },
+    effectiveProfile: profile,
+    complete: true,
+    technicalStatus: "incomplete",
+    measurements: { probe: null, decodedThroughSeconds: null, audio: [] },
+    capabilities: { ffprobe: { available: false, version: null }, ffmpeg: { available: false, version: null }, decodeScope: "all_audio_video_streams", timestampBasis: "seconds_from_container_start", peakMethod: "sample_peak_whole_mix_per_audio_stream", truePeak: "not_assessed", loudness: "not_assessed", repeatedFootage: "not_assessed", subtitleStreams: "not_assessed" },
+    checks: [],
+    findings: [],
+    findingsSummary: { total: 0, returned: 0, truncated: false, byKind: { silence_candidate: 0, black_candidate: 0, peak_candidate: 0 } },
+    creativeQuality: { narrative: "not_assessed", readability: "not_assessed", sfxAudibility: "not_assessed", style: "not_assessed" },
+    limitations: [
+      "This report is a technical inspection of the identified file, not approval of its editing or creative quality.",
+      "Default detector thresholds are sensitivities, not requirements for a platform, niche, style, music, pacing or frame rate.",
+      "Silence, black and peak findings require contextual review; no automatic cuts or audio changes are performed.",
+      "Whole-mix sample peaks cannot establish SFX audibility, true-peak clipping, speech clarity or perceived loudness.",
+      "Frame rate is container-reported average; constant frame cadence, HDR, color appearance, rotation and subtitle rendering are not certified.",
+      "Black interval boundaries follow decoded frame timestamps and may differ from presentation duration by a frame.",
+      "Attached cover art is decoded but excluded from video requirements and black-interval detection.",
+      "Reports retain at most 1,000 timestamped findings; exceeding this cap marks the result incomplete and preserves total counts."
+    ]
+  };
+  let probe;
+  try {
+    probe = await probeLocalMedia(options.file);
+    report.file = { path: probe.path, sha256: probe.sha256, bytes: probe.bytes };
+    report.measurements.probe = probe;
+    report.capabilities.ffprobe.available = true;
+    addCheck(report, { id: "probe", status: "pass", detail: "Read stream metadata and SHA-256 from the local file." });
+  } catch (error) {
+    report.complete = false;
+    addCheck(report, { id: "probe", status: "not_checked", code: errorCode(error), detail: "The local file could not be probed. No successful inspection is implied." });
+    for (const id of ["expected_format", "audio_requirement", "decode", "silence", "black", "peak", "file_stability"]) addCheck(report, { id, status: "not_checked", detail: "Requires a successful local media probe." });
+    return finish(report);
+  }
+  const versions = await Promise.all([toolVersion("ffprobe"), toolVersion("ffmpeg")]);
+  report.capabilities.ffprobe = { ...versions[0], available: true };
+  report.capabilities.ffmpeg = versions[1];
+  const video = probe.streams.filter((stream) => stream.type === "video");
+  const motionVideo = video.filter((stream) => !stream.attachedPicture);
+  const audio = probe.streams.filter((stream) => stream.type === "audio");
+  checkExpected(report, probe, profile);
+  const audioMismatch = profile.audio === "required" && !audio.length || profile.audio === "forbidden" && audio.length > 0;
+  addCheck(report, { id: "audio_requirement", status: audioMismatch ? "fail" : profile.audio === "optional" ? "not_applicable" : "pass", detail: `Audio policy: ${profile.audio}; found ${audio.length} audio stream(s). This checks stream presence, not audibility.` });
+  const filters = [];
+  const maps = [];
+  for (const stream of video) {
+    filters.push(`[0:${stream.index}]${profile.black.enabled && !stream.attachedPicture ? `blackdetect@v${stream.index}=d=${profile.black.minDurationSeconds}:pix_th=${profile.black.pixelThreshold}:pic_th=${profile.black.pictureBlackRatio}` : "null"}[v${stream.index}]`);
+    maps.push("-map", `[v${stream.index}]`);
+  }
+  for (const stream of audio) {
+    filters.push(`[0:${stream.index}]${profile.silence.enabled ? `silencedetect@a${stream.index}=n=${profile.silence.thresholdDb}dB:d=${profile.silence.minDurationSeconds},` : ""}astats@a${stream.index}=metadata=0:reset=0:measure_perchannel=none:measure_overall=Peak_level+Number_of_samples[a${stream.index}]`);
+    maps.push("-map", `[a${stream.index}]`);
+  }
+  let decoded = false;
+  if (!filters.length) {
+    addCheck(report, { id: "decode", status: "fail", code: "NO_PLAYABLE_STREAMS", detail: "No audio or video streams are available for inspection." });
+  } else {
+    try {
+      const result = await runMediaTool("ffmpeg", ["-hide_banner", "-nostdin", "-nostats", "-loglevel", "info", "-xerror", "-copyts", "-start_at_zero", ...localInputArgs(probe.path), "-filter_complex", filters.join(";"), ...maps, "-progress", "pipe:1", "-stats_period", "60", "-f", "null", "-"], profile.limits);
+      report.capabilities.ffmpeg.available = true;
+      readDetectorOutput(report, result.stderr, audio);
+      const progress = [...result.stdout.matchAll(/^out_time_us=(-?\d+)$/gm)].at(-1);
+      report.measurements.decodedThroughSeconds = progress ? Number(progress[1]) / 1e6 : null;
+      const frames = [...result.stdout.matchAll(/^frame=(\d+)$/gm)].at(-1);
+      const empty = video.length > 0 && !!frames && Number(frames[1]) <= 0 || audio.length > 0 && report.measurements.audio.some((stream) => stream.sampleCount === 0);
+      const missingEvidence = !/^progress=end$/m.test(result.stdout) || video.length > 0 && !frames || audio.length > 0 && report.measurements.audio.some((stream) => stream.sampleCount === null);
+      if (empty) addCheck(report, { id: "decode", status: "fail", code: "EMPTY_DECODE", detail: "An expected stream produced no decoded frames or samples." });
+      else if (missingEvidence) {
+        report.complete = false;
+        addCheck(report, { id: "decode", status: "not_checked", code: "DECODE_EVIDENCE_MISSING", detail: "The tool exited without complete decode evidence. Empty or incomplete logs are not a pass." });
+      } else {
+        decoded = true;
+        addCheck(report, { id: "decode", status: "pass", detail: "FFmpeg decoded the complete file to end-of-input with explicit audio/video maps and no reported fatal decoding error." });
+      }
+    } catch (error) {
+      const code = errorCode(error);
+      const failed = code === "MEDIA_TOOL_FAILED";
+      report.complete = false;
+      addCheck(report, { id: "decode", status: failed ? "fail" : "not_checked", code, detail: failed ? "FFmpeg did not finish successfully. Inspect the file or local tool compatibility; this does not establish creative quality." : "Full-file decoding did not complete within the available tools or limits; detector results are incomplete." });
+    }
+  }
+  for (const id of ["silence", "black", "peak"]) {
+    if (report.checks.some((check) => check.id === id)) continue;
+    const applicable = id === "black" ? motionVideo.length > 0 : audio.length > 0;
+    if (!applicable) {
+      addCheck(report, { id, status: "not_applicable", detail: `No ${id === "black" ? "video streams excluding attached cover art" : "audio streams"}.` });
+      continue;
+    }
+    if (!profile[id].enabled) {
+      addCheck(report, { id, status: "not_checked", detail: "Explicitly disabled in the effective profile." });
+      continue;
+    }
+    if (!decoded) {
+      addCheck(report, { id, status: "not_checked", detail: "Requires successful full-file decoding." });
+      continue;
+    }
+    if (id === "peak") {
+      if (report.measurements.audio.some((stream) => stream.peakState === "unavailable")) {
+        report.complete = false;
+        addCheck(report, { id, status: "not_checked", code: "DETECTOR_OUTPUT_INCOMPLETE", detail: "A whole-mix sample peak could not be read for every audio stream." });
+        continue;
+      }
+      for (const stream of report.measurements.audio) if (stream.samplePeakDbFS !== null && stream.samplePeakDbFS >= profile.peak.thresholdDbFS) addFinding(report, { kind: "peak_candidate", streamIndex: stream.streamIndex, measuredDbFS: stream.samplePeakDbFS, requiresReview: true, message: "Whole-mix sample peak reached the configured threshold. Check possible clipping or limiting; peak level alone is not proof of distortion." });
+    }
+    const count = report.findingsSummary.byKind[`${id}_candidate`];
+    addCheck(report, { id, status: count ? "warning" : "pass", detail: count ? `${count} candidate(s) require contextual review; they are not automatic editing errors.` : "No candidates met the effective detector threshold during full-file decoding." });
+  }
+  try {
+    const after = await probeLocalMedia(probe.path);
+    const same = after.sha256 === probe.sha256 && after.bytes === probe.bytes;
+    if (!same) report.complete = false;
+    addCheck(report, { id: "file_stability", status: same ? "pass" : "fail", ...same ? {} : { code: "MEDIA_CHANGED_DURING_CHECK" }, detail: same ? "SHA-256 and byte length matched before and after inspection." : "The file changed during inspection; findings must not be treated as a verified report for the current file." });
+  } catch (error) {
+    report.complete = false;
+    addCheck(report, { id: "file_stability", status: "not_checked", code: errorCode(error), detail: "The input fingerprint could not be verified after inspection." });
+  }
+  return finish(report);
+}
+
+// packages/cli/src/production-output.ts
+import { constants as constants6 } from "node:fs";
+import { mkdir as mkdir4, open as open6 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+async function productionOutputPath(root, relativePath) {
+  if (!relativePath.startsWith(".editorbrain-local/") || relativePath.split(/[\\/]/).some((p) => !p || p === ".." || p === ".") || /[\\\x00-\x1f\x7f]/.test(relativePath)) {
+    throw new CliError("LOCAL_OUTPUT_REQUIRED", "Production output must be inside .editorbrain-local/.", "Use --out .editorbrain-local/<project>/inventory.json, or omit --out for JSON stdout. These reports are not synced.");
+  }
+  return checkedPath(root, relativePath, false);
+}
+async function prepareSampleDirectory(root, path) {
+  const target = await productionOutputPath(root, path);
+  await mkdir4(dirname5(target), { recursive: true });
+  await productionOutputPath(root, path);
+  return target;
+}
+async function readProductionJson(root, path) {
+  const target = await checkedPath(root, path, false);
+  const handle = await open6(target, constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > 16 * 1024 * 1024) throw new CliError("INVALID_REPORT", "Expected a regular JSON file of at most 16 MiB.", "Select a local inventory, plan or check profile.");
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+async function saveProductionReport(root, path, report) {
+  const target = await productionOutputPath(root, path);
+  if (!path.endsWith(".json")) throw new CliError("INVALID_ARGUMENT", "Report output needs a .json extension.", "Use a new path under .editorbrain-local/.");
+  await atomicWrite(root, path, stableJson(report), { document: false, overwrite: false, mode: 384 });
+  return target;
+}
+function summarizeProductionReport(value) {
+  const r = value;
+  const base = { schemaVersion: r.schemaVersion, kind: r.kind, summary: true, mediaUploaded: false, quality: "not_assessed" };
+  if (r.kind === "editorbrain.media-inventory") return {
+    ...base,
+    complete: r.complete,
+    contentReviewed: false,
+    counts: { assets: r.assets.length, failures: r.failures.length, skipped: r.skipped.length },
+    assets: r.assets.slice(0, 8),
+    failures: r.failures.slice(0, 5),
+    omitted: { assets: Math.max(0, r.assets.length - 8), failures: Math.max(0, r.failures.length - 5), skipped: r.skipped.length },
+    next: "Inspect selected source content. Use media sample for specific frames. Read the saved report or rerun with --details for omitted metadata; no content was reviewed automatically."
+  };
+  if (r.kind === "editorbrain.media-samples") return { ...base, sourceSha256: r.source.sha256, frames: r.frames, contentReviewed: false, next: "View these frames to inspect composition. They do not prove motion or sound." };
+  if (r.kind === "editorbrain.production-plan-check") return {
+    ...base,
+    valid: r.valid,
+    inventoryComplete: r.inventoryComplete,
+    observations: r.observations,
+    sourceFilesReverified: false,
+    counts: { sources: r.coverage.length, findings: r.findings.length, repeatedPairs: r.repeatedPairs ?? 0 },
+    findings: [...r.findings].sort((a, b) => ({ error: 0, warning: 1, info: 2 })[a.severity] - { error: 0, warning: 1, info: 2 }[b.severity]).slice(0, 8),
+    omittedFindings: Math.max(0, r.findings.length - 8),
+    next: "Review source reuse and inspection gaps in the saved report. Observations are agent-declared, not independently certified."
+  };
+  if (r.kind === "editorbrain.render-check") return {
+    ...base,
+    complete: r.complete,
+    technicalStatus: r.technicalStatus,
+    file: r.file,
+    checks: r.checks,
+    findings: r.findings.slice(0, 8),
+    findingsSummary: r.findingsSummary,
+    omittedFindings: Math.max(0, r.findings.length - 8),
+    next: "Reconcile technical candidates with the brief; inspect the actual video/audio. Technical checks do not assess narrative, aesthetics or SFX audibility."
+  };
+  throw new CliError("INVALID_REPORT", "Unknown production report kind.", "Use media inventory/sample or production check/plan-check.");
+}
+
 // packages/cli/src/index.ts
 var HELP = `EditorBrain \u2014 portable editorial context for AI video agents
 
@@ -1414,6 +2619,12 @@ editorbrain library media <video-id> --sha256 media-hash --out file
 editorbrain narrative search [query] [--kind hook|cta|...] [--channel visual|spoken|...] [--limit 10]
 editorbrain narrative get <video-id> [--sha256 document-hash] [--event-offset 0] [--relation-offset 0] [--limit 50]
 editorbrain styles list
+editorbrain styles create <style-id> [--name name] [--dir folder]
+editorbrain styles check <style-id> [--dir folder]
+editorbrain media inventory --input file-or-folder [--max-files 200] [--dir folder] [--out .editorbrain-local/report.json] [--details]
+editorbrain media sample --file source --at 0,5,12 --out .editorbrain-local/frames [--dir folder] [--details]
+editorbrain production check --file render [--profile local-profile.json] [--dir folder] [--out .editorbrain-local/report.json] [--details]
+editorbrain production plan-check --inventory local-inventory.json --plan local-plan.json [--dir folder] [--out .editorbrain-local/report.json] [--details]
 editorbrain styles recommend <project-id> [--assets tag,tag] [--capabilities tag,tag] [--style pack-id] [--duration seconds]
 editorbrain direction draft <project-id> [--assets tag,tag] [--capabilities tag,tag] [--style pack-id] [--duration seconds] [--out new-folder]
 editorbrain assets list [--limit 200] [--cursor opaque-cursor]
@@ -1428,14 +2639,17 @@ Secrets go to a user config with mode 0600, never the portable project.
 Resolve writes the source-hash lock. Export produces a handoff, not a rendered video.
 Push/pull preserve conflicting changes; media uploads use the separate assets command.
 Skill install works offline, preserves existing instructions, and defaults to both agents.
+Styles create/check work locally without login or media upload; checks do not certify render quality.
+Media/production commands run locally with ffprobe/ffmpeg, without automatic installation or media upload.
+Production output is compact by default; --details expands it. --out saves full private reports without overwriting.
 Keys create stores the returned secret in the private user config; stdout has no key.
 Output is JSON except help; login progress/code goes to stderr. --url overrides the configured endpoint.
 `;
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
-  const booleans = /* @__PURE__ */ new Set(["help", "version", "offline", "dry-run", "key-stdin", "invite-stdin", "no-browser", "skip-mcp", "all", "share-authorized"]);
-  const known = /* @__PURE__ */ new Set(["dir", "brand", "style", "project", "topic", "goal", "name", "adapter", "out", "url", "document", "mime", "label", "role", "limit", "cursor", "timeout", "assets", "capabilities", "duration", "agent", "workspace", "prefix", "sha256", "kind", "channel", "epistemic-status", "event-offset", "relation-offset", "script", "video", "asset", "requirements", "mode", "review", "previous-version", "file", "revision", "expected-revision", "before", "scope", "id", "text", "conditions", "status", "index", "title", "days", ...booleans]);
+  const booleans = /* @__PURE__ */ new Set(["help", "version", "offline", "dry-run", "key-stdin", "invite-stdin", "no-browser", "skip-mcp", "all", "share-authorized", "details"]);
+  const known = /* @__PURE__ */ new Set(["input", "max-files", "at", "profile", "inventory", "plan", "dir", "brand", "style", "project", "topic", "goal", "name", "adapter", "out", "url", "document", "mime", "label", "role", "limit", "cursor", "timeout", "assets", "capabilities", "duration", "agent", "workspace", "prefix", "sha256", "kind", "channel", "epistemic-status", "event-offset", "relation-offset", "script", "video", "asset", "requirements", "mode", "review", "previous-version", "file", "revision", "expected-revision", "before", "scope", "id", "text", "conditions", "status", "index", "title", "days", ...booleans]);
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith("--")) {
@@ -1461,16 +2675,16 @@ function output(value) {
   process.stdout.write(stableJson(value));
 }
 async function configRoot(create = false) {
-  let path = process.env.EDITORBRAIN_CONFIG_DIR ?? process.env.EDITORHARNESS_CONFIG_DIR ?? join2(homedir(), ".config", "editorbrain");
+  let path = process.env.EDITORBRAIN_CONFIG_DIR ?? process.env.EDITORHARNESS_CONFIG_DIR ?? join3(homedir(), ".config", "editorbrain");
   if (!create && !process.env.EDITORBRAIN_CONFIG_DIR && !process.env.EDITORHARNESS_CONFIG_DIR) {
     try {
-      await lstat4(path);
+      await lstat7(path);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
-      path = join2(homedir(), ".config", "editorharness");
+      path = join3(homedir(), ".config", "editorharness");
     }
   }
-  if (create) await mkdir2(path, { recursive: true, mode: 448 });
+  if (create) await mkdir5(path, { recursive: true, mode: 448 });
   return ensureRoot(path);
 }
 async function loadConfig() {
@@ -1487,7 +2701,7 @@ async function loadConfig() {
 async function saveConfig(config2) {
   const root = await configRoot(true);
   await atomicWrite(root, "config.json", stableJson(config2), { document: false, mode: 384 });
-  await chmod(join2(root, "config.json"), 384);
+  await chmod(join3(root, "config.json"), 384);
 }
 async function config(args, requireKey = true) {
   const stored = await loadConfig();
@@ -1515,7 +2729,7 @@ async function init(args) {
   for (const path of Object.keys(files)) {
     const target = await checkedPath(root, path);
     try {
-      await lstat4(target);
+      await lstat7(target);
       throw new Error(`Refusing to replace existing file: ${path}`);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -1527,13 +2741,13 @@ async function init(args) {
   for (const path of directories) {
     const target = await checkedPath(root, path, false);
     try {
-      if (!(await lstat4(target)).isDirectory()) throw new Error(`Not a directory: ${path}`);
+      if (!(await lstat7(target)).isDirectory()) throw new Error(`Not a directory: ${path}`);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
   }
   for (const [path, content] of Object.entries(files)) await atomicWrite(root, path, content, { overwrite: false });
-  for (const path of directories) await mkdir2(await checkedPath(root, path, false), { recursive: true });
+  for (const path of directories) await mkdir5(await checkedPath(root, path, false), { recursive: true });
   const guidance = await installGuidance();
   const entryPoints = guidance.readInstructions.filter((item) => item.entryPointStatus === "created").map((item) => item.entryPoint);
   output({ root, created: Object.keys(files), entryPoints, guidance, next: `Edit brand tokens and brief, then run editorbrain resolve ${project}` });
@@ -1593,6 +2807,49 @@ async function main() {
     process.stdout.write(HELP);
     return;
   }
+  if (args.flags.details && !["media", "production"].includes(command)) throw new CliError("INVALID_ARGUMENT", "--details is supported only by media and production.", "Read editorbrain help.");
+  if (command === "media" || command === "production") {
+    const required = (name) => {
+      const value = str(args, name);
+      if (!value) throw new CliError("INVALID_ARGUMENT", `--${name} is required.`, "Read editorbrain help.");
+      return value;
+    };
+    if (argument) throw new CliError("INVALID_ARGUMENT", "Media/production inputs use named flags.", "Read editorbrain help.");
+    const allowed = /* @__PURE__ */ new Set(["dir", "out", "details", ...command === "media" && subcommand === "inventory" ? ["input", "max-files"] : command === "media" && subcommand === "sample" ? ["file", "at"] : command === "production" && subcommand === "check" ? ["file", "profile"] : command === "production" && subcommand === "plan-check" ? ["inventory", "plan"] : []]);
+    for (const flag of Object.keys(args.flags)) if (!allowed.has(flag)) throw new CliError("INVALID_ARGUMENT", `--${flag} is not supported for this local command.`, "Read editorbrain help.");
+    const root2 = await ensureRoot(str(args, "dir") ?? process.cwd());
+    const out = str(args, "out");
+    if (out) await productionOutputPath(root2, out);
+    const run2 = async () => {
+      let report;
+      if (command === "media" && subcommand === "inventory") {
+        const limit = str(args, "max-files");
+        report = await inventoryMedia({ input: resolve6(root2, required("input")), ...limit ? { maxFiles: Number(limit) } : {} });
+        if (!report.complete) process.exitCode = 2;
+      } else if (command === "media" && subcommand === "sample") {
+        const times = required("at").split(",");
+        if (times.some((t) => !t.trim() || !/^(?:\d+(?:\.\d*)?|\.\d+)$/.test(t.trim()))) throw new CliError("INVALID_ARGUMENT", "--at requires comma-separated nonnegative seconds.", "For example: --at 0,5.5,12");
+        const directory = await prepareSampleDirectory(root2, required("out"));
+        report = await sampleMedia({ file: resolve6(root2, required("file")), times: times.map(Number), outputDirectory: directory });
+      } else if (command === "production" && subcommand === "check") {
+        const profilePath = str(args, "profile");
+        const profile = profilePath ? validateRenderCheckProfile(await readProductionJson(root2, profilePath)) : void 0;
+        report = await checkRender({ file: resolve6(root2, required("file")), profile });
+        if (report.technicalStatus === "fail") process.exitCode = 1;
+        else if (!report.complete) process.exitCode = 2;
+      } else if (command === "production" && subcommand === "plan-check") {
+        const [inventory, plan] = await Promise.all([readProductionJson(root2, required("inventory")), readProductionJson(root2, required("plan"))]);
+        report = checkProductionPlan(inventory, plan);
+        if (!report.valid) process.exitCode = 1;
+        else if (!report.inventoryComplete) process.exitCode = 2;
+      } else throw new CliError("INVALID_ARGUMENT", "Unknown media/production command.", "Use media inventory/sample or production check/plan-check.");
+      const reportPath = out && subcommand !== "sample" ? await saveProductionReport(root2, out, report) : void 0;
+      output({ ...args.flags.details ? report : summarizeProductionReport(report), ...reportPath ? { reportPath } : {} });
+    };
+    if (out) await withWorkspaceLock(root2, run2, { migrateLegacy: false });
+    else await run2();
+    return;
+  }
   if (command === "doctor") {
     let selected, configError;
     if (!args.flags.offline) {
@@ -1639,6 +2896,20 @@ async function main() {
     output({ endpoint: client.url, ...await client.me() });
     return;
   }
+  if (command === "styles" && (subcommand === "create" || subcommand === "check")) {
+    const allowed = new Set(subcommand === "create" ? ["dir", "name"] : ["dir"]);
+    if (args.positional.length !== 3 || Object.keys(args.flags).some((flag) => !allowed.has(flag))) {
+      throw new CliError("INVALID_ARGUMENT", `Use styles ${subcommand} <style-id> [--dir folder]${subcommand === "create" ? " [--name name]" : ""}.`, "Style authoring runs locally and accepts only the documented options.");
+    }
+    const options = { directory: str(args, "dir") ?? process.cwd(), id: argument };
+    if (subcommand === "create") output(await createLocalStyle({ ...options, name: str(args, "name") }));
+    else {
+      const result = await checkLocalStyle(options);
+      output(result);
+      if (!result.valid) process.exitCode = 1;
+    }
+    return;
+  }
   if (command === "styles" || command === "direction") {
     const client = new Client(await config(args));
     if (command === "styles" && subcommand === "list") {
@@ -1661,10 +2932,10 @@ async function main() {
     const destination = str(args, "out");
     if (destination) {
       if (command !== "direction" || !result.files) throw new Error("--out is supported only for direction draft.");
-      const outRoot = await ensureRoot(resolve4(str(args, "dir") ?? process.cwd(), destination), true);
+      const outRoot = await ensureRoot(resolve6(str(args, "dir") ?? process.cwd(), destination), true);
       for (const path of Object.keys(result.files)) {
         try {
-          await lstat4(await checkedPath(outRoot, path, false));
+          await lstat7(await checkedPath(outRoot, path, false));
           throw new Error(`Refusing to replace existing proposal: ${path}`);
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -1690,7 +2961,7 @@ async function main() {
       if (!/^[a-zA-Z0-9_-]{1,100}$/.test(result.id) || typeof result.apiKey !== "string") throw new Error("Invalid key response");
       const file = `keys/${result.id}.json`;
       await atomicWrite(root2, file, stableJson({ url: client.url, apiKey: result.apiKey, id: result.id, label, role }), { document: false, mode: 384, overwrite: false });
-      output({ id: result.id, label, role, credentialFile: join2(root2, file) });
+      output({ id: result.id, label, role, credentialFile: join3(root2, file) });
       return;
     }
     if (subcommand === "revoke" && argument) {
@@ -1777,8 +3048,8 @@ async function main() {
       return;
     }
     if (subcommand === "upload" && argument) {
-      const target = resolve4(str(args, "dir") ?? process.cwd(), argument);
-      const handle = await open4(target, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+      const target = resolve6(str(args, "dir") ?? process.cwd(), argument);
+      const handle = await open7(target, constants7.O_RDONLY | constants7.O_NOFOLLOW);
       let bytes;
       try {
         const info = await handle.stat();
@@ -1788,24 +3059,24 @@ async function main() {
         await handle.close();
       }
       const types = { ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".ogg": "audio/ogg" };
-      const mimeType = str(args, "mime") ?? types[extname(target).toLowerCase()];
+      const mimeType = str(args, "mime") ?? types[extname3(target).toLowerCase()];
       if (!mimeType) throw new Error("Unsupported extension; specify --mime for a supported media format");
-      const hash = await sha256(bytes);
-      const result = await client.media(`/v1/assets/${hash}?name=${encodeURIComponent(basename(target))}`, { content: bytes, mimeType });
+      const hash2 = await sha256(bytes);
+      const result = await client.media(`/v1/assets/${hash2}?name=${encodeURIComponent(basename2(target))}`, { content: bytes, mimeType });
       const body = await result.json();
-      if (body.sha256 !== hash) throw new Error("Upload response hash mismatch");
+      if (body.sha256 !== hash2) throw new Error("Upload response hash mismatch");
       output(body);
       return;
     }
     if (subcommand === "download" && argument && str(args, "out")) {
       if (!/^[a-f0-9]{64}$/.test(argument)) throw new Error("Asset ID must be its SHA-256");
-      const destination = resolve4(str(args, "dir") ?? process.cwd(), str(args, "out"));
-      const root2 = await ensureRoot(dirname2(destination), true);
-      await checkedPath(root2, basename(destination), false);
+      const destination = resolve6(str(args, "dir") ?? process.cwd(), str(args, "out"));
+      const root2 = await ensureRoot(dirname6(destination), true);
+      await checkedPath(root2, basename2(destination), false);
       const response = await client.media(`/v1/assets/${argument}`);
       const bytes = new Uint8Array(await response.arrayBuffer());
       if (await sha256(bytes) !== argument) throw new Error("Downloaded asset failed SHA-256 verification");
-      await atomicWrite(root2, basename(destination), bytes, { document: false, overwrite: false });
+      await atomicWrite(root2, basename2(destination), bytes, { document: false, overwrite: false });
       output({ path: destination, sha256: argument, bytes: bytes.length });
       return;
     }
@@ -1835,7 +3106,7 @@ async function main() {
   if (command === "search" && subcommand === "brief") {
     const path = str(args, "file");
     if (!path) throw new Error("Provide --file with the editorial brief JSON after inspecting the actual material.");
-    const handle = await open4(resolve4(path), constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    const handle = await open7(resolve6(path), constants7.O_RDONLY | constants7.O_NOFOLLOW);
     let brief;
     try {
       const stat = await handle.stat();
@@ -1857,7 +3128,7 @@ async function main() {
     const scriptPath = str(args, "script"), videoPath = str(args, "video");
     let script, assetId = str(args, "asset");
     const readInput = async (path, max) => {
-      const handle = await open4(resolve4(path), constants4.O_RDONLY | constants4.O_NOFOLLOW);
+      const handle = await open7(resolve6(path), constants7.O_RDONLY | constants7.O_NOFOLLOW);
       try {
         const stat = await handle.stat();
         if (!stat.isFile() || stat.size < 1 || stat.size > max) throw new Error(`Input must be a regular file of at most ${max} bytes.`);
@@ -1877,10 +3148,10 @@ async function main() {
     if (assetId && !/^[a-f0-9]{64}$/.test(assetId)) throw new Error("--asset requires an owned production asset SHA-256.");
     if (videoPath) {
       const bytes = await readInput(videoPath, 12 * 1024 * 1024);
-      const mimeType = { ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm" }[extname(videoPath).toLowerCase()];
+      const mimeType = { ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm" }[extname3(videoPath).toLowerCase()];
       if (!mimeType) throw new Error("Use MP4, MOV or WebM.");
       assetId = await sha256(bytes);
-      const uploaded = await client.media(`/v1/assets/${assetId}?name=${encodeURIComponent(basename(videoPath))}`, { content: bytes, mimeType });
+      const uploaded = await client.media(`/v1/assets/${assetId}?name=${encodeURIComponent(basename2(videoPath))}`, { content: bytes, mimeType });
       if ((await uploaded.json()).sha256 !== assetId) throw new Error("Upload hash mismatch.");
     }
     if (!script && !assetId && !str(args, "project")) throw new Error("Provide --script, --video, --asset or --project with a saved script.");
@@ -1895,20 +3166,20 @@ async function main() {
     }
     if (subcommand === "get" && argument) {
       const document = str(args, "document");
-      const hash = str(args, "sha256");
-      if (hash && !document) throw new Error("--sha256 requires --document for library get.");
-      const result = await client.request(`/v1/library/${encodeURIComponent(argument)}${document ? `/documents?${new URLSearchParams({ path: document, ...hash ? { sha256: hash } : {} })}` : ""}`);
-      if (document && (typeof result.content !== "string" || await sha256(result.content) !== result.sha256 || hash && result.sha256 !== hash)) throw new CliError("HASH_MISMATCH", "Reference document verification failed.", "Do not use this evidence; retry the pinned version.");
+      const hash2 = str(args, "sha256");
+      if (hash2 && !document) throw new Error("--sha256 requires --document for library get.");
+      const result = await client.request(`/v1/library/${encodeURIComponent(argument)}${document ? `/documents?${new URLSearchParams({ path: document, ...hash2 ? { sha256: hash2 } : {} })}` : ""}`);
+      if (document && (typeof result.content !== "string" || await sha256(result.content) !== result.sha256 || hash2 && result.sha256 !== hash2)) throw new CliError("HASH_MISMATCH", "Reference document verification failed.", "Do not use this evidence; retry the pinned version.");
       output(result);
       return;
     }
     if (subcommand === "media" && argument && str(args, "out")) {
-      const hash = str(args, "sha256");
-      if (!hash || !/^[a-f0-9]{64}$/.test(hash)) throw new Error("--sha256 must be a media SHA-256 from library get.");
-      const destination = resolve4(str(args, "dir") ?? process.cwd(), str(args, "out"));
-      const root2 = await ensureRoot(dirname2(destination), true);
-      await checkedPath(root2, basename(destination), false);
-      const response = await client.media(`/v1/library/${encodeURIComponent(argument)}/media/${hash}`);
+      const hash2 = str(args, "sha256");
+      if (!hash2 || !/^[a-f0-9]{64}$/.test(hash2)) throw new Error("--sha256 must be a media SHA-256 from library get.");
+      const destination = resolve6(str(args, "dir") ?? process.cwd(), str(args, "out"));
+      const root2 = await ensureRoot(dirname6(destination), true);
+      await checkedPath(root2, basename2(destination), false);
+      const response = await client.media(`/v1/library/${encodeURIComponent(argument)}/media/${hash2}`);
       const reader = response.body?.getReader();
       if (!reader) throw new Error("Media body missing.");
       const chunks = [];
@@ -1924,9 +3195,9 @@ async function main() {
         chunks.push(value);
       }
       const bytes = Buffer.concat(chunks);
-      if (await sha256(bytes) !== hash) throw new CliError("HASH_MISMATCH", "Reference media verification failed.", "Do not use this file as evidence.");
-      await atomicWrite(root2, basename(destination), bytes, { document: false, overwrite: false });
-      output({ videoId: argument, path: destination, sha256: hash, bytes: size, mimeType: response.headers.get("Content-Type"), reviewed: false });
+      if (await sha256(bytes) !== hash2) throw new CliError("HASH_MISMATCH", "Reference media verification failed.", "Do not use this file as evidence.");
+      await atomicWrite(root2, basename2(destination), bytes, { document: false, overwrite: false });
+      output({ videoId: argument, path: destination, sha256: hash2, bytes: size, mimeType: response.headers.get("Content-Type"), reviewed: false });
       return;
     }
     throw new Error("Use library search, library get, or library media <video-id> --sha256 hash --out file.");
@@ -1961,7 +3232,7 @@ async function main() {
     const adapter = str(args, "adapter") ?? "neutral";
     if (!["neutral", "hyperframes", "remotion"].includes(adapter)) throw new Error("Adapter must be neutral, hyperframes or remotion");
     const generated = exportProject(resolved, adapter);
-    const destination = resolve4(root, str(args, "out") ?? `videos/${project}/plans/${adapter}`);
+    const destination = resolve6(root, str(args, "out") ?? `videos/${project}/plans/${adapter}`);
     const outRoot = await ensureRoot(destination, true);
     for (const [path, content] of Object.entries(generated)) await atomicWrite(outRoot, path, content, { document: false });
     output({ adapter, kind: "editorial_handoff", rendered: false, directory: outRoot, files: Object.keys(generated), warnings: resolved.warnings });