weftens 0.0.1 → 0.1.1

package/content-org/metrics.mjs

@@ -0,0 +1,166 @@
+// content-org — deterministic metrics module for the Growth/Analyst seat (#14).
+// Parses a published-piece metrics file (CSV or JSON array), computes per-piece engagement
+// rate, per-angle/format/platform rollups (joined to published/log.jsonl where slugs match),
+// top/bottom performers, and a dataSufficiency verdict. Zero-dependency, no model calls —
+// the growth seat gets this SUMMARY, never raw rows. Tolerant of missing columns: computes
+// what it can and lists what it couldn't in `couldNotCompute`.
+
+// Sufficiency boundaries: none = 0 rows; thin = < 10 pieces OR < 14-day span (or unusable dates).
+export const THIN_MIN_PIECES = 10;
+export const THIN_MIN_SPAN_DAYS = 14;
+
+// Column aliases — normalize whatever header the platform export used (compared with
+// non-alphanumerics stripped, lowercase: "Piece ID" / "piece_id" / "pieceId" all match).
+const ALIASES = {
+  id: ["id", "piece", "pieceid", "slug", "postid"],
+  title: ["title", "name"],
+  platform: ["platform", "channel", "network"],
+  date: ["date", "published", "publishedat", "postdate", "publishdate"],
+  angle: ["angle"],
+  format: ["format"],
+  views: ["views", "plays", "videoviews", "impressions"],
+  reach: ["reach", "accountsreached"],
+  likes: ["likes", "reactions"],
+  comments: ["comments"],
+  shares: ["shares", "reposts"],
+  saves: ["saves", "bookmarks"],
+  watchTime: ["watchtime", "avgwatchtime", "watchtimesec"],
+};
+const NUMERIC = new Set(["views", "reach", "likes", "comments", "shares", "saves", "watchTime"]);
+const INTERACTIONS = ["likes", "comments", "shares", "saves"];
+
+function canonical(header) {
+  const h = String(header).trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+  for (const [field, aliases] of Object.entries(ALIASES)) if (aliases.includes(h)) return field;
+  return null; // unknown column — ignored
+}
+
+function coerce(rec) {
+  for (const k of Object.keys(rec)) {
+    if (NUMERIC.has(k)) {
+      const n = Number(String(rec[k]).replace(/,/g, ""));
+      if (Number.isNaN(n)) delete rec[k]; else rec[k] = n;
+    } else rec[k] = String(rec[k]);
+  }
+  return rec;
+}
+
+function normalizeRecord(raw) {
+  const rec = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const field = canonical(k);
+    if (field && v !== null && v !== undefined && v !== "") rec[field] = v;
+  }
+  return coerce(rec);
+}
+
+// Minimal CSV line split with quoted-field support ("a, b" stays one cell, "" escapes a quote).
+function splitCsvLine(line) {
+  const cells = []; let cur = "", inQ = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (inQ) {
+      if (c === '"') { if (line[i + 1] === '"') { cur += '"'; i++; } else inQ = false; }
+      else cur += c;
+    } else if (c === '"') inQ = true;
+    else if (c === ",") { cells.push(cur); cur = ""; }
+    else cur += c;
+  }
+  cells.push(cur);
+  return cells.map((s) => s.trim());
+}
+
+const fieldsOf = (rows) => [...new Set(rows.flatMap((r) => Object.keys(r)))];
+const round = (n) => (n === null || n === undefined ? null : Math.round(n * 10000) / 10000);
+
+// --- parse: CSV or JSON array -> normalized rows ---------------------------------------
+export function parseMetrics(text) {
+  const trimmed = String(text).trim();
+  if (!trimmed) return { rows: [], fields: [] };
+  if (trimmed.startsWith("[")) {
+    const rows = JSON.parse(trimmed).map(normalizeRecord);
+    return { rows, fields: fieldsOf(rows) };
+  }
+  const lines = trimmed.split(/\r?\n/).filter((l) => l.trim() !== "");
+  const header = splitCsvLine(lines[0]).map(canonical);
+  const rows = lines.slice(1).map((line) => {
+    const cells = splitCsvLine(line);
+    const rec = {};
+    header.forEach((field, i) => { if (field && cells[i] !== undefined && cells[i] !== "") rec[field] = cells[i]; });
+    return coerce(rec);
+  });
+  return { rows, fields: fieldsOf(rows) };
+}
+
+// --- engagement rate: interactions / (views, else reach); null when it can't be computed
+export function engagementRate(row) {
+  const denom = typeof row.views === "number" ? row.views : row.reach;
+  if (typeof denom !== "number" || denom <= 0) return null;
+  const present = INTERACTIONS.filter((k) => typeof row[k] === "number");
+  if (!present.length) return null;
+  return present.reduce((s, k) => s + row[k], 0) / denom;
+}
+
+// --- rollup: group rows by a field (angle/format/platform), avg engagement, sorted best-first
+export function rollup(rows, key) {
+  const groups = new Map();
+  for (const r of rows) {
+    if (!r[key]) continue;
+    const g = groups.get(r[key]) || { [key]: r[key], pieces: 0, views: 0, ers: [] };
+    g.pieces++;
+    if (typeof r.views === "number") g.views += r.views;
+    const er = engagementRate(r);
+    if (er !== null) g.ers.push(er);
+    groups.set(r[key], g);
+  }
+  return [...groups.values()]
+    .map(({ ers, ...g }) => ({ ...g, avgEngagementRate: ers.length ? round(ers.reduce((a, b) => a + b, 0) / ers.length) : null }))
+    .sort((a, b) => (b.avgEngagementRate ?? -1) - (a.avgEngagementRate ?? -1));
+}
+
+// --- dataSufficiency: "none" | "thin" | "adequate" + plain-language note ----------------
+export function sufficiency(rows) {
+  if (!rows.length) {
+    return { verdict: "none", note: `0 metric rows — nothing to read yet. No trend, no recommendation. Revisit once ~${THIN_MIN_PIECES} pieces have published over ${THIN_MIN_SPAN_DAYS}+ days.` };
+  }
+  const dates = rows.map((r) => Date.parse(r.date)).filter((t) => !Number.isNaN(t));
+  const spanDays = dates.length >= 2 ? Math.round((Math.max(...dates) - Math.min(...dates)) / 86400000) : null;
+  const reasons = [];
+  if (rows.length < THIN_MIN_PIECES) reasons.push(`only ${rows.length} piece(s) (want ${THIN_MIN_PIECES}+)`);
+  if (spanDays === null) reasons.push("no usable dates, so the time span is unknown");
+  else if (spanDays < THIN_MIN_SPAN_DAYS) reasons.push(`only a ${spanDays}-day span (want ${THIN_MIN_SPAN_DAYS}+)`);
+  if (reasons.length) {
+    return { verdict: "thin", note: `Data is thin: ${reasons.join("; ")}. Read directionally only — one strong piece is not a strategy; do not restack the board on this.` };
+  }
+  return { verdict: "adequate", note: `${rows.length} pieces over ${spanDays} days — enough to read angles and formats with normal care.` };
+}
+
+// --- summarize: the one entry point the orchestrator calls ------------------------------
+// input: raw file text (CSV/JSON) or pre-parsed rows. published: entries from published/log.jsonl,
+// joined by slug to fill format/client/tier on rows that lack them.
+export function summarize(input, { published = [] } = {}) {
+  const { rows, fields } = typeof input === "string" ? parseMetrics(input) : { rows: input, fields: fieldsOf(input) };
+  const bySlug = new Map(published.filter((p) => p.slug).map((p) => [String(p.slug).toLowerCase(), p]));
+  for (const r of rows) {
+    const p = r.id && bySlug.get(String(r.id).toLowerCase());
+    if (p) for (const k of ["format", "client", "tier"]) if (r[k] === undefined && p[k] != null) r[k] = p[k];
+  }
+
+  const couldNotCompute = [];
+  const pieces = rows.map((r) => ({ ...r, engagementRate: round(engagementRate(r)) }));
+  const noEr = pieces.filter((p) => p.engagementRate === null).length;
+  if (noEr) couldNotCompute.push(`engagementRate for ${noEr}/${pieces.length} piece(s) — missing views/reach or all interaction columns`);
+
+  const rollups = {};
+  for (const [name, key] of [["byAngle", "angle"], ["byFormat", "format"], ["byPlatform", "platform"]]) {
+    const g = rollup(rows, key);
+    if (g.length) rollups[name] = g;
+    else couldNotCompute.push(`${name} rollup — no '${key}' on any row (and no published/log.jsonl join filled it)`);
+  }
+
+  const ranked = pieces.filter((p) => p.engagementRate !== null).sort((a, b) => b.engagementRate - a.engagementRate);
+  const top = ranked.slice(0, 3);
+  const bottom = ranked.length > 3 ? ranked.slice(-3).reverse() : []; // worst first; empty when it would just repeat top
+
+  return { dataSufficiency: sufficiency(rows), pieces, rollups, top, bottom, fieldsPresent: fields, couldNotCompute };
+}

