@synap-core/workspace-templates 0.29.0 → 0.31.0

package/src/crm.yaml

@@ -51,7 +51,6 @@ meta:
     label: Sales
     promise: Leads and deals, each with a dated next step.
     suggestFor: [small-business, founder]
-    profile: deal
     views: [deal-pipeline, deals-table, deals-list]
     example:
       - { title: "Acme renewal", values: { commercialStage: negotiating, value: 12000, nextStep: "Send revised quote Thu" } }
@@ -69,6 +68,8 @@ meta:
   # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
   intent:
     label: Sales
+    # The ONE primary output (One model decision 3): the won deal; the lead-becomes-client role flow is not modeled yet (S8, decision 10).
+    primary: deal
     produces:
       - profile: lead
       - profile: client
@@ -829,10 +830,9 @@ views:
     slug: outreach-touches
     type: kanban
     scopeProfileSlug: outreach-touch
-    groupBy: status
     description: Every outreach message, grouped by where it stands — drafted for a person to send, through replied.
     config:
-      groupBy: status
+      groupByField: status
       cardFields: [channel, touchType, sentDate]
 
 onboarding:
@@ -971,8 +971,6 @@ playbooks:
       step converts the lead. Never mark the lead a client.
     subjectProfile:
       profileSlug: lead
-      statusProperty: leadStage
-    humanOnlyStatuses: [new, outreach, engaged, nurturing, converted, disqualified]
     # Manual only (founder decision 2026-10-27): the `created` worker started
     # one run per lead and burned the budget; a list is scored in ONE run by
     # "Score a list" instead, and a person qualifies the leads worth it.
@@ -1096,8 +1094,6 @@ playbooks:
       person's call — record why it was lost.
     subjectProfile:
       profileSlug: deal
-      statusProperty: commercialStage
-    humanOnlyStatuses: [lost]
     activators:
       - { on: created, mode: propose }
     params:
@@ -1696,8 +1692,8 @@ playbooks:
   # next step, and a deal is never opened. "Read the reply" keeps only the
   # touches marked sent before the channels. A lifecycle READER of leadStage:
   # no stage moves the lead; nurturing after the second follow-up is proposed
-  # through the door once the last date passes in silence. `statusProperty`
-  # is named because the schedule worker reads `outreach`.
+  # through the door once the last date passes in silence. Its schedule worker
+  # reads `outreach`, a value of the lead role's lifecycle (foundation).
   # Next action (CRM review 2026-10-27): a drafted message becomes the lead's
   # `nextAction` ("Send the drafted message to <name>", `nextActionAt` today),
   # and a message marked sent sets `nextActionAt` by the CADENCE (founder
@@ -1783,7 +1779,6 @@ playbooks:
       reads it and proposes the next step.
     subjectProfile:
       profileSlug: lead
-      statusProperty: leadStage
     activators:
       # Weekdays 07:00 UTC, one batch over the leads in outreach.
       - { on: schedule, cron: "0 7 * * 1-5", status: outreach, mode: propose }
@@ -1906,8 +1901,6 @@ playbooks:
       meeting. Pausing or cancelling is a person's call.
     subjectProfile:
       profileSlug: campaign
-      statusProperty: campaign-status
-    humanOnlyStatuses: [paused, cancelled]
     activators:
       - { on: created, mode: propose }
     params:
@@ -2004,11 +1997,9 @@ playbooks:
       person does. Opened is recorded by a person.
     subjectProfile:
       profileSlug: outreach-touch
-      statusProperty: status
     # No stage of this process owns these: drafted and sent come before it
     # starts, opened is a person's record, replaced closes a draft moved into
     # the person's channel.
-    humanOnlyStatuses: [drafted, sent, opened, replaced]
     activators:
       - { on: enters_status, status: sent, mode: run }
     params:

package/src/decisions-wave.template.test.ts

