weftens 0.0.1 → 0.1.1

package/agents/supply-verify.md

@@ -0,0 +1,38 @@
+---
+name: supply-verify
+description: Run on programmatic campaign data (placement/log-level reports, supply-path data, vendor reports) to find where ad spend actually went — MFA sites, invalid traffic, fee extraction, misreporting. A verification agent, not a buyer. Output is an evidenced waste report with exclusion proposals.
+---
+
+You are an ad-spend verification analyst — detection, not media buying. The market fact that defines
+the job: only ~43% of programmatic spend reaches a quality impression (viewable, measurable,
+fraud-free, not made-for-advertising), and ~20% of open-web traffic shows invalid-traffic signals.
+The buyer's dashboards won't tell them this. You will, with evidence.
+
+## The work
+1. **Placement forensics.** From placement/log-level reports: where did ads actually serve? Every
+   domain/app ranked by spend, then screened.
+2. **MFA detection.** Made-for-advertising sites pass standard fraud filters while delivering
+   nothing. Markers: extreme ad density, templated design across "different" sites, content velocity
+   no editorial team produces, traffic bought not earned (sourced-traffic patterns), arbitrage
+   economics. A site isn't MFA on one marker; it is on three.
+3. **IVT patterns.** Non-human signatures: impossible session behavior, geo anomalies, datacenter
+   ranges, spoofed domains (the premium domain serving from a URL that isn't theirs), ad stacking /
+   1×1 placements. Note the frontier honestly: agentic-AI bots now mimic scrolling and hesitation —
+   flag "consistent with" rather than "proven" where detection is heuristic.
+4. **Supply-path audit.** Who sat between advertiser and impression, and what did each hop take?
+   Undisclosed intermediaries and duplicate paths to the same inventory are findings.
+5. **Vendor verification.** Reconcile the platform's/agency's report against raw data. Discrepancies
+   are findings with the delta quantified.
+
+## Method
+Every finding carries a confidence tier (verified / probable / consistent-with / needs-data) and its
+evidence. Never present a heuristic hit as proof. Quantify: spend touched, estimated waste,
+reclaimable amount.
+
+## Output
+1. Waste report: finding | evidence | confidence | spend affected.
+2. Exclusion-list proposal (domains/apps/paths) with the marker evidence per entry.
+3. Reclaimable-spend estimate and the questions to put to the vendor, written to be forwarded as-is.
+
+Good output: "these 40 domains took $X and show MFA markers A, B, C — evidence attached; exclusion
+list ready." Bad output: "consider a brand-safety vendor."

package/agents/video-editor.md

@@ -0,0 +1,13 @@
+---
+name: video-editor
+description: Video Editor seat for Weftens' Media Content team — turns an approved script into a concrete, generation-ready shot list (one entry per 5–10s clip with an AI-video prompt), plus pacing notes and on-screen-text placement. Canonical runtime is the content-org pipeline (`node orchestrator.mjs --seat cut`); this file is a thin pointer. Feeds the Producer.
+---
+
+You are the Video Editor on Weftens' Media Content team — turn the approved script into a generation-ready shot list (one entry per 5–10s clip, ~4–7 clips for a ~30–45s Reel; each with an AI-video-model prompt), plus pacing notes and where each on-screen text lands. Clip generation + assembly downstream is the Producer (`producer.mjs`, FFmpeg), a runtime, not a prompt-agent.
+
+Audience/brand (canonical in content-org): older Facebook users; faceless; "declare what's real"; disclosure is a per-piece choice, never moralized; scam content is THEATRE only.
+
+**Canonical runtime:** `content-org\orchestrator.mjs --seat cut`.
+**Output schema:** `{ shots: [ { file, seconds, prompt, onScreenText } ], pacingNotes }`.
+
+content-org is the single source of truth for this seat's prompt. This file is a pointer — do not add divergent instructions here.

package/agents/writer.md

@@ -0,0 +1,45 @@
+---
+name: writer
+description: The one writing agent (copywriter and script writer merged). Writes scripts for content pieces AND conversion copy (headlines, landing pages, VSLs, ads) — one craft, two output shapes. Mines real language first, writes second. Downstream gates (Script Editor / human approval) still apply.
+---
+
+You are the writing seat — the merger of the script writer and the conversion copywriter. One craft:
+words built from found language, aimed at a reader who owes you nothing.
+
+## The method spine (both output shapes)
+The writing is not the job — research is. Before drafting, mine the real language:
+- For content pieces: the research packet (Researcher's facts, sources, claims-to-verify) and the
+  format brief; the audience's own words from comments/UGC where available.
+- For conversion copy: the corpus (reviews of the product AND competitors, threads, transcripts,
+  support logs) → a voice-of-customer map: pains, desired outcomes, objections, the switch moment,
+  competitor complaints — verbatim, with frequency and emotional weight per phrase.
+Copy assembled from found language beats invented copy; the customer's words are more specific,
+more emotional, and more believable than anything written at a desk.
+
+## Output shape 1 — scripts (content pieces) = the content-org `script` seat
+From brief + beats: the script with VO notes, written to the Showrunner's voice guardrails and the
+format's structure. Hook carries the highest-weight found phrase. Hands off to Script Editor
+(copy gate: tighten, voice, fact-check against Research).
+
+In the Media Content pipeline this is the `script` seat: canonical runtime
+`content-org\orchestrator.mjs --seat script`, output schema `{ script, onScreenText, voNotes }`. When
+run in the pipeline, content-org is the single source of truth for that seat's prompt — match its
+schema and do not add divergent script-seat instructions here. This file additionally holds the
+standalone conversion-copy craft below, which the pipeline does not cover.
+
+## Output shape 2 — conversion copy (offers, pages, VSLs, ads)
+Headlines, bullets, CTAs, leads from the VOC map, minimally edited, each annotated to its source
+row. One message per asset; problem first in their words; proof before promise. VSL/funnel: open on
+the highest frequency × weight pain, sequence proof against objections in descending order.
+
+## Hard rules (both shapes)
+- Banned: marketer vocabulary ("streamline," "unlock," "empower," "seamless," "elevate"), wordplay
+  that costs clarity, invented benefits, superlatives without a source.
+- Every claim traces to the corpus, the research packet, or the offer — a caught overclaim kills
+  the asset.
+- Voice is locked per surface (Showrunner's guardrails for own channels; the client voice doc for
+  client work). Drift is a defect even when the copy is good.
+- Nothing publishes from this seat — Script Editor / Disclosure-QC / human approval sit downstream.
+
+Good output: a line the audience could have said themselves, in the locked voice. Bad output:
+brand-voice adjectives arranged pleasingly — reads well, converts nothing, retells as nothing.

package/bin/weftens.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+// Weftens CLI — the agent front door.
+//
+//   weftens ask "how do we look online and who came to our events?" --org "Acme" [--website https://…]
+//   weftens chat --org "Acme"                       # interactive conversation
+//   weftens route request.json                      # deterministic router/synthesizer (no LLM, no key)
+//   echo '{"org":{...},"question":"..."}' | weftens route -
+//
+// ask/chat need ANTHROPIC_API_KEY (or an `ant auth login` profile). Specialists:
+//   WEFTENS_RICHY_URL + WEFTENS_RICHY_KEY                       → live Richy audit service
+//   WEFTENS_PIO_URL + WEFTENS_PIO_MEMBER + WEFTENS_PIO_PASSWORD → live PIO (member session)
+//   WEFTENS_PIO_TENANT                                          → tenant slug (hosted PIO only)
+// Without them the specialists run as clearly-flagged fixtures so the agent always works.
+
+import { readFileSync } from "node:fs";
+import readline from "node:readline";
+import { orchestrate } from "../src/weftens.js";
+import { isChangeSheet, formatChangeSheet } from "../src/format.js";
+import { askWeftens } from "../src/agent.js";
+import { RichyClient, FixtureRichyClient } from "../src/richy-client.js";
+import { PioClient, FixturePioClient } from "../src/pio-client.js";
+import { route } from "../src/agent-router.js";
+import { invoke } from "../src/invoke.js";
+import { REGISTRY, dispatchableAgents } from "../src/registry.js";
+
+// A specialist is live only when its FULL env group is set. A partial group is a
+// hard error, not a silent fixture fallback — an operator who typo'd one variable
+// would otherwise get sample data while believing they're looking at their org.
+function envGroup(label, names) {
+  const set = names.filter((n) => process.env[n]);
+  if (set.length === 0) return null;
+  if (set.length < names.length) {
+    const missing = names.filter((n) => !process.env[n]).join(", ");
+    throw new Error(`${label} is partially configured — set ${missing} (or unset ${set.join(", ")} to run with sample data)`);
+  }
+  return Object.fromEntries(names.map((n) => [n, process.env[n]]));
+}
+
+function buildAgents() {
+  const richyEnv = envGroup("Richy", ["WEFTENS_RICHY_URL", "WEFTENS_RICHY_KEY"]);
+  const pioEnv = envGroup("PIO", ["WEFTENS_PIO_URL", "WEFTENS_PIO_MEMBER", "WEFTENS_PIO_PASSWORD"]);
+  const richy = richyEnv
+    ? new RichyClient({ baseUrl: richyEnv.WEFTENS_RICHY_URL, key: richyEnv.WEFTENS_RICHY_KEY })
+    : new FixtureRichyClient();
+  const pio = pioEnv
+    ? new PioClient({
+        baseUrl: pioEnv.WEFTENS_PIO_URL,
+        member: pioEnv.WEFTENS_PIO_MEMBER,
+        password: pioEnv.WEFTENS_PIO_PASSWORD,
+        tenant: process.env.WEFTENS_PIO_TENANT ?? null,
+      })
+    : new FixturePioClient();
+  const fixtures = [!richyEnv && "Richy", !pioEnv && "PIO"].filter(Boolean);
+  if (fixtures.length > 0) {
+    process.stderr.write(`weftens: ${fixtures.join(" and ")} not configured — using clearly-flagged sample data\n`);
+  }
+  return { richy, pio };
+}
+
+function parseFlags(args) {
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--org") flags.org = args[++i];
+    else if (args[i] === "--website") flags.website = args[++i];
+    else rest.push(args[i]);
+  }
+  return { flags, rest };
+}
+
+function orgPreamble(flags) {
+  if (!flags.org) return "";
+  const site = flags.website ? ` (website: ${flags.website})` : "";
+  return `The organization we're discussing is "${flags.org}"${site}. `;
+}
+
+async function cmdAsk(args) {
+  const { flags, rest } = parseFlags(args);
+  const question = rest.join(" ").trim();
+  if (!question) {
+    process.stderr.write('usage: weftens ask "<question>" [--org NAME] [--website URL]\n');
+    process.exitCode = 1;
+    return;
+  }
+  const { text } = await askWeftens({ question: orgPreamble(flags) + question, agents: buildAgents() });
+  process.stdout.write(`${text}\n`);
+}
+
+async function cmdChat(args) {
+  const { flags } = parseFlags(args);
+  const agents = buildAgents();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let history = [];
+  let first = true;
+  process.stdout.write("Weftens. Ask about how your organization looks online or how it's running. Ctrl+C to exit.\n");
+  for (;;) {
+    const line = await new Promise((resolve) => rl.question("> ", resolve));
+    const question = line.trim();
+    if (!question) continue;
+    if (question === "exit" || question === "quit") break;
+    try {
+      const { text, messages } = await askWeftens({
+        question: first ? orgPreamble(flags) + question : question,
+        history,
+        agents,
+      });
+      history = messages;
+      first = false;
+      process.stdout.write(`${text}\n`);
+    } catch (error) {
+      process.stderr.write(`weftens: ${error?.message ?? error}\n`);
+    }
+  }
+  rl.close();
+}
+
+async function cmdRoute(arg) {
+  const raw = !arg || arg === "-" ? readFileSync(0, "utf8") : readFileSync(arg, "utf8");
+  const result = await orchestrate(JSON.parse(raw), buildAgents());
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+// --- Registry front door: route across the whole roster, not just Richy/PIO ---
+// `list` shows the directory (and prints the live count); `send` routes a request
+// (auto or direct-addressed) and
+// invokes the chosen agent. Deterministic routing needs no key; see src/invoke.js for
+// what producing needs. This sits alongside ask/chat (the Richy+PIO conversational
+// surface) — those two agents are also reachable here through the registry.
+
+function cmdList() {
+  const pad = (s, n) => String(s).padEnd(n);
+  process.stdout.write(`Weftens registry — ${REGISTRY.length} agents (${dispatchableAgents().length} dispatchable at the door)\n\n`);
+  process.stdout.write(`${pad("AGENT", 18)}${pad("TIER", 6)}${pad("TEAM", 12)}${pad("CORE", 6)}OWNED-BY\n`);
+  for (const a of REGISTRY) {
+    const owned = a.ownedBy ?? (a.leads ? `(leads ${a.leads})` : "-");
+    process.stdout.write(`${pad(a.name, 18)}${pad(a.tier, 6)}${pad(a.team, 12)}${pad(a.core ? "yes" : "-", 6)}${owned}\n`);
+  }
+}
+
+async function cmdSend(args, { routeOnly } = {}) {
+  const rest = [];
+  let inputFile = null, provider = null, org = null, website = null, asJson = false;
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--input") inputFile = args[++i] ?? null;
+    else if (args[i] === "--provider") provider = args[++i] ?? null;
+    else if (args[i] === "--json") asJson = true;
+    else if (args[i] === "--org") org = args[++i] ?? null;
+    else if (args[i] === "--website") website = args[++i] ?? null;
+    else rest.push(args[i]);
+  }
+  const firstIsAgent = rest.length >= 1 && REGISTRY.some((a) => a.name === rest[0].toLowerCase());
+  const request = firstIsAgent
+    ? { agent: rest[0], text: rest.slice(1).join(" ") }
+    : { text: rest.join(" ") };
+  if (!request.text && !request.agent) {
+    process.stderr.write('usage: weftens send "<request>"  |  weftens send <agent> "<request>"\n');
+    process.exitCode = 1;
+    return;
+  }
+  const decision = route(request);
+  if (!decision.agent) {
+    process.stdout.write(`→ (no route) — ${decision.reason}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`→ ${decision.agent.name}  [${decision.reason}]${decision.confident ? "" : "  (low confidence)"}\n`);
+  if (decision.alternatives?.length) {
+    process.stdout.write(`  also considered: ${decision.alternatives.map((x) => `${x.name}(${x.score})`).join(", ")}\n`);
+  }
+  if (routeOnly) return;
+
+  // Richy and PIO are specialist legs: they answer about an ORGANIZATION, not about a
+  // bare sentence, so they run through orchestrate() rather than as leaf agents. They
+  // used to refuse here with a note about "wire contracts" — true internally, useless
+  // to the person typing, and wrong in effect: the legs are reachable (with fixture
+  // clients when unconfigured), so refusing categorically made the two headline seats
+  // look dead. Now `send richy --org NAME "<question>"` does the real thing.
+  if (decision.agent.tier === 1 && decision.agent.wire) {
+    // An org is genuinely required — Richy audits a specific organization, PIO reports on one —
+    // but demanding a FLAG for it is a door that doesn't open for a plain sentence. Whoever is
+    // running this almost always means the same org every time, so it's config, not an argument:
+    // set WEFTENS_ORG once and `send richy "audit our listings"` just works.
+    org = org ?? process.env.WEFTENS_ORG ?? null;
+    website = website ?? process.env.WEFTENS_WEBSITE ?? null;
+    if (!org) {
+      process.stdout.write(
+        `\n[orchestrator] ${decision.agent.name} answers about a specific organization — which one?\n` +
+        `  once:    weftens send ${decision.agent.name} --org "Acme Co" [--website acme.com] "${request.text || "your question"}"\n` +
+        `  always:  set WEFTENS_ORG="Acme Co" (and optionally WEFTENS_WEBSITE) — then this command works as typed\n`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const intent = decision.agent.name === "richy" ? "representation" : "operations";
+    const result = await orchestrate(
+      { org: { name: org, ...(website ? { website } : {}) }, intent, question: request.text || undefined },
+      buildAgents()
+    );
+    process.stdout.write(`\n[orchestrator] ran ${decision.agent.name} over ${org} (intent: ${intent})\n`);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  const outcome = await invoke(decision.agent, { text: request.text, inputFile, provider });
+  process.stdout.write(`\n[${outcome.path}] ${outcome.note}\n`);
+  if (outcome.result !== undefined) {
+    // A change sheet renders for a human by default — the whole point of one is that a
+    // person can read a line and decide. `--json` returns the raw object for piping.
+    if (!asJson && isChangeSheet(outcome.result)) {
+      process.stdout.write(`\n${formatChangeSheet(outcome.result)}\n`);
+    } else {
+      process.stdout.write(`\n--- result ---\n${typeof outcome.result === "string" ? outcome.result : JSON.stringify(outcome.result, null, 2)}\n`);
+    }
+  }
+}
+
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "ask") return cmdAsk(args);
+  if (command === "chat") return cmdChat(args);
+  if (command === "list" || command === "--list") return cmdList();
+  if (command === "send") return cmdSend(args);
+  if (command === "--route") return cmdSend(args, { routeOnly: true });
+  if (command === "route" || (command && (command === "-" || command.endsWith(".json")))) {
+    return cmdRoute(command === "route" ? args[0] : command);
+  }
+  process.stderr.write("usage: weftens ask|chat|list|send|--route|route …\n");
+  process.exitCode = 1;
+}
+
+main().catch((error) => {
+  process.stderr.write(`weftens: ${error?.message ?? error}\n`);
+  process.exitCode = 1;
+});

package/content-org/.preflight/telemetry.jsonl

@@ -0,0 +1,6 @@
+{"ts":"2026-07-19T17:03:20.481Z","tool":"edit_file","source":"raw","status":"pass","counts":{"total":8,"pass":8,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\src\\registry.js","durationMs":3}
+{"ts":"2026-07-19T17:03:27.408Z","tool":"edit_file","source":"raw","status":"pass","counts":{"total":8,"pass":8,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\src\\invoke.js","durationMs":2}
+{"ts":"2026-07-19T17:03:35.845Z","tool":"edit_file","source":"raw","status":"pass","counts":{"total":8,"pass":8,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\src\\invoke.js","durationMs":2}
+{"ts":"2026-07-19T17:03:39.916Z","tool":"edit_file","source":"raw","status":"pass","counts":{"total":8,"pass":8,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\src\\invoke.js","durationMs":2}
+{"ts":"2026-07-19T17:03:56.374Z","tool":"write_file","source":"raw","status":"pass","counts":{"total":7,"pass":7,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\index.js","durationMs":2}
+{"ts":"2026-07-19T17:04:01.490Z","tool":"edit_file","source":"raw","status":"pass","counts":{"total":8,"pass":8,"warn":0,"fail":0},"topRules":[],"findings":[],"pathPreview":"C:\\Users\\teche\\weftens\\package.json","durationMs":2}

package/content-org/briefs/BRIEFS.md

@@ -0,0 +1,47 @@
+# Format briefs
+
+The five formats the org produces. Each is a **brief the seats consume** — angle patterns, structure,
+and the disclosure stance. `RISK` in `config.mjs` sets which auto-post vs hold. Audience across all:
+**older Facebook users**; brand voice: *declare what's real*; disclosure is a **per-piece call, never an
+always-rule**; the scam guardrail is **theatre** (instant reveal, captures nothing, no real person harmed).
+
+---
+
+## traveler  · auto
+The recurring time-traveler character dropped into a different time+place each episode. **The moat** —
+people subscribe to a *who*, not a vibe. Needs character-consistent clips (Veo/Seedance hero lane).
+- **Hook (3s):** the character mid-scene in a vivid era ("It's Tokyo, 1985, and…").
+- **Structure:** cold open in-scene → one wistful observation that ties past to now → button line.
+- **Disclosure:** "Imagined with AI" when it fits; sometimes the era-craft *is* the point. Kayla's call.
+- **Continuity:** same face, voice, and one signature line across episodes.
+
+## scam-reveal  · hold
+Nostalgia/relatable hook → theatrical "attempted hack" → **"YOU COULD HAVE BEEN HACKED"** → one defensive tell.
+- **Hook (3s):** a familiar scenario (a text from "your bank," a too-good deal).
+- **Structure:** set the trap → the reveal beat → one concrete thing the viewer can do tomorrow.
+- **HARD LINE:** theatre only. Instant reveal, page/piece captures NOTHING, no real non-consenting person
+  is hacked or harmed. QC blocks anything that crosses this.
+- **Disclosure:** the reveal is the disclosure; label as AI where useful.
+
+## is-this-real  · hold
+Teach older viewers to spot AI fakes / deepfakes / cloned voices. **Most on-brand** — the content *is* the
+"declare what's real" demo.
+- **Hook (3s):** "Is this real? Watch closely." (a clip with one tell).
+- **Structure:** show the fake → reveal the tell(s) → "here's how to check next time."
+- **Disclosure:** always clarify what was AI vs real in-piece — here it's the whole point.
+- **QC:** claim accuracy is critical; never mislabel a real thing as fake or vice-versa.
+
+## nostalgia  · auto
+Straight "remember when" archival-feeling reach. Pure audience fuel; highest raw engagement with older FB.
+- **Hook (3s):** a specific sensory memory ("If you remember the sound of a rotary phone…").
+- **Structure:** montage of era details → one warm line of meaning → gentle prompt to comment.
+- **Disclosure:** label as AI-imagined where the footage is fabricated (Meta throttles undisclosed
+  fake-real-events — proactive labeling protects reach).
+- **Bulk lane** (Wan) is fine; no recurring face needed.
+
+## ai-for-seniors  · hold
+Calm, plain-language explainers ("what's an agent?", "is the AI listening to me?"). Empowerment, no fear.
+- **Hook (3s):** a real question they've wondered ("Is your phone spying on you? Sort of — here's the truth").
+- **Structure:** the worry → the plain answer → one practical takeaway.
+- **Disclosure:** AI-made, said plainly; builds the brand credibility the flywheel cashes in.
+- **QC:** no false/overblown claims about AI; accuracy is the whole value.

package/content-org/config.mjs

@@ -0,0 +1,78 @@
+// content-org — central config. Change tiers/models here; nothing else needs editing.
+
+export const MODELS = {
+  haiku: "claude-haiku-4-5",   // $1/$5 per 1M — routine seats
+  sonnet: "claude-sonnet-5",   // $3/$15 — writing-quality seats
+  opus: "claude-opus-4-8",     // $5/$25 — only if a real test shows a lift
+};
+
+// Value tier (locked 2026-07-08): pay for quality only where it moves reach/moat.
+// Sonnet on the seats whose prose the viewer feels (Strategy board, Script, Editor);
+// Haiku on the structured hand-offs the viewer never sees.
+export const SEAT_MODEL = {
+  showrunner: "haiku",
+  strategy: "sonnet",
+  ideator: "haiku",
+  research: "haiku",
+  script: "sonnet",
+  editor: "sonnet",
+  cut: "sonnet", // Video Editor — the cut decides completion rate; worth Sonnet
+  feed: "haiku",
+  qc: "haiku",
+  growth: "haiku", // Growth/Analyst — reads the deterministic metrics.mjs summary; structured hand-off, viewer never sees it
+};
+
+// Clip lanes — pick per piece. Prices are RANGES (sources disagree; price the exact
+// tier on fal.ai at commit). No flat-unlimited *automated* lane exists (verified 2026-07-08).
+export const CLIP_LANES = {
+  manual: { label: "manual flat sub", usdPerSec: 0, note: "hand-generate; ~$0 marginal; cheapest" },
+  bulk: { label: "Wan 2.6 (bulk B-roll)", usdPerSec: 0.06, audio: true },
+  hero: { label: "Veo 3.1 (hero / recurring face)", usdPerSec: 0.05, audio: true, note: "value king: audio + consistency" },
+  // Kling deliberately omitted from defaults — priciest, no consistency edge over Veo/Seedance.
+};
+
+// Approx token cost per finished piece by model mix (for cost.mjs). ~per-piece USD of the
+// 8 text-seat calls; Batch API halves it. Rough, tune against real usage.
+export const TEXT_COST_PER_PIECE = {
+  valueTier: 0.20, // Sonnet(strategy/script/editor) + Haiku(rest)
+  valueTierBatch: 0.10, // with Batch API (50% off)
+  allHaiku: 0.05,
+  allOpus: 0.55,
+};
+
+export const VOICE = {
+  elevenlabs: { label: "ElevenLabs Starter", usdPerMonth: 5, perPieceUsd: 0.03 },
+  kokoro: { label: "Kokoro (OSS, local)", usdPerMonth: 0, perPieceUsd: 0 },
+  veoNative: { label: "Veo native audio (no separate voice)", usdPerMonth: 0, perPieceUsd: 0 },
+};
+
+// Client-facing price tiers (DRAFT — Kayla to confirm numbers). reels = pieces/month.
+export const CLIENT_TIERS = {
+  starter: {
+    name: "Starter", priceUsd: 399, reels: 8,
+    clip: "bulk", script: "sonnet", voice: "elevenlabs",
+    recurringCharacter: 0, managedPosting: false, complianceQC: "basic", revisions: 1,
+  },
+  growth: {
+    name: "Growth", priceUsd: 899, reels: 20,
+    clip: "hero+bulk", script: "sonnet", voice: "elevenlabs",
+    recurringCharacter: 1, managedPosting: true, complianceQC: "disclosed+claim-clean",
+    analytics: "monthly", revisions: 2,
+  },
+  signature: {
+    name: "Signature", priceUsd: 1999, reels: 40,
+    clip: "hero", script: "sonnet+opus-hero", voice: "elevenlabs",
+    recurringCharacter: 2, managedPosting: true, complianceQC: "senior/finance/health compliance pass",
+    analytics: "full+strategy", revisions: "generous",
+  },
+  alacarte: { name: "À la carte", priceUsd: 100, reels: 1, note: "$75–150/Reel for one-offs & tests" },
+};
+
+// Format → risk tier (tiered approval). Sensitive formats HOLD for Kayla.
+export const RISK = {
+  "traveler": "auto",
+  "nostalgia": "auto",
+  "scam-reveal": "hold",
+  "is-this-real": "hold",
+  "ai-for-seniors": "hold",
+};

package/content-org/cost.mjs

@@ -0,0 +1,36 @@
+// content-org — COGS + margin calculator. `node cost.mjs [piecesPerMonth]`
+// No dependencies. Prices are estimates from config.mjs — tune against real usage.
+import { CLIENT_TIERS, TEXT_COST_PER_PIECE, CLIP_LANES, VOICE } from "./config.mjs";
+
+const usd = (n) => "$" + n.toFixed(2);
+const REEL_SECONDS = 30; // ~30s Reel
+
+// per-finished-Reel COGS given a clip lane + text tier + voice
+function cogsPerReel({ clip = "hero", textTier = "valueTierBatch", voice = "elevenlabs" } = {}) {
+  const text = TEXT_COST_PER_PIECE[textTier] ?? TEXT_COST_PER_PIECE.valueTierBatch;
+  const clipUsd = (CLIP_LANES[clip]?.usdPerSec ?? 0) * REEL_SECONDS;
+  const voiceUsd = VOICE[voice]?.perPieceUsd ?? 0;
+  return text + clipUsd + voiceUsd;
+}
+
+console.log("=== per-Reel COGS by clip lane (value text tier + Batch, ElevenLabs voice) ===");
+for (const lane of Object.keys(CLIP_LANES)) {
+  console.log(`  ${lane.padEnd(7)} ${usd(cogsPerReel({ clip: lane }))}   (${CLIP_LANES[lane].label})`);
+}
+
+console.log("\n=== client tiers (DRAFT prices) ===");
+for (const key of ["starter", "growth", "signature"]) {
+  const t = CLIENT_TIERS[key];
+  const lane = key === "starter" ? "bulk" : "hero";
+  const cogs = cogsPerReel({ clip: lane }) * t.reels;
+  const voiceSub = VOICE.elevenlabs.usdPerMonth; // one sub covers all clients
+  const margin = t.priceUsd - cogs;
+  const marginPct = ((margin / t.priceUsd) * 100).toFixed(0);
+  console.log(`  ${t.name.padEnd(10)} ${usd(t.priceUsd)}/mo  ${String(t.reels).padStart(2)} Reels  COGS ${usd(cogs)}  →  margin ${usd(margin)} (${marginPct}%)`);
+}
+console.log(`  (+ shared fixed: ElevenLabs sub ${usd(VOICE.elevenlabs.usdPerMonth)}/mo across all clients; tooling floor ~$130/mo automated)`);
+
+console.log("\n=== YOUR OWN pages ===");
+const own = Number(process.argv[2] || "90");
+const ownCogs = cogsPerReel({ clip: "hero" }) * own;
+console.log(`  ${own} Reels/mo automated (Veo hero): clips+text+voice ≈ ${usd(ownCogs)}  |  manual clips ≈ ${usd(cogsPerReel({ clip: "manual" }) * own)}`);

package/content-org/lead.js

@@ -0,0 +1,64 @@
+// Content lead — the single callable entry the Weftens front door hands to when a
+// request is about making content. The door calls this; this runs the 10-seat
+// pipeline and returns one result. The door never addresses the individual seats
+// (ideator, writer, qc, …) — the Content lead owns them.
+//
+// It shells the existing orchestrator rather than importing a run() function: the
+// orchestrator's full-run body is argv/global-driven, and wrapping it by shell keeps
+// its 27 passing tests untouched (no refactor risk). The orchestrator writes packet
+// JSON into content-org/inbox/<date>/; we run it, read those packets back, and return
+// them as the result.
+//
+// Defaults to dry-run. A real content run depends on Phase-0 decisions that are
+// Kayla's and still open (local vs cloud, cadence, keys) — so this wiring proves the
+// pipeline is callable as one node WITHOUT producing real published content. Pass
+// { dry: false } only once those decisions are made and a key is configured.
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile, readdir, rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const execFileP = promisify(execFile);
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Run the content pipeline as one node.
+ * @param opts { format?, count?, client?, tier?, dry? }  // dry defaults true (safe)
+ * @returns { dry, format, count, artifacts, result, log }
+ *   artifacts  packet file paths produced
+ *   result     the parsed packets (dry-run packets are stub-shaped, clearly slugged dryrun-N)
+ */
+export async function runContent(opts = {}) {
+  const { format = "scam-reveal", count = 1, client = null, tier = null, dry = true } = opts;
+
+  const args = ["orchestrator.mjs", format, String(count)];
+  if (client) args.push(`--client=${client}`);
+  if (tier) args.push(`--tier=${tier}`);
+  if (dry) args.push("--dry-run");
+
+  const { stdout } = await execFileP("node", args, { cwd: HERE, maxBuffer: 8_000_000 });
+
+  // The orchestrator writes to inbox/<date>/; recover <date> from its own output line
+  // ("Packets in inbox/2026-07-19/.") rather than recomputing a clock here.
+  const m = stdout.match(/Packets in (inbox[\\/][^\s/]+)/);
+  const outRel = m ? m[1].replace(/[\\/]$/, "") : null;
+  const artifacts = [];
+  const result = [];
+  if (outRel) {
+    const outDir = join(HERE, outRel);
+    for (const name of (await readdir(outDir)).filter((n) => n.endsWith(".json"))) {
+      const file = join(outDir, name);
+      artifacts.push(file);
+      result.push(JSON.parse(await readFile(file, "utf8")));
+    }
+    // A dry run's stub packets are throwaway — remove them so a verification run does
+    // not litter content-org/inbox. Real runs keep their packets.
+    if (dry) {
+      await Promise.all(artifacts.map((f) => rm(f, { force: true })));
+    }
+  }
+
+  return { dry, format, count, artifacts, result, log: stdout.trim() };
+}