@synap-core/workspace-templates 0.12.0 → 0.23.0

package/src/lifecycle-waits.parity.test.ts

@@ -0,0 +1,319 @@
+/**
+ * PARITY — a template's lifecycle option `dateBinding` and step `waits` are
+ * accepted by the catalog validator EXACTLY when the pod accepts them.
+ *
+ * Three bindings, each against the source of the repo that owns the rule:
+ *  1. VOCABULARY: the validator's mirrors (`LIFECYCLE_WAITS_ON`,
+ *     `LIFECYCLE_WAIT_KINDS`) equal `@synap-core/types` (`HOLD_ON` without
+ *     `unspecified`, `WAIT_KINDS`), imported at run time.
+ *  2. FIELD SET: `LIFECYCLE_OPTION_FIELDS` / `LIFECYCLE_OPTION_WAITS_FIELDS`
+ *     equal the keys of `interface LifecycleOption` / `LifecycleOptionWaits` in
+ *     synap-backend `packages/types/src/lifecycle/option.ts`, and the pod's
+ *     parser carries every one of them through.
+ *  3. BEHAVIOUR: synap-backend's OWN parser (`parseLifecycleOptions`,
+ *     `packages/database/src/utils/lifecycle-model.ts`, compiled here with
+ *     esbuild and run against the types this package resolves) and
+ *     `validateTemplate` give the same verdict on every row of a fixture table.
+ *     A convergence check proves sameness, not correctness, so every row also
+ *     names the verdict the rule should give (`ok`), read from the pod's rules,
+ *     and both sides are held to it.
+ *
+ * The rows are chosen where a plausible wrong rule DISAGREES: `unspecified`
+ * (a validator that takes all of `HOLD_ON`), the 64/65-character slug (an
+ * off-by-one length), a done or lost step (a validator that forgets the
+ * category), an unknown `waits` field (a validator that ignores it), `null`
+ * (a validator that treats null as absent).
+ *
+ * NOT covered (stated, not implied): unknown TOP-LEVEL option fields (the pod
+ * ignores them and so does the validator; no row asserts it), `humanOnly`
+ * and `stuckAfterDays` (pinned by `lifecycle-stuck.test.ts`), and whether the
+ * named property exists on the kind (the pod does not check it either). The
+ * behaviour half skips, with the reason logged, when synap-backend is not a
+ * sibling checkout.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { transformSync } from "esbuild";
+import { describe, expect, it } from "vitest";
+import * as typesLifecycle from "@synap-core/types/lifecycle";
+import * as typesUnits from "@synap-core/types/units";
+import { stripComments } from "../../design-tokens/scripts/strip-comments.mjs";
+import {
+  LIFECYCLE_OPTION_FIELDS,
+  LIFECYCLE_OPTION_WAITS_FIELDS,
+  LIFECYCLE_WAIT_KINDS,
+  LIFECYCLE_WAITS_ON,
+  validateTemplate,
+} from "./validate.js";
+import { resolveLifecyclePresets } from "./lifecycle-presets.js";
+import type { WorkspaceYaml } from "./types.js";
+import { readYamlTemplates } from "./generate.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const BE = resolve(HERE, "../../../../synap-backend/packages");
+const OPTION_TS = resolve(BE, "types/src/lifecycle/option.ts");
+const MODEL_TS = resolve(BE, "database/src/utils/lifecycle-model.ts");
+const DID_YOU_MEAN_TS = resolve(BE, "database/src/services/did-you-mean.ts");
+const hasBackend = existsSync(OPTION_TS) && existsSync(MODEL_TS) && existsSync(DID_YOU_MEAN_TS);
+if (!hasBackend) console.warn(`[lifecycle-waits parity] SKIP the backend half: ${MODEL_TS} or ${OPTION_TS} is absent`);
+
+describe("lifecycle waits parity — the vocabulary", () => {
+  it("waits.on is HOLD_ON without unspecified", () => {
+    expect([...LIFECYCLE_WAITS_ON]).toEqual(typesLifecycle.HOLD_ON.filter((on) => on !== "unspecified"));
+  });
+  it("waits.waitKind is WAIT_KINDS", () => {
+    expect([...LIFECYCLE_WAIT_KINDS]).toEqual([...typesUnits.WAIT_KINDS]);
+  });
+});
+
+/** The keys of `export interface <name> {…}` (no nested braces in these two). */
+function interfaceKeys(src: string, name: string): string[] {
+  const code = stripComments(src, "ts");
+  const at = code.indexOf(`export interface ${name} {`);
+  if (at < 0) throw new Error(`interface ${name} not found`);
+  const body = code.slice(code.indexOf("{", at) + 1, code.indexOf("}", at));
+  return [...body.matchAll(/^\s*([A-Za-z_]\w*)\??\s*:/gm)].map((m) => m[1]!);
+}
+
+type ParseLifecycleOptions = (raw: unknown) => { options: Array<Record<string, unknown>>; errors: string[] };
+
+/**
+ * The pod's parser, compiled from its source and run against the types this
+ * package resolves. Every import it makes must be provided here: a new one
+ * throws, naming it, instead of being stubbed silently.
+ */
+function loadBackendParser(): ParseLifecycleOptions {
+  const load = (file: string, deps: Record<string, unknown>): Record<string, unknown> => {
+    const { code } = transformSync(readFileSync(file, "utf8"), { loader: "ts", format: "cjs", target: "es2022" });
+    const mod = { exports: {} as Record<string, unknown> };
+    const req = (id: string) => {
+      if (Object.hasOwn(deps, id)) return deps[id];
+      throw new Error(`[parity] ${file} imports "${id}", which this harness does not provide`);
+    };
+    new Function("require", "module", "exports", code)(req, mod, mod.exports);
+    return mod.exports;
+  };
+  const didYouMean = load(DID_YOU_MEAN_TS, {});
+  const model = load(MODEL_TS, {
+    "@synap-core/types/lifecycle": typesLifecycle,
+    "@synap-core/types/units": typesUnits,
+    "../services/did-you-mean.js": didYouMean,
+  });
+  if (typeof model.parseLifecycleOptions !== "function")
+    throw new Error("[parity] lifecycle-model.ts no longer exports parseLifecycleOptions");
+  return model.parseLifecycleOptions as ParseLifecycleOptions;
+}
+
+describe.skipIf(!hasBackend)("lifecycle waits parity — the field set", () => {
+  it("the option and waits fields are the types' interfaces", () => {
+    const src = readFileSync(OPTION_TS, "utf8");
+    const option = interfaceKeys(src, "LifecycleOption");
+    const waits = interfaceKeys(src, "LifecycleOptionWaits");
+    // non-vacuity: the extraction still sees fields it must
+    expect(option).toContain("stuckAfterDays");
+    expect(waits).toContain("on");
+    expect([...option].sort()).toEqual([...LIFECYCLE_OPTION_FIELDS].sort());
+    expect([...waits].sort()).toEqual([...LIFECYCLE_OPTION_WAITS_FIELDS].sort());
+  });
+
+  it("the pod's parser carries every field the validator names", () => {
+    const parse = loadBackendParser();
+    const full = {
+      key: "sent",
+      label: "Sent",
+      category: "active",
+      tone: "info",
+      humanOnly: true,
+      stuckAfterDays: 7,
+      dateBinding: "dueDate",
+      waits: { on: "external", waitKind: "payment", refFrom: "clientId", dateBinding: "dueDate" },
+    };
+    const { options, errors } = parse([full]);
+    expect(errors).toEqual([]);
+    expect(Object.keys(options[0]!).sort()).toEqual([...LIFECYCLE_OPTION_FIELDS].sort());
+    expect(Object.keys(options[0]!.waits as object).sort()).toEqual([...LIFECYCLE_OPTION_WAITS_FIELDS].sort());
+  });
+});
+
+// ── the behaviour table ─────────────────────────────────────────────────────
+
+const crm = readYamlTemplates()
+  .map((t) => t.data as WorkspaceYaml)
+  .find((t) => t.meta.slug === "crm")!;
+
+/** crm's deal lifecycle: draft (open) · proposed, negotiating (active) · won (done) · lost (lost). */
+function dealWith(key: string, extra: Record<string, unknown>): WorkspaceYaml {
+  const clone = structuredClone(crm);
+  const deal = clone.profiles.find((p) => p.slug === "deal")!;
+  deal.lifecycle!.options = deal.lifecycle!.options.map((o) => (o.key === key ? { ...o, ...extra } : o));
+  return clone;
+}
+
+const waitsErrors = (t: WorkspaceYaml) =>
+  validateTemplate(t).errors.filter((e) => /\.options\[\d+\]\.(dateBinding|waits)$/.test(e.path));
+
+const SLUG_64 = `a${"b".repeat(63)}`;
+const SLUG_65 = `a${"b".repeat(64)}`;
+
+type Row = { name: string; key: string; extra: Record<string, unknown>; ok: boolean };
+const ROWS: Row[] = [
+  { name: "dateBinding on an active step", key: "proposed", extra: { dateBinding: "dueDate" }, ok: true },
+  { name: "dateBinding on an open step, - and _", key: "draft", extra: { dateBinding: "next_action-at" }, ok: true },
+  { name: "dateBinding of 64 characters", key: "proposed", extra: { dateBinding: SLUG_64 }, ok: true },
+  { name: "dateBinding of 65 characters", key: "proposed", extra: { dateBinding: SLUG_65 }, ok: false },
+  { name: "dateBinding with a space", key: "proposed", extra: { dateBinding: "due date" }, ok: false },
+  { name: "dateBinding starting with a digit", key: "proposed", extra: { dateBinding: "1dueDate" }, ok: false },
+  { name: "dateBinding that is a number", key: "proposed", extra: { dateBinding: 42 }, ok: false },
+  { name: "dateBinding null", key: "proposed", extra: { dateBinding: null }, ok: false },
+  { name: "dateBinding on a done step", key: "won", extra: { dateBinding: "dueDate" }, ok: false },
+  { name: "waits on an active step", key: "proposed", extra: { waits: { on: "external" } }, ok: true },
+  {
+    name: "waits with every field",
+    key: "negotiating",
+    extra: { waits: { on: "nobody", waitKind: "payment", refFrom: "contactId", dateBinding: "nextActionAt" } },
+    ok: true,
+  },
+  { name: "waits on an open step", key: "draft", extra: { waits: { on: "date", dateBinding: "nextActionAt" } }, ok: true },
+  { name: "waits.on unspecified", key: "proposed", extra: { waits: { on: "unspecified" } }, ok: false },
+  { name: "waits.on unknown", key: "proposed", extra: { waits: { on: "client" } }, ok: false },
+  { name: "waits without on", key: "proposed", extra: { waits: { waitKind: "payment" } }, ok: false },
+  { name: "waits.waitKind unknown", key: "proposed", extra: { waits: { on: "person", waitKind: "bogus" } }, ok: false },
+  { name: "waits.refFrom with a space", key: "proposed", extra: { waits: { on: "person", refFrom: "contact id" } }, ok: false },
+  { name: "waits.dateBinding a number", key: "proposed", extra: { waits: { on: "date", dateBinding: 3 } }, ok: false },
+  { name: "waits with an unknown field", key: "proposed", extra: { waits: { on: "person", who: "x" } }, ok: false },
+  { name: "waits on a lost step", key: "lost", extra: { waits: { on: "person" } }, ok: false },
+  { name: "waits as a list", key: "proposed", extra: { waits: [] }, ok: false },
+  { name: "waits as a word", key: "proposed", extra: { waits: "external" }, ok: false },
+  { name: "waits null", key: "proposed", extra: { waits: null }, ok: false },
+];
+
+describe("lifecycle waits parity — the table is discriminating", () => {
+  it("non-vacuity: the table holds accepted and refused rows of both fields, on every category", () => {
+    for (const field of ["dateBinding", "waits"]) {
+      const rows = ROWS.filter((r) => field in r.extra);
+      expect(rows.some((r) => r.ok), field).toBe(true);
+      expect(rows.some((r) => !r.ok), field).toBe(true);
+    }
+    expect(new Set(ROWS.map((r) => r.key))).toEqual(new Set(["draft", "proposed", "negotiating", "won", "lost"]));
+  });
+
+  it("the unmodified crm template has no waits errors (the clone is a clean base)", () => {
+    expect(waitsErrors(structuredClone(crm))).toEqual([]);
+  });
+});
+
+describe("lifecycle waits parity — the validator gives each row's verdict", () => {
+  it.each(ROWS)("$name → ok=$ok", ({ key, extra, ok }) => {
+    const errs = waitsErrors(dealWith(key, extra));
+    expect(errs.length === 0, errs.map((e) => e.message).join("; ")).toBe(ok);
+  });
+});
+
+describe.skipIf(!hasBackend)("lifecycle waits parity — the pod's parser gives the same verdict", () => {
+  const parse = hasBackend ? loadBackendParser() : null;
+  const dealOption = (key: string) => crm.profiles.find((p) => p.slug === "deal")!.lifecycle!.options.find((o) => o.key === key)!;
+
+  it.each(ROWS)("$name → ok=$ok", ({ key, extra, ok }) => {
+    const option = { ...dealOption(key), ...extra };
+    const { options, errors } = parse!([option]);
+    expect(errors.length === 0, errors.join("; ")).toBe(ok);
+    if (ok) {
+      // accepted means CARRIED, never silently dropped
+      for (const [field, value] of Object.entries(extra)) expect(options[0]![field]).toEqual(value);
+    }
+  });
+
+  it("the same words: a refused row says what the pod would say", () => {
+    for (const row of ROWS.filter((r) => !r.ok)) {
+      const option = { ...dealOption(row.key), ...row.extra };
+      const pod = parse!([option]).errors;
+      const ours = waitsErrors(dealWith(row.key, row.extra)).map((e) => e.message);
+      expect(ours, row.name).toEqual(pod);
+    }
+  });
+});
+
+// ── presets carry them ──────────────────────────────────────────────────────
+
+describe("lifecycle presets carry dateBinding and waits", () => {
+  /** crm, plus a kind `invoice` declaring `lifecycle` (a real template, so the validator runs whole). */
+  const withLifecycle = (lifecycle: Record<string, unknown>): WorkspaceYaml => {
+    const clone = structuredClone(crm);
+    clone.profiles.push({
+      slug: "invoice",
+      displayName: "Invoice",
+      properties: [
+        { slug: "invoice-status", label: "Status", valueType: "string", inputType: "select" },
+        { slug: "dueDate", label: "Due date", valueType: "date", inputType: "date" },
+      ],
+      lifecycle,
+    } as unknown as WorkspaceYaml["profiles"][number]);
+    return clone;
+  };
+  const resolved = (lifecycle: Record<string, unknown>) => {
+    const { template, problems } = resolveLifecyclePresets(withLifecycle(lifecycle));
+    const invoice = template.profiles.find((p) => p.slug === "invoice")!;
+    return { options: invoice.lifecycle!.options, problems };
+  };
+
+  it("per resulting key, and on an added step, as given", () => {
+    const waits = { on: "external", waitKind: "payment" };
+    const { options, problems } = resolved({
+      property: "invoice-status",
+      adopts: "agreement",
+      dateBinding: { sent: "dueDate" },
+      waits: { sent: waits },
+      add: [{ key: "reminded", category: "active", after: "sent", waits: { on: "date", dateBinding: "dueDate" } }],
+    });
+    expect(problems).toEqual([]);
+    const sent = options.find((o) => o.key === "sent")!;
+    expect(sent.dateBinding).toBe("dueDate");
+    expect(sent.waits).toEqual(waits);
+    expect(sent.stuckAfterDays).toBe(7);
+    expect(options.find((o) => o.key === "reminded")!.waits).toEqual({ on: "date", dateBinding: "dueDate" });
+    // a step the overlay did not name carries neither
+    expect("waits" in options.find((o) => o.key === "draft")!).toBe(false);
+  });
+
+  it("a flat lifecycle keeps them untouched", () => {
+    const flat = {
+      property: "invoice-status",
+      options: [
+        { key: "draft", category: "open" },
+        { key: "sent", category: "active", dateBinding: "dueDate", waits: { on: "external" } },
+        { key: "paid", category: "done" },
+      ],
+    };
+    expect(resolved(flat).options[1]).toEqual(flat.options[1]);
+  });
+
+  it("refuses an override of the wrong type, and an unknown step", () => {
+    const { problems } = resolved({
+      property: "invoice-status",
+      adopts: "agreement",
+      dateBinding: { sent: 3, nope: "dueDate" },
+      waits: { sent: "external" },
+    });
+    expect(problems.map((p) => p.path)).toEqual([
+      "profiles.invoice.lifecycle.dateBinding.sent",
+      "profiles.invoice.lifecycle.dateBinding.nope",
+      "profiles.invoice.lifecycle.waits.sent",
+    ]);
+  });
+
+  it("the validator judges what the presets carried", () => {
+    const tpl = withLifecycle({
+      property: "invoice-status",
+      adopts: "agreement",
+      waits: { sent: { on: "unspecified" }, fulfilled: { on: "person" } },
+    });
+    const errs = validateTemplate(tpl).errors.filter(
+      (e) => e.path.startsWith("profiles.invoice.") && e.path.endsWith(".waits")
+    );
+    expect(errs.map((e) => e.message)).toEqual([
+      'option "sent" waits.on must be one of person | agent | external | thing | decision | date | nobody',
+      'option "fulfilled" is done: a finished thing waits on nothing (waits is for open, active or paused options)',
+    ]);
+  });
+});