@@ -54,15 +54,18 @@ describe("decision 1 — Business Developer folds into CRM", () => {
   it("'Qualify a lead' is a process on the lead ROLE's leadStage, started by a person", () => {
     const crm = tpl("crm");
     const pb = playbookOf(crm, "Qualify a lead");
-    expect(pb?.subjectProfile).toMatchObject({ profileSlug: "lead", statusProperty: "leadStage" });
+    expect(pb?.subjectProfile).toEqual({ profileSlug: "lead" });
     // Manual only since 2026-10-27 (founder): a `created` worker ran once per
     // lead and burned the budget; "Score a list" scores a whole list in one run.
     expect(pb?.activators).toEqual([{ on: "manual", mode: "propose" }]);
     // The subject is a ROLE, declared pod-wide by foundation.
     expect(profileOf(tpl("foundation"), "lead")).toMatchObject({ profileKind: "role", scope: "shared" });
-    // Every leadStage value is a stage's status or the person's.
-    const owned = new Set([...(pb?.stages ?? []).map((s) => s.subjectStatus), ...(pb?.humanOnlyStatuses ?? [])]);
-    expect([...owned].filter(Boolean).sort()).toEqual([...(propOf(tpl("foundation"), "lead", "leadStage")?.enumValues ?? [])].sort());
+    // It owns researching and qualified; the other leadStage values belong to a
+    // person or another flow — derived by the pod, never listed (One model
+    // decision 4, 7 Nov 2026; conflict C2 on `outreach` closed).
+    const owned = (pb?.stages ?? []).map((s) => s.subjectStatus).filter(Boolean);
+    expect(owned).toEqual(["researching", "qualified"]);
+    for (const s of owned) expect(propOf(tpl("foundation"), "lead", "leadStage")?.enumValues).toContain(s);
     // Only the last stage, reached when the person chose pursue, moves the lead
     // to qualified. It opens no deal (CRM build plan A4, 2026-10-22): a deal is
     // opened when a person records a booked meeting, which converts the lead.
@@ -130,7 +133,6 @@ describe("decision 4 — 'Deliver a deliverable' starts when the deliverable ent
     expect(pb.stages?.[0]?.subjectStatus).toBeUndefined();
     expect(pb.stages?.map((s) => s.subjectStatus)).not.toContain("not-started");
     // `cancelled` (0.20.0, plan aac47c4a W5) is a person's call too: no stage writes it.
-    expect(pb.humanOnlyStatuses).toEqual(["not-started", "cancelled"]);
     expect(pb.stages?.map((s) => s.subjectStatus)).not.toContain("cancelled");
     expect(errorsOf(tpl("operations"))).toEqual([]);
   });

package/src/define.primary-surface.test.ts

@@ -90,6 +90,7 @@ describe('workspace primary-surface conversion', () => {
           slug: 'pipeline',
           type: 'kanban',
           scopeProfileSlug: 'thing',
+          config: { groupByField: 'status' },
         },
       ],
       layout: {
@@ -100,6 +101,14 @@ describe('workspace primary-surface conversion', () => {
         },
       },
     });
+    // The kanban groups by a real select of its kind (view-kanban-group-*).
+    source.profiles = [
+      {
+        slug: 'thing',
+        displayName: 'Thing',
+        properties: [{ slug: 'status', label: 'Status', valueType: 'string', inputType: 'select', enumValues: ['open', 'done'] }],
+      },
+    ] as typeof source.profiles;
 
     expect(toWorkspaceDefinition(source).definition.layoutConfig).toMatchObject(
       {

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)", () => {
@@ -147,7 +171,24 @@ describe("meta.intent — the catalog", () => {
     expect(table["operations"]).toEqual(["Delivery", "engagement", "deliverable"]);
     expect(table["content-os"]).toEqual(["Content", "post", "newsletter", "campaign"]);
     expect(table["finance"]).toEqual(["Finance", "invoice", "expense"]);
-    expect(table["research-base"]).toEqual(["Research", "hypothesis", "finding"]);
+    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", () => {

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