@synap-core/workspace-templates 0.11.0 → 0.23.0

package/src/content-creation.yaml

@@ -0,0 +1,192 @@
+# Content Creation — the public editorial + production suite
+# ==========================================================
+# A SUITE template: it stands up a content operation in one install by REQUIRING
+# its constituent workspaces (deps-first), then adds a thin "program tower" home
+# of its own — a place to track the editorial programs that cut across the
+# lenses it just installed.
+#
+# What it composes (all public, all bundled):
+#   • brand-library  — brand identity spine (both constituents consume `brand`)
+#   • content-os     — the editorial engine (pillars, posts, platforms, newsletters)
+#                      AND the video / visual pipeline (compositions, assets,
+#                      renders); transitively requires foundation + marketing-campaign
+#
+# content-studio was retired into content-os (retired.yaml, 2026-11-03): one
+# space per domain, and content-os.yaml said never to install it beside
+# content-os. This suite no longer requires it.
+#
+# Brand is required because content-os declares `sourceRoles.brand: consumer`
+# — skipping it would silently drop the spine it consumes. Foundation is NOT a direct dep: content-os already
+# requires it (and marketing-campaign) via its own `dependencies[]`; sourceRoles
+# do not consume `strategy`.
+#
+# It uses `require` (not `compose`): each constituent is a REAL workspace, not an
+# overlay. Installing Content Creation a second time is idempotent — the resolver
+# reuses existing constituent workspaces by slug.
+
+meta:
+  slug: content-creation
+  domain: content
+  name: Content Creation
+  description: Stand up a content operation in one install — brand, editorial engine, and video pipeline — plus a program tower to track what you are making across them.
+  icon: pen-tool
+  color: "#6366F1"
+  tags: [suite, content, creation, editorial, video, studio]
+  isPublic: true
+
+# Deps-first: brand-library is the brand-vocabulary provider content-os
+# consumes, so it must resolve before content-os reuses it. `require` (not
+# `compose`): each is a standalone workspace, not an additive overlay.
+dependencies:
+  - slug: brand-library
+    kind: workspace
+    relation: require
+    reason: "Brand identity spine — Content OS consumes `brand`; skipping it would drop the provider that sourceRole requires."
+  - slug: content-os
+    kind: workspace
+    relation: require
+    reason: "The editorial engine and the video / visual pipeline — pillars, posts, platforms, newsletters, compositions and renders. Transitively brings foundation (strategy spine) and marketing-campaign."
+
+workspace:
+  name: Content Creation
+  description: The program tower for the content operation — track the editorial programs that cut across the brand, editorial, and production lenses this suite installs.
+  subtype: content-creation
+  visibility: pod_visible
+  sourceRoles:
+    brand: consumer
+    content: provider
+
+profiles:
+  # The one native profile the program tower owns: a content program the
+  # operation is driving across the lenses this suite installs. Deliberately
+  # light — the depth lives in the constituent workspaces; this is the
+  # cross-cutting scoreboard that ties them together.
+  - slug: content-program
+    displayName: Content Program
+    icon: target
+    color: "#6366F1"
+    description: A content program the operation is driving — the cross-cutting outcome the editorial and production lenses serve.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: on-track, category: active }
+        - { key: at-risk, category: active }
+        - { key: off-track, category: active }
+        - { key: shipped, category: done }
+    properties:
+      - slug: outcome
+        label: Outcome
+        valueType: string
+        inputType: textarea
+      - slug: status
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [on-track, at-risk, off-track, shipped]
+        constraints: { defaultValue: on-track }
+      - slug: horizon
+        label: Horizon
+        valueType: string
+        inputType: select
+        enumValues: [now, next, later]
+        constraints: { defaultValue: now }
+      - slug: owner
+        label: Owner
+        valueType: string
+        inputType: text
+      - slug: targetDate
+        label: Target Date
+        valueType: date
+        inputType: date
+
+views:
+  - name: Programs
+    slug: programs
+    type: table
+    scopeProfileSlug: content-program
+    description: The content programs across editorial and production, by horizon and status.
+    defaultView: true
+    config:
+      columns: [title, status, horizon, owner, targetDate]
+  - name: Program Board
+    slug: program-board
+    type: kanban
+    scopeProfileSlug: content-program
+    description: Programs grouped by status — a running scoreboard for the content operation.
+    config:
+      groupBy: status
+
+onboarding:
+  goal: >
+    Stand up the content operation and name the handful of programs it is
+    driving — so brand, editorial, and production are all in place and pointed
+    at the same outcomes from day one.
+  framing: |
+    THE EDITORIAL PRODUCER: Act as a sharp producer standing up the content OS.
+    Brand and Content OS are already installed — your job is
+    to name the 3-5 programs that cut across them, so the operation has a
+    scoreboard, not just structure.
+  expertise:
+    starters:
+      - >
+        Name few, real programs. A content operation with 20 programs has
+        none; force the 3-5 that actually decide this quarter, each with an
+        owner and a horizon (now / next / later).
+      - >
+        Tie each program to a lens. A good program names where it lives —
+        a series (editorial), a production pipeline (video and visual
+        posts), or a brand system
+        (library) — so the scoreboard maps to the structure underneath it.
+    blindSpots:
+      - >
+        Programs with no owner and no date are wishes. Every one needs a
+        single owner and a target date, or it will not move.
+      - >
+        "Make more content" is not a program — it is a category. Push for
+        the specific outcome that would make this quarter a win.
+    bar: >
+      A short, honest scoreboard: 3-5 programs, each owned, dated, placed on a
+      horizon, and tied to the lens that serves it — sitting on top of a fully
+      installed content operation.
+  collect:
+    - profileSlug: content-program
+      what: The 3-5 content programs the operation is driving this horizon.
+      cardinality: few
+      keyFields: [status, horizon, owner]
+  openingQuestions:
+    - "What are the 3-5 content programs that will decide this quarter?"
+    - "Who owns each one, and is it a now, next, or later horizon?"
+  doneWhen: A few programs captured, each with an owner and a horizon.
+
+app:
+  kind: stored
+  cellKey: entity-detail
+
+layout:
+  defaultView: Programs
+  defaultApp: null
+  pinnedApps: [dashboard, data]
+  sidebarItems:
+    - kind: view
+      viewName: Programs
+      label: Programs
+      icon: target
+    - kind: view
+      viewName: Program Board
+      label: Board
+      icon: kanban-square
+    - kind: app
+      appId: data
+      label: Data
+      icon: database
+
+bento:
+  viewName: Programs
+  blocks:
+    - kind: view
+      viewName: Programs
+      pos: { x: 0, y: 0, w: 8, h: 4 }
+    - kind: view
+      viewName: Program Board
+      pos: { x: 8, y: 0, w: 4, h: 4 }

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

