@synap-core/workspace-templates 0.12.0 → 0.24.0

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

@@ -0,0 +1,349 @@
+/**
+ * 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");
+  });
+});
+
+// "Write the caption" (founder, 5 Nov): Content Studio's "Write it for me" runs it on ONE post. It drafts, never
+// decides: it writes the script's "## Caption draft" section, never the "## Caption" on its own; the person's yes to ONE
+// owed confirm ask (or their Save in the app) makes it the caption. It binds no stage and moves no status.
+describe("Content OS Write the caption drafts one post's caption, never the person's", () => {
+  const playbooks = (template.playbooks ?? []) as TemplatePlaybook[];
+  const caption = playbooks.find((p) => p.name === "Write the caption");
+
+  it("is a post's process, run by hand on one post (non-vacuity)", () => {
+    expect(caption?.subjectProfile?.profileSlug).toBe("post");
+    expect(caption?.params).toEqual([expect.objectContaining({ name: "post", type: "entity", required: true })]);
+    expect(caption?.goalTemplate).toContain("{post}");
+    expect(caption?.status).toBe("active");
+  });
+
+  it("writes the draft section only, never the saved caption, and never moves the status", () => {
+    expect(caption?.goalTemplate).toMatch(/"## Caption draft" section/);
+    expect(caption?.goalTemplate).toMatch(/Never write or change the "## Caption" section on\s+your own/);
+    // The person's approval is ONE owed confirm ask; only their yes makes the draft the caption.
+    expect(caption?.goalTemplate).toMatch(/ONE confirm ask on this session/);
+    expect(caption?.goalTemplate).toMatch(/On yes, put the draft in\s+the "## Caption" section/);
+    expect(caption?.goalTemplate).toMatch(/Never move the post's status/);
+    expect(caption?.stages ?? []).toEqual([]);
+    expect(caption?.activators ?? []).toEqual([]);
+    expect(caption?.expectedOutputs).toEqual([expect.objectContaining({ kind: "document", label: "Caption draft", relationToSubject: "none" })]);
+  });
+});