package/content-org/orchestrator.mjs

@@ -0,0 +1,246 @@
+// content-org — local orchestrator (the "prep half": API-only text seats).
+// Showrunner → Strategy → per-piece [Ideator → Researcher → Script → Editor → Feed → QC]
+// Output: ready-to-assemble packet per piece in inbox/<date>/<slug>.json → Kayla reviews,
+// generates clips into clips/<slug>/, then producer.mjs assembles.
+//
+// Run (full pipeline — "together"):
+//   node orchestrator.mjs <format> <count> [--client=acme] [--tier=growth] [--dry-run]
+//   e.g. node orchestrator.mjs scam-reveal 2 --client=acme --tier=growth
+//   --dry-run uses canned data (NO API key needed) to verify the pipeline end-to-end.
+//
+// Run (single seat — "separately"):
+//   node orchestrator.mjs --seat <key> --input <file-or-json-or-text> [--out <file>] [--dry-run]
+//   e.g. node orchestrator.mjs --seat ideator --input briefs/angle.json
+//        node orchestrator.mjs --seat qc --input '{"script":"..."}' --dry-run
+//        node orchestrator.mjs --seat growth --input examples/metrics-sample.csv --dry-run
+//   Seat keys: showrunner, strategy, ideator, research, script, editor, cut, feed, qc, growth.
+//   (growth runs metrics.mjs deterministically FIRST; the model sees the computed summary, never raw rows)
+//   Output: the seat's schema-shaped JSON to stdout (or --out <file>).
+//
+// Model tiers come from config.mjs (Haiku routine / Sonnet script+editor). Producer
+// (clip-gen + voice + FFmpeg) is a separate step — see producer.mjs.
+
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { MODELS, SEAT_MODEL, RISK } from "./config.mjs";
+import { summarize } from "./metrics.mjs";
+
+const argv = process.argv.slice(2);
+// Flags: --k=v always works; for value-taking flags, `--k v` (space-separated) also works.
+const VALUE_FLAGS = new Set(["seat", "input", "out", "client", "tier"]);
+const flags = {};
+const positional = [];
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (!a.startsWith("--")) { positional.push(a); continue; }
+  const [k, v] = a.replace(/^--/, "").split(/=(.*)/s);
+  if (v !== undefined) flags[k] = v;
+  else if (VALUE_FLAGS.has(k) && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--")) flags[k] = argv[++i];
+  else flags[k] = true;
+}
+const format = positional[0];
+const count = Number(positional[1] || "1");
+const DRY = !!flags["dry-run"];
+
+// SDK is loaded lazily so --dry-run needs no dependencies installed.
+let _client = null;
+async function getClient() {
+  if (!_client) {
+    const { default: Anthropic } = await import("@anthropic-ai/sdk"); // reads ANTHROPIC_API_KEY or `ant auth login`
+    _client = new Anthropic();
+  }
+  return _client;
+}
+
+// --- Seats: role prompt + output JSON schema (model chosen per-seat from config) ------
+const AUDIENCE =
+  "Primary audience: older Facebook users. Faceless, disclosed-AI-where-Kayla-chooses. " +
+  "Brand voice: 'declare what's real'. NEVER moralize disclosure — it is a per-piece choice. " +
+  "The one hard line on scam content: it is THEATRE (instant reveal, captures nothing, no real " +
+  "non-consenting person is harmed).";
+
+const obj = (properties, required) => ({ type: "object", additionalProperties: false, properties, required });
+const str = { type: "string" };
+const bool = { type: "boolean" };
+const arr = (items) => ({ type: "array", items });
+
+const SHOWRUNNER = {
+  key: "showrunner", title: "Showrunner",
+  system: `You are the Showrunner — voice + continuity across every piece. ${AUDIENCE}`,
+  schema: obj({ voiceGuardrails: str, continuityNotes: str }, ["voiceGuardrails", "continuityNotes"]),
+};
+const STRATEGY = {
+  key: "strategy", title: "Content Strategy",
+  system: `You are Content Strategy. Given a format and count, produce distinct, non-repetitive angles that land with the audience. ${AUDIENCE}`,
+  schema: obj({ pieces: arr(obj({ slug: str, angle: str, why: str }, ["slug", "angle", "why"])) }, ["pieces"]),
+};
+const PIPELINE = [
+  { key: "ideator", title: "Ideator",
+    system: `You are the Ideator. Turn the angle into a concept + a 3-second scroll-stopping hook + beat list. ${AUDIENCE}`,
+    schema: obj({ hook: str, concept: str, beats: arr(str) }, ["hook", "concept", "beats"]) },
+  { key: "research", title: "Researcher",
+    system: `You are the Researcher. Source the facts/material; flag any claim that must be verified before publish. ${AUDIENCE}`,
+    schema: obj({ facts: arr(str), claimsToVerify: arr(str) }, ["facts", "claimsToVerify"]) },
+  { key: "script", title: "Script Agent",
+    system: `You are the Script Agent. Write the full voiceover script (tight, spoken-word, older-FB cadence) + per-beat on-screen text. ${AUDIENCE}`,
+    schema: obj({ script: str, onScreenText: arr(str), voNotes: str }, ["script", "onScreenText", "voNotes"]) },
+  { key: "editor", title: "Script Editor",
+    system: `You are the Script Editor. Tighten the script, enforce the Showrunner's voice, fact-check against research. Return the improved script and what you changed. ${AUDIENCE}`,
+    schema: obj({ script: str, changes: arr(str), voicePass: bool }, ["script", "changes", "voicePass"]) },
+  { key: "cut", title: "Video Editor",
+    system: `You are the Video Editor. Turn the script into a concrete shot list Kayla can generate clips from: one entry per clip (5-10s each, ~4-7 clips for a ~30-45s Reel), each with a generation prompt (subject, era/setting, camera, mood — written for an AI video model), plus pacing notes and where each on-screen text lands. Number clips 01, 02… ${AUDIENCE}`,
+    schema: obj({
+      shots: arr(obj({ file: str, seconds: { type: "number" }, prompt: str, onScreenText: str }, ["file", "seconds", "prompt", "onScreenText"])),
+      pacingNotes: str,
+    }, ["shots", "pacingNotes"]) },
+  { key: "feed", title: "Feed Optimizer",
+    system: `You are the Feed Optimizer. Nail the first 3 seconds; write the caption + hashtags + per-platform notes (Facebook, Instagram Reels). ${AUDIENCE}`,
+    schema: obj({ firstThreeSec: str, caption: str, hashtags: arr(str),
+      perPlatform: obj({ facebook: str, instagram: str }, ["facebook", "instagram"]) },
+      ["firstThreeSec", "caption", "hashtags", "perPlatform"]) },
+  { key: "qc", title: "Disclosure/QC",
+    system: `You are Disclosure/QC — the publish gate. Check: (1) every claim accurate/supported; (2) if scam-reveal or is-this-real, the THEATRE line holds (instant reveal, captures nothing, no real non-consenting person harmed); (3) recommend Kayla's per-piece disclosure call (labeled / reveal-is-the-point / neither) but DO NOT enforce always-labeling. List blockers if any check fails. ${AUDIENCE}`,
+    schema: obj({ claimsClean: bool, theatreLineOk: bool, disclosureCall: str, blockers: arr(str) },
+      ["claimsClean", "theatreLineOk", "disclosureCall", "blockers"]) },
+];
+// Growth/Analyst (#14) — NOT in the per-piece pipeline; closes the loop after publish.
+// Runs only via --seat growth. metrics.mjs computes the numbers deterministically first;
+// the model reads that summary (never raw rows) and honors its dataSufficiency verdict.
+const GROWTH = {
+  key: "growth", title: "Growth/Analyst",
+  system: `You are the Growth/Analyst. You receive a DETERMINISTIC metrics summary computed by metrics.mjs — trust its numbers, do not recompute them. Read what landed and why: attribute movement to a specific angle, hook, format, or timing, never vanity totals. One viral piece is not a strategy. Every finding must end in a concrete next-brief recommendation for Content Strategy. Copy the summary's dataSufficiency verdict/note through unchanged; if it is "none" or "thin", say so plainly, scale confidence down, and do NOT fabricate a trend. ${AUDIENCE}`,
+  schema: obj({
+    dataSufficiency: obj({ verdict: str, note: str }, ["verdict", "note"]), // verdict: "none" | "thin" | "adequate"
+    pieceReads: arr(obj({ id: str, read: str }, ["id", "read"])),           // per-piece: what landed / didn't, and why
+    angleRollup: arr(obj({ angle: str, read: str }, ["angle", "read"])),    // per-angle rollup read
+    recommendations: arr(str),                                              // next-brief signal for Content Strategy
+  }, ["dataSufficiency", "pieceReads", "angleRollup", "recommendations"]),
+};
+
+// All 10 prompt seats, addressable by key (for --seat single-invocation and tests).
+export const SEATS = Object.fromEntries(
+  [SHOWRUNNER, STRATEGY, ...PIPELINE, GROWTH].map((s) => [s.key, s])
+);
+
+// --- dry-run: fabricate schema-shaped stub data, no API call ---------------------------
+export function stub(schema, seatKey) {
+  if (schema.type === "string") return `[${seatKey}:sample]`;
+  if (schema.type === "boolean") return true;
+  if (schema.type === "number") return 5; // e.g. cut.shots[].seconds
+  if (schema.type === "array") return [stub(schema.items, seatKey), stub(schema.items, seatKey)];
+  if (schema.type === "object") {
+    const o = {};
+    for (const [k, v] of Object.entries(schema.properties)) o[k] = stub(v, `${seatKey}.${k}`);
+    return o;
+  }
+  return null;
+}
+
+async function runSeat(seat, userContent) {
+  if (DRY) return stub(seat.schema, seat.key);
+  const model = MODELS[SEAT_MODEL[seat.key]] || MODELS.sonnet;
+  const client = await getClient();
+  const res = await client.messages.create({
+    model, max_tokens: 16000, system: seat.system,
+    output_config: { format: { type: "json_schema", schema: seat.schema } },
+    messages: [{ role: "user", content: userContent }],
+  });
+  const text = res.content.find((b) => b.type === "text")?.text ?? "{}";
+  return JSON.parse(text);
+}
+
+// Growth input prep: parse the metrics file text and join published/log.jsonl (if any) for context.
+function growthSummary(raw) {
+  const logPath = join("published", "log.jsonl");
+  const published = existsSync(logPath)
+    ? readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l))
+    : [];
+  return summarize(raw, { published });
+}
+
+// --- single-seat mode ("separately"): run one seat alone, JSON in -> JSON out ----------
+async function runSingleSeat() {
+  const key = flags.seat;
+  const seat = SEATS[key];
+  if (!seat) {
+    console.error(`Unknown seat '${key}'. Seats: ${Object.keys(SEATS).join(", ")}`);
+    process.exit(1);
+  }
+  if (!flags.input || flags.input === true) {
+    console.error(`--seat ${key} needs --input <file-or-json-or-text>`);
+    process.exit(1);
+  }
+  // Input: a file path (read it), or an inline JSON/text string (use as-is).
+  let userContent = String(flags.input);
+  if (existsSync(userContent)) userContent = readFileSync(userContent, "utf8");
+  let out;
+  if (key === "growth") {
+    // Deterministic metrics module runs FIRST; the model gets the computed summary, never raw rows.
+    const summary = growthSummary(userContent);
+    console.error(`[metrics.mjs] ${summary.pieces.length} piece(s), sufficiency=${summary.dataSufficiency.verdict}`);
+    if (!DRY && summary.dataSufficiency.verdict === "none") {
+      // 0 rows: the honest read is deterministic — don't spend a model call restating it.
+      out = { dataSufficiency: summary.dataSufficiency, pieceReads: [], angleRollup: [], recommendations: [] };
+    } else {
+      out = await runSeat(seat, `Deterministic metrics summary (computed by metrics.mjs; trust these numbers):\n${JSON.stringify(summary, null, 2)}`);
+    }
+  } else {
+    out = await runSeat(seat, userContent);
+  }
+  const json = JSON.stringify(out, null, 2);
+  if (flags.out && flags.out !== true) {
+    writeFileSync(flags.out, json);
+    console.error(`${DRY ? "[DRY-RUN] " : ""}[${seat.title}] ${SEAT_MODEL[key]} -> ${flags.out}`);
+  } else {
+    if (DRY) console.error(`[DRY-RUN] [${seat.title}] ${SEAT_MODEL[key]}`);
+    console.log(json);
+  }
+}
+
+async function main() {
+  if (flags.seat) return runSingleSeat();
+  if (!format || !RISK[format]) {
+    console.error(`Usage: node orchestrator.mjs <format> <count> [--client=x] [--tier=y] [--dry-run]\n  formats: ${Object.keys(RISK).join(", ")}`);
+    process.exit(1);
+  }
+  const date = new Date().toISOString().slice(0, 10);
+  const outDir = join("inbox", date);
+  mkdirSync(outDir, { recursive: true });
+  console.log(`${DRY ? "[DRY-RUN] " : ""}format=${format} count=${count} client=${flags.client || "-"} tier=${flags.tier || "-"}`);
+
+  const showrunner = await runSeat(SHOWRUNNER, `Format: ${format}. Set voice + continuity guardrails.`);
+  console.log(`[Showrunner] ${SEAT_MODEL.showrunner}  ok`);
+  const board = await runSeat(STRATEGY, `Format: ${format}. Count: ${count}. Voice: ${showrunner.voiceGuardrails}. Produce ${count} distinct angles.`);
+  console.log(`[Strategy] ${SEAT_MODEL.strategy}  ${board.pieces.length} angles`);
+
+  for (let i = 0; i < Math.min(count, board.pieces.length); i++) {
+    const piece = board.pieces[i];
+    const slug = DRY ? `dryrun-${i + 1}` : piece.slug;
+    console.log(`\n=== ${slug} — ${piece.angle} ===`);
+    const packet = {
+      slug, format, client: flags.client || null, tier: flags.tier || null,
+      angle: piece.angle, why: piece.why,
+      voiceGuardrails: showrunner.voiceGuardrails, continuityNotes: showrunner.continuityNotes,
+      createdAt: date,
+    };
+    let context = `Format: ${format}. Angle: ${piece.angle}. Why: ${piece.why}. Voice: ${showrunner.voiceGuardrails}.`;
+    for (const seat of PIPELINE) {
+      const out = await runSeat(seat, `${context}\n\nWork so far: ${JSON.stringify(packet)}`);
+      packet[seat.key] = out;
+      console.log(`  [${seat.title}] ${SEAT_MODEL[seat.key]}  ok`);
+      if (out.script) context += `\nScript: ${out.script}`;
+    }
+    const held = RISK[format] === "hold" || (packet.qc?.blockers?.length ?? 0) > 0;
+    packet.approval = held ? "hold" : "auto";
+    const file = join(outDir, `${slug}.json`);
+    writeFileSync(file, JSON.stringify(packet, null, 2));
+    console.log(`  -> ${file}  [${packet.approval.toUpperCase()}]`);
+  }
+  console.log(`\nDone. Packets in ${outDir}/. Next: review → generate clips → producer.mjs assembles.`);
+}
+
+// Only auto-run when executed directly (lets tests `import { SEATS }` without side effects).
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((e) => { console.error(e); process.exit(1); });
+}