@@ -0,0 +1,210 @@
+/**
+ * The static asset edit loop, W1 (founder D0-D2, 2 Nov 2026; build plan pod document ab3e0a5a):
+ *
+ *   - ONE edit-run contract for every engine, written once in the `edit-loop` skill: the `layer-<pass>` slots,
+ *     `studio`, `studio-app`, `needs-tool-<tool>`, the three answers, and the rules that keep the person's edits
+ *     safe. The Draft goal and `facecam-edit` name it instead of spelling it again. The keys keep their names:
+ *     Content Studio, Relay and runs in flight read them.
+ *   - Carousels, LinkedIn PDFs and image posts are layered compositions in the pod (`carousel-format`); decks,
+ *     PDF documents and presentations are built in Open Design (`open-design-edit`). The VISUAL branch no longer
+ *     routes to the whiteboard generators.
+ *   - The kinds gain their engines and formats additively (the reconciler is add-only).
+ *
+ * Read from the YAML source and the skill JSON, so an edit is seen without a rebuild.
+ */
+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 here = dirname(fileURLToPath(import.meta.url));
+const yaml = (file: string) => load(readFileSync(join(here, file), "utf8")) as WorkspaceYaml;
+const skill = (slug: string) =>
+  JSON.parse(readFileSync(join(here, `../skills/${slug}/${slug}.skill.json`), "utf8")) as {
+    meta: { slug: string; description: string };
+    spec: { slug: string; body: string; description: string };
+  };
+const flat = (s: string) => s.replace(/\s+/g, " ");
+
+const source = yaml("content-os.yaml");
+const produce = (source.playbooks ?? []).find((p) => p.name === "Produce Content") as TemplatePlaybook | undefined;
+const draftGoal = flat(produce?.stages?.find((s) => s.key === "draft")?.goal ?? "");
+const loop = skill("edit-loop").spec.body;
+
+describe("the edit-loop skill holds the one edit-run contract", () => {
+  it("is a package whose slug is its folder", () => {
+    for (const slug of ["edit-loop", "open-design-edit"]) {
+      expect(skill(slug).meta.slug).toBe(slug);
+      expect(skill(slug).spec.slug).toBe(slug);
+    }
+  });
+
+  it("keeps every key Content Studio reads, unrenamed", () => {
+    for (const key of ['"layer-<pass>"', '"studio"', '"studio-app"', '"needs-tool-<tool>"', "retireOutput studio"]) {
+      expect(loop).toContain(key);
+    }
+    // The video pass keys, in build order (Content Studio's PASSES).
+    const video = ["`cut`", "`background`", "`colour`", "`captions`", "`graphics`"].map((k) => loop.indexOf(k));
+    expect(video.every((i) => i > 0)).toBe(true);
+    expect([...video].sort((a, b) => a - b)).toEqual(video);
+    // The static passes: structure and copy, visual, polish.
+    expect(loop).toContain("`structure` (structure and copy), `visual`, `polish`");
+  });
+
+  it("asks the same three answers on every pass, and says what each does", () => {
+    expect(loop).toContain(
+      "options **Approve** (recommended: keeps this pass and builds the next), **Rework** (redoes this pass only) and **Use my edit** (the person changed this pass in its editor)",
+    );
+    for (const answer of ["- **Approve**:", "- **Rework**:", "- **Use my edit**:", "- **Remove this pass**"]) {
+      expect(loop).toContain(answer);
+    }
+    expect(loop).toContain("keep it as the pass and change nothing of it");
+  });
+
+  it("states the static rules: version first, diff per slide, never regenerate, no write on the person's turn, acknowledge", () => {
+    for (const rule of [
+      "**A version before every pass of yours.**",
+      "**Work from the diff, never from the prompt.**",
+      "slide by slide (by slide number, then layer id)",
+      "Never regenerate a pass, a slide or a page from the brief or the script",
+      "**Never write while a pass is the person's.**",
+      "**Acknowledge every answer in the room.**",
+      "`Got <answer> on <pass>: <what you do now>`",
+    ]) {
+      expect(loop).toContain(rule);
+    }
+  });
+
+  it("routes each format to its engine skill", () => {
+    expect(loop).toContain("| Carousel, LinkedIn PDF | Layered composition in the pod | `carousel-format`");
+    expect(loop).toContain("| Deck, PDF document, presentation | Open Design on the person's Mac | `open-design-edit`");
+  });
+});
+
+describe("the Draft goal and facecam-edit name the contract instead of spelling it twice", () => {
+  it("the Draft goal loads edit-loop and routes the static formats to their engines", () => {
+    expect(draftGoal).toContain("built pass by pass through the edit-loop skill and its engine's skill");
+    expect(draftGoal).toContain("a layered composition saved on the post (carousel-format; passes layer-structure, layer-visual, layer-polish");
+    expect(draftGoal).toContain("Open Design (open-design-edit, same passes)");
+    for (const rule of [
+      "Before each of your passes record a version",
+      "never regenerate from the prompt",
+      "never write while a pass is the person's",
+      "acknowledge each answer in the room",
+    ]) {
+      expect(draftGoal).toContain(rule);
+    }
+  });
+
+  it("every Produce Content stage goal stays under the pod's 5,000-character cap, the Draft goal shorter than before", () => {
+    for (const s of produce?.stages ?? []) expect((s.goal ?? "").length).toBeLessThanOrEqual(5000);
+    // 4,911 on 63f6f004a: moving the contract into the skill must not grow it.
+    expect((produce?.stages?.find((s) => s.key === "draft")?.goal ?? "").length).toBeLessThanOrEqual(4911);
+  });
+
+  it("facecam-edit points at edit-loop, and keeps no second copy of the needs-tool slot", () => {
+    const body = skill("facecam-edit").spec.body;
+    expect(body).toContain("**The passes follow the `edit-loop` skill**");
+    expect(body).toContain("declare ONE `needs-tool-<tool>` slot per missing tool, shaped and answered as the `edit-loop` skill spells out");
+    // The slot as facecam-edit spelled it before 2 Nov: now only in edit-loop.
+    expect(body).not.toContain('{label:"Use another agent"');
+    expect(body).not.toContain('key:"needs-tool-<tool>"');
+  });
+});
+
+describe("the VISUAL branch uses the edit loop", () => {
+  it("drops the whiteboard generators from the process and the creative director", () => {
+    const process = [produce?.goalTemplate ?? "", ...(produce?.stages ?? []).map((s) => s.goal ?? "")].join(" ");
+    for (const gone of ["generate_carousel", "generate_deck", "whiteboard"]) {
+      expect(process).not.toContain(gone);
+      expect(skill("creative-director").spec.body).not.toContain(gone === "whiteboard" ? "onto a whiteboard board" : gone);
+    }
+    expect(flat(produce?.goalTemplate ?? "")).toContain("VISUAL: build it pass by pass through the edit-loop skill");
+  });
+
+  it("the creative director routes carousel/image to the layered composition and decks to Open Design", () => {
+    const cd = skill("creative-director").spec.body;
+    expect(cd).toContain("| carousel / image   | VISUAL — approved carousel template → a layered composition on the post |");
+    expect(cd).toContain("| deck / document    | VISUAL — approved deck template → Open Design on the person's Mac  |");
+    expect(cd).toContain("`carousel-format` (carousel, LinkedIn PDF, image), `open-design-edit` (deck, PDF document). Then build pass by pass with `edit-loop`.");
+    // The frames and the script gate stay.
+    expect(cd).toContain("| hot-take     | Claim · Tension · Reason · Invitation   |");
+    expect(cd).toContain("### 4. Script gate — the written version comes first");
+  });
+
+  it("creative-director stays always-on: its body fits the 2,000-token budget (length / 4), or the IS demotes it", () => {
+    // @synap-core/types space-brief `estimateSkillTokens`; the validator only warns (always-skill-over-budget).
+    expect(Math.ceil(skill("creative-director").spec.body.length / 4)).toBeLessThanOrEqual(2000);
+  });
+
+  it("video-toolbox (name pinned) maps the static jobs to their engines", () => {
+    const toolbox = skill("video-toolbox");
+    expect(toolbox.meta.slug).toBe("video-toolbox");
+    expect(toolbox.spec.body).toContain("| Carousel, LinkedIn PDF, image post (not a video) | a **layered composition**");
+    expect(toolbox.spec.body).toContain("| Deck, PDF document, presentation (not a video) | **Open Design**");
+    expect(toolbox.spec.body).toContain("`open-design-edit`, then `edit-loop`");
+  });
+
+  it("carousel-format builds the layered composition through the revision-checked composition door", () => {
+    const body = skill("carousel-format").spec.body;
+    for (const part of [
+      "### Build it: the layered composition",
+      '"type": "rect" | "image" | "asset" | "text" | "chip"',
+      "`tells`",
+      "a headline 96 px or more (104 by default), body 36 px or more (40 by default)",
+      "`baseRevision` = that revision",
+      "Carousel NN vX — slide n/N",
+      "the composition `made_for` the post",
+      "Agents never publish",
+    ]) {
+      expect(body).toContain(part);
+    }
+  });
+
+  it("open-design-edit follows the W0 recipe: privacy, project locations (never import/folder), ai versions, export", () => {
+    const body = skill("open-design-edit").spec.body;
+    for (const part of [
+      '`telemetry` must be `{ "metrics": false, "content": false }`',
+      "`enabled` must be `false`",
+      "`GET http://127.0.0.1:<port>/api/health`",
+      "`PUT /api/project-locations`",
+      "`POST /api/project-locations/scan`",
+      "Never `POST /api/import/folder`",
+      '`<section class="slide">`',
+      "**Never write into `out/` or `dist/`**",
+      '`{ "source": "ai", "label": "<pass> v<n>", "prompt":',
+      "`manual` versions",
+      "`POST /api/projects/<id>/export/pdf-image`",
+      "`needs-tool-open-design`",
+      "od-design-system-project/v1",
+    ]) {
+      expect(body).toContain(part);
+    }
+  });
+});
+
+describe("Content OS installs and links the new skills, and the kinds grow additively", () => {
+  it("requires and links edit-loop and open-design-edit", () => {
+    for (const slug of ["edit-loop", "open-design-edit"]) {
+      expect((source.dependencies ?? []).some((d) => d.slug === slug && d.kind === "skill" && (d.relation ?? "require") === "require")).toBe(true);
+      expect((source.skills ?? []).some((s) => s.slug === slug)).toBe(true);
+    }
+  });
+
+  it("adds the static engines and formats without dropping a value, in Content OS", () => {
+    for (const file of ["content-os.yaml"]) {
+      const profiles = yaml(file).profiles;
+      const prop = (profile: string, slug: string) =>
+        profiles.find((p) => p.slug === profile)?.properties.find((d) => d.slug === slug) as { enumValues?: string[] } | undefined;
+      expect(prop("content-composition", "render-engine")?.enumValues).toEqual(["hyperframes", "layered", "open-design"]);
+      expect(prop("render-job", "output-format")?.enumValues).toEqual(["mp4", "gif", "webm", "mp3", "pdf", "png", "pptx"]);
+    }
+  });
+
+  it("adds no stage and no required param", () => {
+    expect(produce?.stages?.map((s) => s.key)).toEqual(["brief", "script", "draft", "review", "schedule", "publish"]);
+    expect((produce?.params ?? []).filter((p) => p.required).map((p) => p.name)).toEqual(["post", "platform"]);
+  });
+});

