editorbrain 0.11.0 → 0.12.0

package/bin/editorbrain.mjs

@@ -52,7 +52,7 @@ function validateStyleResources(value, expectedId) {
   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 text = (value2, label) => {
+  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`);
   };
@@ -74,7 +74,7 @@ function validateStyleResources(value, expectedId) {
       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`);
-      text(resource.purpose, `${label} purpose`);
+      text2(resource.purpose, `${label} purpose`);
       if (typeof resource.required !== "boolean") add(`${label} required must be boolean`);
       const source = resource.source;
       if (!object(source)) {
@@ -94,7 +94,7 @@ function validateStyleResources(value, expectedId) {
         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`);
-        text(source.description, `${label} requirement description`);
+        text2(source.description, `${label} requirement description`);
       } else add(`${label} source must be local, asset or requirement`);
     }
   }
@@ -151,21 +151,21 @@ function checkStyle(files, id) {
     "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 finish = (documents2) => ({ valid: issues.length === 0, issues, warnings, documents: documents2, manualChecks });
+  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 finish([]);
+    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 finish([]);
+    return finish2([]);
   }
   const documents = Object.keys(selected).sort();
   for (const name of ["style.json", "style.md", "examples.json"]) {
@@ -197,7 +197,138 @@ function checkStyle(files, id) {
       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 finish(documents);
+  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
@@ -985,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", "09740ab4b275eada65b5040ae6000104ff39094f534a2784e67feb2afc2a59b3"], "AGENTS.md": ["4f3ef860ade3a31aa7c6a6aab5cf6ec2a700850bf19ea2320324c12c2e0fbf5b", "1b07de01698a0040b47ea0eddb1b017f70a69e81acd0bf9710647ca5e02f5125", "b5ee3439ff974c668755816149fab76899d7ad9266f63978b30fbc9b7d2cd640", "bacedb7bdedab5abe75c9601717cfdb05a96208fa2e2a42af878e2dfd2ae4251", "ea3b473179857ccc07e9e4f21a6ede9e0906a09e495f4a051069d15aee1556cd"], "references/cli-mcp.md": ["5d3a79343fbd76cdae5bdbe12fb9c944d5dff4f489ac6534fd96e0cb8630b988", "8e011c31368cef2117a28ee972b39aab9535eeb0f601a4a0f9d6fc019b22c1c2", "666082653efc000f8a7cc5f1836c80bbdda5f0f57cdbbdcb393f2b84aeb93a01", "78b737796a8685b1135e0acb91b620c51845b62e31dba04eb51dd9dd38b41008", "8b2e01bfd937237919f5ade794eed01dc6e32b556ede9de3a0ccc28cbdd988d1", "ca88b2816a795a5ebe834074b178469367634b80ad837e3697182ea585af1c05"], "references/production-and-review.md": ["055c6df9e0f167be148b0a5c0bba5b43e108eb1f58f478d88b3536c6589ac7b3"], "references/workspace-files.md": ["e72af2871f42cd776be1bfff8009ed5562780e7f8a65b12c27887f3880631f81", "00780c64bd0244c6afb18d786b7512b43e315c376e8f88c67d6ba53d91275ccf", "97053b092e0ff36e3cfb764095fcb4a4fca94e722567e774b53bc118279f40e5", "70fc660e7ed3d70c16c33c62c8e0399b99c3251808f093ef3d4ea5e8d39e4c8a", "28c62c1e28842142607f5168ee79b18fd797900dd66dd9ac5eb3cfcf8a09f781"] };
+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" }
@@ -1034,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);
@@ -1175,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;
@@ -1203,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;
@@ -1345,10 +1478,10 @@ async function setup(options, runner = runHost) {
 }
 
 // packages/cli/src/index.ts
-import { chmod, lstat as lstat5, mkdir as mkdir3, open as open5 } from "node:fs/promises";
-import { constants as constants5 } 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 dirname3, 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";
@@ -1369,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();
     });
   });
 }
@@ -1387,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) {
@@ -1435,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 = {}) {
@@ -1463,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) {
@@ -1475,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);
@@ -1502,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;
     }
@@ -1697,14 +1830,14 @@ async function checkLocalResource(root, path, expected) {
     const before = await handle.stat();
     if (!before.isFile()) throw new Error("Resource is not a regular file.");
     if (!expected) return {};
-    const hash = createHash2("sha256");
-    for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
+    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: hash.digest("hex") };
+    return { actualSha256: hash2.digest("hex") };
   } finally {
     await handle.close();
   }
@@ -1769,6 +1902,683 @@ async function checkLocalStyle(options) {
   };
 }
 
+// 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
 
@@ -1811,6 +2621,10 @@ editorbrain narrative get <video-id> [--sha256 document-hash] [--event-offset 0]
 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]
@@ -1826,14 +2640,16 @@ Resolve writes the source-hash lock. Export produces a handoff, not a rendered v
 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("--")) {
@@ -1859,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 lstat5(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 mkdir3(path, { recursive: true, mode: 448 });
+  if (create) await mkdir5(path, { recursive: true, mode: 448 });
   return ensureRoot(path);
 }
 async function loadConfig() {
@@ -1885,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();
@@ -1913,7 +2729,7 @@ async function init(args) {
   for (const path of Object.keys(files)) {
     const target = await checkedPath(root, path);
     try {
-      await lstat5(target);
+      await lstat7(target);
       throw new Error(`Refusing to replace existing file: ${path}`);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -1925,13 +2741,13 @@ async function init(args) {
   for (const path of directories) {
     const target = await checkedPath(root, path, false);
     try {
-      if (!(await lstat5(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 mkdir3(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}` });
@@ -1991,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) {
@@ -2073,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 lstat5(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;
@@ -2102,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) {
@@ -2189,8 +3048,8 @@ async function main() {
       return;
     }
     if (subcommand === "upload" && argument) {
-      const target = resolve4(str(args, "dir") ?? process.cwd(), argument);
-      const handle = await open5(target, constants5.O_RDONLY | constants5.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();
@@ -2200,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(dirname3(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;
     }
@@ -2247,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 open5(resolve4(path), constants5.O_RDONLY | constants5.O_NOFOLLOW);
+    const handle = await open7(resolve6(path), constants7.O_RDONLY | constants7.O_NOFOLLOW);
     let brief;
     try {
       const stat = await handle.stat();
@@ -2269,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 open5(resolve4(path), constants5.O_RDONLY | constants5.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.`);
@@ -2289,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.");
@@ -2307,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(dirname3(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 = [];
@@ -2336,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.");
@@ -2373,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 });