@synap-core/workspace-templates 0.12.0 → 0.24.0

package/src/hr.yaml

@@ -13,6 +13,12 @@ meta:
   color: "#E8663D"
   tags: [hr, people, hiring, team]
   isPublic: true
+  # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
+  intent:
+    label: Team
+    produces:
+      - profile: candidate
+      - profile: review
 
 workspace:
   name: People
@@ -20,7 +26,10 @@ workspace:
   proposalId: hr-v1
   subtype: hr
   visibility: members
-  workspaceType: operational
+  # A DOMAIN workspace that holds entities — NOT `operational`. `operational`
+  # marks an admin/system surface: `isDomainHomeWorkspace` refuses filing
+  # entities into it and excludes it from auto-placement (2026-09-25).
+  workspaceType: personal
   capabilities:
     - hr.team
     - hr.hiring
@@ -153,6 +162,17 @@ profiles:
     profileKind: role
     applicableKinds:
       - person
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: stage
+      options:
+        - { key: applied, category: open }
+        - { key: screening, category: active }
+        - { key: interview, category: active }
+        - { key: offer, category: active }
+        - { key: hired, category: done }
+        - { key: rejected, category: lost }
+        - { key: withdrawn, category: lost }
     properties:
       - slug: stage
         label: Stage
@@ -195,6 +215,16 @@ profiles:
     icon: clipboard-check
     color: violet
     description: "A performance review within a company review cycle."
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: not-started, category: open }
+        - { key: self-review, category: active }
+        - { key: manager-review, category: active }
+        - { key: calibration, category: active }
+        - { key: shared, category: active }
+        - { key: complete, category: done }
     properties:
       - slug: cycle
         label: Cycle
@@ -315,13 +345,13 @@ views:
         ]
   - name: Hiring Pipeline
     slug: hiring-pipeline
-    type: kanban
+    # The ONE board (work model L3, D3): columns ARE the candidate role's
+    # declared lifecycle (`stage`), moves go through the one mover.
+    type: pipeline
     scopeProfileSlug: candidate
-    groupBy: stage
-    description: Candidates moving through the pipeline, by stage.
     config:
-      groupBy: stage
-      cardFields: [source, rating, email]
+      profileSlug: candidate
+    description: Candidates moving through the pipeline, by stage.
   - name: Open Roles
     slug: open-roles
     type: table
@@ -430,10 +460,12 @@ onboarding:
       30/60/90 plan rather than ambiguity.
   collect:
     - profileSlug: team-member
+      min: 1
       what: The people currently on the team, with their role, department, and status.
       cardinality: several
       keyFields: [role-title, department, status]
     - profileSlug: role
+      min: 1
       what: The positions you're hiring for right now — open reqs with their hiring bar.
       cardinality: few
       keyFields: [status, department, seniority]
@@ -442,6 +474,7 @@ onboarding:
       cardinality: few
       keyFields: [stage, source]
     - profileSlug: review
+      min: 1
       what: The current review cycle and how you run performance (cadence + rubric).
       cardinality: one
       keyFields: [cycle, status]

package/src/index.ts

@@ -50,13 +50,26 @@ export type {
   TemplatePlaybookParam,
   TemplateAutomation,
   TemplateActionPlacement,
+  TemplateIntent,
+  TemplateSpacePackage,
+  TemplateSpacePackageCell,
 } from "./types.js";
 
+// A template's space package: its built frame modules (the base layer of the
+// space's own experience, installed as `cell:<slug>:<key>`).
+export { spacePackageCells } from "./space-packages.js";
+export type {
+  BuiltSpacePackage,
+  BuiltSpacePackageCell,
+  SpacePackageCellWire,
+} from "./space-packages.js";
+
 // The dependency-kind vocabulary as a VALUE — so consumers (marketplace,
 // onboarding, backend, hub zod, browser, CP zod) can `z.enum(PACKAGE_DEPENDENCY_KINDS)`
 // / derive their type from it instead of hand-copying the list. Six mirrors
 // exist today; this is the door that lets them stop being mirrors.
