@synap-core/workspace-templates 0.12.0 → 0.24.0

package/src/research-decision.yaml

@@ -58,6 +58,15 @@ profiles:
     icon: git-branch
     color: violet
     description: A candidate option under consideration — argued for and against by sources.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: stance
+      options:
+        - { key: proposed, category: open }
+        - { key: supported, category: done }
+        - { key: contested, category: active }
+        - { key: refuted, category: lost }
+        - { key: superseded, category: lost }
     properties:
       - slug: stance
         label: Stance
@@ -131,9 +140,10 @@ playbooks:
       sources with a reason — never drop the counter-evidence). (4) Weigh the
       options against explicit, named criteria (cost, reversibility, risk, time,
       evidence strength). (5) Record the recommendation as a `decision` entity
-      that `resolves` the question — its rationale explains why it won, and its
-      `alternatives` field preserves the options that lost and WHY. (6) Note what
-      evidence would change the decision. Every write is proposal-gated.
+      at the proposed status that `resolves` the question — its rationale
+      explains why it won, and its `alternatives` field preserves the options
+      that lost and WHY. (6) Note what evidence would change the decision.
+      Accepting the decision is a person's call. Every write is proposal-gated.
     subjectProfile:
       profileSlug: question
     params:
@@ -145,6 +155,44 @@ playbooks:
       - exa_search
       - entity.create
     status: active
+    expectedOutputs:
+      - { kind: decision, label: Recommended decision, relationToSubject: resolves }
+
+  - name: Decide
+    description: Put a proposed decision in front of a person with its options and evidence, and record what they chose.
+    goalTemplate: >-
+      Bring this decision ({decision}) to a person. Summarise the question it
+      resolves, the options that were considered, the evidence for and
+      against each, and the recommendation, in one screen. A person accepts or
+      rejects it. When a later decision replaces it, the person marks it
+      superseded.
+    subjectProfile:
+      profileSlug: decision
+      statusProperty: decisionStatus
+    humanOnlyStatuses: [superseded, rejected]
+    activators:
+      - { on: created, mode: propose }
+    params:
+      - { name: decision, type: entity, label: Decision, required: true }
+    executor: is-agent
+    status: active
+    stages:
+      - key: prepare
+        name: Prepare
+        category: started
+        subjectStatus: proposed
+        goal: Summarise the question, the options, the evidence and the recommendation in one screen.
+        criteria:
+          - key: decision-options-listed
+            statement: The decision lists every option considered and why each lost or won.
+            check: { kind: judge }
+      - key: accept
+        name: Accept
+        category: completed
+        subjectStatus: accepted
+        goal: A person accepts the decision.
+        gate: { kind: human }
+        onFail: { toStage: prepare }
 
 actionPlacements:
   - profileSlug: question
@@ -156,3 +204,12 @@ actionPlacements:
 integrations:
   - templateKey: research-methods
   - templateKey: exa
+
+# ── 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:
+  - search_external

package/src/reserved-profile-slugs.test.ts