package/src/marketing.yaml

@@ -10,6 +10,11 @@ meta:
   color: "#E91E8C"
   tags: [marketing, crm, outreach, leads, campaigns]
   isPublic: true
+  # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
+  intent:
+    label: Marketing
+    produces:
+      - profile: campaign
 
 # SSOT ordering guarantee — this template REFERENCES foundation's pod-wide
 # shared `lead` role. The apply engine seeds a shared profile's pod-wide BASE
@@ -47,6 +52,15 @@ profiles:
     color: pink
     description: "A marketing campaign — email, social, event, content, or partnership"
     semanticSlug: marketing.campaign
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: campaign-status
+      options:
+        - { key: planning, category: open }
+        - { key: active, category: active }
+        - { key: paused, category: paused, humanOnly: true }
+        - { key: completed, category: done }
+        - { key: cancelled, category: lost, humanOnly: true }
     properties:
       - slug: campaign-status
         label: Status
@@ -96,7 +110,7 @@ profiles:
       # `campaign-channel` (the delivery medium). scoping/outreach/live have no
       # channel equivalent, so folding them into `campaign-channel` would lose
       # them — they get their own def. Kept verbatim across the three campaign
-      # declarations (business-developer / content-os / here) so there is no drift.
+      # declarations (crm / content-os / here) so there is no drift.
       - slug: campaign-type
         label: Type
         valueType: string