-export { PACKAGE_DEPENDENCY_KINDS } from "./types.js";
+export { PACKAGE_DEPENDENCY_KINDS, INTENT_LABEL_MAX, START_VIEWS_MAX, START_EXAMPLE_RANGE, START_STARTERS_RANGE } from "./types.js";
+export type { TemplateStart } from "./types.js";
 
 export {
   WORKSPACE_TEMPLATES,
@@ -73,6 +86,9 @@ export {
   assembleCatalog,
   computeTemplateUpdates,
   isHashVersion,
+  derivePlaybookItems,
+  TRACK_TEMPLATE_ITEM_KIND,
+  WORK_TEMPLATE_ITEM_KIND,
 } from "./catalog.js";
 export type {
   MergeCatalogInput,
@@ -133,6 +149,11 @@ export {
   SYSTEM_PROFILES,
   REQUIRED_META_FIELDS,
   REQUIRED_WORKSPACE_FIELDS,
+  lifecycleOptionWaitsProblems,
+  LIFECYCLE_OPTION_FIELDS,
+  LIFECYCLE_OPTION_WAITS_FIELDS,
+  LIFECYCLE_WAITS_ON,
+  LIFECYCLE_WAIT_KINDS,
 } from "./validate.js";
 export type {
   ValidationError,
@@ -141,6 +162,18 @@ export type {
   TemplateConverters,
 } from "./validate.js";
 
+// The ten base lifecycles as template-time presets (`lifecycle.adopts`) and the
+// ONE compiler that turns them into the flat declaration the pod stores. The
+// catalog loader (scripts/catalog-lib.mjs) compiles authored YAML through it.
+export { BASE_LIFECYCLES, resolveLifecyclePresets } from "./lifecycle-presets.js";
+export type {
+  BaseLifecycleName,
+  TemplateLifecycleAdoption,
+  TemplateLifecycleStepAdd,
+  LifecyclePresetProblem,
+  LifecyclePresetResolution,
+} from "./lifecycle-presets.js";
+
 // The pure, DB-free automation-flow node-contract validator. `validateTemplate`
 // runs it over every `automations[].flow` so broken flows (unknown node type,
 // dangling edge, cycle, typo'd channelType, verb-less capability node) fail at
@@ -165,6 +198,7 @@ export {
   toPackageDefinition,
   splitBentoBlocks,
   normalizeTemplateLayout,
+  toAutomationWire,
 } from "./define.js";
 export type {
   WorkspaceDefinitionInput,
@@ -173,4 +207,5 @@ export type {
   SplitBentoBlocks,
   BentoWidgetBlockWire,
   BentoViewBlockWire,
+  PackageAutomationWire,
 } from "./define.js";

package/src/intent.test.ts

@@ -0,0 +1,161 @@
+/**
+ * `meta.intent` — what a space PRODUCES (object-first homes H0).
+ *
+ * Pinned:
+ *  - each `intent-*` rule fires on a minimal broken template and stays silent
+ *    on the fixed one (label length, unknown profile, profile without a
+ *    lifecycle, duplicate, shape);
+ *  - a produced profile may come from the dependency closure, and its
+ *    lifecycle may be declared there (a role foundation owns);
+ *  - (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.
+ */
+import { describe, expect, it } from "vitest";
+import { validateTemplate } from "./validate.js";
+import { toPackageDefinition, toWorkspaceDefinition } from "./define.js";
+import type { TemplateIntent, TemplateProfile, WorkspaceYaml } from "./types.js";
+import { INTENT_LABEL_MAX } from "./types.js";
+import { readYamlTemplates } from "./generate.mjs";
+
+const lifecycled = (slug: string): TemplateProfile => ({
+  slug,
+  displayName: slug,
+  properties: [{ slug: "stage", label: "Stage", valueType: "string", inputType: "select", enumValues: ["a", "b"] }],
+  lifecycle: { property: "stage", options: [{ key: "a", category: "open" }, { key: "b", category: "done" }] },
+} as TemplateProfile);
+const plain = (slug: string): TemplateProfile => ({ slug, displayName: slug, properties: [] } as unknown as TemplateProfile);
+
+const make = (slug: string, profiles: TemplateProfile[], intent?: TemplateIntent, deps: string[] = []): WorkspaceYaml =>
+  ({
+    meta: { slug, name: slug, description: "d", icon: "box", color: "blue", ...(intent ? { intent } : {}) },
+    workspace: { name: slug, description: "d" },
+    profiles,
+    dependencies: deps.map((d) => ({ slug: d, relation: "require" as const })),
+  }) as WorkspaceYaml;
+
+const base = make("base-dep", [lifecycled("role-x"), plain("bare-dep")]);
+const resolveDep = (s: string) => (s === "base-dep" ? base : undefined);
+const intentErrors = (t: WorkspaceYaml) =>
+  validateTemplate(t, { resolveDep }).errors.filter((e) => e.rule.startsWith("intent-"));
+
+describe("meta.intent — validator rules", () => {
+  it("a well-formed intent (own kind + a dependency's role) passes", () => {
+    const t = make("t", [lifecycled("thing")], { label: "Product", produces: [{ profile: "thing" }, { profile: "role-x" }] }, ["base-dep"]);
+    expect(intentErrors(t)).toEqual([]);
+  });
+
+  it("a library (label only, or empty produces) passes", () => {
+    expect(intentErrors(make("t", [plain("x")], { label: "Library" }))).toEqual([]);
+    expect(intentErrors(make("t", [plain("x")], { label: "Library", produces: [] }))).toEqual([]);
+  });
+
+  it("intent-label: empty or longer than the max is refused", () => {
+    expect(intentErrors(make("t", [plain("x")], { label: "" })).map((e) => e.rule)).toEqual(["intent-label"]);
+    const long = "x".repeat(INTENT_LABEL_MAX + 1);
+    expect(intentErrors(make("t", [plain("x")], { label: long })).map((e) => e.rule)).toEqual(["intent-label"]);
+    expect(intentErrors(make("t", [plain("x")], { label: "x".repeat(INTENT_LABEL_MAX) }))).toEqual([]);
+  });
+
+  it("intent-profile-unknown: a profile neither own nor in the closure", () => {
+    const errs = intentErrors(make("t", [lifecycled("thing")], { label: "P", produces: [{ profile: "ghost" }] }));
+    expect(errs.map((e) => e.rule)).toEqual(["intent-profile-unknown"]);
+    expect(errs[0]!.message).toContain('"ghost"');
+  });
+
+  it("intent-profile-unknown: a dependency's profile is NOT reachable without the dependency", () => {
+    const errs = intentErrors(make("t", [lifecycled("thing")], { label: "P", produces: [{ profile: "role-x" }] }));
+    expect(errs.map((e) => e.rule)).toEqual(["intent-profile-unknown"]);
+  });
+
+  it("intent-no-lifecycle: names the produced profile that declares none", () => {
+    const own = intentErrors(make("t", [plain("thing")], { label: "P", produces: [{ profile: "thing" }] }));
+    expect(own.map((e) => e.rule)).toEqual(["intent-no-lifecycle"]);
+    expect(own[0]!.message).toContain('"thing"');
+    const dep = intentErrors(make("t", [lifecycled("thing")], { label: "P", produces: [{ profile: "bare-dep" }] }, ["base-dep"]));
+    expect(dep.map((e) => e.rule)).toEqual(["intent-no-lifecycle"]);
+  });
+
+  it("a re-declaration without the lifecycle still counts the dependency's declaration", () => {
+    const t = make("t", [plain("role-x")], { label: "P", produces: [{ profile: "role-x" }] }, ["base-dep"]);
+    expect(intentErrors(t)).toEqual([]);
+  });
+
+  it("intent-duplicate and intent-shape", () => {
+    const dup = intentErrors(make("t", [lifecycled("thing")], { label: "P", produces: [{ profile: "thing" }, { profile: "thing" }] }));
+    expect(dup.map((e) => e.rule)).toEqual(["intent-duplicate"]);
+    const shape = intentErrors(make("t", [lifecycled("thing")], { label: "P", produces: "thing" } as unknown as TemplateIntent));
+    expect(shape.map((e) => e.rule)).toEqual(["intent-shape"]);
+  });
+
+  it("intent-no-workspace: an overlay or a pack declares no intent", () => {
+    const overlay = make("t", [lifecycled("thing")], { label: "P" });
+    overlay.dependencies = [{ slug: "base-dep", relation: "compose" }];
+    expect(intentErrors(overlay).map((e) => e.rule)).toEqual(["intent-no-workspace"]);
+    const pack = make("t", [lifecycled("thing")], { label: "P" });
+    pack.meta.tags = ["suite"];
+    expect(intentErrors(pack).map((e) => e.rule)).toEqual(["intent-no-workspace"]);
+  });
+
+  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([]);
+  });
+});
+
+describe("meta.intent — both install doors carry it", () => {
+  const intent = { label: "Product", 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)", () => {
+    const def = toPackageDefinition(t);
+    expect(def.intent).toEqual(intent);
+    expect("intent" in def._meta).toBe(false);
+  });
+
+  it("workspace door: intent", () => {
+    expect(toWorkspaceDefinition(t).definition.intent).toEqual(intent);
+  });
+
+  it("no intent → no field on either door", () => {
+    const none = make("t", [lifecycled("thing")]);
+    expect("intent" in toPackageDefinition(none)).toBe(false);
+    expect(toWorkspaceDefinition(none).definition.intent).toBeUndefined();
+  });
+});
+
+describe("meta.intent — the catalog", () => {
+  const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+  const table = Object.fromEntries(
+    corpus
+      .filter((t) => t.meta.intent)
+      .map((t) => [t.meta.slug, [t.meta.intent!.label, ...(t.meta.intent!.produces ?? []).map((p) => p.profile)]])
+  );
+
+  it("the whole corpus validates with zero intent-* errors", () => {
+    const errs = corpus.flatMap((t) =>
+      validateTemplate(t, { corpus }).errors.filter((e) => e.rule.startsWith("intent-")).map((e) => `${t.meta.slug} ${e.rule}: ${e.message}`)
+    );
+    expect(errs).toEqual([]);
+  });
+
+  it("the founder's table (homes plan §1), in produces order", () => {
+    expect(table["builder-workspace"]).toEqual(["Product", "devplane_feature", "devplane_story", "ui-design"]);
+    // outreach-touch joined when CRM absorbed Outreach & Comms (founder decision 2026-10-23):
+    // the messages drafted for a person to send are part of the commercial job.
+    expect(table["crm"]).toEqual(["Sales", "lead", "client", "deal", "campaign", "outreach-touch"]);
+    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"]);
+  });
+
+  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) {
+      const ownsNone =
+        (t.dependencies ?? []).some((d) => d.relation === "compose") || (t.meta.tags ?? []).includes("suite");
+      if (ownsNone) expect(t.meta.intent, t.meta.slug).toBeUndefined();
+    }
+  });
+});