@@ -0,0 +1,81 @@
+/**
+ * A template may never declare a profile on a slug the pod reserves.
+ *
+ * `project` was declared by builder, life-os and project-management (and the
+ * project-management pack) long after migration 0151 moved projects to their
+ * own table — every such declaration is refused by `ProfileRepository.create`
+ * on install, so it was dead schema at best. `validateTemplate` now refuses it
+ * at authoring time (`profile-slug-reserved`), and the catalog validator runs
+ * `validateTemplate` for every workspace and pack.
+ *
+ * The mirror check reads the pod's own reservation module from the sibling
+ * synap-backend checkout and skips, with the reason logged, when it is absent.
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { RESERVED_PROFILE_SLUGS, validateTemplate } from "./validate.js";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+
+const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const BACKEND_RESERVED = resolve(
+  PKG,
+  "../../../synap-backend/packages/database/src/utils/reserved-profile-slugs.ts"
+);
+
+const template = (profiles: WorkspaceYaml["profiles"]): WorkspaceYaml =>
+  ({
+    meta: { slug: "reserved-probe", name: "Probe", description: "d", icon: "x", color: "violet" },
+    workspace: { name: "Probe", description: "d" },
+    profiles,
+  }) as unknown as WorkspaceYaml;
+
+const reservedErrors = (tpl: WorkspaceYaml) =>
+  validateTemplate(tpl).errors.filter((e) => e.rule === "profile-slug-reserved");
+
+describe("profile-slug-reserved", () => {
+  it("refuses a declared `project` profile, case- and whitespace-insensitively", () => {
+    for (const slug of ["project", "Projects", " project "]) {
+      const errors = reservedErrors(
+        template([{ slug, displayName: "Project", properties: [] }] as unknown as WorkspaceYaml["profiles"])
+      );
+      expect(errors, slug).toHaveLength(1);
+      expect(errors[0].message).toContain("projects table");
+    }
+  });
+
+  it("leaves a free slug that merely contains the word alone", () => {
+    const errors = reservedErrors(
+      template([{ slug: "grant-project", displayName: "Grant project", properties: [] }] as unknown as WorkspaceYaml["profiles"])
+    );
+    expect(errors).toEqual([]);
+  });
+
+  // Profiles are declared only by workspace YAMLs: the CP pack fragments that
+  // also declared them were retired (catalog-lib refuses a `_meta` fragment).
+  it("no shipped template declares a reserved slug", () => {
+    const yamls = readYamlTemplates().map((t) => ({ file: `src/${t.file}`, data: t.data as WorkspaceYaml }));
+    // Non-vacuity: the scan sees the corpus, and the corpus declares profiles.
+    expect(yamls.length).toBeGreaterThan(20);
+    const declared = yamls.flatMap((t) => (t.data?.profiles ?? []).map((p: { slug: string }) => p.slug));
+    expect(declared.length).toBeGreaterThan(100);
+
+    const offenders = yamls.flatMap((t) =>
+      reservedErrors(t.data as WorkspaceYaml).map((e) => `${t.file}: ${e.path}`)
+    );
+    expect(offenders).toEqual([]);
+  });
+});
+
+describe.skipIf(!existsSync(BACKEND_RESERVED))("RESERVED_PROFILE_SLUGS mirrors the pod's reservation", () => {
+  if (!existsSync(BACKEND_RESERVED))
+    console.warn(`[reserved-profile-slugs] SKIP: no synap-backend checkout at ${BACKEND_RESERVED}`);
+
+  it("is the same set as @synap/database reservedProfileSlugs()", async () => {
+    const mod = (await import(BACKEND_RESERVED)) as { reservedProfileSlugs: () => readonly string[] };
+    expect([...RESERVED_PROFILE_SLUGS].sort()).toEqual([...mod.reservedProfileSlugs()].sort());
+  });
+});

package/src/retired-goal-kinds.test.ts

@@ -0,0 +1,52 @@
+/**
+ * No catalog template declares a goal-like kind (decision D2, 2026-10-23).
+ *
+ * "Goal" is the user's word for a track (`project_tracks`). The catalog used to
+ * ship three entity kinds that read as goals: Life OS `goal`, Enterprise OS
+ * `objective`, Project Management `okr`. A pod that installed two of them
+ * showed two "Goals". New installs no longer create them; a pod that already
+ * has them keeps its entities (profiles are never removed from an installed
+ * pod) until the "Make it a goal" conversion is offered.
+ *
+ * `retired.yaml` tombstones whole templates, not a kind inside a live template,
+ * so this list is the kind-level record. A template that needs the idea of a
+ * goal links to the pod's goals (tracks); it never re-declares the kind.
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+
+const RETIRED_GOAL_KINDS = ["goal", "objective", "okr"] as const;
+
+type Declared = { slug?: string };
+type Corpus = { file: string; data: { profiles?: Declared[] } };
+
+/** `file: slug` for every declared profile whose slug is a retired goal kind. */
+const retiredKindsDeclared = (corpus: Corpus[]): string[] =>
+  corpus.flatMap((t) =>
+    (t.data?.profiles ?? [])
+      .filter((p) => (RETIRED_GOAL_KINDS as readonly string[]).includes(String(p.slug).trim().toLowerCase()))
+      .map((p) => `${t.file}: ${p.slug}`)
+  );
+
+describe("retired goal-like kinds", () => {
+  it("the scan catches a template that declares one (so the guard is not vacuous)", () => {
+    const probe: Corpus[] = [
+      { file: "probe.yaml", data: { profiles: [{ slug: "task" }, { slug: " OKR " }] } },
+      { file: "probe2.yaml", data: { profiles: [{ slug: "goal" }, { slug: "objective" }] } },
+    ];
+    expect(retiredKindsDeclared(probe)).toEqual(["probe.yaml:  OKR ", "probe2.yaml: goal", "probe2.yaml: objective"]);
+  });
+
+  // Profiles are declared only by workspace YAMLs: the CP pack fragments that
+  // also declared them were retired (catalog-lib refuses a `_meta` fragment).
+  it("no shipped workspace template declares one", () => {
+    const yamls: Corpus[] = readYamlTemplates().map((t) => ({ file: `src/${t.file}`, data: t.data as Corpus["data"] }));
+    // Non-vacuity: the scan reads the corpus, and the corpus declares profiles.
+    expect(yamls.length).toBeGreaterThan(20);
+    const declared = yamls.flatMap((t) => t.data?.profiles ?? []);
+    expect(declared.length).toBeGreaterThan(100);
+
+    expect(retiredKindsDeclared(yamls)).toEqual([]);
+  });
+});