@@ -256,10 +270,13 @@ views:
     description: "Marketing contacts in a table."
   - name: Lead Pipeline
     slug: lead-pipeline
-    type: kanban
+    # The ONE board (work model L3, D3): columns ARE the lead role's declared
+    # lifecycle (foundation's leadStage), moves go through the one mover.
+    type: pipeline
     scopeProfileSlug: lead
-    groupBy: leadStage
-    description: "Lead pipeline kanban by stage."
+    config:
+      profileSlug: lead
+    description: "Leads in the columns of their stage."
 
 onboarding:
   goal: >
@@ -311,10 +328,12 @@ onboarding:
       leaking, and where the next dollar should go.
   collect:
     - profileSlug: campaign
+      min: 1
       what: The campaigns live or planned right now — one per real initiative, with its channel and goal.
       cardinality: several
       keyFields: [campaign-channel, campaign-goal, campaign-status]
     - profileSlug: lead
+      min: 1
       what: A few representative leads already in motion, placed at their true pipeline stage.
       cardinality: several
       keyFields: [leadStage, lead-source, lead-company]
@@ -362,3 +381,88 @@ bento:
     - kind: view
       viewName: Lead Pipeline
       pos: { x: 6, y: 0, w: 6, h: 5 }
+
+playbooks:
+  - name: Run a campaign
+    description: Take a campaign from brief to results — goal, audience, plan, content, launch with a person's approval, and a report on the leads it brought.
+    goalTemplate: >-
+      Run this campaign ({campaign}); each stage moves its status. BRIEF: write
+      the campaign's goal as a number, its target audience, channel, budget,
+      start and end dates, from the brand kit and the agency's offers. PLAN:
+      list the pieces to make and the outreach to send, each with a date. MAKE:
+      create each piece as a post at the Idea status in Content OS and each
+      outreach sequence as an outreach campaign, so their own processes
+      produce them. LAUNCH: a person approves the launch; nothing is published,
+      sent or paid for before that. REPORT: after the end date, record the lead
+      count and conversion rate, link every new lead the campaign brought, and
+      write what worked and what to change. Pausing or cancelling is a
+      person's call.
+    subjectProfile:
+      profileSlug: campaign
+      statusProperty: campaign-status
+    humanOnlyStatuses: [paused, cancelled]
+    activators:
+      - { on: created, mode: propose }
+    params:
+      - { name: campaign, type: entity, label: Campaign, required: true }
+    executor: is-agent
+    status: active
+    requiredIntents: [publish_post, send_message, list_records]
+    expectedOutputs:
+      - { kind: post, label: Campaign pieces, relationToSubject: relates_to }
+      - { kind: person, label: Leads from the campaign, relationToSubject: relates_to }
+      - { kind: document, label: Campaign report }
+    stages:
+      - key: brief
+        name: Brief
+        category: planned
+        subjectStatus: planning
+        goal: Write the goal as a number, the audience, channel, budget and dates.
+        criteria:
+          - key: campaign-goal-number
+            statement: The campaign's goal is a number with a unit (leads, sign-ups, revenue).
+            check: { kind: judge }
+          - key: campaign-audience
+            statement: The target audience is written and matches an audience in Foundation.
+            check: { kind: judge }
+          - key: campaign-dates-budget
+            statement: The start date, end date and budget are set.
+            check: { kind: judge }
+      - key: plan
+        name: Plan
+        category: planned
+        goal: List every piece and outreach to send, each with a date.
+        gate: { kind: check }
+        onFail: { toStage: brief }
+        criteria:
+          - key: campaign-plan-dated
+            statement: Every planned piece and outreach has a date inside the campaign window.
+            check: { kind: judge }
+      - key: make
+        name: Make
+        category: started
+        goal: Create each piece as a post at Idea and each outreach sequence as an outreach campaign.
+        criteria:
+          - key: campaign-pieces-created
+            statement: Every planned piece exists as a post or an outreach campaign linked to this campaign.
+            check: { kind: judge }
+      - key: launch
+        name: Launch
+        category: started
+        subjectStatus: active
+        goal: A person approves the launch; then the pieces go out on their dates.
+        gate: { kind: human }
+        onFail: { toStage: make }
+        indefinite: true
+      - key: report
+        name: Report
+        category: completed
+        subjectStatus: completed
+        goal: Record lead count and conversion rate, link the leads, and write what to change.
+        criteria:
+          - key: campaign-results
+            statement: The lead count and conversion rate are set.
+            check: { kind: judge }
+          - key: campaign-learnings
+            statement: The report says what worked and what to change next time.
+            check: { kind: judge }

