@synap-core/workspace-templates 0.30.0 → 0.32.0

package/src/define.ts

@@ -16,6 +16,7 @@ import type {
   WorkspacePrimarySurface,
   WorkspaceYaml, } from './types.js';
 import { getWorkspaceTemplate } from './templates.js';
+import { startProfileOf } from './types.js';
 import { resolveLifecyclePresets } from './lifecycle-presets.js';
 import { spacePackageCells, type SpacePackageCellWire } from './space-packages.js';
 
@@ -753,7 +754,9 @@ export function toPackageDefinition(
     // `taskIntents` note on the PackageDefinition type above.
     taskIntents: tpl.taskIntents,
     ...(tpl.meta.intent ? { intent: tpl.meta.intent } : {}),
-    ...(tpl.meta.start ? { start: tpl.meta.start } : {}),
+    // The start's kind defaults to the primary output (one source); the wire
+    // always carries it, so the pod, the CP and the landing read `start.profile`.
+    ...(tpl.meta.start ? { start: { ...tpl.meta.start, profile: startProfileOf(tpl.meta) } } : {}),
     sourceRoles: ws.sourceRoles,
     defaultSources: ws.defaultSources,
     profiles: tpl.profiles,

package/src/finance.yaml

@@ -15,6 +15,8 @@ meta:
   # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
   intent:
     label: Finance
+    # The ONE primary output (One model decision 3): a paid invoice is the money in (Bill a client).
+    primary: invoice
     produces:
       - profile: invoice
       - profile: expense
@@ -346,14 +348,20 @@ views:
       defaultSort:
         field: due-date
         direction: asc
+  - name: Invoice Board
+    slug: invoice-board
+    type: kanban
+    scopeProfileSlug: invoice
+    description: Invoices by status, draft to paid — the flow board of Bill a client.
+    config:
+      groupByField: status
   - name: Expenses
     slug: expenses
     type: kanban
     scopeProfileSlug: expense
-    groupBy: status
     description: Accounts payable and spend, grouped by approval/payment status.
     config:
-      groupBy: status
+      groupByField: status
       cardFields: [category, amount, vendor, expense-date]
   - name: Revenue
     slug: revenue
@@ -583,8 +591,6 @@ playbooks:
       back to Paid. Voiding an invoice is a person's call.
     subjectProfile:
       profileSlug: invoice
-      statusProperty: status
-    humanOnlyStatuses: [void]
     activators:
       - { on: created, mode: propose }
     params:
@@ -689,8 +695,6 @@ playbooks:
       a person's call.
     subjectProfile:
       profileSlug: expense
-      statusProperty: status
-    humanOnlyStatuses: [reimbursed, rejected]
     activators:
       - { on: created, mode: propose }
     params:

package/src/foundation.yaml

@@ -643,9 +643,8 @@ views:
     slug: pain-points
     type: kanban
     scopeProfileSlug: pain-point
-    groupBy: severity
     config:
-      groupBy: severity
+      groupByField: severity
       cardFields: [description, audience, evidence]
     description: Pains grouped by severity.
   - name: Positioning & Differentiators

package/src/hr.yaml

@@ -16,6 +16,8 @@ meta:
   # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
   intent:
     label: Team
+    # The ONE primary output (One model decision 3): a hire is what the hiring pipeline produces.
+    primary: candidate
     produces:
       - profile: candidate
       - profile: review
@@ -364,10 +366,9 @@ views:
     slug: reviews
     type: kanban
     scopeProfileSlug: review
-    groupBy: status
     description: Performance reviews across the cycle, by status.
     config:
-      groupBy: status
+      groupByField: status
       cardFields: [cycle, rating, reviewer]
   - name: Policies
     slug: policies

package/src/intent.test.ts

@@ -7,6 +7,8 @@
  *    lifecycle, duplicate, shape);
  *  - a produced profile may come from the dependency closure, and its
  *    lifecycle may be declared there (a role foundation owns);