package/src/internal-runbook.yaml

@@ -14,6 +14,9 @@ meta:
   color: "#64748B"
   tags: [operations, sops, vendors, workflows]
   isPublic: true
+  # A LIBRARY: it produces nothing a home counts (homes).
+  intent:
+    label: Runbook
 
 workspace:
   name: Internal Runbook
@@ -26,7 +29,10 @@ workspace:
   # operations), so it must own its own identity.
   subtype: internal-runbook
   visibility: members
-  workspaceType: operational
+  # A DOMAIN workspace that holds entities — NOT `operational`. `operational`
+  # marks an admin/system surface: `isDomainHomeWorkspace` refuses filing
+  # entities into it and excludes it from auto-placement (2026-09-25).
+  workspaceType: personal
   capabilities:
     - operations.sops
     - operations.vendors
@@ -90,6 +96,15 @@ profiles:
     color: "#0EA5E9"
     description: "A recurring business process — a repeatable flow with an owner, a cadence, and an input/output."
     scope: WORKSPACE
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: workflow-status
+      options:
+        - { key: Backlog, category: open }
+        - { key: Active, category: active }
+        - { key: Blocked, category: paused }
+        - { key: Optimizing, category: active }
+        - { key: Retired, category: lost }
     properties:
       - slug: workflow-status
         label: Status
@@ -423,14 +438,17 @@ onboarding:
       person's head.
   collect:
     - profileSlug: sop
+      min: 1
       what: The core documented procedures / runbooks — the repeatable ways of doing key things.
       cardinality: several
       keyFields: [title, category, owner, sop-status]
     - profileSlug: workflow
+      min: 1
       what: The recurring processes that run the business, each with an owner and a cadence.
       cardinality: several
       keyFields: [title, workflow-status, frequency, owner]
     - profileSlug: vendor
+      min: 1
       what: The suppliers and service providers the company pays and depends on.
       cardinality: few
       keyFields: [title, vendor-category, monthly-cost, owner]