package/src/meetings-knowledge.yaml

@@ -13,6 +13,9 @@ meta:
   color: "#8B5CF6"
   tags: [meetings, notes, tasks, transcripts, calendar]
   isPublic: true
+  # A LIBRARY: it produces nothing a home counts (homes).
+  intent:
+    label: Meetings
 
 workspace:
   name: Meetings & Knowledge
@@ -226,6 +229,21 @@ integrations:
   - templateKey: fireflies
   - templateKey: nango-google
 
+# ── taskIntents — WHAT THIS WORKSPACE NEEDS TO FUNCTION ───────────────────
+# Closed vocabulary: `@synap-core/types/capability-intents` (pod migrations
+# 0283/0284). DERIVED from the declared intents of this template's own
+# `integrations` capability packs — not hand-guessed. Checked at authoring
+# time by `validateTemplate` (`task-intent-unknown`) and by
+# `src/task-intents.test.ts`.
+taskIntents:
+  - capture_into_pod
+  - search_external
+  - fetch_record
+  - list_records
+  - send_message
+  - schedule_event
+  - manage_file
+
 onboarding:
   goal: >
     Get recent meetings into the pod so summaries, action items, and attendees

package/src/networking.yaml

@@ -77,6 +77,15 @@ profiles:
     color: amber
     description: A client's stated ask — the demand The Arch brokers a provider against.
     scope: WORKSPACE
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: needStatus
+      options:
+        - { key: open, category: open }
+        - { key: matching, category: active }
+        - { key: intro-made, category: active }
+        - { key: satisfied, category: done }
+        - { key: dropped, category: lost }
     properties:
       - slug: needStatus
         label: Status
@@ -133,6 +142,17 @@ profiles:
     color: violet
     description: The middleman brokerage artifact — connects a requester to a provider for a need, and bills the match as a deal.
     scope: WORKSPACE
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: introStage
+      options:
+        - { key: identified, category: open }
+        - { key: proposed, category: active }
+        - { key: approved, category: active }
+        - { key: introduced, category: active }
+        - { key: in-discussion, category: active }
+        - { key: signed, category: done }
+        - { key: dead, category: lost }
     properties:
       - slug: introStage
         label: Stage
@@ -155,8 +175,9 @@ profiles:
         valueType: entity_id
         inputType: entity_select
         targetProfileSlug: need
-      # ── Fee vocabulary — REUSED VERBATIM from business-developer.yaml's `deal`
-      # commercial contract, so an intro bills exactly like a CRM deal does. ──
+      # ── Fee vocabulary — REUSED VERBATIM from the `deal` overlay of the retired
+      # arch-sales (retired-sources/arch-sales.yaml), so an intro bills exactly
+      # like a CRM deal did. ──
       - slug: synapFeeModel
         label: Synap fee model
         valueType: string