package/content-org/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "content-org",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "AI content production org — local MVP orchestrator (text pipeline)",
+  "scripts": {
+    "produce": "node orchestrator.mjs",
+    "test": "node test.mjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.68.0"
+  }
+}

package/content-org/producer.mjs

@@ -0,0 +1,59 @@
+// content-org — Producer: turns an inbox packet + clips (+ optional voice) into a Reel.
+// Stages clips -> runs studio/assemble.sh (FFmpeg) -> queue/<slug>/{<slug>.mp4, manifest.json}.
+//
+// Run:  node producer.mjs <path-to-packet.json>
+//
+// Inputs it expects (each is its own upstream step, kept out of this file):
+//   clips/<slug>/*.mp4   — Kayla generates (flat sub) OR a clip-gen API writes them here.
+//   studio/voice/vo.mp3  — optional narration; generate with your voice step first
+//                          (ElevenLabs or Kokoro) — see SERVICE_SOP.md. Absent -> silent cut.
+//
+// CONCURRENCY: run at most 2 producers at once (FFmpeg is the only CPU-heavy step);
+//   set FFMPEG_THREADS=3 to cap each. See CONTENT_ENGINE_TECHNICAL_PLAN.md section 5.
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, copyFileSync, renameSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+const packetPath = process.argv[2];
+if (!packetPath || !existsSync(packetPath)) {
+  console.error("Usage: node producer.mjs <path-to-packet.json>");
+  process.exit(1);
+}
+const packet = JSON.parse(readFileSync(packetPath, "utf8"));
+const slug = packet.slug;
+const clipsDir = join("clips", slug);
+const outDir = join("queue", slug);
+mkdirSync(outDir, { recursive: true });
+
+// Clips: expect clips/<slug>/*.mp4 (manual, or written by a clip-gen step).
+// CLIP-GEN INTEGRATION POINT: drive a fal.ai call (Veo hero / Wan bulk) from the Video
+// Editor's shot list, writing numbered mp4s into clipsDir. Kept manual for now.
+const haveClips = existsSync(clipsDir) && readdirSync(clipsDir).filter((f) => f.endsWith(".mp4")).length > 0;
+if (!haveClips) {
+  console.error("[clips] none in " + clipsDir + "/ — drop or generate clips there, then re-run.");
+  writeFileSync(join(outDir, "manifest.json"), JSON.stringify({ ...packet, status: "awaiting-clips" }, null, 2));
+  process.exit(2);
+}
+const voiceNote = existsSync("studio/voice/vo.mp3") ? "vo.mp3 present" : "no vo.mp3 (silent cut)";
+console.log("[voice] " + voiceNote);
+
+// Staging must hold ONLY this piece's clips — leftovers from a prior slug end up in the cut.
+rmSync("studio/clips", { recursive: true, force: true });
+mkdirSync("studio/clips", { recursive: true });
+readdirSync(clipsDir).filter((f) => f.endsWith(".mp4")).sort().forEach((f) => copyFileSync(join(clipsDir, f), join("studio/clips", f)));
+
+try {
+  execFileSync("bash", ["studio/assemble.sh", slug], { stdio: "inherit", env: { ...process.env } });
+  const rendered = join("studio/output", slug + ".mp4");
+  if (existsSync(rendered)) renameSync(rendered, join(outDir, slug + ".mp4"));
+} catch (e) {
+  console.error("[assemble] failed: " + e.message);
+}
+
+const ready = existsSync(join(outDir, slug + ".mp4"));
+writeFileSync(
+  join(outDir, "manifest.json"),
+  JSON.stringify({ ...packet, reel: ready ? slug + ".mp4" : null, voiceNote, status: ready ? "ready-for-approval" : "assemble-failed" }, null, 2)
+);
+console.log("[producer] " + slug + ": " + (ready ? "ready-for-approval" : "assemble-failed") + " (approval=" + packet.approval + ")");