package/src/role-reference-and-step-domain.test.ts

@@ -0,0 +1,192 @@
+/**
+ * W4a (concept consolidation) validator rules — each driven with a template
+ * built to BREAK it, plus the real corpus passing it.
+ *
+ *   shared-role-reference-no-foundation  a template re-declaring/referencing a
+ *       foundation shared role must reach foundation through its dependencies.
+ *   shared-role-reference-unknown        a reference (no applicableKinds) must
+ *       name a role foundation actually defines.
+ *   stage-domain-shape / -unknown / -not-a-domain  a step's `domain` is a slug
+ *       of a workspace template that OWNS a workspace.
+ *   pack-requires-pack                   D8: a pack lists workspace templates.
+ *
+ * NOT covered: that the pod honours a reference (resolves it to the pod-wide
+ * row, grants access) — that is the backend apply door, not this package.
+ */
+
+import { describe, expect, it } from "vitest";
+import { validateTemplate } from "./validate.js";
+import { WORKSPACE_TEMPLATES } from "./templates.js";
+import type { WorkspaceYaml } from "./types.js";
+
+const corpus: WorkspaceYaml[] = Object.values(WORKSPACE_TEMPLATES);
+
+const tpl = (over: Record<string, unknown>): WorkspaceYaml =>
+  ({
+    meta: {
+      slug: "acme",
+      name: "Acme",
+      description: "d",
+      icon: "x",
+      color: "#000000",
+    },
+    workspace: { name: "Acme", description: "d" },
+    profiles: [{ slug: "gadget", displayName: "Gadget", properties: [] }],
+    ...over,
+  }) as unknown as WorkspaceYaml;
+
+const rules = (t: WorkspaceYaml, prefix: string) =>
+  validateTemplate(t, { corpus })
+    .errors.filter((e) => e.rule.startsWith(prefix))
+    .map((e) => e.rule);
+
+const leadReference = {
+  slug: "lead",
+  displayName: "Lead",
+  scope: "shared",
+  profileKind: "role",
+  properties: [],
+};
+
+describe("shared-role references need foundation in the dependency chain", () => {
+  it("non-vacuity: foundation defines the shared roles the rule reads", () => {
+    const roles = (WORKSPACE_TEMPLATES["foundation"]?.profiles ?? []).filter(
+      (p) => p.scope === "shared" && p.profileKind === "role"
+    );
+    expect(roles.map((p) => p.slug)).toEqual(
+      expect.arrayContaining(["client", "partner", "lead"])
+    );
+  });
+
+  it("a reference with NO foundation in its chain is refused", () => {
+    expect(rules(tpl({ profiles: [leadReference] }), "shared-role-reference")).toEqual([
+      "shared-role-reference-no-foundation",
+    ]);
+  });
+
+  it("a FULL re-declaration of a foundation role without foundation is refused too", () => {
+    const full = { ...leadReference, applicableKinds: ["company", "person"] };
+    expect(rules(tpl({ profiles: [full] }), "shared-role-reference")).toEqual([
+      "shared-role-reference-no-foundation",
+    ]);
+  });
+
+  it("foundation reached TRANSITIVELY (via crm) satisfies it", () => {
+    const t = tpl({
+      profiles: [leadReference],
+      dependencies: [{ slug: "crm", kind: "workspace", relation: "require" }],
+    });
+    expect(rules(t, "shared-role-reference")).toEqual([]);
+  });
+
+  it("a reference to a role foundation does not define is refused", () => {
+    const t = tpl({
+      profiles: [{ ...leadReference, slug: "investor", displayName: "Investor" }],
+      dependencies: [{ slug: "foundation", kind: "workspace", relation: "require" }],
+    });
+    expect(rules(t, "shared-role-reference")).toEqual(["shared-role-reference-unknown"]);
+  });
+
+  it("a shared role the template OWNS (full body, not foundation's) is left alone", () => {
+    const own = {
+      slug: "competitor",
+      displayName: "Competitor",
+      scope: "shared",
+      profileKind: "role",
+      applicableKinds: ["company"],
+      properties: [],
+    };
+    expect(rules(tpl({ profiles: [own] }), "shared-role-reference")).toEqual([]);
+  });
+
+  it("crm and ecosystem now carry references, not bodies", () => {
+    for (const slug of ["crm", "ecosystem"]) {
+      const roles = (WORKSPACE_TEMPLATES[slug]?.profiles ?? []).filter(
+        (p) =>
+          p.scope === "shared" &&
+          p.profileKind === "role" &&
+          ["client", "partner", "lead"].includes(p.slug)
+      );
+      expect(roles.length, `${slug} references no foundation role`).toBeGreaterThan(0);
+      for (const r of roles) {
+        expect(r.applicableKinds, `${slug}.${r.slug} restates applicableKinds`).toBeUndefined();
+        expect(r.description, `${slug}.${r.slug} restates description`).toBeUndefined();
+        expect(r.icon, `${slug}.${r.slug} restates icon`).toBeUndefined();
+      }
+    }
+  });
+});
+
+const withStep = (domain: unknown) =>
+  tpl({
+    playbooks: [
+      {
+        name: "M",
+        goalTemplate: "g",
+        scope: "project",
+        stages: [{ key: "s", name: "S", category: "started", domain }],
+      },
+    ],
+  });
+
+describe("step domains name a workspace template that owns a workspace", () => {
+  it("a real domain template passes", () => {
+    expect(rules(withStep("finance"), "stage-domain")).toEqual([]);
+  });
+  it("a workspace id is refused", () => {
+    expect(rules(withStep("8f894661-db21-4f6d-ba30-5334f7b67bef"), "stage-domain")).toEqual([
+      "stage-domain-shape",
+    ]);
+  });
+  it("a display name is refused", () => {
+    expect(rules(withStep("Foundation"), "stage-domain")).toEqual(["stage-domain-shape"]);
+  });
+  it("a slug no template carries is refused", () => {
+    expect(rules(withStep("no-such-domain"), "stage-domain")).toEqual(["stage-domain-unknown"]);
+  });
+  it("an overlay's slug is refused (it never owns a workspace)", () => {
+    expect(rules(withStep("business-model"), "stage-domain")).toEqual([
+      "stage-domain-not-a-domain",
+    ]);
+  });
+  it("a pack's slug is refused", () => {
+    expect(rules(withStep("enterprise-os"), "stage-domain")).toEqual([
+      "stage-domain-not-a-domain",
+    ]);
+  });
+});
+
+describe("D8: a pack lists workspace templates, never a pack", () => {
+  const pack = (deps: unknown[]) =>
+    tpl({ meta: { slug: "p", name: "P", description: "d", icon: "x", color: "#000000", tags: ["suite"] }, dependencies: deps });
+  it("pack → pack is refused", () => {
+    expect(
+      rules(pack([{ slug: "enterprise-os", kind: "workspace", relation: "require" }]), "pack-")
+    ).toEqual(["pack-requires-pack"]);
+  });
+  it("pack → workspace templates passes", () => {
+    expect(
+      rules(pack([{ slug: "foundation", kind: "workspace", relation: "require" }]), "pack-")
+    ).toEqual([]);
+  });
+});
+
+describe("the real corpus passes every W4a rule", () => {
+  it("no template trips a W4a rule", () => {
+    expect(corpus.length).toBeGreaterThan(20);
+    const hits = corpus.flatMap((t) =>
+      validateTemplate(t, { corpus })
+        .errors.filter((e) =>
+          /^(shared-role-reference|stage-domain|pack-requires-pack)/.test(e.rule)
+        )
+        .map((e) => `${t.meta?.slug}: ${e.rule} ${e.path}`)
+    );
+    expect(hits).toEqual([]);
+  });
+  it("non-vacuity: the corpus HAS step domains and role references to check", () => {
+    const domains = corpus.flatMap((t) =>
+      (t.playbooks ?? []).flatMap((p) => (p.stages ?? []).map((s) => s.domain))
+    ).filter(Boolean);
+    expect(domains.length).toBeGreaterThanOrEqual(12); // business-model 6 + grants 6
+  });
+});

