@synap-core/workspace-templates 0.9.3 → 0.10.0

package/src/types.ts

@@ -10,14 +10,14 @@
 // App Reference — what opens as first screen when entering this workspace
 // ============================================================================
 
-export type TemplateAppKind = 'native' | 'stored' | 'url';
+export type TemplateAppKind = "native" | "stored" | "url";
 
 export interface TemplateAppRef {
   kind: TemplateAppKind;
   /** For kind='native': the appId registered in the browser manifest */
   appId?: string;
   /** For kind='native': how the platform renders the app */
-  rendererType?: 'native' | 'external' | 'iframe-srcdoc';
+  rendererType?: "native" | "external" | "iframe-srcdoc";
   /** For kind='stored': the cell key registered in the cell registry */
   cellKey?: string;
   /** For kind='stored': default props passed to the cell */
@@ -42,28 +42,38 @@ export type WorkspaceJsonValue =
 
 export type WorkspacePrimarySurface =
   | {
-      kind: 'app';
+      kind: "app";
       appId: string;
-      rendererType: 'native';
+      rendererType: "native";
       title?: string;
       props?: Record<string, WorkspaceJsonValue>;
     }
   | {
-      kind: 'app';
+      kind: "app";
       appId: string;
-      rendererType: 'external';
+      rendererType: "external";
       url: string;
       title?: string;
       props?: Record<string, WorkspaceJsonValue>;
     }
   | {
-      kind: 'cell';
+      kind: "cell";
       cellKey: string;
       title?: string;
       props?: Record<string, WorkspaceJsonValue>;
     }
   | {
-      kind: 'view';
+      /**
+       * Ordinary website. Unlike an external `app`, this has no trusted app
+       * identity and is always opened through the Browser's unprivileged URL
+       * surface.
+       */
+      kind: "url";
+      url: string;
+      title?: string;
+    }
+  | {
+      kind: "view";
       viewId: string;
       title?: string;
     };
@@ -75,13 +85,13 @@ export type WorkspacePrimarySurface =
  */
 export type WorkspacePrimarySurfaceViewReference =
   | {
-      kind: 'view';
+      kind: "view";
       viewName: string;
       viewSlug?: string;
       title?: string;
     }
   | {
-      kind: 'view';
+      kind: "view";
       viewName?: string;
       viewSlug: string;
       title?: string;
@@ -134,11 +144,11 @@ export interface TemplateProfile {
    * `entity_scope` of an existing profile (a divergence is reported as an
    * advisory `scopeConflict` and the live row is left alone).
    */
-  entityScope?: 'pod' | 'workspace';
+  entityScope?: "pod" | "workspace";
   /** Semantic slug for system profiles. */
   semanticSlug?: string;
   /** Kind vs role profile. Omit for default ('kind'). */
-  profileKind?: 'kind' | 'role';
+  profileKind?: "kind" | "role";
   /** For profileKind='role': which base-kind profile slugs this role can attach to. */
   applicableKinds?: string[];
   properties: TemplateProperty[];
@@ -164,6 +174,29 @@ export interface TemplateEntityLink {
   label?: string;
 }
 
+/**
+ * A domain-level relation TYPE definition — a `relation_defs` row, the workspace's
+ * relation vocabulary. Distinct from {@link TemplateEntityLink}, which is a
+ * profile→profile EDGE (and only carries `type` + `label`). A relation def stands
+ * alone: it has no source/target profile pairing and it carries the rich metadata
+ * (`description`, `isDirectional`, `uiHints`) that the entity-link path drops.
+ *
+ * Mirrors `DefaultRelationDef` in synap-backend
+ * `packages/database/src/utils/default-relation-defs.ts` VERBATIM — the door
+ * find-or-creates a `relation_defs` row from each entry (idempotent by
+ * `slug` within the workspace), which is `ensureDefaultRelationDefs`'s body.
+ */
+export interface TemplateRelationDef {
+  slug: string;
+  displayName: string;
+  description?: string;
+  isDirectional?: boolean;
+  uiHints?: {
+    category?: "workflow" | "social" | "reference" | "hierarchy";
+    inverseLabel?: string;
+  };
+}
+
 export interface TemplateSeedEntity {
   profileSlug: string;
   title: string;
@@ -201,22 +234,22 @@ export interface TemplateDisplayTemplate {
 // ============================================================================
 
 export interface TemplateSidebarSurface {
-  kind: 'cell' | 'view' | 'entity' | 'document' | 'channel' | 'app' | 'url';
+  kind: "cell" | "view" | "entity" | "document" | "channel" | "app" | "url";
   cellKey?: string;
   viewId?: string;
   viewName?: string;
   appId?: string;
   url?: string;
-  rendererType?: 'native' | 'external' | 'iframe-srcdoc';
-  placement?: 'main' | 'side' | 'floating' | 'modal' | 'popover' | 'embed';
-  displayMode?: 'compact' | 'medium' | 'full';
+  rendererType?: "native" | "external" | "iframe-srcdoc";
+  placement?: "main" | "side" | "floating" | "modal" | "popover" | "embed";
+  displayMode?: "compact" | "medium" | "full";
   props?: Record<string, unknown>;
   title?: string;
   meta?: Record<string, unknown>;
 }
 
 export interface TemplateSidebarItem {
-  kind: 'app' | 'view' | 'profile' | 'external' | 'cell';
+  kind: "app" | "view" | "profile" | "external" | "cell";
   appId?: string;
   viewName?: string;
   viewId?: string;
@@ -253,7 +286,7 @@ export interface TemplateLayoutConfig {
 // ============================================================================
 
 export interface TemplateBentoBlock {
-  kind: 'view' | 'widget';
+  kind: "view" | "widget";
   viewName?: string;
   widgetType?: string;
   pos: { x: number; y: number; w: number; h: number };
@@ -272,7 +305,7 @@ export interface TemplateProfileEntityBentoTemplates {
 // ============================================================================
 
 /** Mirrors `WorkspaceSourceRole` in synap-backend `schema/workspaces.ts`. */
-export type TemplateSourceRole = 'provider' | 'consumer' | 'provider-consumer';
+export type TemplateSourceRole = "provider" | "consumer" | "provider-consumer";
 
 /** Mirrors `WorkspaceDefaultSource` in synap-backend `schema/workspaces.ts`. */
 export interface TemplateDefaultSource {
@@ -302,7 +335,7 @@ export interface TemplateOnboardingCollectTarget {
   /** Human description of what to capture for this target. */
   what: string;
   /** Roughly how many to expect — guides interview depth. */
-  cardinality?: 'one' | 'few' | 'several';
+  cardinality?: "one" | "few" | "several";
   /** Key fields the agent should make sure to fill. */
   keyFields?: string[];
 }
@@ -357,7 +390,7 @@ export interface TemplateOnboarding {
 
 export interface TemplatePlaybookParam {
   name: string;
-  type: 'text' | 'number' | 'entity' | 'choice' | 'boolean';
+  type: "text" | "number" | "entity" | "choice" | "boolean";
   label?: string;
   required?: boolean;
   defaultValue?: unknown;
@@ -368,12 +401,12 @@ export interface TemplatePlaybook {
   description?: string;
   goalTemplate: string;
   params?: TemplatePlaybookParam[];
-  executor?: 'is-agent' | 'external-agent' | 'hybrid';
-  inputStrategy?: 'none' | 'static' | 'rotating' | 'query';
+  executor?: "is-agent" | "external-agent" | "hybrid";
+  inputStrategy?: "none" | "static" | "rotating" | "query";
   channelSpec?: {
-    type: 'GROUP' | 'AGENT_COLLAB' | 'THREAD';
+    type: "GROUP" | "AGENT_COLLAB" | "THREAD";
     members?: string[];
-    aiReactionMode?: 'on_mention' | 'always' | 'never';
+    aiReactionMode?: "on_mention" | "always" | "never";
   };
   /**
    * A cron schedule that maintains ONE backing cron automation (a single
@@ -399,7 +432,7 @@ export interface TemplatePlaybook {
    * captured entity of this kind can auto-launch the playbook as a session.
    */
   subjectProfile?: { profileSlug: string; filter?: Record<string, unknown> };
-  status?: 'draft' | 'active' | 'paused';
+  status?: "draft" | "active" | "paused";
 }
 
 // ============================================================================
@@ -429,10 +462,38 @@ export interface TemplateAutomation {
   key?: string;
   name: string;
   description?: string;
-  triggerType: 'event' | 'cron' | 'webhook' | 'manual';
+  triggerType: "event" | "cron" | "webhook" | "manual";
   triggerConfig?: Record<string, unknown>;
   flow: { nodes: unknown[]; edges: unknown[]; precondition?: string };
-  status?: 'draft' | 'active' | 'paused';
+  status?: "draft" | "active" | "paused";
+}
+
+// ============================================================================
+// Commands — workspace-scoped intelligence commands seeded with the workspace
+//
+// A prompt-template command (the "Default Command Pack") the workspace exposes
+// in its command surface. Mirrors `DefaultCommandDef` in synap-backend
+// `packages/database/src/utils/ensure-default-commands.ts` — the door
+// find-or-creates an `intelligence_commands` row from each entry, idempotent by
+// `title` within the workspace (`ensureDefaultCommands`'s body generalized).
+// ============================================================================
+
+export interface TemplateCommandDerivedInput {
+  name: string;
+  label?: string;
+  /** Mirrors `DerivedInput.type` (text | number | entity | view | choice). */
+  type?: string;
+}
+
+export interface TemplateCommand {
+  title: string;
+  promptTemplate: string;
+  derivedInputs?: TemplateCommandDerivedInput[];
+  /** text | proposal | view */
+  outputMode?: string;
+  canCreateViews?: boolean;
+  /** read_only | propose_writes */
+  permissionsProfile?: string;
 }
 
 // ============================================================================
@@ -464,9 +525,9 @@ export interface TemplateActionPlacement {
   /** Entity kind whose detail surface this action appears on. */
   profileSlug: string;
   /** Where the action renders. Only "entity-detail" is consumed today. */
-  surface: 'entity-detail' | string;
+  surface: "entity-detail" | string;
   /** What the action does when clicked. */
-  kind: 'capability' | 'playbook' | 'automation';
+  kind: "capability" | "playbook" | "automation";
   /**
    * Reference to the thing to run: a capability verb key, or a playbook /
    * automation NAME (resolved to a row id at apply time).
@@ -509,7 +570,7 @@ export interface TemplateIntegration {
   /** Override default params with {{var}} interpolation. */
   params?: Record<string, string>;
   /** "apply" (create+update) or "install" (create only). */
-  mode?: 'apply' | 'install';
+  mode?: "apply" | "install";
 }
 
 // ============================================================================
@@ -583,10 +644,10 @@ export interface TemplateExtendsRef {
  *   3. Once no payload carries `'automation'`, drop it from the wire enums and this tuple.
  */
 export const PACKAGE_DEPENDENCY_KINDS = [
-  'workspace',
-  'capability',
+  "workspace",
+  "capability",
   /** @deprecated Retired by CP 0049 in favour of `workflow`. See note above. */
-  'automation',
+  "automation",
 ] as const;
 
 /** What a `TemplateDependency` points at. Derived — never re-declare the list. */
@@ -610,7 +671,7 @@ export interface TemplateDependency {
    * - `'require'` (default): the dependency must be present on the pod as its
    *   own artifact, but this template does not merge into it.
    */
-  relation?: 'compose' | 'require';
+  relation?: "compose" | "require";
   /**
    * Short human reason shown in the install-time "this also installs…" prompt.
    */
@@ -654,7 +715,7 @@ export interface WorkspaceYaml {
      * Workspace classifier — consumed by createFromDefinition (settings.workspaceType,
      * creator-role + agent-workspace behavior). Mirrors the backend union.
      */
-    workspaceType?: 'personal' | 'agent' | 'project' | 'operational';
+    workspaceType?: "personal" | "agent" | "project" | "operational";
     visibility?: string;
     /** Capabilities this workspace provides (e.g. "brand.library", "content.pipeline") */
     capabilities?: string[];
@@ -684,6 +745,21 @@ export interface WorkspaceYaml {
   /** Schema-level links between entity types */
   entityLinks?: TemplateEntityLink[];
 
+  /**
+   * Domain-level relation TYPE vocabulary seeded into the workspace's
+   * `relation_defs`. Distinct from `entityLinks` (profile→profile edges): a
+   * relation def stands alone and carries `description`/`isDirectional`/`uiHints`.
+   * The `base` template carries the universal defaults. See {@link TemplateRelationDef}.
+   */
+  relationDefs?: TemplateRelationDef[];
+
+  /**
+   * Workspace-scoped intelligence commands (prompt-template "Default Command
+   * Pack") seeded with the workspace. The `base` template carries the universal
+   * pack. See {@link TemplateCommand}.
+   */
+  commands?: TemplateCommand[];
+
   /** Initial data to seed on workspace creation */
   seedEntities?: TemplateSeedEntity[];
 
@@ -751,7 +827,7 @@ export interface WorkspaceYaml {
 
 export interface ResolvedWorkspaceTemplate {
   meta: TemplateMeta;
-  definition: WorkspaceYaml['workspace'] & {
+  definition: WorkspaceYaml["workspace"] & {
     profiles: TemplateProfile[];
     views: TemplateView[];
     entityLinks: TemplateEntityLink[];

package/src/validate-flow.ts

@@ -36,9 +36,9 @@
  * `schema/automations.ts`.
  */
 
-// ── Contract constants (mirror @synap/database schema/automations.ts) ─────────
+// ── Contract constants (mirror schema/automations.ts — keep in sync) ──────────
 
-/** The 21 node types — `AutomationNodeBase.type` union (schema/automations.ts). */
+/** The 23 node types — `AutomationNodeBase.type` union (schema/automations.ts). */
 export const FLOW_NODE_TYPES = [
   "trigger",
   "command",
@@ -56,6 +56,8 @@ export const FLOW_NODE_TYPES = [
   "select",
   "claim",
   "messages_query",
+  "runs_query",
+  "proposals_query",
   "switch",
   "skill",
   "capability",
@@ -81,22 +83,73 @@ export const FLOW_OUTPUT_TYPES = [
 /**
  * The known `config.channelType` values for a `channel_message` output. Mirrors
  * the executor's channel_message resolution (automation-executor.ts). The output
- * channel is CONTEXT-DERIVED — a channel_message is valid with `channelId`, OR
- * `channelEntityRef` (an entity-id expression → that entity's internal channel),
- * OR a `channelType` from this set, OR NOTHING (the executor defaults a targetless
- * channel_message to the automation's own run channel). A `channelType` that is
- * PRESENT but not one of these is still a typo → still an error.
+ * channel is now CONTEXT-DERIVED — a channel_message is valid with `channelId`,
+ * OR `channelEntityRef` (an entity-id expression → that entity's internal
+ * channel), OR a `channelType` from this set, OR NOTHING (the executor defaults a
+ * targetless channel_message to the automation's own run channel). A `channelType`
+ * that is PRESENT but not one of these is still a typo → still an error.
  */
+// The executor's channel_message resolution (automation-executor.ts) is the SSOT
+// for these values; config is an untyped Record so there is no compile-time
+// drift guard here — keep this array in sync with the executor by hand.
 export const CHANNEL_MESSAGE_CHANNEL_TYPES = [
   "personal_thread",
   "proactive",
   "subjectEntity",
 ] as const;
 
+/**
+ * Node types a `loop` may dispatch PER ITEM. Mirrors `LOOP_BODY_NODE_TYPES` in
+ * `packages/jobs/src/workers/automation-executor.ts` (the runtime SSOT — the
+ * `switch (childNode.type)` inside the loop body). A loop OWNS the contiguous
+ * chain of these reachable from it; traversal STOPS at any other type
+ * (switch / delay / nested loop / sub_automation / entity_read / …), which runs
+ * ONCE in the main topological pass instead.
+ *
+ * Hand-mirrored: `@synap/api` does not depend on `@synap/jobs`, so there is no
+ * compile-time drift guard here — keep this array in sync with the executor by
+ * hand (same convention as CHANNEL_MESSAGE_CHANNEL_TYPES above).
+ */
+export const LOOP_BODY_NODE_TYPES = [
+  "command",
+  "output",
+  "playbook_run",
+  "messages_query",
+  "runs_query",
+  "proposals_query",
+  "query",
+  "fetch",
+  "transform",
+  "condition",
+  "skill",
+  "capability",
+] as const;
+
+/**
+ * What a loop actually PUTS in scope for its body: `context.loop = { item, index }`
+ * (automation-executor.ts, `case "loop"`). Any other `{{loop.<x>}}` segment
+ * resolves to undefined at runtime.
+ */
+export const LOOP_PROVIDED_BINDINGS = ["item", "index"] as const;
+
 const NODE_TYPE_SET = new Set<string>(FLOW_NODE_TYPES);
+const LOOP_BODY_TYPE_SET = new Set<string>(LOOP_BODY_NODE_TYPES);
+const LOOP_BINDING_SET = new Set<string>(LOOP_PROVIDED_BINDINGS);
 const OUTPUT_TYPE_SET = new Set<string>(FLOW_OUTPUT_TYPES);
 const CHANNEL_TYPE_SET = new Set<string>(CHANNEL_MESSAGE_CHANNEL_TYPES);
 
+// ── Drift guard — NOT compile-time IN THIS COPY ───────────────────────────────
+// The arrays above are hand-mirrored from TS *union types* in the schema. The
+// BACKEND copy carries an `AssertExact` binding that fails `tsc` on drift; THIS
+// package has no `@synap/database` dependency, so that guard cannot live here.
+// Do not assume tsc protects you when editing these arrays — what protects this
+// copy is `validate-flow.drift.test.ts`, which strips comments and therefore
+// could never have caught this paragraph being wrong (it was, until 2026-07-31).
+//
+// ⚠️ If you re-generate this file FROM the backend copy, re-apply this block and
+// de-duplicate the header above: a naive strip of the `AssertExact` CODE leaves
+// its comment behind, asserting a guard that does not exist here.
+
 // ── Result / error types ──────────────────────────────────────────────────────
 
 export interface FlowValidationError {
@@ -479,6 +532,54 @@ export function validateFlowDefinition(
     }
   }
 
+  // ── Loop bindings: `{{loop.*}}` only inside a loop body, only real paths ──────
+  // `context.loop` exists ONLY while a loop dispatches its body and is deleted
+  // right after, so a node OUTSIDE every loop body that reads `{{loop.item.id}}`
+  // resolves it to `undefined` at runtime — a Zod "expected string, received
+  // undefined" at best, a junk entity/relation written with an empty id at worst.
+  // The ownership walk below is the SAME rule the executor applies
+  // (`computeLoopBodyNodeIds`), so a node behind a boundary type (switch, delay,
+  // nested loop, …) or with no edge from the loop at all is correctly reported:
+  // those are exactly the shapes that leak into the main pass.
+  const loopBodyNodeIds = new Set<string>();
+  for (const node of nodes) {
+    if (!nonEmptyString(node.id) || node.type !== "loop") continue;
+    for (const id of collectLoopBody(node.id, nodesById, edges)) {
+      loopBodyNodeIds.add(id);
+    }
+  }
+  for (const node of nodes) {
+    if (!nonEmptyString(node.id)) continue;
+    const refs = collectLoopBindingRefs(node.data);
+    if (refs.length === 0) continue;
+    if (!loopBodyNodeIds.has(node.id)) {
+      errors.push({
+        nodeId: node.id,
+        code: "loop_ref_outside_loop_body",
+        message: `Node "${node.id}" references ${refs
+          .map((r) => `\`{{loop.${r}...}}\``)
+          .join(
+            ", "
+          )} but is not inside a loop body, so there is no item to bind — it would run once with an empty value. Connect it downstream of a loop node with no switch/delay/nested-loop/sub_automation node in between.`,
+      });
+      continue;
+    }
+    const unknown = refs.filter((r) => !LOOP_BINDING_SET.has(r));
+    if (unknown.length > 0) {
+      errors.push({
+        nodeId: node.id,
+        code: "loop_ref_unknown_path",
+        message: `Node "${node.id}" references ${unknown
+          .map((r) => `\`{{loop.${r}}}\``)
+          .join(
+            ", "
+          )}, which a loop does not provide. A loop binds only: ${LOOP_PROVIDED_BINDINGS.map(
+          (b) => `\`loop.${b}\``
+        ).join(", ")}.`,
+      });
+    }
+  }
+
   // ── Acyclic (Kahn's algorithm — mirrors topoSort in automation-executor.ts) ───
   // Only run when edges reference real nodes; dangling edges are already reported
   // and would corrupt the in-degree bookkeeping.
@@ -495,6 +596,84 @@ export function validateFlowDefinition(
   return { valid: errors.length === 0, errors };
 }
 
+/**
+ * The node ids a loop OWNS as its per-item body — the contiguous chain of
+ * LOOP_BODY_NODE_TYPES nodes reachable from it, stopping at any other type.
+ * Mirrors `computeLoopBodyNodeIds` in automation-executor.ts exactly (all
+ * out-edges, handle-agnostic); the `seen` set makes a cyclic graph terminate
+ * (cycles are reported separately).
+ */
+function collectLoopBody(
+  loopNodeId: string,
+  nodesById: Map<string, LooseNode>,
+  edges: LooseEdge[]
+): Set<string> {
+  const body = new Set<string>();
+  const stack: string[] = [];
+  for (const edge of edges) {
+    if (edge.source === loopNodeId && nonEmptyString(edge.target))
+      stack.push(edge.target);
+  }
+  while (stack.length > 0) {
+    const id = stack.pop()!;
+    if (body.has(id)) continue;
+    const node = nodesById.get(id);
+    if (
+      !node ||
+      !nonEmptyString(node.type) ||
+      !LOOP_BODY_TYPE_SET.has(node.type)
+    )
+      continue; // boundary — runs once in the main pass, not per item
+    body.add(id);
+    for (const edge of edges) {
+      if (edge.source === id && nonEmptyString(edge.target))
+        stack.push(edge.target);
+    }
+  }
+  return body;
+}
+
+/**
+ * The FIRST path segment of every `{{loop.<segment>…}}` reference anywhere in a
+ * node's `data` (deep: objects + arrays), deduped. Mirrors
+ * `collectLoopBindingRefs` in automation-executor.ts — including the PRE-PIPE
+ * restriction: an array pipe argument (`{{x | map:{{loop.item.id}}}}`) binds
+ * `loop` per item inside the RESOLVER, a scope that is valid outside any loop
+ * node, so it must not be reported.
+ */
+function collectLoopBindingRefs(data: unknown): string[] {
+  const found = new Set<string>();
+  const walk = (v: unknown): void => {
+    if (typeof v === "string") {
+      const head = v.split("|")[0];
+      const re = /\{\{\s*loop\.([A-Za-z0-9_$]+)/g;
+      let m: RegExpExecArray | null;
+      let matched = false;
+      while ((m = re.exec(head)) !== null) {
+        found.add(m[1]);
+        matched = true;
+      }
+      // The executor's own detector is the LOOSER `/\{\{\s*loop\./` — it fires on
+      // `{{loop.}}` or `{{loop.-x}}`, which this stricter segment pattern does
+      // not. Without this fallback a malformed reference passes save-time
+      // validation and then throws at RUN time, which is exactly the class of
+      // failure the loop rules were added to eliminate. Report it under the
+      // empty segment so it surfaces as `loop_ref_unknown_path`.
+      if (!matched && /\{\{\s*loop\./.test(head)) found.add("");
+      return;
+    }
+    if (Array.isArray(v)) {
+      for (const x of v) walk(x);
+      return;
+    }
+    if (isRecord(v)) {
+      for (const x of Object.values(v)) walk(x);
+    }
+  };
+  walk(data);
+  return [...found];
+}
+
 /**
  * Return the set of node ids that participate in a cycle (empty if acyclic).
  * Kahn's algorithm — the same ordering the executor's `topoSort` relies on; a

package/src/validate-onboarding.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { validateTemplate } from "./validate.js";
+import type { WorkspaceYaml } from "./types.js";
+
+function templateWithOnboarding(onboarding: unknown): WorkspaceYaml {
+  return {
+    meta: {
+      slug: "onboarding-validation",
+      name: "Onboarding validation",
+      description: "Validation fixture",
+      icon: "circle",
+      color: "blue",
+    },
+    workspace: {
+      name: "Onboarding validation",
+      description: "Validation fixture",
+    },
+    profiles: [
+      {
+        slug: "record",
+        displayName: "Record",
+        properties: [],
+      },
+    ],
+    onboarding,
+  } as WorkspaceYaml;
+}
+
+describe("validateTemplate onboarding contract", () => {
+  it("accepts a complete domain recipe", () => {
+    const result = validateTemplate(
+      templateWithOnboarding({
+        goal: "Create the first useful record.",
+        framing: "Act as a domain expert.",
+        expertise: {
+          starters: ["Begin with the live work."],
+          blindSpots: ["Do not collect records without an owner."],
+          bar: "Every record has a clear next step.",
+        },
+        collect: [
+          {
+            profileSlug: "record",
+            what: "The records currently in motion.",
+            cardinality: "few",
+            keyFields: ["title"],
+          },
+        ],
+        openingQuestions: ["What is currently in motion?"],
+        doneWhen: "At least one useful record exists.",
+      }),
+      {}
+    );
+
+    expect(result, JSON.stringify(result.errors)).toEqual({
+      ok: true,
+      errors: [],
+    });
+  });
+
+  it("rejects empty expertise prose and collection instructions", () => {
+    const result = validateTemplate(
+      templateWithOnboarding({
+        goal: "Set up this workspace.",
+        framing: "Act as a domain expert.",
+        expertise: {
+          starters: [""],
+          blindSpots: ["  "],
+          bar: "",
+        },
+        collect: [{ profileSlug: "record", what: "", keyFields: [""] }],
+        openingQuestions: [""],
+        doneWhen: "",
+      }),
+      {}
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.errors.map((error) => error.rule)).toEqual(
+      expect.arrayContaining([
+        "onboarding-expertise-invalid",
+        "onboarding-collect-what-empty",
+        "onboarding-collect-key-fields-invalid",
+        "onboarding-opening-questions-invalid",
+        "onboarding-done-when-invalid",
+      ])
+    );
+  });
+});