@synap-core/workspace-templates 0.12.0 → 0.23.0

package/src/content-os.template.test.ts

@@ -0,0 +1,322 @@
+/**
+ * Content OS pin strategy — Produce Content is pinned; the weekly cron that
+ * runs it ships paused; Plan Next Content's workers (weekly and by hand) run
+ * once over every post and propose. Not a YAML snapshot.
+ */
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+import { getWorkspaceTemplate } from "./templates.js";
+import type { TemplatePlaybook, WorkspaceYaml } from "./types.js";
+
+const template = (() => {
+  const resolved = getWorkspaceTemplate("content-os");
+  if (!resolved) throw new Error("content-os template is not registered");
+  return resolved;
+})();
+
+type Strategy = NonNullable<TemplatePlaybook["inputStrategy"]>;
+
+function strategyKind(strategy: Strategy): string {
+  return typeof strategy === "string" ? strategy : strategy.kind;
+}
+
+describe("Content OS pin strategy", () => {
+  it("keeps the legacy string form and the pinned object", () => {
+    expect(strategyKind("query")).toBe("query");
+    expect(strategyKind({ kind: "pinned" })).toBe("pinned");
+    // @ts-expect-error pinned entity ids are not part of the strategy
+    const rejected: Strategy = { kind: "pinned", pinnedEntityIds: ["post-1"] };
+    expect(rejected).toBeDefined();
+  });
+
+  it("pins Produce Content; Plan Next Content runs weekly and by hand, once over every post, proposing", () => {
+    const produce = template.playbooks?.find((p) => p.name === "Produce Content");
+    const plan = template.playbooks?.find((p) => p.name === "Plan Next Content");
+
+    expect(produce?.inputStrategy).toEqual({
+      kind: "pinned",
+      fallback: {
+        filter: { "post-status": "Idea" },
+        orderBy: "createdAt",
+        orderDir: "asc",
+      },
+    });
+    expect(produce).not.toHaveProperty("schedule");
+    expect(produce?.inputStrategy).not.toHaveProperty("pinnedEntityIds");
+
+    // A subject-bound playbook's `schedule:` fans out one run per post: the
+    // plan's clock is a per_moment activator instead, never that field.
+    expect(plan).not.toHaveProperty("schedule");
+    expect(plan).not.toHaveProperty("inputStrategy");
+    expect(plan?.subjectProfile).toEqual({ profileSlug: "post" });
+    expect(plan?.stages ?? []).toEqual([]);
+    expect(plan?.activators).toEqual([
+      { on: "schedule", cron: "0 9 * * 1", mode: "propose" },
+      { on: "manual", size: "per_moment", mode: "propose" },
+    ]);
+    // The plan reads its numbers from the pod, and files dates as proposals.
+    expect(plan?.goalTemplate).toContain("platform-posting-freq");
+    expect(plan?.goalTemplate).toContain("never apply a date yourself");
+  });
+
+  it("ships one paused playbook_run of Produce Content, with no subject binding", () => {
+    // Two automations: this weekly run, and Publish due posts (content-os.publish-due-posts.template.test.ts).
+    expect(template.automations?.map((a) => a.key)).toEqual(["content-os-weekly-produce", "content-os-publish-due-posts"]);
+    const automation = template.automations?.find((a) => a.key === "content-os-weekly-produce");
+    expect(automation).toMatchObject({
+      key: "content-os-weekly-produce",
+      triggerType: "cron",
+      status: "paused",
+      triggerConfig: { expression: "0 9 * * 1" },
+    });
+
+    const nodes = (automation?.flow.nodes ?? []) as Array<{
+      id?: string;
+      type?: string;
+      data?: Record<string, unknown>;
+    }>;
+    const runs = nodes.filter((n) => n.type === "playbook_run");
+    expect(runs).toHaveLength(1);
+    expect(runs[0]?.data).toMatchObject({ playbookName: "Produce Content" });
+    expect(runs[0]?.data).not.toHaveProperty("paramsMapping");
+    expect(runs[0]?.data).not.toHaveProperty("subject");
+    expect(runs[0]?.data).not.toHaveProperty("playbookId");
+
+    expect(automation?.flow.edges).toEqual([
+      { id: "e-trigger-produce", source: "trigger", target: "produce" },
+    ]);
+  });
+});
+
+/**
+ * Content OS is THE Content space (one space per domain), so it — not the
+ * superseded content-studio — must declare the video/visual kinds the browser
+ * Content app reads (`CONTENT_KINDS`). Without them "New video" fails on a pod
+ * with only Content OS: `Profile not found: content-composition`.
+ */
+describe("Content OS owns the video / visual pipeline", () => {
+  const profile = (slug: string) => template.profiles.find((p) => p.slug === slug);
+
+  it("declares content-composition, content-asset and render-job (workspace scope)", () => {
+    for (const slug of ["content-composition", "content-asset", "render-job"]) {
+      const p = profile(slug);
+      expect(p, `content-os must declare ${slug}`).toBeDefined();
+      expect(p?.scope ?? "workspace", `${slug} scope`).not.toBe("shared");
+    }
+    // The fields the Content app and the composition detail read.
+    expect(profile("render-job")?.properties.map((d) => d.slug)).toEqual(
+      expect.arrayContaining(["job-status", "render-progress", "composition-ref"])
+    );
+    expect(profile("content-asset")?.properties.map((d) => d.slug)).toContain("asset-kind");
+  });
+
+  it("re-declares brand-template as shared (the grant) and requires brand-library (the SSOT)", () => {
+    expect(profile("brand-template")?.scope).toBe("shared");
+    expect(
+      (template.dependencies ?? []).some(
+        (d) => d.slug === "brand-library" && (d.relation ?? "require") === "require"
+      )
+    ).toBe(true);
+  });
+
+  it("ships the pipeline views and links", () => {
+    const viewScopes = (template.views ?? []).map((v) => v.scopeProfileSlug);
+    expect(viewScopes).toEqual(
+      expect.arrayContaining(["content-composition", "content-asset", "render-job"])
+    );
+    const links = (template.entityLinks ?? []).map(
+      (l) => `${l.sourceProfileSlug}-${l.type}->${l.targetProfileSlug}`
+    );
+    expect(links).toEqual(
+      expect.arrayContaining([
+        "render-job-renders->content-composition",
+        "content-asset-used_in->content-composition",
+        "content-asset-used_in->render-job",
+        "content-composition-made_for->post",
+      ])
+    );
+  });
+
+  it("keeps its own home: the content-home cell", () => {
+    expect(template.app).toMatchObject({ kind: "stored", cellKey: "content-home" });
+  });
+});
+
+// A stage's `subjectStatus` is written when the run ENTERS it, and the pod holds
+// it only behind a HUMAN gate (a check gate judges the stage being left, so it
+// passes on entry). A status that claims an outside act — the post is live, the
+// issue went out — or that starts ANOTHER process must therefore sit behind a
+// person's approval, or the record says it happened before anyone confirmed it
+// (review M6: Repurpose fired on a post that never shipped).
+describe("Content OS never writes an outside act before a person confirms it", () => {
+  const playbooks = (template.playbooks ?? []) as TemplatePlaybook[];
+  type Stage = NonNullable<TemplatePlaybook["stages"]>[number];
+  const bound: Array<{ playbook: string; stage: Stage }> = playbooks.flatMap((pb) =>
+    (pb.stages ?? [])
+      .filter((s) => typeof s.subjectStatus === "string")
+      .map((stage) => ({ playbook: pb.name, stage })),
+  );
+  // Values another playbook's activator listens for, per subject kind.
+  const activatedElsewhere = (owner: string, kind: string | undefined, status: string) =>
+    playbooks.some(
+      (pb) =>
+        pb.name !== owner &&
+        pb.subjectProfile?.profileSlug === kind &&
+        (pb.activators ?? []).some((a) => a.on === "enters_status" && a.status === status),
+    );
+  const kindOf = (name: string) => playbooks.find((p) => p.name === name)?.subjectProfile?.profileSlug;
+
+  const mustBeHuman = bound.filter(
+    ({ playbook, stage }) =>
+      stage.category === "completed" ||
+      activatedElsewhere(playbook, kindOf(playbook), stage.subjectStatus as string),
+  );
+
+  it("finds the stages it guards (non-vacuity)", () => {
+    expect(mustBeHuman.map(({ playbook, stage }) => `${playbook}/${stage.key}`).sort()).toEqual([
+      "Newsletter issue/sent",
+      "Produce Content/publish",
+    ]);
+  });
+
+  it("gates each of them on a person", () => {
+    for (const { playbook, stage } of mustBeHuman) {
+      expect({ at: `${playbook}/${stage.key}`, gate: stage.gate }).toEqual({
+        at: `${playbook}/${stage.key}`,
+        gate: { kind: "human" },
+      });
+    }
+  });
+
+  it("keeps a recorded-evidence criterion on each (URL / date)", () => {
+    for (const { playbook, stage } of mustBeHuman) {
+      const evidence = (stage.criteria ?? [])
+        .map((c) => (c as { check?: { kind?: string; evidenceKey?: string } }).check)
+        .filter((c) => c?.kind === "evidence")
+        .map((c) => c!.evidenceKey);
+      expect({ at: `${playbook}/${stage.key}`, has: evidence.length > 0 }).toEqual({
+        at: `${playbook}/${stage.key}`,
+        has: true,
+      });
+    }
+  });
+});
+
+// The script step (D4, 2026-10-12): a post is WRITTEN (script / outline) and a
+// person approves that before anything is generated. Read from the YAML SOURCE,
+// not the generated templates.ts, so the assertion sees this file's edit
+// without a rebuild.
+describe("Content OS scripts a post before generating it", () => {
+  const source = load(
+    readFileSync(join(dirname(fileURLToPath(import.meta.url)), "content-os.yaml"), "utf8"),
+  ) as WorkspaceYaml;
+  const post = source.profiles.find((p) => p.slug === "post");
+  const prop = (slug: string) => post?.properties.find((d) => d.slug === slug);
+  const produce = (source.playbooks ?? []).find((p) => p.name === "Produce Content") as
+    | TemplatePlaybook
+    | undefined;
+  const stage = (key: string) => produce?.stages?.find((s) => s.key === key);
+
+  it("puts Scripted between Briefed and In Draft, in the enum and the lifecycle", () => {
+    const order = ["Idea", "Briefed", "Scripted", "In Draft", "Review", "Scheduled", "Published", "Archived"];
+    expect(prop("post-status")?.enumValues).toEqual(order);
+    expect(post?.lifecycle?.options.map((o) => o.key)).toEqual(order);
+    expect(post?.lifecycle?.options.find((o) => o.key === "Scripted")?.category).toBe("active");
+  });
+
+  it("declares post-goal with the shared goal enum", () => {
+    expect(prop("post-goal")).toMatchObject({ inputType: "select" });
+    expect(prop("post-goal")?.enumValues).toEqual([
+      "sell",
+      "hot-take",
+      "tutorial",
+      "product-demo",
+      "announcement",
+      "proof",
+      "behind-the-scenes",
+      "community",
+    ]);
+  });
+
+  it("runs a script stage at Scripted, right after the brief, producing a Script document", () => {
+    expect(produce?.stages?.map((s) => s.key)).toEqual([
+      "brief",
+      "script",
+      "draft",
+      "review",
+      "schedule",
+      "publish",
+    ]);
+    expect(stage("script")?.subjectStatus).toBe("Scripted");
+    expect(stage("script")?.expectedOutputs).toEqual([
+      expect.objectContaining({ kind: "document", label: "Script" }),
+    ]);
+  });
+
+  it("holds the draft behind a person's approval of the script, reworking the script on reject", () => {
+    expect(stage("draft")?.gate).toEqual({ kind: "human" });
+    expect(stage("draft")?.onFail).toEqual({ toStage: "script" });
+  });
+});
+
+// Decision B (review 22fec5ee, 3 Nov 2026): an idea is its own kind, linked
+// many-to-many to posts by `feeds`, and "Package ideas" is the door that
+// proposes posts from the bank without writing them.
+describe("Content OS ideas: their own kind, feeding posts", () => {
+  const idea = (template.profiles ?? []).find((p) => p.slug === "idea");
+
+  it("declares the idea kind with one lifecycle and no post fields", () => {
+    expect(idea?.lifecycle?.property).toBe("idea-status");
+    expect(idea?.lifecycle?.options.map((o) => `${o.key}:${o.category}`)).toEqual([
+      "New:open",
+      "Shaped:active",
+      "Used:done",
+      "Dropped:lost",
+    ]);
+    const fields = (idea?.properties ?? []).map((p) => p.slug);
+    expect(fields).toEqual(expect.arrayContaining(["idea-status", "content", "idea-pillar", "idea-stage", "idea-tags"]));
+    // An idea has no format and no date (that is what makes it not a post).
+    expect(fields.some((f) => f.startsWith("post-") || f === "publish-date")).toBe(false);
+  });
+
+  it("links an idea to the posts it feeds, many-to-many", () => {
+    const links = (template.entityLinks ?? []).map((l) => `${l.sourceProfileSlug}-${l.type}->${l.targetProfileSlug}`);
+    expect(links).toEqual(expect.arrayContaining(["idea-feeds->post", "idea-belongs_to_pillar->pillar"]));
+  });
+
+  it("packages ideas through a bank-wide playbook that proposes posts, never writes them", () => {
+    const pkg = template.playbooks?.find((p) => p.name === "Package ideas");
+    expect(pkg?.subjectProfile).toBeUndefined();
+    expect(pkg?.expectedOutputs).toEqual([expect.objectContaining({ kind: "post", relationToSubject: "none" })]);
+    expect(pkg?.goalTemplate).toMatch(/idea feeds post/);
+    expect(pkg?.goalTemplate).toMatch(/ONE synap_capture graph/);
+    expect(pkg?.goalTemplate).toMatch(/Never a script/);
+  });
+});
+
+// A post sent for another account (L9: one post per extra account, `post-copy-of`)
+// enters Published like its original. Repurpose must still propose once per
+// ORIGINAL: its activator leaves out a post that carries post-copy-of
+// (backend#766 `unless`), and that property is one the post kind declares.
+describe("Content OS Repurpose proposes once per original, never for a copy", () => {
+  const playbooks = (template.playbooks ?? []) as TemplatePlaybook[];
+  const repurpose = playbooks.find((p) => p.name === "Repurpose");
+
+  it("finds Repurpose and its Published activator (non-vacuity)", () => {
+    expect(repurpose?.subjectProfile?.profileSlug).toBe("post");
+    expect(repurpose?.activators?.filter((a) => a.on === "enters_status" && a.status === "Published")).toHaveLength(1);
+  });
+
+  it("leaves out a post that carries post-copy-of", () => {
+    const published = repurpose?.activators?.find((a) => a.on === "enters_status" && a.status === "Published");
+    expect(published?.unless).toEqual({ property: "post-copy-of", present: true });
+  });
+
+  it("names a property the post kind declares", () => {
+    const post = template.profiles.find((p) => p.slug === "post");
+    expect(post?.properties.map((d) => d.slug)).toContain("post-copy-of");
+  });
+});