+ *  - one `primary` output per producing space, one of `produces`; a library
+ *    names none (`intent-primary-*`, One model decision 3);
  *  - (the catalog header half lives in `schema/intent-header.test.ts`);
  *  - BOTH install doors carry it (top-level `intent` on both), driven through
  *    the real converters.
@@ -26,9 +28,14 @@ const lifecycled = (slug: string): TemplateProfile => ({
 } as TemplateProfile);
 const plain = (slug: string): TemplateProfile => ({ slug, displayName: slug, properties: [] } as unknown as TemplateProfile);
 
+/** Fixtures name their first produced profile as the primary unless they set one (or pass `primary: undefined`). */
+const withPrimary = (intent: TemplateIntent): TemplateIntent => {
+  if ("primary" in intent || !Array.isArray(intent.produces) || intent.produces.length === 0) return intent;
+  return { ...intent, primary: intent.produces[0]!.profile };
+};
 const make = (slug: string, profiles: TemplateProfile[], intent?: TemplateIntent, deps: string[] = []): WorkspaceYaml =>
   ({
-    meta: { slug, name: slug, description: "d", icon: "box", color: "blue", ...(intent ? { intent } : {}) },
+    meta: { slug, name: slug, description: "d", icon: "box", color: "blue", ...(intent ? { intent: withPrimary(intent) } : {}) },
     workspace: { name: slug, description: "d" },
     profiles,
     dependencies: deps.map((d) => ({ slug: d, relation: "require" as const })),
@@ -97,6 +104,23 @@ describe("meta.intent — validator rules", () => {
     expect(intentErrors(pack).map((e) => e.rule)).toEqual(["intent-no-workspace"]);
   });
 
+  // Negative control: each goes red with the intent-primary-* block removed from checkIntent.
+  it("intent-primary-missing: a producing space names its primary", () => {
+    const errs = intentErrors(make("t", [lifecycled("thing")], { label: "P", primary: undefined, produces: [{ profile: "thing" }] }));
+    expect(errs.map((e) => e.rule)).toEqual(["intent-primary-missing"]);
+  });
+
+  it("intent-primary-not-produced: the primary is one of produces", () => {
+    const errs = intentErrors(make("t", [lifecycled("thing"), lifecycled("other")], { label: "P", primary: "other", produces: [{ profile: "thing" }] }));
+    expect(errs.map((e) => e.rule)).toEqual(["intent-primary-not-produced"]);
+    expect(intentErrors(make("t", [lifecycled("thing"), lifecycled("other")], { label: "P", primary: "other", produces: [{ profile: "thing" }, { profile: "other" }] }))).toEqual([]);
+  });
+
+  it("intent-primary-library: a library names no primary", () => {
+    const errs = intentErrors(make("t", [lifecycled("thing")], { label: "Library", primary: "thing" }));
+    expect(errs.map((e) => e.rule)).toEqual(["intent-primary-library"]);
+  });
+
   it("an unresolvable dependency does not fabricate an unknown-profile error", () => {
     const t = make("t", [lifecycled("thing")], { label: "P", produces: [{ profile: "elsewhere" }] }, ["not-in-corpus"]);
     expect(intentErrors(t)).toEqual([]);
@@ -104,7 +128,7 @@ describe("meta.intent — validator rules", () => {
 });
 
 describe("meta.intent — both install doors carry it", () => {
-  const intent = { label: "Product", produces: [{ profile: "thing" }] };
+  const intent = { label: "Product", primary: "thing", produces: [{ profile: "thing" }] };
   const t = make("t", [lifecycled("thing")], intent);
 
   it("package door: top-level intent, never in _meta (the CP rebuilds _meta on serve)", () => {
@@ -150,6 +174,23 @@ describe("meta.intent — the catalog", () => {
     expect(table["research-base"]).toEqual(["Research", "hypothesis", "research-finding"]);
   });
 
+  it("every producing space names its primary (One model decision 3)", () => {
+    const primaries = Object.fromEntries(corpus.filter((t) => t.meta.intent?.produces?.length).map((t) => [t.meta.slug, t.meta.intent!.primary]));
+    expect(primaries).toEqual({
+      "builder-workspace": "devplane_feature",
+      "content-os": "post",
+      crm: "deal",
+      finance: "invoice",
+      hr: "candidate",
+      legal: "legal-contract",
+      "marketing-campaign": "campaign",
+      operations: "engagement",
+      "project-management": "sprint",
+      "research-base": "research-finding",
+      social: "post",
+    });
+  });
+
   it("libraries carry a label only; overlays and packs carry none", () => {
     for (const slug of ["brand-library", "foundation", "ecosystem"]) expect(table[slug], slug).toHaveLength(1);
     for (const t of corpus) {

package/src/internal-runbook.yaml

@@ -324,7 +324,6 @@ views:
     slug: workflows
     type: kanban
     scopeProfileSlug: workflow
-    groupBy: workflow-status
     description: Recurring processes on a board by status.
     config:
       groupByField: workflow-status

package/src/kanban-grouping.test.ts

@@ -0,0 +1,72 @@
+/**
+ * A kanban's columns are the values of the field the board reads from
+ * `config.groupByField` (`KanbanAdapter`: `render.groupByField`, else
+ * `properties.status`). Until 7 Nov 2026, 21 catalog kanbans wrote a
+ * `groupBy` instead, which the board never reads, so each silently grouped by
+ * `status`. Rules `view-kanban-group-*` (validate.ts `checkKanbanGrouping`).
+ *
+ * Negative control: each rule test goes red with `checkKanbanGrouping` removed
+ * from `validateTemplate`; the corpus test goes red on the pre-fix catalog.
+ */
+import { describe, expect, it } from "vitest";
+import { validateTemplate } from "./validate.js";
+import type { WorkspaceYaml } from "./types.js";
+import { readYamlTemplates } from "./generate.mjs";
+
+const make = (view: Record<string, unknown>): WorkspaceYaml =>
+  ({
+    meta: { slug: "t", name: "t", description: "d", icon: "box", color: "blue" },
+    workspace: { name: "t", description: "d" },
+    profiles: [
+      {
+        slug: "thing",
+        displayName: "Thing",
+        properties: [
+          { slug: "thing-status", label: "Status", valueType: "string", inputType: "select", enumValues: ["a", "b"] },
+          { slug: "notes", label: "Notes", valueType: "string", inputType: "text" },
+        ],
+      },
+    ],
+    views: [{ name: "Board", type: "kanban", scopeProfileSlug: "thing", ...view }],
+  }) as unknown as WorkspaceYaml;
+
+const rules = (t: WorkspaceYaml) =>
+  validateTemplate(t).errors.filter((e) => e.rule.startsWith("view-kanban-group")).map((e) => e.rule);
+
+describe("kanban grouping — view-kanban-group-*", () => {
+  it("config.groupByField naming a select of the kind passes (bare or properties.-prefixed)", () => {
+    expect(rules(make({ config: { groupByField: "thing-status" } }))).toEqual([]);
+    expect(rules(make({ config: { groupByField: "properties.thing-status" } }))).toEqual([]);
+  });
+
+  it("a top-level groupBy, or one in config, is dead", () => {
+    expect(rules(make({ groupBy: "thing-status", config: { groupByField: "thing-status" } }))).toEqual(["view-kanban-group-dead"]);
+    expect(rules(make({ config: { groupBy: "thing-status", groupByField: "thing-status" } }))).toEqual(["view-kanban-group-dead"]);
+  });
+
+  it("no config.groupByField is refused", () => {
+    expect(rules(make({}))).toEqual(["view-kanban-group-missing"]);
+    expect(rules(make({ groupBy: "thing-status" }))).toEqual(["view-kanban-group-dead", "view-kanban-group-missing"]);
+  });
+
+  it("a field that is not a select of the kind is refused", () => {
+    expect(rules(make({ config: { groupByField: "notes" } }))).toEqual(["view-kanban-group-unknown"]);
+    expect(rules(make({ config: { groupByField: "ghost" } }))).toEqual(["view-kanban-group-unknown"]);
+  });
+
+  it("a kind with no declaration in reach (a system kind) is not judged", () => {
+    expect(rules(make({ scopeProfileSlug: "task", config: { groupByField: "anything" } }))).toEqual([]);
+  });
+
+  it("the whole catalog: every kanban names a real grouping (non-vacuity: at least 30 kanbans)", () => {
+    const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+    const kanbans = corpus.flatMap((t) => (t.views ?? []).filter((v) => v.type === "kanban"));
+    expect(kanbans.length).toBeGreaterThanOrEqual(30);
+    const errs = corpus.flatMap((t) =>
+      validateTemplate(t, { corpus })
+        .errors.filter((e) => e.rule.startsWith("view-kanban-group"))
+        .map((e) => `${t.meta.slug}: ${e.message}`)
+    );
+    expect(errs).toEqual([]);
+  });
+});

package/src/legal.yaml

@@ -16,6 +16,8 @@ meta:
   # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
   intent:
     label: Legal
+    # The ONE primary output (One model decision 3): a signed contract is what legal work produces.
+    primary: legal-contract
     produces:
       - profile: legal-contract
       - profile: compliance-item
@@ -387,20 +389,18 @@ views:
     slug: renewals
     type: kanban
     scopeProfileSlug: legal-contract
-    groupBy: status
     description: Contracts by lifecycle stage — catch renewals and expirations before they bite.
     config:
-      groupBy: status
+      groupByField: status
       cardFields:
         [counterparty, renewalType, renewalDate, expirationDate, value]
   - name: Compliance
     slug: compliance
     type: kanban
     scopeProfileSlug: compliance-item
-    groupBy: status
     description: Obligations by status — nothing goes overdue.
     config:
-      groupBy: status
+      groupByField: status
       cardFields: [obligationType, jurisdiction, dueDate, frequency, owner]
   - name: IP Assets
     slug: ip-assets

package/src/lifecycle-coverage.test.ts

@@ -3,7 +3,7 @@
  *
  * A kind with a lifecycle select (`post-status`, `deal-stage`, …) is a process
  * waiting to be declared: the engine can bind a playbook's stages to it
- * (`subjectProfile.statusProperty` + `stages[].subjectStatus`), but only if a
+ * (`stages[].subjectStatus`, values of the kind's declared lifecycle), but only if a
  * playbook binds the kind at all. This file holds two guards.
  *
  * (1) RATCHET. Count the kinds across the WHOLE corpus that have a lifecycle and
@@ -18,22 +18,14 @@
  *     (RUNTIME_STATUS below). Kind identity is the profile slug, deduplicated
  *     across templates (a shared kind re-declared in two templates counts once).
  *
- * (2) COVERAGE. For every playbook whose stages bind the lifecycle (it declares
- *     `subjectProfile.statusProperty` AND at least one stage `subjectStatus`),
- *     every enum value of that property must be some stage's `subjectStatus` or
- *     listed in `humanOnlyStatuses`. A value in neither is a state the process
- *     silently cannot reach or leave.
- *
- *     NOT covered: a playbook that declares `statusProperty` only to READ the
- *     lifecycle (an activator, e.g. Content OS "Repurpose" fires on Published
- *     and creates NEW posts) and binds no stage. It owns no status, so asking it
- *     to cover the enum would force it to list every value as human-only.
+ * (2) COVERAGE was retired with the playbook's `humanOnlyStatuses` list (One
+ *     model decision 4, 7 Nov 2026): a status no stage owns is derived by the
+ *     pod, and a person-only status is `humanOnly` on the kind's lifecycle.
  *
  * The functions + BASELINE live in scripts/catalog-lib.mjs (validateCatalog
- * enforces them at publish). Both scans derive their set by globbing `src/*.yaml` (readYamlTemplates);
- * nothing is hand-listed. Negative controls (run 2026-10-08): baseline 94 →
- * red "expected 95 to be less than or equal to 94"; removing "Archived" from
- * Produce Content's humanOnlyStatuses → red, naming `post-status = Archived`.
+ * enforces them at publish). The scan derives its set by globbing `src/*.yaml`
+ * (readYamlTemplates); nothing is hand-listed. Negative control (run
+ * 2026-10-08): baseline 94 → red "expected 95 to be less than or equal to 94".
  */
 
 import { describe, expect, it } from "vitest";
@@ -47,7 +39,6 @@ import {
   boundKinds,
   lifecycleKinds,
   unboundLifecycleKinds,
-  uncoveredStatuses,
 } from "../scripts/catalog-lib.mjs";
 
 const { RUNTIME_STATUS, LIFECYCLE } = LIFECYCLE_PATTERNS;
@@ -74,51 +65,3 @@ describe("lifecycle coverage — ratchet", () => {
     expect(unbound.length, unbound.join(", ")).toBeLessThanOrEqual(BASELINE);
   });
 });
-
-describe("lifecycle coverage — every status of a stage-bound lifecycle is owned", () => {
-  it("non-vacuity: at least two playbooks bind stages to a lifecycle", () => {
-    const binders = corpus.flatMap((t) =>
-      (t.playbooks ?? []).filter(
-        (pb) => pb.subjectProfile?.statusProperty && (pb.stages ?? []).some((s) => s.subjectStatus)
-      )
-    );
-    expect(binders.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it("self-check: an un-owned status is reported", () => {
-    const clone = structuredClone(corpus);
-    const produce = clone
-      .find((t) => t.meta.slug === "content-os")!
-      .playbooks!.find((p) => p.name === "Produce Content")!;
-    produce.humanOnlyStatuses = ["Idea"];
-    expect(uncoveredStatuses(clone)).toContain("content-os › Produce Content: post-status = Archived");
-  });
-
-  it("every enum value is a stage's subjectStatus or a humanOnlyStatus", () => {
-    expect(uncoveredStatuses(corpus)).toEqual([]);
-  });
-});
-
-// ONE LIFECYCLE PER KIND OR ROLE (work model, founder rule 2026-10-11). A
-// second lifecycle select on the same kind is two truths about where the thing
-// stands (deal once carried `dealStage` AND `commercialStage`; the lead role
-// `leadStage` AND an overlay `lifecycleStage`). RATCHET on the EXCESS — the sum
-// over kinds of (lifecycle-named selects − 1) — so re-adding a second stage to a
-// kind that is already counted still turns this red. It counts by NAME, so side
-// statuses (`handoffStatus`, `commissionStatus`) are counted too: that is the
-// limit of a name scan, and why this is a ratchet, not a zero assertion.
-// Lower EXCESS_BASELINE when you fold one; never raise it.
-const EXCESS_BASELINE = 9;
-describe("one lifecycle per kind or role — ratchet", () => {
-  it(`excess lifecycle-named selects never grow past ${EXCESS_BASELINE}`, () => {
-    const kinds = lifecycleKinds(corpus);
-    const multi = [...kinds].filter(([, set]) => set.size > 1);
-    const excess = multi.reduce((n, [, set]) => n + set.size - 1, 0);
-    expect(kinds.get("deal")?.has("commercialStage")).toBe(true); // non-vacuity
-    expect(kinds.get("deal")?.has("dealStage"), "deal's retired dealStage is back").toBe(false);
-    expect(kinds.get("lead")?.has("lifecycleStage"), "lead's retired lifecycleStage is back").toBe(false);
-    expect(excess, multi.map(([k, s]) => `${k}: ${[...s].join(",")}`).join("; ")).toBeLessThanOrEqual(
-      EXCESS_BASELINE
-    );
-  });
-});

package/src/lifecycle-declarations.test.ts

@@ -7,12 +7,12 @@
  *  - the validator's category list equals `@synap-core/types/lifecycle`;
  *  - the mandatory declarations (deal, lead, client, the post that Produce
  *    Content drives) carry the founder-confirmed categories;
- *  - COVERAGE, derived: every non-system kind a playbook moves through
- *    `subjectProfile.statusProperty` declares that property as its lifecycle;
- *  - `humanOnly` = the binding playbooks' `humanOnlyStatuses` that stop, pause
- *    or end the thing (category paused/done/lost) — never an invented one —
- *    plus the exact ledger of founder-decided ACTIVE person-only options
- *    (`PERSON_ONLY_ACTIVE`);
+ *  - COVERAGE, derived: every non-system kind a playbook moves (a stage
+ *    `subjectStatus` or a worker `status`) declares a lifecycle, on every
+ *    declaration that carries its property — the playbook follows it;
+ *  - `humanOnly` lives ONLY on the kind's lifecycle (One model decision 4, the
+ *    playbook's `humanOnlyStatuses` list is retired): the exact ledger below
+ *    pins every person-only option, so changing one is a deliberate edit;
  *  - the whole corpus validates with zero `lifecycle-*` errors, and each rule
  *    fires on a broken clone (self-checks).
  */
@@ -72,18 +72,24 @@ describe("lifecycle declarations — the mandatory four", () => {
 
   it("the post Produce Content drives declares post-status", () => {
     const produce = tpl("content-os").playbooks!.find((p) => p.name === "Produce Content")!;
-    expect(produce.subjectProfile).toMatchObject({ profileSlug: "post", statusProperty: "post-status" });
+    expect(produce.subjectProfile).toEqual({ profileSlug: "post" });
     const lc = lifecycleOf(tpl("content-os"), "post");
     expect(lc?.property).toBe("post-status");
     expect(categories(lc)).toMatchObject({ Idea: "open", Published: "done", Archived: "lost" });
   });
 });
 
+/** The lifecycle property a kind declares anywhere in the corpus. */
+const lifecyclePropertyOf = (kind: string) =>
+  corpus.flatMap((t) => t.profiles).find((p) => p.slug === kind && p.lifecycle)?.lifecycle?.property;
+
 /**
- * Every (kind, statusProperty, playbook) a catalog playbook moves. `withSystem`
- * false drops the pod's system kinds (task, decision, question…), whose
- * lifecycle the pod seeds itself (`ensure-system-lifecycles.ts`) — except
- * `deal`, a system kind whose lifecycle the CRM template owns.
+ * Every (kind, lifecycle property, playbook) a catalog playbook moves: a stage
+ * with a `subjectStatus` or a worker with a `status`. The property is the
+ * kind's declared lifecycle (the playbook names none). `withSystem` false drops
+ * the pod's system kinds (task, decision, question…), whose lifecycle the pod
+ * seeds itself (`ensure-system-lifecycles.ts`) — except `deal`, a system kind
+ * whose lifecycle the CRM template owns.
  */
 const TEMPLATE_OWNED_SYSTEM_LIFECYCLES = new Set(["deal"]);
 function playbookBindings({ withSystem = false } = {}) {
@@ -91,12 +97,13 @@ function playbookBindings({ withSystem = false } = {}) {
     (t.playbooks ?? [])
       .filter(
         (pb) =>
-          pb.subjectProfile?.statusProperty &&
+          pb.subjectProfile?.profileSlug &&
+          ((pb.stages ?? []).some((st) => st.subjectStatus) || (pb.activators ?? []).some((a) => a.status)) &&
           (withSystem ||
             !SYSTEM_PROFILES.has(pb.subjectProfile.profileSlug) ||
             TEMPLATE_OWNED_SYSTEM_LIFECYCLES.has(pb.subjectProfile.profileSlug))
       )
-      .map((pb) => ({ template: t, pb, kind: pb.subjectProfile!.profileSlug, property: pb.subjectProfile!.statusProperty! }))
+      .map((pb) => ({ template: t, pb, kind: pb.subjectProfile!.profileSlug, property: lifecyclePropertyOf(pb.subjectProfile!.profileSlug) }))
   );
 }
 
@@ -137,7 +144,9 @@ describe("lifecycle declarations — coverage (derived from the playbooks)", ()
   });
 
   it("every kind a playbook moves declares that property as its lifecycle, wherever it is declared", () => {
-    const missing: string[] = [];
+    const missing: string[] = playbookBindings({ withSystem: true })
+      .filter((b) => !b.property)
+      .map((b) => `${b.template.meta.slug}:${b.pb.name} moves ${b.kind}, which declares no lifecycle`);
     for (const b of playbookBindings())
       for (const t of corpus)
         for (const p of t.profiles.filter((x) => x.slug === b.kind && x.properties.some((pr) => pr.slug === b.property)))
@@ -146,58 +155,56 @@ describe("lifecycle declarations — coverage (derived from the playbooks)", ()
   });
 
   /**
-   * ACTIVE options a person must set, each a founder decision — the only place
-   * `humanOnly` may sit outside paused/done/lost. Still never invented: each
-   * must ALSO be in its binding playbook's `humanOnlyStatuses` (the rule below
-   * reads both). EXACT: an entry that is no longer humanOnly turns this red.
-   *  - ui-design.approved — the design review is a person's call; a coding
-   *    agent implements only from an approved design (DESIGN-DEV-XP-PLAN P6,
-   *    founder-approved 2026-10-12).
-   *  - outreach-touch.sent — the agent drafts, a person sends (founder decision
-   *    2026-10-20; the CRM absorbed Outreach & Comms 2026-10-23): no agent ever
-   *    marks a message sent, and the reply reader starts only once a person did.
+   * Every person-only option in the catalog, EXACT. Until 7 Nov 2026 this was
+   * derived from the binding playbooks' `humanOnlyStatuses`; that list is
+   * retired (One model decision 4), so the flags themselves are the source and
+   * this ledger makes any change to one a deliberate, reviewed edit. Founder
+   * decisions among them: ui-design.approved (design review, DESIGN-DEV-XP-PLAN
+   * P6, 2026-10-12), outreach-touch.sent (a person sends, 2026-10-20),
+   * devplane_feature.cancelled / devplane_story.dropped (homes, 2026-10-13).
    */
-  const PERSON_ONLY_ACTIVE = new Set(["builder-workspace:ui-design.approved", "crm:outreach-touch.sent"]);
-
-  /**
-   * Person-only options the FOUNDER decided on a lifecycle no playbook moves
-   * yet (so no `humanOnlyStatuses` can carry them). Each one a dated decision;
-   * EXACT, like the ledger above.
-   *  - devplane_feature.cancelled / devplane_story.dropped — "Dropped (lost,
-   *    humanOnly)", object-first homes decision 2026-10-13.
-   */
-  const FOUNDER_HUMAN_ONLY = new Set([
+  const HUMAN_ONLY = [
+    "brand-library:brand-asset.deprecated",
+    "brand-library:brand-voice-guide.deprecated",
+    "brand-library:content-guideline.deprecated",
     "builder-workspace:devplane_feature.cancelled",
     "builder-workspace:devplane_story.dropped",
-  ]);
-
-  it("humanOnly = the binding playbooks' humanOnlyStatuses that pause or end the thing", () => {
-    const drift: string[] = [];
-    const activeSeen: string[] = [];
-    const founderSeen: string[] = [];
-    for (const t of corpus)
-      for (const p of t.profiles) {
-        if (!p.lifecycle) continue;
-        const ho = new Set(
-          playbookBindings({ withSystem: true })
-            .filter((b) => b.kind === p.slug && b.property === p.lifecycle!.property)
-            .flatMap((b) => b.pb.humanOnlyStatuses ?? [])
-        );
-        for (const o of p.lifecycle.options) {
-          const id = `${t.meta.slug}:${p.slug}.${o.key}`;
-          const want =
-            (ho.has(o.key) && (["paused", "done", "lost"].includes(o.category) || PERSON_ONLY_ACTIVE.has(id))) ||
-            FOUNDER_HUMAN_ONLY.has(id);
-          if (want && PERSON_ONLY_ACTIVE.has(id)) activeSeen.push(id);
-          if (o.humanOnly && FOUNDER_HUMAN_ONLY.has(id)) founderSeen.push(id);
-          if (Boolean(o.humanOnly) !== want) drift.push(`${id} humanOnly=${Boolean(o.humanOnly)}`);
-        }
-      }
-    expect(drift).toEqual([]);
-    expect(activeSeen.sort()).toEqual([...PERSON_ONLY_ACTIVE].sort());
-    expect(founderSeen.sort()).toEqual([...FOUNDER_HUMAN_ONLY].sort());
-    // non-vacuity: the rule marks real options
-    expect(lifecycleOf(tpl("content-os"), "post")?.options.find((o) => o.key === "Archived")?.humanOnly).toBe(true);
+    "builder-workspace:finding.superseded",
+    "builder-workspace:finding.wont_fix",
+    "builder-workspace:issue.wont_fix",
+    "builder-workspace:ui-design.approved",
+    "builder-workspace:ui-design.archived",
+    "content-os:campaign.cancelled",
+    "content-os:campaign.paused",
+    "content-os:newsletter.Archived",
+    "content-os:post.Archived",
+    "crm:campaign.cancelled",
+    "crm:campaign.paused",
+    "crm:deal.lost",
+    "crm:outreach-touch.replaced",
+    "crm:outreach-touch.sent",
+    "finance:expense.reimbursed",
+    "finance:expense.rejected",
+    "finance:invoice.void",
+    "foundation:lead.converted",
+    "foundation:lead.disqualified",
+    "marketing-campaign:campaign.cancelled",
+    "marketing-campaign:campaign.paused",
+    "operations:contract.expired",
+    "operations:contract.terminated",
+    "operations:deliverable.cancelled",
+    "operations:engagement.cancelled",
+    "operations:engagement.on-hold",
+    "social:post.Archived",
+  ];
+
+  it("humanOnly sits on the kind's lifecycle, exactly the ledger", () => {
+    const seen = corpus.flatMap((t) =>
+      t.profiles.flatMap((p) =>
+        (p.lifecycle?.options ?? []).filter((o) => o.humanOnly).map((o) => `${t.meta.slug}:${p.slug}.${o.key}`)
+      )
+    );
+    expect([...new Set(seen)].sort()).toEqual(HUMAN_ONLY);
   });
 });
 
@@ -238,15 +245,4 @@ describe("lifecycle declarations — the validator", () => {
     delete campaignIn(c2, "crm").lifecycle;
     expect(lifecycleErrors(crmIn(c2), c2).map((e) => e.rule)).toContain("lifecycle-diverges");
   });
-
-  it("self-check: a playbook moving another property than the lifecycle is refused", () => {
-    const c = clone();
-    const produce = c.find((t) => t.meta.slug === "content-os")!.playbooks!.find((p) => p.name === "Produce Content")!;
-    const post = c.find((t) => t.meta.slug === "content-os")!.profiles.find((p) => p.slug === "post")!;
-    post.lifecycle!.property = "platform";
-    produce.subjectProfile!.statusProperty = "post-status";
-    expect(lifecycleErrors(c.find((t) => t.meta.slug === "content-os")!, c).map((e) => e.rule)).toContain(
-      "lifecycle-status-property"
-    );
-  });
 });

package/src/marketing.yaml

@@ -13,6 +13,8 @@ meta:
   # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
   intent:
     label: Marketing
+    # The ONE primary output (One model decision 3): a run campaign (Run a campaign).
+    primary: campaign
     produces:
       - profile: campaign
 
@@ -261,7 +263,8 @@ views:
     slug: campaigns
     type: kanban
     scopeProfileSlug: campaign
-    groupBy: campaign-status
+    config:
+      groupByField: campaign-status
     description: "Campaign kanban board by status."
   - name: Contacts
     slug: contacts
@@ -399,8 +402,6 @@ playbooks:
       person's call.
     subjectProfile:
       profileSlug: campaign
-      statusProperty: campaign-status
-    humanOnlyStatuses: [paused, cancelled]
     activators:
       - { on: created, mode: propose }
     params:

package/src/meetings-knowledge.yaml

@@ -172,10 +172,9 @@ views:
     slug: meeting-action-items
     type: kanban
     scopeProfileSlug: task
-    groupBy: status
     description: Tasks generated from meetings, by status.
     config:
-      groupBy: status
+      groupByField: status
 
 entityLinks:
   - sourceProfileSlug: meeting