package/src/content-os.publish-due-posts.template.test.ts

@@ -0,0 +1,261 @@
+/**
+ * "Publish due posts" (decision A, founder, 3 Nov: a Scheduled post goes out
+ * through Unipile on its date, with no second approval) and the fields it
+ * reads, pinned on the template that owns them (content-os owns `post` and
+ * `platform`).
+ *
+ * What it proves, each from the authored flow, never a hand copy of it:
+ *  - the flow passes the catalog's own flow validator;
+ *  - every property the flow READS from the due post and every property it
+ *    WRITES is declared on `post`, and every value it writes to a select or the
+ *    lifecycle is one of its options (an undeclared key would be stored
+ *    unmodeled and an unknown option refused: the send would go out and the
+ *    post would never say so);
+ *  - the send's input maps the verb's required parameters, and only declared
+ *    ones (`unipile_publish_post` in the unipile-linkedin capability);
+ *  - the send is never retried, its failure continues to a branch that writes
+ *    publish-outcome failed and publish-error, and the post is claimed
+ *    (and the claim checked as written) before it is sent;
+ *  - one post per run (a loop would abort a failed item with no failure
+ *    branch): the send is never inside a loop, and it ships paused;
+ *  - accounts and destinations (founder, 4 Nov, L9): the send passes the
+ *    company page and the repost's original; a sent post keeps its Unipile
+ *    id and queues the reposts waiting for it, with that id, in a loop whose
+ *    body is that one write.
+ *
+ * NOT covered: the engine running it (query, transform, condition and template
+ * semantics live in synap-backend's automation executor; read there on
+ * 3 Nov: `to_ms`, numeric `$lte` on a property, `continueOnError` storing
+ * `{ error }`, entity_update returning `status: "updated"`); Unipile accepting
+ * the post.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { WORKSPACE_TEMPLATES } from "./templates.js";
+import type { TemplateProfile, WorkspaceYaml } from "./types.js";
+import { validateFlowDefinition } from "./validate-flow.js";
+
+const contentOs = WORKSPACE_TEMPLATES["content-os"] as WorkspaceYaml;
+const profile = (slug: string): TemplateProfile => {
+  const p = (contentOs.profiles ?? []).find((x) => x.slug === slug);
+  if (!p) throw new Error(`content-os declares no ${slug}`);
+  return p;
+};
+const post = profile("post");
+const declared = new Set((post.properties ?? []).map((p) => p.slug));
+const optionsOf = (slug: string): string[] => {
+  const prop = (post.properties ?? []).find((p) => p.slug === slug) as { enumValues?: unknown } | undefined;
+  return Array.isArray(prop?.enumValues) ? (prop.enumValues as string[]) : [];
+};
+const lifecycle = (post as { lifecycle?: { property: string; options: Array<{ key: string }> } }).lifecycle;
+
+const automation = (contentOs.automations ?? []).find((a) => a.key === "content-os-publish-due-posts");
+type Node = { id: string; type: string; data: Record<string, any> };
+type Edge = { id: string; source: string; target: string; sourceHandle?: string };
+const nodes = (automation?.flow.nodes ?? []) as Node[];
+const edges = (automation?.flow.edges ?? []) as Edge[];
+const node = (id: string) => {
+  const n = nodes.find((x) => x.id === id);
+  if (!n) throw new Error(`no node ${id}`);
+  return n;
+};
+
+const unipile = JSON.parse(
+  readFileSync(join(import.meta.dirname, "..", "capabilities", "unipile-linkedin.capability.json"), "utf8"),
+) as { spec: { skills: Array<{ name: string; parameters?: Record<string, string> }> } };
+const verb = unipile.spec.skills.find((s) => s.name === "unipile_publish_post");
+
+/** Every `{{steps.due.output.entities.0.properties.<key>}}` the flow reads, from its whole JSON. */
+const READ = /\{\{steps\.due\.output\.entities\.0\.properties\.([a-z0-9-]+)\}\}/g;
+
+describe("Publish due posts — the automation", () => {
+  it("ships paused, every 15 minutes, and passes the catalog's flow validator", () => {
+    expect(automation).toMatchObject({ name: "Publish due posts", triggerType: "cron", status: "paused", triggerConfig: { expression: "*/15 * * * *" } });
+    const result = validateFlowDefinition(automation?.flow, { verbExists: (v) => v === "unipile_publish_post" });
+    expect(result.errors).toEqual([]);
+  });
+
+  it("sends one post per run, never inside a loop", () => {
+    expect(node("due").data.limit).toBe(1);
+    // The only loop queues reposts after the send: nothing that sends, and
+    // nothing before the send, is reachable from it.
+    const loops = nodes.filter((n) => n.type === "loop");
+    expect(loops.map((n) => n.id)).toEqual(["each-repost"]);
+    const reach = new Set<string>();
+    const stack = ["each-repost"];
+    while (stack.length) {
+      const id = stack.pop() as string;
+      for (const e of edges.filter((x) => x.source === id)) if (!reach.has(e.target)) reach.add(e.target), stack.push(e.target);
+    }
+    expect([...reach]).toEqual(["arm-repost"]);
+  });
+
+  it("finds only an armed Scheduled post whose time has come, oldest first", () => {
+    // The filter is a templated JSON string: with a number for its one placeholder it must parse.
+    const filter = JSON.parse(String(node("due").data.filter).replace("{{steps.now.output.result}}", "1762416000000"));
+    expect(filter).toEqual({ "post-status": "Scheduled", "publish-outcome": "queued", "publish-at-ms": { $lte: 1762416000000 } });
+    expect(lifecycle?.property).toBe("post-status");
+    expect(lifecycle?.options.map((o) => o.key)).toContain("Scheduled");
+    for (const key of Object.keys(filter)) expect(declared, key).toContain(key);
+    expect(optionsOf("publish-outcome")).toContain("queued");
+    expect(node("due").data).toMatchObject({ profileSlug: "post", orderBy: "properties.publish-at-ms", orderDir: "asc" });
+    expect(node("now").data.expression).toBe("{{trigger.payload.scheduledAt}} | to_ms");
+  });
+
+  it("reads only declared post properties", () => {
+    const reads = [...JSON.stringify(automation?.flow).matchAll(READ)].map((m) => m[1]);
+    // Non-vacuity: it reads the frozen fields, the company page and the repost's original among them.
+    expect(new Set(reads)).toEqual(
+      new Set(["publish-account-id", "publish-text", "publish-media", "publish-as-organization", "publish-quote-id"]),
+    );
+    for (const key of reads) expect(declared, key).toContain(key);
+  });
+
+  it("sends through unipile_publish_post with its required parameters, and only declared ones", () => {
+    const send = node("send");
+    expect(send.type).toBe("capability");
+    expect(send.data.verbId).toBe("unipile_publish_post");
+    const params = verb?.parameters ?? {};
+    const required = Object.entries(params).filter(([, t]) => !t.endsWith("?")).map(([k]) => k);
+    expect(required.sort()).toEqual(["accountId", "text"]);
+    for (const k of required) expect(Object.keys(send.data.inputMapping)).toContain(k);
+    for (const k of Object.keys(send.data.inputMapping)) expect(Object.keys(params)).toContain(k);
+  });
+
+  it("claims the post before it sends, and sends only once the claim is written", () => {
+    expect(node("claim").data).toMatchObject({ outputType: "entity_update", config: { properties: { "publish-outcome": "sending" } } });
+    expect(optionsOf("publish-outcome")).toContain("sending");
+    expect(node("claimed").data.expression).toBe("steps.claim.output.status === 'updated'");
+    expect(edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ source: "any-due", target: "claim", sourceHandle: "yes" }),
+        expect.objectContaining({ source: "claim", target: "claimed" }),
+        expect.objectContaining({ source: "claimed", target: "send", sourceHandle: "yes" }),
+      ]),
+    );
+    // Nothing else leads to the send.
+    expect(edges.filter((e) => e.target === "send").map((e) => e.source)).toEqual(["claimed"]);
+  });
+
+  it("is never retried, and a failure goes to the branch that writes it on the post", () => {
+    expect(node("send").data.errorHandling).toEqual({ continueOnError: true });
+    expect(edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ source: "send", target: "sent" }),
+        expect.objectContaining({ source: "sent", target: "published", sourceHandle: "yes" }),
+        expect.objectContaining({ source: "sent", target: "failed", sourceHandle: "no" }),
+      ]),
+    );
+    expect(node("sent").data.expression).toBe("steps.send.output.error === ''");
+    expect(node("failed").data.config.properties).toEqual({ "publish-outcome": "failed", "publish-error": "{{steps.send.output.error}}" });
+  });
+
+  it("writes only declared properties, and only options a select or the lifecycle has", () => {
+    const writes = nodes.filter((n) => n.type === "output" && n.data.outputType === "entity_update");
+    expect(writes.map((w) => w.id).sort()).toEqual(["arm-repost", "claim", "failed", "link", "published", "remember-id"]);
+    for (const w of writes) {
+      // Every write is on the due post, except the one that queues each of its reposts.
+      expect(w.data.config.entityId).toBe(w.id === "arm-repost" ? "{{loop.item.id}}" : "{{steps.due.output.entities.0.id}}");
+      for (const [key, value] of Object.entries(w.data.config.properties as Record<string, string>)) {
+        expect(declared, `${w.id} writes ${key}`).toContain(key);
+        if (key === "post-status") expect(lifecycle?.options.map((o) => o.key)).toContain(value);
+        if (key === "publish-outcome") expect(optionsOf(key)).toContain(value);
+      }
+    }
+    expect(node("published").data.config.properties).toMatchObject({ "post-status": "Published", "publish-outcome": "succeeded" });
+    // The link is its own write and may fail alone: Unipile may return none.
+    expect(node("link").data).toMatchObject({ config: { properties: { "post-url": "{{steps.send.output.shareUrl}}" } }, errorHandling: { continueOnError: true } });
+  });
+});
+
+describe("Publish due posts — the fields Content Studio freezes when a post is approved", () => {
+  it("declares the frozen fields on post, and the Unipile account on platform", () => {
+    for (const key of ["publish-text", "publish-account-id", "publish-media", "publish-at-ms"]) expect(declared, key).toContain(key);
+    expect((post.properties ?? []).find((p) => p.slug === "publish-at-ms")?.valueType).toBe("number");
+    expect((post.properties ?? []).find((p) => p.slug === "publish-media")?.valueType).toBe("array");
+    expect(optionsOf("publish-outcome")).toEqual(["succeeded", "failed", "queued", "sending", "waiting"]);
+    expect((profile("platform").properties ?? []).map((p) => p.slug)).toContain("unipile-account-id");
+  });
+
+  it("Produce Content's Schedule arms the post for Unipile, and its Publish says who writes Published", () => {
+    const pb = (contentOs.playbooks ?? []).find((p) => p.name === "Produce Content") as
+      | { stages?: Array<{ key: string; goal?: string }> }
+      | undefined;
+    const schedule = pb?.stages?.find((s) => s.key === "schedule")?.goal ?? "";
+    for (const word of [
+      "unipile-account-id",
+      "publish-account-id",
+      "publish-text",
+      "publish-media",
+      "publish-at-ms",
+      "publish-outcome queued",
+      "Publish due posts",
+      "account-owner",
+      "publish-as-organization",
+      "post-copy-to",
+      "post-reshare-on",
+      "post-copy-of",
+      "publish-outcome waiting",
+    ])
+      expect(schedule, word).toContain(word);
+    const publish = pb?.stages?.find((s) => s.key === "publish")?.goal ?? "";
+    expect(publish).toContain("Publish due posts");
+    expect(publish).toContain("publish-outcome failed");
+  });
+});
+
+describe("Publish due posts — accounts and destinations (founder, 4 Nov)", () => {
+  const platform = profile("platform");
+  const platformProp = (slug: string) => (platform.properties ?? []).find((p) => p.slug === slug) as { enumValues?: unknown; valueType?: string } | undefined;
+  const postProp = (slug: string) => (post.properties ?? []).find((p) => p.slug === slug) as
+    | { enumValues?: unknown; valueType?: string; targetProfileSlug?: string }
+    | undefined;
+
+  it("a platform row is one account: Personal or Company, and a LinkedIn page id", () => {
+    expect(platformProp("account-owner")?.enumValues).toEqual(["Personal", "Company"]);
+    expect(platformProp("linkedin-organization-id")?.valueType).toBe("string");
+  });
+
+  it("a post names its other accounts, and a post sent for another says which and how", () => {
+    expect(postProp("post-copy-to")?.valueType).toBe("array");
+    expect(postProp("post-reshare-on")?.valueType).toBe("array");
+    expect(postProp("post-copy-of")).toMatchObject({ valueType: "entity_id", targetProfileSlug: "post" });
+    expect(postProp("post-send-mode")?.enumValues).toEqual(["copy", "reshare"]);
+    for (const key of ["publish-as-organization", "publish-quote-id", "publish-post-id"]) expect(postProp(key)?.valueType, key).toBe("string");
+  });
+
+  it("the send passes the company page and the repost's original, and the verb declares both", () => {
+    expect(node("send").data.inputMapping).toMatchObject({
+      postAs: "{{steps.due.output.entities.0.properties.publish-as-organization}}",
+      quotedPostId: "{{steps.due.output.entities.0.properties.publish-quote-id}}",
+    });
+    expect(verb?.parameters).toMatchObject({ postAs: "string?", quotedPostId: "string?" });
+  });
+
+  it("a sent post keeps its Unipile id, then queues its waiting reposts with that id", () => {
+    expect(edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ source: "published", target: "link" }),
+        expect.objectContaining({ source: "link", target: "has-id" }),
+        expect.objectContaining({ source: "has-id", target: "remember-id", sourceHandle: "yes" }),
+        expect.objectContaining({ source: "remember-id", target: "reposts" }),
+        expect.objectContaining({ source: "reposts", target: "each-repost" }),
+        expect.objectContaining({ source: "each-repost", target: "arm-repost" }),
+      ]),
+    );
+    // Only a sent post gets there: the failure branch leads nowhere near it.
+    expect(edges.filter((e) => e.target === "has-id").map((e) => e.source)).toEqual(["link"]);
+    expect(node("has-id").data.expression).toBe("steps.send.output.postId !== ''");
+    expect(node("remember-id").data).toMatchObject({
+      config: { properties: { "publish-post-id": "{{steps.send.output.postId}}" } },
+      errorHandling: { continueOnError: true },
+    });
+    const filter = JSON.parse(String(node("reposts").data.filter).replace("{{steps.due.output.entities.0.id}}", "p1"));
+    expect(filter).toEqual({ "post-copy-of": "p1", "publish-outcome": "waiting" });
+    expect(node("reposts").data.profileSlug).toBe("post");
+    expect(optionsOf("publish-outcome")).toContain("waiting");
+    expect(node("each-repost").data).toMatchObject({ iteratorExpression: "steps.reposts.output.entities", itemVariable: "repost" });
+    expect(node("arm-repost").data.config.properties).toEqual({ "publish-quote-id": "{{steps.send.output.postId}}", "publish-outcome": "queued" });
+  });
+});