package/src/content-os.video-takes.template.test.ts

@@ -0,0 +1,338 @@
+/**
+ * "Record once, publish many" (founder decisions D3 and D6, 2026-10-27), as
+ * catalog config — read from the YAML SOURCE so an edit is seen without a
+ * rebuild.
+ *
+ *   - Takes enter Produce Content as a `takes` param, and their presence picks
+ *     the RE-EDIT video route. Said in the Draft goal as well as the playbook
+ *     goal: a template update leaves an owner-edited field alone, so `stages`
+ *     is what still reaches a pod whose goal was edited.
+ *   - Per-pass approval is ONE person-owned slot per video pass, declared by
+ *     the agent as each pass's preview exists — never a stage per pass, and
+ *     never a stage-level slot (all owed on entry, by every format).
+ *   - A take's transcript is ONE Content OS content-asset (Kind script, File
+ *     ID = the take's file), the shape Content Studio already writes: its body
+ *     holds the readable text and a word-level JSON block in HyperFrames'
+ *     `[{text,start,end}]` shape. Never a second, document-per-take shape.
+ * (Founder interview stays a pod-local playbook: changed on the pod, not here.)
+ */
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+import type { TemplatePlaybook, WorkspaceYaml } from "./types.js";
+
+const source = load(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), "content-os.yaml"), "utf8"),
+) as WorkspaceYaml;
+const playbook = (name: string) =>
+  (source.playbooks ?? []).find((p) => p.name === name) as TemplatePlaybook | undefined;
+
+/**
+ * The five passes, in build order (D3; founder, 2 Nov: background and colour right after the cut, then captions and
+ * graphics on top). The keys keep their `layer-` names: Content Studio reads them, in the same order.
+ */
+const LAYER_KEYS = ["layer-cut", "layer-background", "layer-colour", "layer-captions", "layer-graphics"];
+
+/** D6: the transcript convention, as every process that reads or writes one states it. */
+const TRANSCRIPT_SHAPE = '[{"text","start","end"}]';
+
+describe("Produce Content takes footage", () => {
+  const produce = playbook("Produce Content");
+
+  it("declares takes as an optional text param the goal reads", () => {
+    expect(produce?.params?.find((p) => p.name === "takes")).toEqual({
+      name: "takes",
+      type: "text",
+      label: "Takes (file ids)",
+    });
+    expect(produce?.goalTemplate).toContain("takes ({takes}) mean RE-EDIT");
+  });
+
+  it("routes takes and states the transcript convention in the Draft goal", () => {
+    const goal = (produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").replace(/\s+/g, " ");
+    expect(goal).toContain("the run's takes param, on the run session at metadata.params.takes");
+    expect(goal).toContain("mean the RE-EDIT video route");
+    expect(goal).toContain(TRANSCRIPT_SHAPE);
+  });
+
+  it("keeps a take's transcript in ONE shape: the content-asset Content Studio writes, found before it is made", () => {
+    const goal = (produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").replace(/\s+/g, " ");
+    expect(goal).toContain("ONE content-asset, Kind script, whose File ID is the take's file");
+    expect(goal).toContain('the readable text under a "## Transcript" heading');
+    expect(goal).toContain('"## Words" heading followed by exactly one ```json fenced block');
+    expect(goal).toContain("Find it before transcribing");
+    expect(goal).toContain("reuse it and only fill the word timings");
+    expect(goal).toContain("with a references relation");
+    // The second shape this replaced: a document per take.
+    expect(goal).not.toMatch(/transcript is a pod document/i);
+    expect(goal).not.toContain("one per take");
+  });
+});
+
+describe("Produce Content approves a video pass by pass", () => {
+  const produce = playbook("Produce Content");
+  const draft = produce?.stages?.find((s) => s.key === "draft");
+
+  it("adds no stage for a pass", () => {
+    expect(produce?.stages?.map((s) => s.key)).toEqual(["brief", "script", "draft", "review", "schedule", "publish"]);
+  });
+
+  it("declares no pass slot on any stage (a stage's slots are owed on entry, by every format)", () => {
+    const declared = (produce?.stages ?? []).flatMap((s) => s.expectedOutputs ?? []);
+    for (const o of declared) {
+      expect(LAYER_KEYS.some((k) => JSON.stringify(o).includes(k))).toBe(false);
+    }
+    expect(produce?.expectedOutputs ?? []).toEqual([]);
+  });
+
+  it("calls a video editing step a pass, never a layer (founder 2026-10-28)", () => {
+    // Slot keys keep their `layer-` names (Content Studio reads them); the static passes (edit loop, 2 Nov) too.
+    const text = [produce?.goalTemplate ?? "", draft?.goal ?? ""]
+      .join(" ")
+      .replace(/layer-(cut|captions|graphics|background|colour|structure|visual|polish|<pass>)/g, "");
+    expect(text).not.toMatch(/\blayers?\b/i);
+    expect(text).toMatch(/\bpass(es)?\b/);
+  });
+
+  it("fixes the five person-owned slots, in build order, in the Draft goal", () => {
+    const goal = draft?.goal ?? "";
+    const at = LAYER_KEYS.map((k) => goal.indexOf(k));
+    expect(at.every((i) => i >= 0)).toBe(true);
+    expect([...at].sort((a, b) => a - b)).toEqual(at);
+    for (const part of [
+      "owner human",
+      "ask choose with allowOther",
+      "Approve (recommended",
+      "Rework",
+      "completeOutput",
+      "answered as the edit-loop skill spells out",
+    ]) {
+      expect(goal.replace(/\s+/g, " ")).toContain(part);
+    }
+    // The rest of the slot's shape lives once, in the edit-loop skill (2 Nov).
+    const loop = JSON.parse(
+      readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../skills/edit-loop/edit-loop.skill.json"), "utf8"),
+    ) as { spec: { body: string } };
+    expect(loop.spec.body).toContain("owner `human`, blockedReason `decision`, why `Approve the <pass> on its preview`");
+  });
+});
+
+
+describe("Produce Content starts the Background and Colour passes from the booth look", () => {
+  const produce = playbook("Produce Content");
+  const goal = (produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").replace(/\s+/g, " ");
+  const lookAt = goal.indexOf("A LOOK given");
+
+  it("declares look as an optional text param (Content Studio sends it only when declared)", () => {
+    expect(produce?.params?.find((p) => p.name === "look")).toEqual({
+      name: "look",
+      type: "text",
+      label: "Look (JSON)",
+    });
+  });
+
+  it("names the matte and the grading block, and still asks each look pass on its own slot", () => {
+    expect(lookAt).toBeGreaterThan(0);
+    const look = goal.slice(lookAt);
+    expect(look).toContain("the run's look param, at metadata.params.look");
+    expect(look).toContain("npx hyperframes remove-background");
+    expect(look).toContain("grading.lut");
+    expect(look).toContain('{"mode":"blur"}');
+    expect(look).toContain("Each is still its own pass, with its own slot (layer-background, layer-colour) and its own question");
+    expect(look).toContain("Remove this pass");
+    expect(look).toContain("The raw take is never overwritten");
+  });
+
+  it("leaves the path without a look as it was: the look wording follows the pass wording, which is unchanged", () => {
+    // The answers' details moved to the edit-loop skill (2 Nov); the goal keeps the slot and names the skill.
+    const passes =
+      "ask choose with allowOther, options Approve (recommended), Rework and Use my edit, answered as the edit-loop " +
+      "skill spells out (Approve claims the slot: completeOutput). Build the next pass only after the answer.";
+    expect(goal).toContain(passes);
+    expect(goal.indexOf(passes)).toBeLessThan(lookAt);
+    // Nothing before the look sentence mentions it: the old path reads exactly as before.
+    expect(goal.slice(0, lookAt)).not.toMatch(/\blook\b|remove-background|grading/i);
+  });
+});
+
+/**
+ * The Background pass cuts the person out with THEIR matting tool (intent
+ * `edit_video`, founder decisions be0deab7 and ac1ba2b6, 2026-10-28), and the
+ * local HyperFrames matte is only the fallback: it squashes each frame to
+ * 320x320 with no memory between frames (research 2e187277). The chain never
+ * breaks the video: tool → local matte over the real room → raw take.
+ */
+describe("Produce Content's Background pass uses the person's edit_video tool first", () => {
+  const produce = playbook("Produce Content");
+  const goal = (produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").replace(/\s+/g, " ");
+  const look = goal.slice(goal.indexOf("A LOOK given"));
+  const skill = JSON.parse(
+    readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../skills/facecam-edit/facecam-edit.skill.json"), "utf8"),
+  ) as { spec: { body: string } };
+  const body = skill.spec.body;
+  const pass = body.slice(body.indexOf("**Background pass.**"), body.indexOf("**Colour pass.**"));
+
+  it("the Draft goal finds the tool by intent and hands it the take's pod file id, signed by the pod", () => {
+    expect(look).toContain("the person's edit_video tool (synap_list_capabilities with intent edit_video)");
+    expect(look).toContain('take\'s pod file id ({"videoFile": id}; the pod signs it at run time)');
+  });
+
+  it("the Draft goal gates the matte and finishes the composite, in order", () => {
+    const steps = ["gate the matte", "frame count and duration match the take", "no flicker", "defocus the background once", "choke, feather, light wrap", "grain on the background and a light match on the person"];
+    const at = steps.map((s) => look.indexOf(s));
+    expect(at.every((i) => i >= 0)).toBe(true);
+    expect([...at].sort((a, b) => a - b)).toEqual(at);
+  });
+
+  it("the Draft goal falls back tool → local matte over the chosen background → raw take marked background not applied", () => {
+    const tool = look.indexOf("edit_video tool");
+    const local = look.indexOf("npx hyperframes remove-background instead and composite the same way over the same background");
+    const raw = look.indexOf('says "background not applied"');
+    expect(tool).toBeGreaterThanOrEqual(0);
+    expect(local).toBeGreaterThan(tool);
+    expect(raw).toBeGreaterThan(local);
+    expect(look.indexOf("No edit_video tool, a failed run or a failed gate")).toBeLessThan(local);
+  });
+
+  it("the skill runs the tool with the video alone, waits through next, and never re-runs the billed verb", () => {
+    expect(pass).toContain('synap_list_capabilities({ intent: "edit_video" })');
+    expect(pass).toContain('RVM takes `{ "videoFile": <file entity id> }`');
+    expect(pass).toContain("never fetch a signed URL yourself for it");
+    expect(pass).toContain("`GET /api/hub/files/<fileId>/url` just before the run");
+    expect(pass).toContain("run its `next`");
+    expect(pass).toContain("Never run the matte verb again for the same take");
+    expect(pass).toContain("Download every URL at once");
+    // A tool with no pod-file parameter still gets a URL, fetched just before the run.
+    expect(pass).toContain("A tool that declares no pod-file parameter takes `{ \"video\": <https URL> }`");
+  });
+
+  it("the skill gates frames and flicker before use, then composites and treats the layers apart", () => {
+    for (const part of ["nb_read_frames", "tblend=all_mode=difference", "never drops under half its median", "gblur=sigma=12", "alphamerge", '"details":{"grain"', "`adjust` section"]) {
+      expect(pass).toContain(part);
+    }
+    expect(pass.indexOf("**Gate the matte**")).toBeLessThan(pass.indexOf("**Defocus the background once.**"));
+    expect(pass.indexOf("**Defocus the background once.**")).toBeLessThan(pass.indexOf("**Composite the person with ffmpeg**"));
+  });
+
+  it("the skill's fallback order is local matte over the chosen background, then the raw take, and Remove this pass keeps working", () => {
+    const fallback = pass.slice(pass.indexOf("**Fallback, in order.**"));
+    const local = fallback.indexOf("npx hyperframes remove-background");
+    const raw = fallback.indexOf('"background not applied"');
+    expect(local).toBeGreaterThan(0);
+    expect(raw).toBeGreaterThan(local);
+    // 31 Oct (founder: "still not able to easily set up adding a background"):
+    // the local matte goes over the background the look chose, never the room by force.
+    expect(fallback).toContain("over the background the look chose");
+    expect(fallback).not.toContain("whatever the look asked");
+    expect(pass).toContain("Remove this pass: put the raw take back in the cut");
+  });
+
+  it("the Colour pass adds the LUT to an element the Background pass treated, never replaces its grain or light match", () => {
+    const colour = body.slice(body.indexOf("**Colour pass.**"), body.indexOf("## 7."));
+    expect(colour).toContain("send them again with `lut` in the same `--grading` object");
+  });
+});
+
+/**
+ * The video page (D4-D7, 29 Oct): the person sees which pass the agent is on,
+ * can do a pass themselves in HyperFrames Studio and keep it ("Use my edit"),
+ * and opens Studio from the app through the address the run records. The
+ * cut is a HyperFrames project from the first pass (D7), so Studio shows it.
+ */
+describe("Produce Content's passes: agent working, Use my edit, Studio", () => {
+  const produce = playbook("Produce Content");
+  const goal = (produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").replace(/\s+/g, " ");
+  const skill = JSON.parse(
+    readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../skills/facecam-edit/facecam-edit.skill.json"), "utf8"),
+  ) as { meta: { description: string }; spec: { body: string; description: string } };
+  const body = skill.spec.body;
+
+  it("declares a pass's slot as the agent's before building it, then hands the same key to the person", () => {
+    const working = goal.indexOf("When a pass starts, declare its slot as yours first (an outcome with the pass's key, kind file, no owner, no ask)");
+    const handed = goal.indexOf("After each pass, render its preview into the pod and hand the person ONE slot for it");
+    expect(working).toBeGreaterThan(0);
+    expect(handed).toBeGreaterThan(working);
+  });
+
+  it("offers Use my edit on every pass and never overwrites the person's edit", () => {
+    expect(goal).toContain("Use my edit: their edit is the pass; never overwrite or redo their changes");
+    expect(body).toContain("**Use my edit** (an answer on a pass's question)");
+    expect(body).toContain("keep it as the pass and change nothing of it");
+  });
+
+  it("records the Studio address as the run's `studio` outcome on the fixed edit/ project, and retires it", () => {
+    for (const part of [
+      "~/synap-work/<this run's session id>/edit",
+      "whose address is the run's studio outcome",
+      "retireOutput studio",
+    ]) {
+      expect(goal).toContain(part);
+    }
+    // The commands moved out of the goal (2 Nov, edit loop): the skill holds them.
+    expect(body).toContain("npx hyperframes preview --background --port <a free port, from 3002 up>");
+    expect(body).toContain("`npx hyperframes preview --stop`");
+    // The skill says the same key and URL the app reads.
+    expect(body).toContain('{ key: "studio", kind: "link", label: "HyperFrames Studio", required: false, ref: { url: "http://localhost:<port>/#project/edit" } }');
+    expect(body).toContain("`~/synap-work/<run session id>/edit`");
+    expect(body).toContain('retireOutput: "studio"');
+  });
+
+  it("keeps one history turn per pass so the person's Studio edits are never undone", () => {
+    for (const part of ["history begin --who", "history --since mine", "history end", "history undo --who"]) {
+      expect(body).toContain(part);
+    }
+  });
+});
+
+/** D7 (29 Oct, supersedes 19ee2ca2): HyperFrames is the editor of record for the cut. */
+describe("facecam-edit cuts in HyperFrames", () => {
+  const read = (rel: string) =>
+    JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), "utf8")) as {
+      meta: { description: string };
+      spec: { body: string; description: string };
+    };
+  const skill = read("../skills/facecam-edit/facecam-edit.skill.json");
+  const body = skill.spec.body;
+  const cut = body.slice(body.indexOf("## 4. Apply the cut"), body.indexOf("## 5."));
+
+  it("names HyperFrames as the editor of record and lays the cut as clips, never a baked file", () => {
+    expect(cut).toContain("**Editor of record: HyperFrames.**");
+    expect(cut).toContain("never a baked file");
+    expect(cut).toContain("`data-media-start`");
+    expect(cut).toContain("transcript-cut.mjs --plan");
+    expect(cut).toContain("lay them as clips, never encode them");
+  });
+
+  it("no longer sends the cut to OpenChatCut, in the skill or in the toolbox", () => {
+    const toolbox = read("../skills/video-toolbox/video-toolbox.skill.json").spec.body;
+    for (const text of [body, skill.spec.description, skill.meta.description, toolbox]) {
+      expect(text).not.toContain("OpenChatCut");
+    }
+    expect(toolbox).toContain("**Work a take**");
+  });
+
+  it("keeps the invisible-cut rule (founder, 29 Oct)", () => {
+    expect(body).toContain("**Invisible cuts (picture continuity).**");
+    expect(body).toContain("Never move an edge into speech");
+  });
+});
+
+/** Finding f36420d5: the pilot post stayed at Idea while its run reached Draft. */
+describe("Produce Content moves the post's status with its stages", () => {
+  const produce = playbook("Produce Content");
+  const goalOf = (key: string) => (produce?.stages?.find((s) => s.key === key)?.goal ?? "").replace(/\s+/g, " ");
+
+  it("moves an Idea post to Briefed when the run starts, through the status door", () => {
+    expect(goalOf("brief")).toContain(
+      "if the post still reads Idea, move it to Briefed first (synap_update_entity, post-status Briefed, expectedStatus Idea)",
+    );
+    expect(goalOf("brief")).toContain("never skipping one, takes included");
+  });
+
+  it("makes a take's cut plan the script, and says the Draft gate's approval writes In Draft", () => {
+    expect(goalOf("script")).toContain("With takes (the RE-EDIT route), the script is the cut plan");
+    expect(goalOf("draft").startsWith("Entering Draft waits on the person: this stage's gate asks them to approve the script, and that approval moves the post to In Draft. Build nothing before it passes.")).toBe(true);
+  });
+});