@synap-core/workspace-templates 0.12.0 → 0.23.0

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

@@ -0,0 +1,186 @@
+/**
+ * The founder's decisions of 2026-10-12 (pod file 00c1b2fe-ef98-41fa-86cf-801dfab12cd1, decisions wave),
+ * pinned against the REAL YAML corpus (`readYamlTemplates`, the source the
+ * build and the publish both read) and the real validator.
+ *
+ *   1. Business Developer folds into CRM: "Qualify a lead" runs on the `lead`
+ *      ROLE's leadStage; "Advance a commercial proposal" is gone; the Synap-fee
+ *      and commission model went to the private arch-sales, which was retired
+ *      the same day with the-arch (The Arch is no longer in use);
+ *      business-developer
+ *      is a tombstone pointing at crm, and nothing installs it any more.
+ *   4. "Deliver a deliverable" starts when a deliverable ENTERS in-progress.
+ *   5. Billing: per-engagement milestone invoices, and a monthly recurring
+ *      process on revenue-stream whose schedule the pod can actually create.
+ *   6. A new brand voice guide is a draft.
+ *
+ * Does NOT cover: runtime behaviour on a pod (a role activator firing on
+ * attach, the facet status write) — that is the backend lane's (R1).
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+import { validateTemplate } from "./validate.js";
+import { loadRetired } from "../scripts/catalog-lib.mjs";
+
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const tpl = (slug: string, c: WorkspaceYaml[] = corpus) => {
+  const t = c.find((x) => x.meta.slug === slug);
+  if (!t) throw new Error(`template ${slug} not in the corpus`);
+  return t;
+};
+const profileOf = (t: WorkspaceYaml, slug: string) => t.profiles.find((p) => p.slug === slug);
+const propOf = (t: WorkspaceYaml, profile: string, prop: string) =>
+  profileOf(t, profile)?.properties.find((p) => p.slug === prop);
+const playbookOf = (t: WorkspaceYaml, name: string) => t.playbooks?.find((p) => p.name === name);
+const errorsOf = (t: WorkspaceYaml, c: WorkspaceYaml[] = corpus) =>
+  validateTemplate(t, { corpus: c }).errors.map((e) => `${e.rule} ${e.path}`);
+
+describe("decision 1 — Business Developer folds into CRM", () => {
+  it("non-vacuity: the corpus is the real one", () => {
+    expect(corpus.length).toBeGreaterThanOrEqual(25);
+    expect(corpus.some((t) => t.meta.slug === "crm")).toBe(true);
+  });
+
+  it("business-developer is a tombstone replaced by crm, and no live template depends on it", async () => {
+    expect(corpus.some((t) => t.meta.slug === "business-developer")).toBe(false);
+    const { retired } = await loadRetired();
+    expect(retired.find((r) => r.slug === "business-developer")).toMatchObject({ kind: "workspace", replacedBy: "crm" });
+    const dependents = corpus.filter((t) => (t.dependencies ?? []).some((d) => d.slug === "business-developer"));
+    expect(dependents.map((t) => t.meta.slug)).toEqual([]);
+  });
+
+  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" });
+    // 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());
+    // 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.
+    expect(pb?.stages?.at(-1)).toMatchObject({ key: "pursue", subjectStatus: "qualified" });
+    expect(pb?.stages?.flatMap((s) => s.expectedOutputs ?? [])).toEqual([]);
+    expect(pb?.expectedOutputs).toBeUndefined();
+  });
+
+  it("the validator reads a role subject's statuses from the role (a wrong one is refused)", () => {
+    expect(errorsOf(tpl("crm"))).toEqual([]);
+    const c = structuredClone(corpus);
+    const pb = playbookOf(tpl("crm", c), "Qualify a lead")!;
+    pb.stages![0]!.subjectStatus = "won"; // a deal status, not a leadStage one
+    expect(errorsOf(tpl("crm", c), c)).toContain('stage-subject-status-unknown playbooks."Qualify a lead".stages.research.subjectStatus');
+  });
+
+  it("'Advance a commercial proposal' is gone everywhere; CRM's 'Win a deal' remains", () => {
+    const names = corpus.flatMap((t) => (t.playbooks ?? []).map((p) => p.name));
+    expect(names).not.toContain("Advance a commercial proposal");
+    expect(names).not.toContain("Qualify a CRM lead");
+    expect(playbookOf(tpl("crm"), "Win a deal")).toBeDefined();
+  });
+
+  it("CRM carries the moved lead/client fields, the campaign kind and member_of", () => {
+    const crm = tpl("crm");
+    for (const p of ["icpScore", "qualificationNotes", "nextAction", "outreachChannels", "convertedAt", "disqualificationReason"])
+      expect(propOf(crm, "lead", p), `lead.${p}`).toBeDefined();
+    for (const p of ["becameClientAt", "handoffStatus", "handoffDestination", "handoffNotes"])
+      expect(propOf(crm, "client", p), `client.${p}`).toBeDefined();
+    expect(profileOf(crm, "campaign")?.semanticSlug).toBe("marketing.campaign");
+    expect(crm.entityLinks?.filter((l) => l.type === "member_of").map((l) => l.sourceProfileSlug)).toEqual(["person", "company"]);
+  });
+
+  it("the Synap-fee and commission model left the catalog with arch-sales and the-arch, both tombstones", async () => {
+    const FEE = ["synapFeeModel", "synapFixedFee", "synapSuccessFeeRate", "synapFeeAmount", "sourcedByUserId", "commissionEntitlementId", "commissionStatus"];
+    const { retired } = await loadRetired();
+    for (const slug of ["arch-sales", "the-arch"]) {
+      expect(corpus.some((t) => t.meta.slug === slug), `${slug} is live`).toBe(false);
+      const stone = retired.find((r) => r.slug === slug);
+      expect(stone, `${slug} tombstone`).toMatchObject({ kind: "workspace", since: "2026-10-12" });
+      expect(stone?.replacedBy, `${slug} has no replacement`).toBeUndefined();
+      const dependents = corpus.filter((t) => (t.dependencies ?? []).some((d) => d.slug === slug));
+      expect(dependents.map((t) => t.meta.slug), `dependents of ${slug}`).toEqual([]);
+    }
+    // No live template's deal carries the fee model any more (networking's
+    // `intro` keeps its own copy of the fee vocabulary: a separate decision).
+    for (const p of FEE) {
+      const holders = corpus.filter((t) => !!propOf(t, "deal", p)).map((t) => t.meta.slug);
+      expect(holders, `deal.${p}`).toEqual([]);
+    }
+    const holders = (pred: (t: WorkspaceYaml) => boolean) => corpus.filter(pred).map((t) => t.meta.slug);
+    expect(holders((t) => !!profileOf(t, "crm-commission-entitlement"))).toEqual([]);
+    expect(holders((t) => (t.automations ?? []).some((a) => a.name === "Win and hand off"))).toEqual([]);
+  });
+});
+
+describe("decision 4 — 'Deliver a deliverable' starts when the deliverable enters in-progress", () => {
+  const pb = playbookOf(tpl("operations"), "Deliver a deliverable")!;
+
+  it("its one activator is entering in-progress", () => {
+    expect(pb.activators).toEqual([{ on: "enters_status", status: "in-progress", mode: "propose" }]);
+  });
+
+  it("no stage writes not-started (a run started at in-progress never moves the deliverable back)", () => {
+    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([]);
+  });
+});
+
+describe("decision 5 — billing", () => {
+  it("an engagement chooses at-close (default) or per-deliverable billing", () => {
+    expect(propOf(tpl("operations"), "engagement", "engagement-billing-mode")).toMatchObject({
+      inputType: "select",
+      enumValues: ["at-close", "per-deliverable"],
+      constraints: { defaultValue: "at-close" },
+    });
+  });
+
+  it("an accepted deliverable may produce its milestone invoice (an optional slot)", () => {
+    const accepted = playbookOf(tpl("operations"), "Deliver a deliverable")!.stages!.find((s) => s.key === "accepted");
+    expect(accepted?.expectedOutputs?.map((o) => o.kind)).toEqual(["invoice"]);
+    // Owed by nobody (synap-backend 30a9ab85): an at-close run never shows it pending.
+    expect(accepted?.expectedOutputs?.[0]?.optional).toBe(true);
+    expect(accepted?.goal).toMatch(/per deliverable/);
+  });
+
+  it("'Bill a recurring fee' runs monthly over active monthly revenue streams, with a filter the pod keeps", () => {
+    const finance = tpl("finance");
+    const pb = playbookOf(finance, "Bill a recurring fee")!;
+    expect(pb.subjectProfile?.profileSlug).toBe("revenue-stream");
+    expect(pb.schedule).toMatchObject({ cron: "0 8 1 * *", enabled: true });
+    expect(pb.metadata).toMatchObject({ governance: { forceProposeWrites: true } });
+    // The pod's cron door keeps ONLY a string filter (readSubjectProfile), and
+    // refuses an unfiltered AI fan-out, so an object here = no schedule at all.
+    const filter = pb.subjectProfile?.filter;
+    expect(typeof filter).toBe("string");
+    const parsed = JSON.parse(filter as string) as Record<string, string>;
+    expect(Object.keys(parsed).length).toBeGreaterThan(0);
+    // Reachability: every filtered key is a property of revenue-stream and every value one of its options.
+    for (const [key, value] of Object.entries(parsed)) {
+      const prop = propOf(finance, "revenue-stream", key.replace(/^properties\./, ""));
+      expect(prop?.enumValues, key).toContain(value);
+    }
+    expect(pb.expectedOutputs?.map((o) => o.kind)).toEqual(["invoice"]);
+    expect(errorsOf(finance)).toEqual([]);
+  });
+
+  it("the drafted invoice is taken over by 'Bill a client' (its created activator)", () => {
+    expect(playbookOf(tpl("finance"), "Bill a client")?.activators).toContainEqual({ on: "created", mode: "propose" });
+  });
+});
+
+describe("settled item — a new brand voice guide is a draft", () => {
+  it("voice-status defaults to draft", () => {
+    expect(propOf(tpl("brand-library"), "brand-voice-guide", "voice-status")?.constraints).toEqual({ defaultValue: "draft" });
+  });
+});

package/src/define.ts

@@ -16,6 +16,8 @@ import type {
   WorkspacePrimarySurface,
   WorkspaceYaml, } from './types.js';
 import { getWorkspaceTemplate } from './templates.js';
+import { resolveLifecyclePresets } from './lifecycle-presets.js';
+import { spacePackageCells, type SpacePackageCellWire } from './space-packages.js';
 
 /**
  * A `TemplateAutomation` as the apply door expects it: `flowDefinition`, not
@@ -33,7 +35,8 @@ export interface PackageAutomationWire {
   status?: TemplateAutomation['status'];
 }
 
-function toAutomationWire(
+/** The ONE automation projection (authored `flow` → wire `flowDefinition`), shared by workspaces and standalone automation packages. */
+export function toAutomationWire(
   automations: TemplateAutomation[] | undefined
 ): PackageAutomationWire[] | undefined {
   return automations?.map((a) => ({
@@ -211,8 +214,9 @@ export function normalizeTemplateLayout(
  * `kind` is INFERRED from field presence when absent. `TemplateBentoBlock.kind`
  * is a required field in TypeScript, but the generated `templates.ts` casts the
  * parsed YAML `as unknown as Record<string, WorkspaceYaml>` — so the compiler
- * never checks the authored data against the type, and `agent-fleet.yaml`
- * authored 8 widget blocks with no `kind:` at all (bare `widgetType`). Routing
+ * never checks the authored data against the type, and the (since retired,
+ * R7 2026-09-27) `agent-fleet.yaml` authored 8 widget blocks with no `kind:`
+ * at all (bare `widgetType`). Routing
  * strictly on `kind` would silently DROP those — the exact failure mode this
  * function exists to end. Inferring by field mirrors what the pod itself does
  * (it splits by field and never reads `kind`), so the seam is total: a block
@@ -330,6 +334,20 @@ export interface WorkspaceDefinitionInput {
   workspaceType?: NonNullable<WorkspaceYaml['workspace']>['workspaceType'];
   workspaceVisibility?: string;
   workspaceCapabilities?: string[];
+  /**
+   * THE DECLARED INTENT SINK (Phase 3). `taskIntents` is authored at the TOP
+   * level of the template, not inside `workspace`, and is forwarded verbatim to
+   * `workspaces.createFromDefinition`, which persists it to
+   * `settings.taskIntents` — where the intent resolver joins it against what is
+   * actually installed. No shape transform: the authored form IS the wire form.
+   */
+  taskIntents?: WorkspaceYaml['taskIntents'];
+  /**
+   * What the space PRODUCES (`meta.intent`), forwarded verbatim; the pod
+   * projects it into `settings.intent`. Same top-level field on the package
+   * door.
+   */
+  intent?: WorkspaceYaml['meta']['intent'];
   sourceRoles?: NonNullable<WorkspaceYaml['workspace']>['sourceRoles'];
   defaultSources?: NonNullable<WorkspaceYaml['workspace']>['defaultSources'];
   /** Per-workspace onboarding context — written to settings.onboarding. */
@@ -378,6 +396,30 @@ function toWorkspacePlaybooks(
   }));
 }
 
+/**
+ * A template by slug (the bundled corpus, already compiled) or as authored
+ * YAML, with its lifecycle presets compiled (`adopts:` → flat options,
+ * generated `enumValues`; lifecycle-presets.ts), so both install doors carry
+ * the flat declaration the pod stores. An overlay that does not resolve throws,
+ * like an unknown slug: `validateTemplate` names it first on every catalog path.
+ */
+function compiledTemplate(slugOrYaml: string | WorkspaceYaml): WorkspaceYaml {
+  const tpl: WorkspaceYaml | undefined =
+    typeof slugOrYaml === 'string' ? getWorkspaceTemplate(slugOrYaml) : slugOrYaml;
+  if (!tpl) {
+    throw new Error(`Workspace template not found: ${String(slugOrYaml)}`);
+  }
+  const { template, problems } = resolveLifecyclePresets(tpl);
+  if (problems.length > 0) {
+    throw new Error(
+      `Template "${String(tpl.meta?.slug)}": lifecycle presets do not resolve — ${problems
+        .map((p) => `${p.path}: ${p.message}`)
+        .join('; ')}`
+    );
+  }
+  return template;
+}
+
 /**
  * Resolve a template (by slug or YAML object) into the createFromDefinition
  * payload. Pass `nameOverride` to rename the workspace at creation time.
@@ -386,12 +428,7 @@ export function toWorkspaceDefinition(
   slugOrYaml: string | WorkspaceYaml,
   nameOverride?: string
 ): ToDefinitionResult {
-  const tpl: WorkspaceYaml | undefined =
-    typeof slugOrYaml === 'string' ? getWorkspaceTemplate(slugOrYaml) : slugOrYaml;
-
-  if (!tpl) {
-    throw new Error(`Workspace template not found: ${String(slugOrYaml)}`);
-  }
+  const tpl = compiledTemplate(slugOrYaml);
 
   const ws = tpl.workspace;
   const name = nameOverride ?? ws.name;
@@ -432,6 +469,11 @@ export function toWorkspaceDefinition(
     workspaceType: ws.workspaceType,
     workspaceVisibility: ws.visibility,
     workspaceCapabilities: ws.capabilities,
+    // Forwarded VERBATIM from the template's TOP level (not `workspace`) — the
+    // pod persists it to `settings.taskIntents` and reports any gap against what
+    // the installed capabilities actually provide. Authored form IS wire form.
+    taskIntents: tpl.taskIntents,
+    intent: tpl.meta.intent,
     sourceRoles: ws.sourceRoles,
     defaultSources: ws.defaultSources,
     // Workspace creation persists its own compact playbook parameter shape.
@@ -500,7 +542,11 @@ type WorkspaceDefinitionForwarded =
   | 'actionPlacements' // → settings.actionPlacements via applyPackagePostWorkspace
   | 'automations' // → flowAutomations → shared applyPackagePostWorkspace door
   | 'onboarding'
-  | 'dependencies';
+  | 'dependencies'
+  // Phase 3 gave the declaration a sink: `createWorkspaceFromDefinition`
+  // accepts `taskIntents` and persists it verbatim to `settings.taskIntents`,
+  // where the intent resolver joins it against what is actually installed.
+  | 'taskIntents';
 
 /**
  * Keys deliberately NOT forwarded by `toWorkspaceDefinition`. Each needs a
@@ -508,8 +554,21 @@ type WorkspaceDefinitionForwarded =
  * else is a real gap and should say so.
  */
 type WorkspaceDefinitionDropped =
+  // A POST-workspace layer (rule rows via the pod's rule door), carried on the
+  // PACKAGE definition (`toPackageDefinition`), not the workspace door's input.
+  // The workspace door has no rules field; the rule reconcile converges them.
+  | 'rules'
+  // Same layer as `rules`: the skill is LINKED to the space by
+  // `applyPackagePostWorkspace` (`skills.workspaceId` + `scope:"workspace"`),
+  // which owns the row. The workspace door has no skills field, so forwarding
+  // it here would be a no-op — it is carried on the PACKAGE definition instead.
+  | 'skills'
   // Normalized into `layoutConfig.primarySurface`.
   | 'app'
+  // Same layer as `skills`: built into frame cells that `applyPackagePostWorkspace`
+  // installs in the space. The workspace door has no cells field; carried on
+  // the PACKAGE definition as `cells[]` instead.
+  | 'spacePackage'
   // The door DOES accept `extends`, but no template declares it today (0/21).
   // Forwarding is a no-op until one does — wire it then.
   | 'extends';
@@ -543,6 +602,12 @@ void _workspaceDefinitionLedger;
 export interface PackageDefinitionOutput {
   _meta: {
     slug: string;
+    /** The PACKAGE's own name (meta.name). For an overlay this differs from
+     *  `workspaceName`, which names the workspace it composes onto. */
+    name?: string;
+    /** The PACKAGE's own description (meta.description) — what the catalog
+     *  lists. Top-level `description` stays the workspace's (install copy). */
+    description?: string;
     icon?: string;
     color?: string;
     domain?: string;
@@ -556,6 +621,25 @@ export interface PackageDefinitionOutput {
   workspaceSubtype?: string;
   workspaceVisibility?: string;
   workspaceCapabilities?: string[];
+  /**
+   * The DECLARED intents, carried to the marketplace/CLI install path too.
+   * Without it here, a workspace installed from the marketplace would LOSE its
+   * declaration while a bundled one kept it — the same field behaving
+   * differently per install route, which is precisely the fork this package
+   * exists to prevent.
+   */
+  taskIntents?: WorkspaceYaml['taskIntents'];
+  /**
+   * What the space PRODUCES (`meta.intent`), TOP-LEVEL like `taskIntents` —
+   * never in `_meta`, which the CP rebuilds from its row columns on serve
+   * (`normalizePublishedDefinition`), so a key there never reaches a pod.
+   */
+  intent?: WorkspaceYaml['meta']['intent'];
+  /**
+   * The onboarding start (`meta.start`), TOP-LEVEL for the same reason as
+   * `intent`. Package door only: the pod and the CP read starts off the package.
+   */
+  start?: WorkspaceYaml['meta']['start'];
   sourceRoles?: WorkspaceYaml['workspace']['sourceRoles'];
   defaultSources?: WorkspaceYaml['workspace']['defaultSources'];
   profiles: WorkspaceYaml['profiles'];
@@ -596,6 +680,24 @@ export interface PackageDefinitionOutput {
    */
   actionPlacements?: WorkspaceYaml['actionPlacements'];
   onboarding?: WorkspaceYaml['onboarding'];
+  /**
+   * Rules the template installs in its space — applied by the pod's
+   * `applyPackagePostWorkspace` through the ONE rule door and converged by the
+   * template-rule reconcile (three-way stamp on `metadata.rule.seed`).
+   */
+  rules?: WorkspaceYaml['rules'];
+  /**
+   * Skills the template declares for its space — linked to the new space by the
+   * pod's `applyPackagePostWorkspace` (approved skills only), which is why they
+   * travel on the PACKAGE definition and not the workspace door's input.
+   */
+  skills?: WorkspaceYaml['skills'];
+  /**
+   * The space package's built modules (`spacePackage` → `space-packages.ts`),
+   * installed by the pod's `applyPackagePostWorkspace` as sandboxed frame cells
+   * `cell:<_meta.slug>:<key>` — what the template's `app: {kind: stored}` opens.
+   */
+  cells?: SpacePackageCellWire[];
   /** Template-composition dependencies — resolved by the apply endpoint. */
   dependencies?: WorkspaceYaml['dependencies'];
 }
@@ -609,20 +711,18 @@ export interface PackageDefinitionOutput {
 export function toPackageDefinition(
   slugOrYaml: string | WorkspaceYaml
 ): PackageDefinitionOutput {
-  const tpl: WorkspaceYaml | undefined =
-    typeof slugOrYaml === 'string' ? getWorkspaceTemplate(slugOrYaml) : slugOrYaml;
-
-  if (!tpl) {
-    throw new Error(`Workspace template not found: ${String(slugOrYaml)}`);
-  }
+  const tpl = compiledTemplate(slugOrYaml);
 
   const ws = tpl.workspace;
   // Same routing as the tRPC door — the union is split by `kind`, never dumped
   // whole into one field. See `splitBentoBlocks`.
   const bento = splitBentoBlocks(tpl.bento?.blocks);
+  const cells = spacePackageCells(tpl);
   return {
     _meta: {
       slug: tpl.meta.slug,
+      name: tpl.meta.name,
+      description: tpl.meta.description,
       icon: tpl.meta.icon,
       color: tpl.meta.color,
       domain: tpl.meta.domain,
@@ -635,6 +735,11 @@ export function toPackageDefinition(
     workspaceSubtype: ws.subtype,
     workspaceVisibility: ws.visibility,
     workspaceCapabilities: ws.capabilities,
+    // Same declaration, same wire field, on the marketplace path — see the
+    // `taskIntents` note on the PackageDefinition type above.
+    taskIntents: tpl.taskIntents,
+    ...(tpl.meta.intent ? { intent: tpl.meta.intent } : {}),
+    ...(tpl.meta.start ? { start: tpl.meta.start } : {}),
     sourceRoles: ws.sourceRoles,
     defaultSources: ws.defaultSources,
     profiles: tpl.profiles,
@@ -655,6 +760,9 @@ export function toPackageDefinition(
     automations: toAutomationWire(tpl.automations),
     actionPlacements: tpl.actionPlacements,
     onboarding: tpl.onboarding,
+    ...(tpl.rules?.length ? { rules: tpl.rules } : {}),
+    ...(tpl.skills?.length ? { skills: tpl.skills } : {}),
+    ...(cells ? { cells } : {}),
     dependencies: tpl.dependencies,
   };
 }
@@ -686,6 +794,9 @@ type PackageDefinitionForwarded =
   | 'automations'   // → mapped to the apply door's flowDefinition wire shape
   | 'actionPlacements' // → carried verbatim (Hub inbound schema declares it — parity closed)
   | 'onboarding'
+  | 'rules'         // → carried verbatim (applied post-workspace via the rule door)
+  | 'skills'        // → carried verbatim (linked to the space post-workspace)
+  | 'spacePackage'  // → cells (the built frame modules, installed post-workspace)
   | 'dependencies';
 
 /** Keys deliberately NOT forwarded by `toPackageDefinition`. */
@@ -696,7 +807,9 @@ type PackageDefinitionDropped =
   // (package-definition.ts:262), but `PackageDefinitionOutput` omits it. No
   // template declares it today (0/21), so this is latent, not live — wire it
   // when a template first uses one.
-  | 'extends';
+  | 'extends'
+  // Phase 1 declaration with no sink yet — see `WorkspaceDefinitionDropped`.
+  | 'taskIntents';
 
 type UnclassifiedPackageDefinitionKey = Exclude<
   keyof WorkspaceYaml,

package/src/design-to-implementation.template.test.ts

@@ -0,0 +1,94 @@
+/**
+ * The design loop on `ui-design` (Builder, "Design to implementation"):
+ * Generate writes 3 sibling variants, Critique judges them with the
+ * design-critique rubric before a person reviews.
+ *
+ * What this guards:
+ *   1. REACHABILITY: every property an `evidence` criterion of the process reads
+ *      is a property `ui-design` declares (derived from the stages, not listed)
+ *      — an evidence key with no property is a criterion that can never pass;
+ *   2. Critique sits between Generate and Review, writes no status (like
+ *      Verify), is a check gate and loops to Generate;
+ *   3. CORPUS-WIDE: no process that PRODUCES things of its own subject kind
+ *      starts `on: created` — each produced thing would propose another run of
+ *      the same process (the variants of a design are ui-designs). The
+ *      activator grammar has no filter to tell a request from its product.
+ *   4. the skills the goal tells the agent to load exist in the catalog.
+ *
+ * Not covered: the wording of the rubric, and whether the pod honours a
+ * `manual` worker — only the catalog side.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { WORKSPACE_TEMPLATES, getWorkspaceTemplate } from "./templates.js";
+
+const builder = getWorkspaceTemplate("builder-workspace")!;
+const pb = builder.playbooks!.find(
+  (p) => p.name === "Design to implementation"
+)!;
+const kind = builder.profiles.find((p) => p.slug === "ui-design")!;
+type Stage = {
+  key: string;
+  subjectStatus?: string;
+  gate?: { kind: string };
+  onFail?: { toStage: string };
+  criteria?: { check?: { kind: string; evidenceKey?: string } }[];
+  expectedOutputs?: { kind: string }[];
+};
+const stages = (pb as unknown as { stages: Stage[] }).stages;
+
+describe("Design to implementation — the design loop", () => {
+  it("every evidence key the process reads is a property ui-design declares", () => {
+    const keys = stages.flatMap((s) =>
+      (s.criteria ?? []).map((c) => c.check?.evidenceKey).filter(Boolean)
+    );
+    expect(keys.length).toBeGreaterThanOrEqual(4); // non-vacuity: design-json, critique, implementation-pr, implemented-story-id
+    const declared = new Set(kind.properties.map((p) => p.slug));
+    expect(keys.filter((k) => !declared.has(k!))).toEqual([]);
+  });
+
+  it("Critique sits between Generate and Review: no status, a check gate, rework to Generate", () => {
+    expect(stages.map((s) => s.key).slice(0, 3)).toEqual([
+      "generate",
+      "critique",
+      "review",
+    ]);
+    const critique = stages.find((s) => s.key === "critique")!;
+    expect(critique.subjectStatus).toBeUndefined();
+    expect(critique.gate).toEqual({ kind: "check" });
+    expect(critique.onFail).toEqual({ toStage: "generate" });
+  });
+
+  it("no process that produces its own subject kind starts on `created` (corpus-wide)", () => {
+    const selfProducing: string[] = [];
+    const offenders: string[] = [];
+    for (const t of Object.values(WORKSPACE_TEMPLATES))
+      for (const p of t.playbooks ?? []) {
+        const subject = p.subjectProfile?.profileSlug;
+        const ss = (p as unknown as { stages?: Stage[] }).stages ?? [];
+        const outs = [
+          ...ss.flatMap((s) => s.expectedOutputs ?? []),
+          ...((p as unknown as { expectedOutputs?: { kind: string }[] })
+            .expectedOutputs ?? []),
+        ];
+        if (!subject || !outs.some((o) => o.kind === subject)) continue;
+        selfProducing.push(`${t.meta.slug}:${p.name}`);
+        if ((p.activators ?? []).some((a) => a.on === "created"))
+          offenders.push(`${t.meta.slug}:${p.name}`);
+      }
+    expect(selfProducing).toContain(
+      "builder-workspace:Design to implementation"
+    ); // non-vacuity
+    expect(offenders).toEqual([]);
+  });
+
+  it("the skills the goal loads exist in the catalog", () => {
+    for (const slug of ["designing-with-real-components", "design-critique"]) {
+      expect(pb.goalTemplate).toContain(slug);
+      expect(
+        existsSync(join(__dirname, "..", "skills", slug, "SKILL.md"))
+      ).toBe(true);
+    }
+  });
+});

package/src/domain-template-type.test.ts

@@ -0,0 +1,75 @@
+/**
+ * A template that DECLARES entity kinds must be installable as a workspace
+ * that can HOLD them.
+ *
+ * The pod refuses to file entities into a workspace whose type is
+ * `operational` or `agent` (`isDomainHomeWorkspace`, synap-backend
+ * `packages/database/src/services/workspace-resolution-service.ts`; enforced at
+ * `routers/entities/create.ts` with DOMAIN_INTO_NON_DOMAIN_HOME_MESSAGE) and
+ * leaves it out of auto-placement and of the orient domain map. That rule is
+ * deliberate — for real admin/system surfaces. Finance, People (hr), Legal and
+ * Internal Runbook are DOMAINS that ship profiles (account, invoice, contract,
+ * …) yet were typed `operational`, so live 2026-09-25 no entity could be filed
+ * into Finance at all.
+ *
+ * Reads the YAML SOURCES (not the generated `templates.ts`), and derives the
+ * set by globbing every `src/*.yaml` — a new template joins by existing.
+ */
+import { readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const NON_DOMAIN_TYPES = new Set(["operational", "agent"]);
+
+// Declares kinds AND is a non-domain type — an OPEN founder decision, not a
+// silent pass. A ratchet: delete a line once the template is retyped (or its
+// profiles move out); the test fails on a stale entry.
+// Empty since R7 (2026-09-27): both former entries — dev-dashboard and
+// agent-fleet — were retired as templates (option A); their useful views were
+// folded into builder-workspace.
+const KNOWN_CONTRADICTIONS = new Set<string>([]);
+
+type Tpl = {
+  meta?: { slug?: string };
+  workspace?: { workspaceType?: string };
+  profiles?: unknown[];
+};
+
+const templates = readdirSync(HERE)
+  .filter((f) => f.endsWith(".yaml"))
+  .map((f) => load(readFileSync(join(HERE, f), "utf8")) as Tpl)
+  .filter((t) => t && typeof t === "object" && t.meta?.slug);
+
+describe("a template that declares kinds can hold them", () => {
+  it("scans a plausible corpus (non-vacuity)", () => {
+    expect(templates.length).toBeGreaterThan(20);
+    const slugs = templates.map((t) => t.meta!.slug);
+    expect(slugs).toEqual(expect.arrayContaining(["finance", "crm"]));
+  });
+
+  it("no kind-declaring template is typed operational/agent (except the ratchet)", () => {
+    const offenders = templates
+      .filter(
+        (t) =>
+          (t.profiles?.length ?? 0) > 0 &&
+          NON_DOMAIN_TYPES.has(t.workspace?.workspaceType ?? "")
+      )
+      .map((t) => t.meta!.slug!)
+      .sort();
+    expect(offenders.filter((s) => !KNOWN_CONTRADICTIONS.has(s))).toEqual([]);
+    expect(
+      [...KNOWN_CONTRADICTIONS].filter((s) => !offenders.includes(s)),
+      "resolved — remove from KNOWN_CONTRADICTIONS"
+    ).toEqual([]);
+  });
+
+  it("the four domains named in the 2026-09-25 bug are domain homes", () => {
+    const bySlug = new Map(templates.map((t) => [t.meta!.slug, t]));
+    for (const slug of ["finance", "hr", "legal", "internal-runbook"]) {
+      expect(bySlug.get(slug)?.workspace?.workspaceType, slug).toBe("personal");
+    }
+  });
+});