package/content-org/publish.mjs

@@ -0,0 +1,34 @@
+// content-org — Publish approved Reels. `node publish.mjs <slug> [<slug>...]`
+// Moves a reviewed Reel from queue/ to a published/ append-only log. The actual post to
+// Facebook/Instagram is a marked integration point (needs Meta Business Suite creds).
+import { existsSync, readdirSync, readFileSync, appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const slugs = process.argv.slice(2);
+if (!slugs.length) { console.error("Usage: node publish.mjs <slug> [<slug>...]  (or 'auto' to publish all auto-approved)"); process.exit(1); }
+mkdirSync("published", { recursive: true });
+
+let list = slugs;
+if (slugs[0] === "auto") {
+  list = readdirSync("queue").filter((s) => {
+    const mf = join("queue", s, "manifest.json");
+    if (!existsSync(mf)) return false;
+    const m = JSON.parse(readFileSync(mf, "utf8"));
+    return m.approval === "auto" && (m.qc?.blockers || []).filter(Boolean).length === 0 && m.reel;
+  });
+}
+
+const stampNote = "(timestamp added by publish step at runtime)";
+for (const slug of list) {
+  const mf = join("queue", slug, "manifest.json");
+  if (!existsSync(mf)) { console.error(`skip ${slug}: no manifest`); continue; }
+  const m = JSON.parse(readFileSync(mf, "utf8"));
+  if (m.approval === "hold") { console.error(`skip ${slug}: HOLD — needs explicit approval, run with the slug to override`); }
+
+  // POSTING INTEGRATION POINT: call Meta Business Suite / Graph API here to publish
+  // queue/<slug>/<reel>.mp4 with m.feed.caption to the client's page. Left unwired.
+  const entry = { slug, client: m.client, tier: m.tier, format: m.format, reel: m.reel, caption: m.feed?.caption, note: "logged; Meta post not wired " + stampNote };
+  appendFileSync(join("published", "log.jsonl"), JSON.stringify(entry) + "\n");
+  console.log(`published (logged): ${slug} [${m.client || "-"}/${m.tier || "-"}]`);
+}
+console.log(`\n${list.length} logged to published/log.jsonl. Wire the Meta post at the marked integration point to go live.`);

package/content-org/review.mjs

@@ -0,0 +1,32 @@
+// content-org — Review queue. `node review.mjs`
+// Lists finished Reels awaiting Kayla, showing tiered-approval status + any QC blockers.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const Q = "queue";
+if (!existsSync(Q)) { console.log("queue/ empty — run orchestrator.mjs then producer.mjs first."); process.exit(0); }
+
+const rows = [];
+for (const slug of readdirSync(Q)) {
+  const mf = join(Q, slug, "manifest.json");
+  if (!existsSync(mf)) continue;
+  const m = JSON.parse(readFileSync(mf, "utf8"));
+  rows.push({
+    slug, tier: m.tier || "-", client: m.client || "-",
+    status: m.status || "?", approval: m.approval || "?",
+    blockers: (m.qc?.blockers || []).filter(Boolean).length,
+    reel: m.reel ? "yes" : "no",
+  });
+}
+if (!rows.length) { console.log("No manifests in queue/."); process.exit(0); }
+
+console.log("slug".padEnd(22), "client".padEnd(10), "tier".padEnd(8), "approval".padEnd(9), "reel", "blockers", "status");
+for (const r of rows) {
+  console.log(
+    r.slug.padEnd(22), String(r.client).padEnd(10), String(r.tier).padEnd(8),
+    r.approval.padEnd(9), (r.reel + "   ").padEnd(4), String(r.blockers).padStart(3).padEnd(9), r.status
+  );
+}
+const holds = rows.filter((r) => r.approval === "hold" || r.blockers > 0);
+console.log(`\n${rows.length} in queue · ${holds.length} need your yes (hold or blocked) · rest auto-postable.`);
+console.log("Approve → node publish.mjs <slug> [<slug>...]");

package/content-org/studio/README.md

@@ -0,0 +1,27 @@
+# The Traveler — Studio (FFmpeg assembly pipeline)
+
+**Locked stack:** Kling (clips, you) → ElevenLabs (voice, Claude) → **FFmpeg (edit, Claude)**.
+Anti-slop = consistent character + Claude-controlled edit, never a preset.
+
+## How it works
+1. **You** generate clips in Kling and drop them in `clips/` — **named in order**: `01.mp4`, `02.mp4`, …
+2. Drop the voiceover in `voice/vo.mp3` (Claude can generate this via ElevenLabs).
+3. Drop a music bed in `music/bed.mp3` (royalty-free, e.g. Epidemic).
+4. Captions go in `captions/captions.ass` (Claude writes these from the script).
+5. Claude runs `assemble.sh` → finished vertical Reel lands in `output/`.
+
+## CLIP DELIVERY RULES (critical — so it doesn't look like slop)
+- **Silent** (no Kling auto-audio) — Claude owns the audio layer.
+- **No baked-in captions / no auto-music / no watermark.**
+- Vertical, highest resolution Kling allows; consistent across clips.
+- **Same locked character reference image every clip** (the recurring face = the moat).
+- Name strictly in play order: `01.mp4`, `02.mp4`, …
+
+## Folders
+- `clips/` — raw Kling footage (you)
+- `voice/` — `vo.mp3` narrator (Claude/ElevenLabs)
+- `music/` — `bed.mp3` (you, or Mubert)
+- `captions/` — `captions.ass` (Claude)
+- `output/` — finished Reels (Claude)
+
+`assemble.sh` is v1 — tuned further once we see real Kling footage.

package/content-org/studio/assemble.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# The Traveler — FFmpeg assembly pipeline (v1)
+# Usage: ./assemble.sh [episode_name]
+# Reads clips/*.mp4 (in name order) + voice/vo.mp3 + music/bed.mp3 + captions/captions.ass
+# Outputs a vertical 1080x1920 Reel to output/<episode_name>.mp4
+# Anti-slop layer: uniform grade + film grain + subtle vignette so heterogeneous clips read as ONE piece.
+set -euo pipefail
+
+EP="${1:-episode}"
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+CLIPS="$ROOT/clips"; VOICE="$ROOT/voice/vo.mp3"; MUSIC="$ROOT/music/bed.mp3"
+CAPS="$ROOT/captions/captions.ass"; OUT="$ROOT/output/$EP.mp4"; TMP="$ROOT/.tmp"
+W=1080; H=1920; FPS=30
+mkdir -p "$TMP" "$ROOT/output"
+
+# 1) Normalize every clip to uniform res/fps/codec (reliable concat across mixed Kling outputs)
+i=0; : > "$TMP/list.txt"
+for f in $(ls "$CLIPS"/*.mp4 2>/dev/null | sort); do
+  i=$((i+1)); n=$(printf "%03d" "$i")
+  ffmpeg -y -i "$f" -vf "scale=$W:$H:force_original_aspect_ratio=increase,crop=$W:$H,fps=$FPS" \
+    -c:v libx264 -preset medium -crf 18 -an "$TMP/n_$n.mp4"
+  # Windows fix: write the entry relative to list.txt (concat demuxer resolves it from
+  # the list's own directory). Absolute Git-Bash paths (/c/...) break native ffmpeg.exe.
+  echo "file 'n_$n.mp4'" >> "$TMP/list.txt"
+done
+[ "$i" -gt 0 ] || { echo "No clips in $CLIPS (name them 01.mp4, 02.mp4 ...)"; exit 1; }
+
+# 2) Concatenate normalized clips (video only)
+ffmpeg -y -f concat -safe 0 -i "$TMP/list.txt" -c copy "$TMP/video.mp4"
+
+# 3) Grade + grain + vignette (cohesion / anti-slop) and burn captions if present
+GRADE="eq=contrast=1.06:saturation=1.05:gamma=0.98,noise=alls=8:allf=t+u,vignette=PI/5"
+if [ -f "$CAPS" ]; then VF="$GRADE,subtitles='$CAPS'"; else VF="$GRADE"; fi
+ffmpeg -y -i "$TMP/video.mp4" -vf "$VF" -c:v libx264 -preset medium -crf 18 -an "$TMP/graded.mp4"
+
+# 4) Mix audio: narrator full + music bed ducked under it
+if [ -f "$VOICE" ] && [ -f "$MUSIC" ]; then
+  ffmpeg -y -i "$TMP/graded.mp4" -i "$VOICE" -i "$MUSIC" -filter_complex \
+    "[2:a]volume=0.18[m];[1:a][m]amix=inputs=2:duration=first:dropout_transition=2[a]" \
+    -map 0:v -map "[a]" -c:v copy -c:a aac -shortest "$OUT"
+elif [ -f "$VOICE" ]; then
+  ffmpeg -y -i "$TMP/graded.mp4" -i "$VOICE" -map 0:v -map 1:a -c:v copy -c:a aac -shortest "$OUT"
+else
+  cp "$TMP/graded.mp4" "$OUT"; echo "(no voice/vo.mp3 — output is silent)"
+fi
+
+rm -rf "$TMP"
+echo "Done -> $OUT"