package/src/seed-obligation.test.ts

@@ -37,18 +37,15 @@ import type { WorkspaceYaml } from "./types.js";
  * as debt instead of as a decision.
  */
 const SEEDLESS_BY_DESIGN: Record<string, string> = {
-  "agent-fleet": "Pre-dates this guard. Fleet contents are per-pod; needs a seed pass.",
   base: "Pod substrate, not a workspace a user opens. Seeds would land in every workspace.",
   "blockchain-ecosystem": "Pre-dates this guard; needs a seed pass.",
   "brand-library": "Pre-dates this guard; brand assets are inherently per-company.",
   "builder-workspace": "Pre-dates this guard; needs a seed pass.",
-  "business-developer": "Pre-dates this guard; overlay on CRM, seeds belong on the base.",
   "civic-france": "Pre-dates this guard; needs a seed pass.",
   communication: "Pre-dates this guard; needs a seed pass.",
   "content-os": "Pre-dates this guard; needs a seed pass.",
-  "content-studio": "Pre-dates this guard; needs a seed pass.",
+  "content-creation": "Suite command tower; seeds belong on the constituent workspaces (content-os), same as enterprise-os.",
   crm: "Pre-dates this guard; needs a seed pass.",
-  "dev-dashboard": "Pre-dates this guard; needs a seed pass.",
   ecosystem: "Pre-dates this guard; needs a seed pass.",
   "enterprise-os": "Pre-dates this guard; needs a seed pass.",
   finance:
@@ -64,13 +61,11 @@ const SEEDLESS_BY_DESIGN: Record<string, string> = {
   "meetings-knowledge": "Pre-dates this guard; needs a seed pass.",
   networking: "Pre-dates this guard; needs a seed pass.",
   operations: "Pre-dates this guard; needs a seed pass.",
-  "outreach-comms": "Pre-dates this guard; needs a seed pass.",
   "project-management": "Pre-dates this guard; needs a seed pass.",
   "research-base":
     "Pre-dates this guard. Radar reproduced the empty-workspace pathology on top of this substrate; seed pass wanted.",
   "research-decision": "Overlay on research-base; the method is a playbook, not entities.",
   social: "Pre-dates this guard; needs a seed pass.",
-  "the-arch": "Pre-dates this guard; needs a seed pass.",
 };
 
 /** Slugs of profiles this template declares itself (owned or re-declared). */