editorbrain 0.9.0 → 0.11.0

package/bin/editorbrain.mjs

@@ -1,5 +1,205 @@
 #!/usr/bin/env node
 
+// packages/core/src/memory.ts
+function memoryPath(scope, id) {
+  if (!["brand", "style", "project"].includes(scope) || !/^[a-z0-9][a-z0-9_-]{0,79}$/.test(id)) throw new Error("Invalid memory scope");
+  return scope === "project" ? `videos/${id}/preferences.json` : `.editorbrain/${scope === "brand" ? "brands" : "styles"}/${id}/preferences.json`;
+}
+function memoryScope(path) {
+  const m = path.match(/^\.editorbrain\/(brands|styles)\/([a-z0-9_-]+)\/preferences\.json$/), p = path.match(/^videos\/([a-z0-9_-]+)\/preferences\.json$/);
+  return m ? { scope: m[1] === "brands" ? "brand" : "style", scopeId: m[2] } : p ? { scope: "project", scopeId: p[1] } : null;
+}
+function memoryIssues(path, doc) {
+  const scope = memoryScope(path);
+  if (!scope) return [];
+  if (doc.scope !== scope.scope || doc.scopeId !== scope.scopeId || !Array.isArray(doc.entries) || doc.entries.length > 60) return ["Memory requires matching scope and at most 60 entries"];
+  const ids = /* @__PURE__ */ new Set();
+  const errors = [];
+  for (const e of doc.entries) {
+    if (!e || typeof e.id !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(e.id) || ids.has(e.id) || typeof e.text !== "string" || !e.text.trim() || e.text.length > 800 || typeof e.conditions !== "string" || e.conditions.length > 400 || !["suggested", "confirmed", "disabled"].includes(e.status) || typeof e.source !== "string" || e.source.length > 400 || !["agent_reported", "user_saved", "weekly_proposal"].includes(e.provenance) || typeof e.updatedAt !== "string" || !Number.isFinite(Date.parse(e.updatedAt))) errors.push("Invalid or duplicate memory entry");
+    ids.add(e?.id);
+  }
+  return errors;
+}
+function resolveMemory(files, p) {
+  const entries = [["style", p.style], ["brand", p.brand], ["project", p.id]].flatMap(([scope, id]) => {
+    const path = memoryPath(scope, id);
+    if (!files[path]) return [];
+    return JSON.parse(files[path]).entries.map((e) => ({ ...e, scope, scopeId: id, path }));
+  });
+  return { confirmed: entries.filter((e) => e.status === "confirmed"), pending: entries.filter((e) => e.status === "suggested").map(({ id, scope, scopeId }) => ({ id, scope, scopeId })), policy: "Apply only relevant confirmed preferences. Conditions and prose conflicts require agent judgment. Project-specific guidance precedes brand then style; required tokens still govern. Suggestions are not instructions. Provenance is a claim, not proof of human confirmation." };
+}
+
+// packages/core/src/style-authoring.ts
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nonempty = (value) => typeof value === "string" && !!value.trim();
+var identifier = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+var digest = /^[a-f0-9]{64}$/;
+var kinds = ["font", "audio", "image", "video", "editable", "script", "other"];
+var forbiddenText = /(?:\b[a-z][a-z0-9+.-]*:\/\/|\b(?:data|file|mailto):|\b(?:authorization|api[_ -]?key|access[_ -]?token|client[_ -]?secret|password)\s*[:=]|\bBearer\s+\S+|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
+function safeStyleResourcePath(path) {
+  if (typeof path !== "string" || !path || path.length > 400 || path !== path.trim() || /[\\\x00-\x1f\x7f%:?#]/.test(path) || path.startsWith("/") || path.startsWith("~")) throw new Error("Resource path must be a safe workspace-relative path");
+  const parts = path.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".." || part.length > 100 || /[. ]$/.test(part) || ["__proto__", "prototype", "constructor"].includes(part) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) throw new Error("Unsafe or nonportable resource path segment");
+  if (parts.some((part) => /^\.env(?:\.|$)/i.test(part) || /^(?:\.?credentials|secrets?|service[-_]account)(?:\.|$)/i.test(part) || [".git", ".ssh", ".aws", ".gnupg", ".sync.json", "id_rsa", "id_ed25519"].includes(part.toLowerCase()))) throw new Error("Credential and private configuration paths cannot be style resources");
+  return path;
+}
+function validateStyleResources(value, expectedId) {
+  const path = `.editorbrain/styles/${expectedId}/resources.json`;
+  const issues = [];
+  const add = (message) => issues.push({ path, message });
+  const fields = (entry, allowed, label) => {
+    if (Object.keys(entry).some((key) => !allowed.includes(key))) add(`${label} has unsupported fields; do not include URLs, credentials or hidden resource sources`);
+  };
+  const text = (value2, label) => {
+    if (!nonempty(value2)) add(`${label} must be nonempty text`);
+    else if (forbiddenText.test(value2) || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value2)) add(`${label} cannot contain URLs, credentials or control characters`);
+  };
+  if (!object(value)) return { valid: false, issues: [{ path, message: "Style resources must be a JSON object" }] };
+  fields(value, ["schemaVersion", "id", "resources"], "Style resources");
+  if (value.schemaVersion !== 1) add("schemaVersion must be 1");
+  if (!identifier.test(expectedId) || value.id !== expectedId) add(`Style resource id must match path: ${expectedId}`);
+  if (!Array.isArray(value.resources)) add("Style resources requires a resources array");
+  else {
+    const ids = /* @__PURE__ */ new Set();
+    for (const [index, resource] of value.resources.entries()) {
+      const label = `Resource ${index + 1}`;
+      if (!object(resource)) {
+        add(`${label} must be an object`);
+        continue;
+      }
+      fields(resource, ["id", "kind", "purpose", "required", "source"], label);
+      if (typeof resource.id !== "string" || !identifier.test(resource.id) || ["constructor", "prototype"].includes(resource.id)) add(`${label} requires a valid identifier`);
+      else if (ids.has(resource.id)) add(`Duplicate resource id: ${resource.id}`);
+      else ids.add(resource.id);
+      if (!kinds.includes(resource.kind)) add(`${label} has an invalid kind`);
+      text(resource.purpose, `${label} purpose`);
+      if (typeof resource.required !== "boolean") add(`${label} required must be boolean`);
+      const source = resource.source;
+      if (!object(source)) {
+        add(`${label} source must be local, asset or requirement`);
+        continue;
+      }
+      if (source.type === "local") {
+        fields(source, ["type", "path", "sha256"], `${label} local source`);
+        try {
+          safeStyleResourcePath(source.path);
+        } catch (error) {
+          add(`${label}: ${error.message}`);
+        }
+        if (source.sha256 !== void 0 && (typeof source.sha256 !== "string" || !digest.test(source.sha256))) add(`${label} sha256 must be a 64-character lowercase hexadecimal digest`);
+      } else if (source.type === "asset") {
+        fields(source, ["type", "assetId"], `${label} asset source`);
+        if (typeof source.assetId !== "string" || !digest.test(source.assetId)) add(`${label} assetId must be a 64-character lowercase hexadecimal digest`);
+      } else if (source.type === "requirement") {
+        fields(source, ["type", "description"], `${label} requirement source`);
+        text(source.description, `${label} requirement description`);
+      } else add(`${label} source must be local, asset or requirement`);
+    }
+  }
+  return { valid: issues.length === 0, issues };
+}
+function createStyle(options) {
+  const id = assertIdentifier(options.id);
+  const base = `.editorbrain/styles/${id}`;
+  safeDocumentPath(`${base}/style.json`);
+  const name = options.name ?? id;
+  if (!nonempty(name)) throw new Error("Style name must be nonempty text");
+  const style = { schemaVersion: 1, id, name, tokens: {}, references: [], components: [{ id: "editorial-mechanism", status: "concept" }] };
+  const resources = { schemaVersion: 1, id, resources: [] };
+  return {
+    [`${base}/style.json`]: stableJson(style),
+    [`${base}/style.md`]: `# ${name}
+
+STYLE_DRAFT
+
+Este documento es un borrador. Sustituye las preguntas por decisiones y evidencia; los componentes comienzan como concept.
+
+## Prop\xF3sito y encaje
+
+Describe qu\xE9 funci\xF3n cumple el estilo, para qu\xE9 material y audiencia encaja, qu\xE9 necesita y cu\xE1ndo no conviene usarlo.
+
+## Mecanismos que lo definen
+
+Explica c\xF3mo interact\xFAan narrativa, composici\xF3n, tipograf\xEDa, ritmo y sonido. Define qu\xE9 debe conservarse para reconocer el estilo y qu\xE9 se adapta a la marca, el guion y el footage real. No heredes una paleta, fuente o identidad personal por defecto.
+
+## T\xE9cnicas adaptables
+
+Para cada t\xE9cnica registra su funci\xF3n, requisitos, ancla de timing (voz, acci\xF3n, lectura o beat), par\xE1metros adaptables, cu\xE1ndo omitirla y c\xF3mo verificarla en el render. Los timestamps del piloto son evidencia localizada, no tiempos fijos para otro video. Detalla movimiento, estados y cobertura cuando sean relevantes.
+
+## Pilotos y evidencia
+
+Registra pilotos propios o referencias autorizadas en examples.json y referencias expl\xEDcitas en style.json. Separa observaci\xF3n, propuesta e inferencia; distingue revisi\xF3n de agente de revisi\xF3n humana. Documenta qu\xE9 mecanismo se prob\xF3, el material de destino, el resultado y las limitaciones. Una declaraci\xF3n transfer_tested no demuestra la prueba.
+
+## Recursos y l\xEDmites
+
+Declara recursos en resources.json con su prop\xF3sito, si son necesarios y una ruta relativa al workspace, un assetId permanente o un requisito pendiente. Describe permisos y sustitutos. No guardes URLs temporales ni credenciales. Un scaffold o chequeo estructural no valida calidad editorial ni disponibilidad remota.
+`,
+    [`${base}/examples.json`]: stableJson({ schemaVersion: 1, id, examples: [] }),
+    [`${base}/effects.md`]: "# Efectos y movimiento\n\nSTYLE_DRAFT\n\nPara cada t\xE9cnica define funci\xF3n, requisitos y evidencia del piloto; ancla entradas, estados, duraci\xF3n y salida a voz, acci\xF3n o tiempo de lectura del material real. Especifica qu\xE9 conservar, qu\xE9 adaptar, cu\xE1ndo omitir y c\xF3mo verificar movimiento, legibilidad y cobertura en el render. Separa lo observado de lo propuesto; no copies timestamps del piloto ni impongas efectos en cada beat. No deduzcas SFX a partir de im\xE1genes.\n",
+    [`${base}/music.md`]: "# M\xFAsica y sonido\n\nSTYLE_DRAFT\n\nDescribe funci\xF3n, energ\xEDa, instrumentaci\xF3n y uso del silencio seg\xFAn el relato. Ancla cambios a voz, acci\xF3n y beats reales; define cu\xE1ndo omitir m\xFAsica o SFX y c\xF3mo verificar inteligibilidad y mezcla escuchando el render. Separa sonidos corroborados de candidatos. Declara los recursos necesarios en resources.json y documenta su procedencia, licencia y sustitutos: una referencia no concede derechos de reutilizaci\xF3n.\n",
+    [`${base}/resources.json`]: stableJson(resources)
+  };
+}
+function checkStyle(files, id) {
+  const issues = [];
+  const warnings = [];
+  const manualChecks = [
+    "Review purpose, fit, defining mechanisms, what stays and what adapts against the actual destination material.",
+    "Inspect pilot evidence and its coverage; distinguish observations, proposals, agent review and human verification.",
+    "Preview the implemented edit: verify timing anchors, movement, legibility, audio and when each technique should be omitted.",
+    "Verify resource availability, local bytes, remote workspace authorization, provenance and reuse rights. Structural validation does not certify these."
+  ];
+  const finish = (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([]);
+  }
+  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([]);
+  }
+  const documents = Object.keys(selected).sort();
+  for (const name of ["style.json", "style.md", "examples.json"]) {
+    if (!own(selected, base + name)) issues.push({ path: base + name, message: "Missing required style document" });
+  }
+  for (const name of ["effects.md", "music.md"]) if (!own(selected, base + name)) warnings.push(`${base + name}: Optional guide is absent; document the relevant treatment before using this style.`);
+  for (const path of documents) {
+    const content = selected[path];
+    const result = validateDocument(path, content);
+    issues.push(...result.issues);
+    if (typeof content !== "string") continue;
+    if (!content.trim()) warnings.push(`${path}: Document is empty.`);
+    if (/^\s*(?:STYLE_DRAFT|DRAFT|TODO(?::[^\n]*)?)\s*$/m.test(content)) warnings.push(`${path}: Draft markers remain; complete the authored guidance before claiming readiness.`);
+    if (!result.valid || !path.endsWith(".json")) continue;
+    const doc = JSON.parse(content);
+    if (path === base + "examples.json") {
+      if (!Array.isArray(doc.examples)) issues.push({ path, message: "Style examples requires an examples array" });
+      else if (!doc.examples.length) warnings.push(`${path}: No pilot examples are recorded; evidence and transfer have not been assessed.`);
+      else warnings.push(`${path}: Example entries are preserved as descriptive data; this check cannot assess their evidence, review claims or transfer quality.`);
+    }
+    if (path === base + "style.json" && Array.isArray(doc.components)) {
+      for (const component of doc.components) {
+        if (component.status === "concept") warnings.push(`${path}: Component ${component.id} remains concept; implementation is pending.`);
+        if (component.status === "transfer_tested") warnings.push(`${path}: Component ${component.id} declares transfer_tested; the declaration is not proof of a tested transfer.`);
+      }
+    }
+    if (path === base + "resources.json") {
+      const resources = doc;
+      for (const resource of resources.resources) if (resource.source.type === "requirement") warnings.push(`${path}: Resource ${resource.id} is a requirement; availability has not been verified.`);
+    }
+  }
+  return finish(documents);
+}
+
 // packages/core/src/index.ts
 var SCHEMA_VERSION = 1;
 var MAX_DOCUMENT_BYTES = 128 * 1024;
