@synap-core/workspace-templates 0.12.0 → 0.24.0

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);
+  });
+});

package/src/content-os.work-a-take.template.test.ts

@@ -0,0 +1,125 @@
+/**
+ * "One take, several videos" (founder decisions D1, D2, D3, 29 Oct), as
+ * catalog config, read from the YAML SOURCE so an edit is seen without a
+ * rebuild.
+ *
+ *   - D1: a take is a Content OS content-asset of Kind `recording`, holding
+ *     its facts; its `file-id` is the raw take.
+ *   - D2: a piece is a NEW video file cut from the take, recorded as the same
+ *     Kind with `source-take`, `source-start` and `source-end`. The raw take
+ *     is never overwritten; a re-cut is a new file, the old one kept.
+ *   - D3: the process "Work a take" transcribes, finds the pieces, asks the
+ *     person which to keep, cuts the kept ones and makes one post per piece.
+ *
+ * Content Studio and the other lanes read these exact keys, so they are pinned.
+ */
+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 asset = source.profiles.find((p) => p.slug === "content-asset");
+const prop = (slug: string) => asset?.properties.find((d) => d.slug === slug);
+const work = (source.playbooks ?? []).find((p) => p.name === "Work a take") as TemplatePlaybook | undefined;
+const goalOf = (key: string) => (work?.stages?.find((s) => s.key === key)?.goal ?? "").replace(/\s+/g, " ");
+
+/** The ONE transcript shape (D6 of 27 Oct), as every process that writes one states it. */
+const TRANSCRIPT_SHAPE = '[{"text","start","end"}]';
+
+describe("a take and a piece are content-assets of Kind recording", () => {
+  it("adds recording to the asset kinds, keeping every earlier value", () => {
+    expect(prop("asset-kind")?.enumValues).toEqual(["image", "video", "audio", "font", "script", "recording", "other"]);
+  });
+
+  it("declares the recording facts with their types", () => {
+    for (const slug of ["duration-seconds", "frame-width", "frame-height", "frame-rate", "source-start", "source-end"]) {
+      expect({ slug, valueType: prop(slug)?.valueType }).toEqual({ slug, valueType: "number" });
+    }
+    for (const slug of ["poster-file-id", "take-topic", "take-look", "piece-hook"]) {
+      expect({ slug, valueType: prop(slug)?.valueType }).toEqual({ slug, valueType: "string" });
+    }
+    expect(prop("recorded-at")?.valueType).toBe("date");
+    expect(prop("take-kind")?.enumValues).toEqual(["answer", "free"]);
+    expect(prop("piece-format")?.enumValues).toEqual(["Short Video", "Long Video"]);
+  });
+
+  it("gives a piece its lineage: the take it was cut from, and its earlier cuts", () => {
+    expect(prop("source-take")).toMatchObject({ valueType: "entity_id", targetProfileSlug: "content-asset" });
+    expect(prop("earlier-file-ids")?.valueType).toBe("array");
+  });
+});
+
+describe("Work a take finds the pieces in a take and makes them new files", () => {
+  it("is a process on the take, with no status of its own", () => {
+    expect(work?.subjectProfile).toEqual({ profileSlug: "content-asset" });
+    expect(work?.params).toEqual([{ name: "take", type: "entity", label: "Take", required: true }]);
+    expect(work?.executor).toBe("is-agent");
+    expect(work?.stages?.map((s) => s.key)).toEqual(["transcribe", "analyse", "keep", "cut", "posts"]);
+    for (const stage of work?.stages ?? []) {
+      expect({ stage: stage.key, subjectStatus: stage.subjectStatus }).toEqual({ stage: stage.key, subjectStatus: undefined });
+    }
+  });
+
+  it("asks the person about each piece on a slot, never through a stage gate or a stage-level slot", () => {
+    for (const stage of work?.stages ?? []) {
+      expect({ stage: stage.key, gate: stage.gate }).toEqual({ stage: stage.key, gate: undefined });
+    }
+    const declared = JSON.stringify([...(work?.expectedOutputs ?? []), ...(work?.stages ?? []).flatMap((s) => s.expectedOutputs ?? [])]);
+    for (const key of ["keep-piece-", "piece-<n>", "post-<n>"]) expect(declared).not.toContain(key);
+    const analyse = goalOf("analyse");
+    for (const part of [
+      "key keep-piece-<n>; kind decision; owner human; blockedReason decision",
+      "ask choose with allowOther, options Keep (recommended when it stands alone and fits its format), Drop, and Adjust",
+      "<start>-<end> in seconds",
+    ]) {
+      expect(analyse).toContain(part);
+    }
+    expect(goalOf("keep")).toContain("a piece the person dropped is never cut");
+  });
+
+  it("transcribes into the ONE transcript shape and writes ONE analysis with a pieces block", () => {
+    const transcribe = goalOf("transcribe");
+    expect(transcribe).toContain("ONE content-asset, Kind script, whose File ID is the take's file");
+    expect(transcribe).toContain(TRANSCRIPT_SHAPE);
+    expect(transcribe).toContain("Never transcribe twice, never a separate document");
+    expect(goalOf("analyse")).toContain('"## Pieces" heading followed by exactly one ```json fenced block [{"n","start","end","title","hook","format","why"}]');
+    expect(work?.stages?.find((s) => s.key === "analyse")?.expectedOutputs).toEqual([
+      { kind: "document", label: "Analysis", relationToSubject: "references" },
+    ]);
+  });
+
+  it("cuts each kept piece into a NEW file with ffmpeg and never touches the raw take", () => {
+    const cut = goalOf("cut");
+    for (const part of [
+      "Declare its slot as yours first (an outcome, key piece-<n>, kind content-asset, no owner, no ask)",
+      "from the raw take into a NEW file",
+      "~/synap-work/<this run's session id>/pieces/<n>.mp4",
+      "ffmpeg -ss <start> -to <end> -i <raw take>",
+      "Kind recording",
+      "source-take the take, source-start and source-end",
+      "append the old file id to earlier-file-ids; never delete or overwrite a file",
+    ]) {
+      expect(cut).toContain(part);
+    }
+    // The piece gets its own transcript in the same shape, so Produce Content finds it by its file.
+    expect(cut).toContain("its own transcript in the same ONE shape (File ID = the piece's file)");
+    expect((work?.goalTemplate ?? "").replace(/\s+/g, " ")).toContain("The raw take is never overwritten");
+  });
+
+  it("makes one video post at Idea per piece and starts nothing unasked", () => {
+    const posts = goalOf("posts");
+    expect(posts).toContain("Make one video post per cut piece, at Idea");
+    expect(posts).toContain("linked to the piece with a references relation");
+    expect(posts).toContain("key post-<n>, kind post");
+    expect(posts).toContain("Start Produce Content for a post only if the person asks");
+  });
+
+  it("links ideas from the take back to it", () => {
+    expect(goalOf("analyse")).toContain("propose each as a post at Idea that quotes the person's sentence and links to the take with a references relation");
+  });
+});