@@ -11,15 +211,15 @@ var ValidationError = class extends Error {
   }
   issues;
 };
-var identifier = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+var identifier2 = /^[a-z0-9][a-z0-9_-]{0,79}$/;
 var tokenName = /^[a-z][a-z0-9_.-]{0,79}$/;
-var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-var nonempty = (value) => typeof value === "string" && value.trim().length > 0;
+var own2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var object2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nonempty2 = (value) => typeof value === "string" && value.trim().length > 0;
 var finite = (value) => typeof value === "number" && Number.isFinite(value);
 var tokenValue = (value) => typeof value === "string" || typeof value === "boolean" || finite(value) || Array.isArray(value) && value.every((v) => typeof v === "string");
 function assertIdentifier(value) {
-  if (!identifier.test(value)) throw new Error(`Invalid identifier: ${value}. Use lowercase letters, numbers, _ or - (max 80).`);
+  if (!identifier2.test(value)) throw new Error(`Invalid identifier: ${value}. Use lowercase letters, numbers, _ or - (max 80).`);
   return value;
 }
 function safeDocumentPath(path) {
@@ -31,13 +231,13 @@ function safeDocumentPath(path) {
   return path;
 }
 function checkRules(value, add) {
-  if (!object(value)) {
+  if (!object2(value)) {
     add("tokens must be an object");
     return;
   }
   for (const [key, rule] of Object.entries(value)) {
     if (!tokenName.test(key) || ["__proto__", "constructor", "prototype"].includes(key)) add(`Invalid semantic token ${key}`);
-    if (!object(rule) || !tokenValue(rule.value) || !["required", "preferred", "example"].includes(String(rule.strength))) add(`Token ${key} requires value and strength required/preferred/example`);
+    if (!object2(rule) || !tokenValue(rule.value) || !["required", "preferred", "example"].includes(String(rule.strength))) add(`Token ${key} requires value and strength required/preferred/example`);
   }
 }
 function checkEvidence(value, add) {
@@ -46,7 +246,7 @@ function checkEvidence(value, add) {
     return;
   }
   for (const ref of value) {
-    if (!object(ref) || !nonempty(ref.videoId) || !["reference_only", "licensed_asset", "owned_asset"].includes(String(ref.relationship))) add("Evidence must include videoId and explicit relationship");
+    if (!object2(ref) || !nonempty2(ref.videoId) || !["reference_only", "licensed_asset", "owned_asset"].includes(String(ref.relationship))) add("Evidence must include videoId and explicit relationship");
     else {
       if (ref.timestampSeconds !== void 0 && (!finite(ref.timestampSeconds) || ref.timestampSeconds < 0)) add("Evidence timestamp must be nonnegative seconds");
       if (ref.reviewStatus !== void 0 && !["unreviewed", "agent_reviewed", "human_verified"].includes(String(ref.reviewStatus))) add("Invalid evidence reviewStatus");
@@ -75,11 +275,12 @@ function validateDocument(path, content) {
     add("Invalid JSON");
     return { valid: false, issues };
   }
-  if (!object(doc)) {
+  if (!object2(doc)) {
     add("JSON document must be an object");
     return { valid: false, issues };
   }
   if (doc.schemaVersion !== SCHEMA_VERSION) add("schemaVersion must be 1");
+  for (const message of memoryIssues(canonicalDocumentPath(path), doc)) add(message);
   const parts = canonicalDocumentPath(path).split("/");
   const isBrand = parts[0] === ".editorbrain" && parts[1] === "brands" && parts.length === 4;
   const isStyle = parts[0] === ".editorbrain" && parts[1] === "styles" && parts.length === 4;
@@ -88,38 +289,39 @@ function validateDocument(path, content) {
   const isMedia = parts[0] === "videos" && parts.length === 3 && parts[2] === "media.json";
   if (isBrand || isStyle || isProject || isOutput) {
     const expected = isOutput ? parts[2].slice(0, -5) : parts[isProject ? 1 : 2];
-    if (!identifier.test(expected)) add("Invalid resource identifier in path");
+    if (!identifier2.test(expected)) add("Invalid resource identifier in path");
     if (doc.id !== void 0 && doc.id !== expected) add(`Document id must match path: ${expected}`);
   }
+  if (isStyle && parts[3] === "resources.json") for (const issue of validateStyleResources(doc, parts[2]).issues) add(issue.message);
   if (isBrand && parts[3] === "tokens.json" || isStyle && parts[3] === "style.json") {
-    if (!nonempty(doc.id)) add("id is required");
+    if (!nonempty2(doc.id)) add("id is required");
     if (isBrand || doc.tokens !== void 0) checkRules(doc.tokens, add);
     if (isStyle) {
-      if (!nonempty(doc.name)) add("Style name is required");
+      if (!nonempty2(doc.name)) add("Style name is required");
       if (doc.references !== void 0) checkEvidence(doc.references, add);
-      if (doc.components !== void 0 && (!Array.isArray(doc.components) || doc.components.some((c) => !object(c) || !nonempty(c.id) || !["concept", "implemented", "transfer_tested"].includes(String(c.status))))) add("Components need id and explicit implementation status");
+      if (doc.components !== void 0 && (!Array.isArray(doc.components) || doc.components.some((c) => !object2(c) || !nonempty2(c.id) || !["concept", "implemented", "transfer_tested"].includes(String(c.status))))) add("Components need id and explicit implementation status");
     }
   }
   if (isProject) {
-    for (const key of ["id", "brand", "style", "outputProfile"]) if (typeof doc[key] !== "string" || !identifier.test(doc[key])) add(`${key} must be a valid identifier`);
-    if (!object(doc.intent) || !nonempty(doc.intent.topic) || !nonempty(doc.intent.goal)) add("intent requires topic and goal");
+    for (const key of ["id", "brand", "style", "outputProfile"]) if (typeof doc[key] !== "string" || !identifier2.test(doc[key])) add(`${key} must be a valid identifier`);
+    if (!object2(doc.intent) || !nonempty2(doc.intent.topic) || !nonempty2(doc.intent.goal)) add("intent requires topic and goal");
     if (doc.reviewMode !== void 0 && !["direct", "directions", "sample"].includes(doc.reviewMode)) add("reviewMode must be direct, directions or sample");
     if (doc.script !== void 0 && typeof doc.script !== "string") add("script must be text");
     if (doc.overrides !== void 0) {
-      if (!object(doc.overrides)) add("overrides must be an object");
+      if (!object2(doc.overrides)) add("overrides must be an object");
       else for (const [key, rule] of Object.entries(doc.overrides)) {
         if (!tokenName.test(key) || ["__proto__", "constructor", "prototype"].includes(key)) add(`Invalid override token ${key}`);
-        if (!object(rule) || !tokenValue(rule.value) || !nonempty(rule.reason) || rule.overrideRequired !== void 0 && typeof rule.overrideRequired !== "boolean") add(`Override ${key} requires value and a reason; overrideRequired must be boolean`);
+        if (!object2(rule) || !tokenValue(rule.value) || !nonempty2(rule.reason) || rule.overrideRequired !== void 0 && typeof rule.overrideRequired !== "boolean") add(`Override ${key} requires value and a reason; overrideRequired must be boolean`);
       }
     }
   }
   if (isMedia) {
-    if (!identifier.test(parts[1])) add("Invalid project identifier in media path");
+    if (!identifier2.test(parts[1])) add("Invalid project identifier in media path");
     if (!Array.isArray(doc.assets)) add("Production media requires an assets array");
     else {
       const ids = /* @__PURE__ */ new Set();
       for (const asset of doc.assets) {
-        if (!object(asset) || typeof asset.id !== "string" || !/^[a-f0-9]{64}$/.test(asset.id) || !nonempty(asset.name) || typeof asset.mimeType !== "string" || !/^(video|image|audio)\/[a-zA-Z0-9][a-zA-Z0-9.+-]*$/.test(asset.mimeType) || !Number.isSafeInteger(asset.bytes) || Number(asset.bytes) < 1) {
+        if (!object2(asset) || typeof asset.id !== "string" || !/^[a-f0-9]{64}$/.test(asset.id) || !nonempty2(asset.name) || typeof asset.mimeType !== "string" || !/^(video|image|audio)\/[a-zA-Z0-9][a-zA-Z0-9.+-]*$/.test(asset.mimeType) || !Number.isSafeInteger(asset.bytes) || Number(asset.bytes) < 1) {
           add("Production assets require a SHA-256 id, name, media mimeType and positive integer bytes");
           continue;
         }
@@ -129,11 +331,11 @@ function validateDocument(path, content) {
     }
   }
   if (isOutput) {
-    if (!nonempty(doc.id)) add("id is required");
+    if (!nonempty2(doc.id)) add("id is required");
     for (const key of ["width", "height"]) if (!Number.isInteger(doc[key]) || Number(doc[key]) < 1 || Number(doc[key]) > 16384) add(`${key} must be an integer between 1 and 16384`);
     if (!finite(doc.fps) || doc.fps <= 0 || doc.fps > 240) add("fps must be between 0 and 240");
     if (doc.safeAreas !== void 0) {
-      if (!object(doc.safeAreas) || ["top", "right", "bottom", "left"].some((k) => !finite(doc.safeAreas[k]) || Number(doc.safeAreas[k]) < 0 || Number(doc.safeAreas[k]) >= 0.5)) add("safeAreas must have normalized fractions from 0 up to (not including) 0.5 for all four sides");
+      if (!object2(doc.safeAreas) || ["top", "right", "bottom", "left"].some((k) => !finite(doc.safeAreas[k]) || Number(doc.safeAreas[k]) < 0 || Number(doc.safeAreas[k]) >= 0.5)) add("safeAreas must have normalized fractions from 0 up to (not including) 0.5 for all four sides");
     }
   }
   return { valid: issues.length === 0, issues };
@@ -154,7 +356,7 @@ function projectSources(project) {
   ];
 }
 function optionalProjectSources(project) {
-  return [`.editorbrain/brands/${project.brand}/design.md`, `.editorbrain/styles/${project.style}/effects.md`, `.editorbrain/styles/${project.style}/music.md`, `videos/${project.id}/media.json`];
+  return [`.editorbrain/brands/${project.brand}/design.md`, `.editorbrain/styles/${project.style}/effects.md`, `.editorbrain/styles/${project.style}/music.md`, `videos/${project.id}/media.json`, memoryPath("brand", project.brand), memoryPath("style", project.style), memoryPath("project", project.id), `.editorbrain/styles/${project.style}/resources.json`];
 }
 function validateWorkspace(files) {
   files = canonicalFiles(files);
@@ -163,31 +365,31 @@ function validateWorkspace(files) {
   for (const [path, content] of Object.entries(files)) {
     if (!/^videos\/[^/]+\/project\.json$/.test(path) || !validateDocument(path, content).valid) continue;
     const project = JSON.parse(content);
-    for (const required of projectSources(project)) if (!own(files, required)) issues.push({ path, message: `Missing required source ${required}` });
+    for (const required of projectSources(project)) if (!own2(files, required)) issues.push({ path, message: `Missing required source ${required}` });
   }
   return { valid: issues.length === 0, issues };
 }
 function stableJson(value) {
-  const sort = (item) => Array.isArray(item) ? item.map(sort) : object(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, sort(item[key])])) : item;
+  const sort = (item) => Array.isArray(item) ? item.map(sort) : object2(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, sort(item[key])])) : item;
   return JSON.stringify(sort(value), null, 2) + "\n";
 }
 async function sha256(content) {
   const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
-  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
-  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+  const digest2 = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+  return Array.from(new Uint8Array(digest2), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 async function resolveProject(files, projectId) {
   files = canonicalFiles(files);
   assertIdentifier(projectId);
   const path = `videos/${projectId}/project.json`;
-  if (!own(files, path)) throw new ValidationError([{ path, message: "Project does not exist" }]);
+  if (!own2(files, path)) throw new ValidationError([{ path, message: "Project does not exist" }]);
   const basic = validateDocument(path, files[path]);
   if (!basic.valid) throw new ValidationError(basic.issues);
   const project = JSON.parse(files[path]);
   const requiredPaths = projectSources(project);
   const optionalPaths = optionalProjectSources(project);
-  const sourcePaths = [...requiredPaths, ...optionalPaths.filter((p) => own(files, p))];
-  const relevant = Object.fromEntries(sourcePaths.filter((p) => own(files, p)).map((p) => [p, files[p]]));
+  const sourcePaths = [...requiredPaths, ...optionalPaths.filter((p) => own2(files, p))];
+  const relevant = Object.fromEntries(sourcePaths.filter((p) => own2(files, p)).map((p) => [p, files[p]]));
   const validation = validateWorkspace(relevant);
   if (!validation.valid) throw new ValidationError(validation.issues);
   const [brandPath, tokensPath, languagePath, assetsPath, styleMdPath, stylePath, examplesPath, outputPath, , briefPath, directionPath] = requiredPaths;
@@ -228,11 +430,13 @@ async function resolveProject(files, projectId) {
     output: output2,
     tokens,
     tokenSources,
-    editorial: { brand: files[brandPath], style: files[styleMdPath], brief: files[briefPath], direction: files[directionPath], ...Object.fromEntries(["design", "effects", "music"].flatMap((key, index) => own(files, optionalPaths[index]) ? [[key, files[optionalPaths[index]]]] : [])) },
+    editorial: { brand: files[brandPath], style: files[styleMdPath], brief: files[briefPath], direction: files[directionPath], ...Object.fromEntries(["design", "effects", "music"].flatMap((key, index) => own2(files, optionalPaths[index]) ? [[key, files[optionalPaths[index]]]] : [])) },
     language: JSON.parse(files[languagePath]),
     brandAssets: JSON.parse(files[assetsPath]),
     examples: JSON.parse(files[examplesPath]),
-    ...own(files, optionalPaths[3]) ? { media: JSON.parse(files[optionalPaths[3]]) } : {},
+    ...own2(files, optionalPaths[3]) ? { media: JSON.parse(files[optionalPaths[3]]) } : {},
+    ...own2(files, optionalPaths[7]) ? { styleResources: JSON.parse(files[optionalPaths[7]]) } : {},
+    memory: resolveMemory(files, project),
     evidence: style.references ?? [],
     warnings,
     lock: { schemaVersion: 1, projectId, sourceHashes, overrides: project.overrides ?? {}, adapters: Object.fromEntries(["neutral", "hyperframes", "remotion"].map((key) => [key, { version: "0.2.1", kind: "editorial_handoff", rendered: false }])) }
@@ -250,6 +454,10 @@ ${content}` : "";
 
 \`\`\`json
 ${stableJson(resolved.media)}\`\`\``) : "";
+  const resourcesSection = resolved.styleResources ? section("Style resources", `Resolve local paths from the original workspace root; asset IDs require authorized workspace access. Availability and reuse rights must be verified before use.
+
+\`\`\`json
+${stableJson(resolved.styleResources)}\`\`\``) : "";
   if (adapter === "neutral") return { ...common, "brief.md": `# ${resolved.project.id}
 
 ${disclaimer}
@@ -266,7 +474,7 @@ ${resolved.editorial.brand}
 
 ## Style
 
-${resolved.editorial.style}${section("Design", resolved.editorial.design)}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}
+${resolved.editorial.style}${section("Design", resolved.editorial.design)}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}${resourcesSection}
 
 Exact tokens, output settings and evidence are in resolved.json.
 ` };
@@ -294,13 +502,13 @@ ${resolved.editorial.direction}
 
 ## Style intent
 
-${resolved.editorial.style}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}
+${resolved.editorial.style}${section("Effects", resolved.editorial.effects)}${section("Music and sound", resolved.editorial.music)}${mediaSection}${resourcesSection}
 
 ## Delivery
 
 ${resolved.output.width} \xD7 ${resolved.output.height}, ${resolved.output.fps} fps. Adapt composition to the actual material and safe areas in resolved.json. Implement and preview the composition in Hyperframes before claiming completion.
 ` };
-  if (adapter === "remotion") return { ...common, "remotion-plan.json": stableJson({ schemaVersion: 1, kind: "editorial_handoff", renderer: "remotion", executable: false, note: disclaimer, composition: { width: resolved.output.width, height: resolved.output.height, fps: resolved.output.fps, durationInFrames: null }, tokens: resolved.tokens, project: resolved.project, direction: resolved.editorial.direction, editorial: resolved.editorial, ...resolved.media ? { media: resolved.media } : {}, evidence: resolved.evidence, implementationTasks: ["Determine duration from the script/audio and actual cuts.", "Implement React composition and assets.", "Preview and verify typography, safe areas, motion and audio."] }) };
+  if (adapter === "remotion") return { ...common, "remotion-plan.json": stableJson({ schemaVersion: 1, kind: "editorial_handoff", renderer: "remotion", executable: false, note: disclaimer, composition: { width: resolved.output.width, height: resolved.output.height, fps: resolved.output.fps, durationInFrames: null }, tokens: resolved.tokens, project: resolved.project, direction: resolved.editorial.direction, editorial: resolved.editorial, ...resolved.media ? { media: resolved.media } : {}, ...resolved.styleResources ? { styleResources: resolved.styleResources } : {}, evidence: resolved.evidence, implementationTasks: ["Determine duration from the script/audio and actual cuts.", "Implement React composition and assets.", "Preview and verify typography, safe areas, motion and audio."] }) };
   throw new Error(`Unsupported adapter: ${adapter}`);
 }
 function createWorkspace(options = {}) {
@@ -640,11 +848,11 @@ async function pushWorkspace(client, root, files, options = {}) {
   for (const [path, content] of Object.entries(files)) {
     const validation = validateDocument(path, content);
     if (!validation.valid) throw new Error(validation.issues.map((x) => `${x.path}: ${x.message}`).join("\n"));
-    const digest = await sha256(content);
+    const digest2 = await sha256(content);
     const existing = remote.get(path);
     const base = state.documents[path];
-    if (existing?.sha256 === digest) {
-      state.documents[path] = { revision: existing.revision, sha256: digest };
+    if (existing?.sha256 === digest2) {
+      state.documents[path] = { revision: existing.revision, sha256: digest2 };
       unchanged++;
       continue;
     }
@@ -665,8 +873,8 @@ ${conflicts.join("\n")}`, "Run push --dry-run and reconcile the reported paths."
   for (const item of pending) {
     const result = await client.put(item.path, item.content, item.expectedRevision);
     checkRemote(result);
-    const digest = await sha256(item.content);
-    if (result.path !== item.path || result.sha256 !== digest) throw new Error("Server returned inconsistent write metadata");
+    const digest2 = await sha256(item.content);
+    if (result.path !== item.path || result.sha256 !== digest2) throw new Error("Server returned inconsistent write metadata");
     state.documents[item.path] = { revision: result.revision, sha256: result.sha256 };
     uploaded.push(item.path);
     await saveSyncState(root, state);
@@ -684,14 +892,14 @@ async function pullWorkspace(client, root, local, options = {}) {
   for (const summary of summaries) {
     checkRemote(summary);
     const content = local[summary.path];
-    const digest = content === void 0 ? void 0 : await sha256(content);
+    const digest2 = content === void 0 ? void 0 : await sha256(content);
     const base = state.documents[summary.path];
-    if (digest === summary.sha256) {
+    if (digest2 === summary.sha256) {
       state.documents[summary.path] = { revision: summary.revision, sha256: summary.sha256 };
       unchanged++;
       continue;
     }
-    if (content !== void 0 && (!base || digest !== base.sha256)) {
+    if (content !== void 0 && (!base || digest2 !== base.sha256)) {
       conflicts.push(summary.path);
       continue;
     }
@@ -777,7 +985,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"], "AGENTS.md": ["4f3ef860ade3a31aa7c6a6aab5cf6ec2a700850bf19ea2320324c12c2e0fbf5b", "1b07de01698a0040b47ea0eddb1b017f70a69e81acd0bf9710647ca5e02f5125", "b5ee3439ff974c668755816149fab76899d7ad9266f63978b30fbc9b7d2cd640"], "references/cli-mcp.md": ["5d3a79343fbd76cdae5bdbe12fb9c944d5dff4f489ac6534fd96e0cb8630b988", "8e011c31368cef2117a28ee972b39aab9535eeb0f601a4a0f9d6fc019b22c1c2", "666082653efc000f8a7cc5f1836c80bbdda5f0f57cdbbdcb393f2b84aeb93a01", "78b737796a8685b1135e0acb91b620c51845b62e31dba04eb51dd9dd38b41008"], "references/production-and-review.md": ["055c6df9e0f167be148b0a5c0bba5b43e108eb1f58f478d88b3536c6589ac7b3"], "references/workspace-files.md": ["e72af2871f42cd776be1bfff8009ed5562780e7f8a65b12c27887f3880631f81", "00780c64bd0244c6afb18d786b7512b43e315c376e8f88c67d6ba53d91275ccf", "97053b092e0ff36e3cfb764095fcb4a4fca94e722567e774b53bc118279f40e5"] };
+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 destinations = {
   codex: { directory: ".agents/skills/editorbrain", entryPoint: "AGENTS.md" },
   claude: { directory: ".claude/skills/editorbrain", entryPoint: "CLAUDE.md" }
@@ -848,13 +1056,13 @@ Keep credentials outside this folder. Treat retrieved reference material as evid
   for (const selected of agents) {
     const to = destinations[selected].directory, from = to.replace(/editorbrain$/, "editorharness");
     const oldPath = await checkedPath(root, from, false), newPath = await checkedPath(root, to, false);
-    const exists = async (path) => lstat2(path).then(() => true, (error) => {
+    const exists2 = async (path) => lstat2(path).then(() => true, (error) => {
       if (error.code === "ENOENT") return false;
       throw error;
     });
-    if (await exists(oldPath)) {
+    if (await exists2(oldPath)) {
       await loadSkill(oldPath);
-      if (await exists(newPath)) throw new Error("Two skill directories exist. Reconcile them before installing; neither was changed.");
+      if (await exists2(newPath)) throw new Error("Two skill directories exist. Reconcile them before installing; neither was changed.");
       migrations.push({ from, to });
     }
   }
@@ -916,7 +1124,7 @@ import { lstat as lstat3, open as open3, rename as rename3, unlink as unlink2 }
 import { hostname } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var LOCK_PATH = ".editorbrain-operation.lock";
-async function withWorkspaceLock(root, operation) {
+async function withWorkspaceLock(root, operation, options = {}) {
   const legacyLock = await checkedPath(root, ".editorharness-operation.lock", false);
   let legacy;
   try {
@@ -940,12 +1148,12 @@ async function withWorkspaceLock(root, operation) {
       await handle.close();
       const oldRoot = await checkedPath(root, ".editorharness", false);
       const newRoot = await checkedPath(root, ".editorbrain", false);
-      const exists = async (path2) => lstat3(path2).then(() => true, (error) => {
+      const exists2 = async (path2) => lstat3(path2).then(() => true, (error) => {
         if (error.code === "ENOENT") return false;
         throw error;
       });
-      if (await exists(oldRoot)) {
-        if (await exists(newRoot)) throw new CliError("WORKSPACE_PATH_CONFLICT", "This folder contains two versions of the workspace directory.", "Reconcile the directories before continuing; neither was changed.");
+      if (options.migrateLegacy !== false && await exists2(oldRoot)) {
+        if (await exists2(newRoot)) throw new CliError("WORKSPACE_PATH_CONFLICT", "This folder contains two versions of the workspace directory.", "Reconcile the directories before continuing; neither was changed.");
         await rename3(oldRoot, newRoot);
       }
       return await operation();
@@ -1067,7 +1275,7 @@ async function configureMcp(agent, directory, url, noBrowser, runner = runHost)
   const version = await runner(agent, ["--version"], directory);
   if (version.code !== 0) throw new CliError("AGENT_UNAVAILABLE", `${agent} CLI is unavailable.`, "Install the official agent CLI, or use setup --skip-mcp.");
   const inspect = await runner(agent, agent === "codex" ? ["mcp", "list", "--json"] : ["mcp", "get", "editorbrain"], directory);
-  let exists = false;
+  let exists2 = false;
   if (agent === "codex") {
     if (inspect.code !== 0) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Codex MCP configuration.", "Inspect it manually; setup did not overwrite it.");
     let list;
@@ -1077,12 +1285,12 @@ async function configureMcp(agent, directory, url, noBrowser, runner = runHost)
       throw new CliError("MCP_INSPECTION_FAILED", "Codex returned an unsupported configuration format.", "Inspect MCP configuration manually.");
     }
     if (!Array.isArray(list)) throw new CliError("MCP_INSPECTION_FAILED", "Unsupported MCP configuration response.", "Inspect MCP configuration manually.");
-    exists = list.some((item) => item?.name === "editorbrain");
+    exists2 = list.some((item) => item?.name === "editorbrain");
   } else {
-    exists = inspect.code === 0;
-    if (!exists && !/^No MCP server named "editorbrain"[.\s]/.test(inspect.stderr + inspect.stdout)) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Claude MCP configuration.", "Inspect it manually; setup did not overwrite it.");
+    exists2 = inspect.code === 0;
+    if (!exists2 && !/^No MCP server named "editorbrain"[.\s]/.test(inspect.stderr + inspect.stdout)) throw new CliError("MCP_INSPECTION_FAILED", "Could not inspect Claude MCP configuration.", "Inspect it manually; setup did not overwrite it.");
   }
-  if (exists) return { agent, status: "preserved", next: "An existing editorbrain server was preserved. Check its endpoint and authentication, then " + next, hostVerified: false };
+  if (exists2) return { agent, status: "preserved", next: "An existing editorbrain server was preserved. Check its endpoint and authentication, then " + next, hostVerified: false };
   const added = await runner(agent, args, directory, true);
   return { agent, status: added.code === 0 ? "registered" : "action_required", next, hostVerified: false };
 }
@@ -1137,10 +1345,10 @@ async function setup(options, runner = runHost) {
 }
 
 // packages/cli/src/index.ts
-import { chmod, lstat as lstat4, mkdir as mkdir2, open as open4 } from "node:fs/promises";
-import { constants as constants4 } from "node:fs";
+import { chmod, lstat as lstat5, mkdir as mkdir3, open as open5 } from "node:fs/promises";
+import { constants as constants5 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname as dirname2, extname, join as join2, resolve as resolve4 } from "node:path";
+import { basename, dirname as dirname3, extname, join as join2, resolve as resolve4 } from "node:path";
 
 // packages/cli/src/device-auth.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -1342,6 +1550,225 @@ async function prepareDirectionContext(root, client, projectId) {
   };
 }
 
+// packages/cli/src/style-authoring.ts
+import { createHash as createHash2 } from "node:crypto";
+import { constants as constants4 } from "node:fs";
+import { lstat as lstat4, mkdir as mkdir2, open as open4, readdir as readdir3, rmdir, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+function styleId(id) {
+  try {
+    return assertIdentifier(id);
+  } catch {
+    throw new CliError("INVALID_ARGUMENT", "A style ID must use lowercase letters, numbers, _ or - (1\u201380 characters).", "Use styles create <style-id> or styles check <style-id>.");
+  }
+}
+async function exists(path) {
+  try {
+    await lstat4(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function preflightCreate(root, id, files) {
+  for (const prefix of [".editorbrain", ".editorharness"]) {
+    const path = `${prefix}/styles/${id}`;
+    if (await exists(await checkedPath(root, path, false))) {
+      throw new CliError("STYLE_EXISTS", `Style ${id} already exists in this workspace.`, "Choose a new style ID or edit the existing style documents; creation never replaces a style.");
+    }
+  }
+  if (await exists(await checkedPath(root, ".editorharness", false))) {
+    throw new CliError("WORKSPACE_PATH_CONFLICT", "This workspace still has a legacy portable directory.", "Migrate it using the existing workspace pull flow, or create the style in a separate folder. No style or project was changed.");
+  }
+  for (const path of Object.keys(files)) {
+    if (!path.startsWith(`.editorbrain/styles/${id}/`)) throw new Error("Style template escaped its destination");
+    const target = await checkedPath(root, path);
+    if (await exists(target)) throw new CliError("STYLE_EXISTS", `Refusing to replace existing file: ${path}`, "Choose a new style ID.");
+  }
+}
+async function makeDirectories(root, path, created) {
+  const segments = path.split("/");
+  for (let i = 1; i <= segments.length; i++) {
+    const relative2 = segments.slice(0, i).join("/");
+    const target = await checkedPath(root, relative2, false);
+    try {
+      await mkdir2(target);
+      const info = await lstat4(target);
+      created.push({ path: relative2, dev: info.dev, ino: info.ino });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (!(await lstat4(await checkedPath(root, relative2, false))).isDirectory()) throw new Error(`Not a directory: ${relative2}`);
+    }
+  }
+}
+async function cleanCreated(root, paths, directory) {
+  for (const item of [...paths].reverse()) {
+    try {
+      const target = await checkedPath(root, item.path, false);
+      const info = await lstat4(target);
+      if (info.dev !== item.dev || info.ino !== item.ino || info.isSymbolicLink()) continue;
+      if (directory) await rmdir(target);
+      else await unlink3(target);
+    } catch {
+    }
+  }
+}
+async function createLocalStyle(options) {
+  const id = styleId(options.id);
+  if (options.name !== void 0 && (!options.name.trim() || options.name.length > 200 || /[\x00-\x1f\x7f]/.test(options.name))) {
+    throw new CliError("INVALID_ARGUMENT", "--name must contain 1\u2013200 characters without control characters.", "Use a short, descriptive style name.");
+  }
+  const files = createStyle({ id, name: options.name });
+  const root = await ensureRoot(options.directory, true);
+  await preflightCreate(root, id, files);
+  return withWorkspaceLock(root, async () => {
+    await preflightCreate(root, id, files);
+    const createdFiles = [];
+    const createdDirectories = [];
+    try {
+      for (const [path, content] of Object.entries(files)) {
+        await makeDirectories(root, dirname2(path), createdDirectories);
+        const target = await checkedPath(root, path);
+        const handle = await open4(target, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 420);
+        try {
+          const info = await handle.stat();
+          createdFiles.push({ path, dev: info.dev, ino: info.ino });
+          await handle.writeFile(content, "utf8");
+        } finally {
+          await handle.close();
+        }
+      }
+    } catch (error) {
+      await cleanCreated(root, createdFiles, false);
+      await cleanCreated(root, createdDirectories, true);
+      throw error;
+    }
+    return {
+      root,
+      id,
+      status: "draft",
+      created: Object.keys(files),
+      mediaUploaded: false,
+      next: `Read references/style-creator.md in the EditorBrain skill. Edit .editorbrain/styles/${id}/style.md, effects.md, music.md, resources.json and examples.json, and document evidence actually reviewed; then run editorbrain styles check ${id} --dir <workspace>. Assess adaptation using the actual material in the next requested edit; structural checks do not assess editorial quality.`
+    };
+  }, { migrateLegacy: false });
+}
+async function readStyle(root, id) {
+  const files = /* @__PURE__ */ Object.create(null);
+  const issues = [];
+  const directories = [];
+  for (const prefix of [".editorbrain", ".editorharness"]) {
+    const path = `${prefix}/styles/${id}`;
+    try {
+      const target = await checkedPath(root, path, false);
+      if (!await exists(target)) continue;
+      if (!(await lstat4(target)).isDirectory()) {
+        issues.push({ path, message: "Style path is not a directory." });
+        continue;
+      }
+      directories.push(path);
+      const entries = await readdir3(target, { withFileTypes: true });
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!/\.(json|md)$/.test(entry.name)) continue;
+        const document = `${path}/${entry.name}`;
+        if (!entry.isFile()) {
+          issues.push({ path: document, message: "Style document must be a regular file, not a symlink or directory." });
+          continue;
+        }
+        try {
+          files[document] = await readText(root, document);
+        } catch (error) {
+          issues.push({ path: document, message: `Cannot safely read style document: ${error.message}` });
+        }
+      }
+    } catch (error) {
+      issues.push({ path, message: `Cannot safely read style directory: ${error.message}` });
+    }
+  }
+  if (directories.length > 1) issues.push({ path: `.editorbrain/styles/${id}`, message: "Style exists in both current and legacy directories. Reconcile the duplicate before checking it." });
+  return { files, issues };
+}
+async function checkLocalResource(root, path, expected) {
+  safeStyleResourcePath(path);
+  const target = await checkedPath(root, path, false);
+  const handle = await open4(target, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile()) throw new Error("Resource is not a regular file.");
+    if (!expected) return {};
+    const hash = createHash2("sha256");
+    for await (const chunk of handle.createReadStream({ autoClose: false })) hash.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") };
+  } finally {
+    await handle.close();
+  }
+}
+async function checkLocalStyle(options) {
+  const id = styleId(options.id);
+  const root = await ensureRoot(options.directory);
+  const local = await readStyle(root, id);
+  const structural = checkStyle(local.files, id);
+  const localIssues = [...local.issues];
+  const warnings = [...structural.warnings];
+  const resources = [];
+  const resourcePath = Object.keys(local.files).find((path) => path.endsWith("/resources.json"));
+  let document;
+  if (resourcePath) {
+    try {
+      const parsed = JSON.parse(local.files[resourcePath]);
+      if (validateStyleResources(parsed, id).valid) document = parsed;
+    } catch {
+    }
+  }
+  for (const resource of document?.resources ?? []) {
+    const result = { id: resource.id, source: resource.source.type, required: resource.required, status: "unverified" };
+    resources.push(result);
+    if (resource.source.type !== "local") {
+      warnings.push(`Resource ${resource.id}: ${resource.source.type === "asset" ? "remote asset availability and access" : "installed or external requirement"} not verified by this local check.`);
+      continue;
+    }
+    result.path = resource.source.path;
+    result.expectedSha256 = resource.source.sha256;
+    let message;
+    try {
+      const checked = await checkLocalResource(root, resource.source.path, resource.source.sha256);
+      result.actualSha256 = checked.actualSha256;
+      result.status = resource.source.sha256 ? "verified" : "present";
+      if (resource.source.sha256 && checked.actualSha256 !== resource.source.sha256) {
+        result.status = "hash_mismatch";
+        message = "Resource SHA-256 does not match resources.json.";
+      } else if (!resource.source.sha256) warnings.push(`Resource ${resource.id}: local file is present, but its content hash is not pinned.`);
+    } catch (error) {
+      result.status = error.code === "ENOENT" ? "missing" : "invalid";
+      message = result.status === "missing" ? "Local resource is missing." : `Cannot safely verify resource: ${error.message}`;
+    }
+    if (message) {
+      const detail = `Resource ${resource.id}: ${message}`;
+      if (resource.required) localIssues.push({ path: resource.source.path, message: detail });
+      else warnings.push(`Optional ${detail}`);
+    }
+  }
+  const issues = [...structural.issues, ...localIssues];
+  return {
+    root,
+    id,
+    ...structural,
+    valid: issues.length === 0,
+    issues,
+    warnings,
+    localIssues,
+    resources,
+    mediaUploaded: false,
+    quality: "not_assessed"
+  };
+}
+
 // packages/cli/src/index.ts
 var HELP = `EditorBrain \u2014 portable editorial context for AI video agents
 
@@ -1361,7 +1788,18 @@ editorbrain pull [--project id | --all] [--dir folder] [--dry-run]
 editorbrain push [--dir folder] [--dry-run]
 editorbrain projects list
 editorbrain documents list [--prefix path]
-editorbrain documents get <path>
+editorbrain documents get <path> [--revision N]
+editorbrain documents history <path> [--before N]
+editorbrain documents restore <path> --revision N --expected-revision N
+editorbrain memory list --scope brand|style|project --id ID
+editorbrain memory add --scope brand|style|project --id ID --text TEXT --status suggested|confirmed --expected-revision N
+editorbrain memory confirm|disable ENTRY --scope brand|style|project --id ID --expected-revision N
+editorbrain feedback add --project ID --text TEXT
+editorbrain improvements list --brand ID
+editorbrain improvements accept RUN --index N --expected-revision N
+editorbrain review list --project ID
+editorbrain review create --project ID --asset SHA --title TEXT --kind sample|render --days 7 --share-authorized
+editorbrain review revoke ID
 editorbrain workflow check [--project id] [--previous-version hash]
 editorbrain search brief --file <editorial-brief.json> [--project id] [--mode styles|events|both] [--review direct|directions|sample]
 editorbrain search edit [--script file | --video file | --asset sha256 | --project id] [--requirements text] [--assets tag,tag] [--mode styles|events|both] [--review direct|directions|sample]
@@ -1371,6 +1809,8 @@ editorbrain library media <video-id> --sha256 media-hash --out file
 editorbrain narrative search [query] [--kind hook|cta|...] [--channel visual|spoken|...] [--limit 10]
 editorbrain narrative get <video-id> [--sha256 document-hash] [--event-offset 0] [--relation-offset 0] [--limit 50]
 editorbrain styles list
+editorbrain styles create <style-id> [--name name] [--dir folder]
+editorbrain styles check <style-id> [--dir folder]
 editorbrain 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]
@@ -1385,14 +1825,15 @@ Secrets go to a user config with mode 0600, never the portable project.
 Resolve writes the source-hash lock. Export produces a handoff, not a rendered video.
 Push/pull preserve conflicting changes; media uploads use the separate assets command.
 Skill install works offline, preserves existing instructions, and defaults to both agents.
+Styles create/check work locally without login or media upload; checks do not certify render quality.
 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"]);
-  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", ...booleans]);
+  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]);
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith("--")) {
@@ -1421,13 +1862,13 @@ async function configRoot(create = false) {
   let path = process.env.EDITORBRAIN_CONFIG_DIR ?? process.env.EDITORHARNESS_CONFIG_DIR ?? join2(homedir(), ".config", "editorbrain");
   if (!create && !process.env.EDITORBRAIN_CONFIG_DIR && !process.env.EDITORHARNESS_CONFIG_DIR) {
     try {
-      await lstat4(path);
+      await lstat5(path);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
       path = join2(homedir(), ".config", "editorharness");
     }
   }
-  if (create) await mkdir2(path, { recursive: true, mode: 448 });
+  if (create) await mkdir3(path, { recursive: true, mode: 448 });
   return ensureRoot(path);
 }
 async function loadConfig() {
@@ -1472,7 +1913,7 @@ async function init(args) {
   for (const path of Object.keys(files)) {
     const target = await checkedPath(root, path);
     try {
-      await lstat4(target);
+      await lstat5(target);
       throw new Error(`Refusing to replace existing file: ${path}`);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -1484,13 +1925,13 @@ async function init(args) {
   for (const path of directories) {
     const target = await checkedPath(root, path, false);
     try {
-      if (!(await lstat4(target)).isDirectory()) throw new Error(`Not a directory: ${path}`);
+      if (!(await lstat5(target)).isDirectory()) throw new Error(`Not a directory: ${path}`);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
   }
   for (const [path, content] of Object.entries(files)) await atomicWrite(root, path, content, { overwrite: false });
-  for (const path of directories) await mkdir2(await checkedPath(root, path, false), { recursive: true });
+  for (const path of directories) await mkdir3(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}` });
@@ -1596,6 +2037,20 @@ async function main() {
     output({ endpoint: client.url, ...await client.me() });
     return;
   }
+  if (command === "styles" && (subcommand === "create" || subcommand === "check")) {
+    const allowed = new Set(subcommand === "create" ? ["dir", "name"] : ["dir"]);
+    if (args.positional.length !== 3 || Object.keys(args.flags).some((flag) => !allowed.has(flag))) {
+      throw new CliError("INVALID_ARGUMENT", `Use styles ${subcommand} <style-id> [--dir folder]${subcommand === "create" ? " [--name name]" : ""}.`, "Style authoring runs locally and accepts only the documented options.");
+    }
+    const options = { directory: str(args, "dir") ?? process.cwd(), id: argument };
+    if (subcommand === "create") output(await createLocalStyle({ ...options, name: str(args, "name") }));
+    else {
+      const result = await checkLocalStyle(options);
+      output(result);
+      if (!result.valid) process.exitCode = 1;
+    }
+    return;
+  }
   if (command === "styles" || command === "direction") {
     const client = new Client(await config(args));
     if (command === "styles" && subcommand === "list") {
@@ -1621,7 +2076,7 @@ async function main() {
       const outRoot = await ensureRoot(resolve4(str(args, "dir") ?? process.cwd(), destination), true);
       for (const path of Object.keys(result.files)) {
         try {
-          await lstat4(await checkedPath(outRoot, path, false));
+          await lstat5(await checkedPath(outRoot, path, false));
           throw new Error(`Refusing to replace existing proposal: ${path}`);
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -1667,12 +2122,57 @@ async function main() {
       return;
     }
     if (subcommand === "get" && argument) {
-      const doc = await client.get(argument);
+      const doc = await client.request(`/v1/documents/${argument.split("/").map(encodeURIComponent).join("/")}${str(args, "revision") ? "?revision=" + encodeURIComponent(str(args, "revision")) : ""}`);
       if (await sha256(doc.content) !== doc.sha256) throw new Error("Document integrity failed");
       output(doc);
       return;
     }
-    throw new Error("Use documents list --prefix path or documents get <path>.");
+    if (subcommand === "history" && argument) {
+      output(await client.request("/v1/history?" + new URLSearchParams({ path: argument, ...str(args, "before") ? { before: str(args, "before") } : {} })));
+      return;
+    }
+    if (subcommand === "restore" && argument) {
+      output(await client.request("/v1/history/restore", { method: "POST", body: { path: argument, revision: Number(str(args, "revision")), expectedRevision: Number(str(args, "expected-revision")) } }));
+      return;
+    }
+    throw new Error("Use documents list/get/history/restore. Restore requires --revision and --expected-revision.");
+  }
+  if (command === "memory" || command === "feedback" || command === "review" || command === "improvements") {
+    const client = new Client(await config(args));
+    if (command === "memory" && subcommand === "list") {
+      output(await client.request("/v1/memory?" + new URLSearchParams({ scope: str(args, "scope") ?? "brand", scopeId: str(args, "id") ?? "" })));
+      return;
+    }
+    if (command === "memory" && ["add", "confirm", "disable"].includes(subcommand ?? "")) {
+      output(await client.request("/v1/memory", { method: "POST", body: { scope: str(args, "scope") ?? "brand", scopeId: str(args, "id"), action: subcommand, entryId: argument, expectedRevision: Number(str(args, "expected-revision")), text: str(args, "text"), conditions: str(args, "conditions") ?? "", status: str(args, "status") ?? "suggested" } }));
+      return;
+    }
+    if (command === "feedback" && subcommand === "add") {
+      output(await client.request("/v1/feedback", { method: "POST", body: { projectId: str(args, "project"), text: str(args, "text") } }));
+      return;
+    }
+    if (command === "improvements" && subcommand === "list") {
+      output(await client.request("/v1/improvements?" + new URLSearchParams({ brandId: str(args, "brand") ?? "" })));
+      return;
+    }
+    if (command === "improvements" && subcommand === "accept") {
+      output(await client.request("/v1/improvements/accept", { method: "POST", body: { runId: argument, index: Number(str(args, "index")), expectedRevision: Number(str(args, "expected-revision")) } }));
+      return;
+    }
+    if (command === "review" && subcommand === "list") {
+      output(await client.request("/v1/reviews?" + new URLSearchParams({ projectId: str(args, "project") ?? "" })));
+      return;
+    }
+    if (command === "review" && subcommand === "revoke" && argument) {
+      output(await client.request("/v1/reviews/" + encodeURIComponent(argument), { method: "DELETE" }));
+      return;
+    }
+    if (command === "review" && subcommand === "create") {
+      if (!args.flags["share-authorized"]) throw new Error("Sharing requires explicit user authorization and --share-authorized. Anyone with the link can view.");
+      output(await client.request("/v1/reviews", { method: "POST", body: { projectId: str(args, "project"), assetId: str(args, "asset"), title: str(args, "title"), kind: str(args, "kind") ?? "sample", days: Number(str(args, "days") ?? 7), shareAuthorized: true } }));
+      return;
+    }
+    throw new Error("Use memory list/add/confirm/disable, feedback add, improvements list/accept, review list/create/revoke. See help for flags.");
   }
   if (command === "assets") {
     const client = new Client(await config(args));
@@ -1690,7 +2190,7 @@ async function main() {
     }
     if (subcommand === "upload" && argument) {
       const target = resolve4(str(args, "dir") ?? process.cwd(), argument);
-      const handle = await open4(target, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+      const handle = await open5(target, constants5.O_RDONLY | constants5.O_NOFOLLOW);
       let bytes;
       try {
         const info = await handle.stat();
@@ -1712,7 +2212,7 @@ async function main() {
     if (subcommand === "download" && argument && str(args, "out")) {
       if (!/^[a-f0-9]{64}$/.test(argument)) throw new Error("Asset ID must be its SHA-256");
       const destination = resolve4(str(args, "dir") ?? process.cwd(), str(args, "out"));
-      const root2 = await ensureRoot(dirname2(destination), true);
+      const root2 = await ensureRoot(dirname3(destination), true);
       await checkedPath(root2, basename(destination), false);
       const response = await client.media(`/v1/assets/${argument}`);
       const bytes = new Uint8Array(await response.arrayBuffer());
@@ -1747,7 +2247,7 @@ async function main() {
   if (command === "search" && subcommand === "brief") {
     const path = str(args, "file");
     if (!path) throw new Error("Provide --file with the editorial brief JSON after inspecting the actual material.");
-    const handle = await open4(resolve4(path), constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    const handle = await open5(resolve4(path), constants5.O_RDONLY | constants5.O_NOFOLLOW);
     let brief;
     try {
       const stat = await handle.stat();
@@ -1769,7 +2269,7 @@ async function main() {
     const scriptPath = str(args, "script"), videoPath = str(args, "video");
     let script, assetId = str(args, "asset");
     const readInput = async (path, max) => {
-      const handle = await open4(resolve4(path), constants4.O_RDONLY | constants4.O_NOFOLLOW);
+      const handle = await open5(resolve4(path), constants5.O_RDONLY | constants5.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.`);
@@ -1818,7 +2318,7 @@ async function main() {
       const hash = str(args, "sha256");
       if (!hash || !/^[a-f0-9]{64}$/.test(hash)) throw new Error("--sha256 must be a media SHA-256 from library get.");
       const destination = resolve4(str(args, "dir") ?? process.cwd(), str(args, "out"));
-      const root2 = await ensureRoot(dirname2(destination), true);
+      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 reader = response.body?.getReader();