@synap-core/workspace-templates 0.12.0 → 0.24.0

package/dist/wire.d.ts

@@ -0,0 +1,222 @@
+import { g as PackageDefinitionOutput, X as WorkspaceDefinitionInput } from './define-DqoItRiR.js';
+import '@synap-core/types/presentation';
+import '@synap-core/types/space-brief';
+import '@synap-core/types/capability-intents';
+
+/**
+ * The per-kind wire envelopes and the ONE unwrap — import-free on purpose.
+ *
+ * Re-exported (with the workspace types) by `./wire`, the public subpath
+ * `@synap-core/workspace-templates/wire`. It has no imports so a consumer that
+ * still resolves an older npm copy of this package (the CLI, the CP, the pod)
+ * can carry it as a BYTE-IDENTICAL mirror pinned by a tripwire until it can
+ * import the subpath. Edit it here; the mirror copies it.
+ *
+ * What `GET {CP}/api/packages/:slug` serves as `package.definition`, per kind:
+ * the outputs of this package's producers (`scripts/catalog-lib.mjs`
+ * `toPublishBody`; `toOfficialPublishBody` for workspaces) plus what the CP
+ * adds on store/serve (`_meta.slug` via `withTemplateSlug`,
+ * `capability.contentHash`).
+ *
+ * WHY: a skill package is served as `{ _meta, skill: {…} }`. Read flat, every
+ * field is `undefined`: install refused a "bodiless" skill and the update door
+ * reported "no drift" forever (founder pod 2026-10-13, creative-director). Each
+ * consumer had its own cast; this is the one place the envelope is known.
+ *
+ * Element fields are pinned to the catalog schema (`SKILL_FIELDS`,
+ * `CapabilitySpec`) and `AutomationElement` to `PackageAutomationWire` by
+ * `schema/wire.parity.test.ts` (compile time).
+ */
+/** The kinds whose served definition this module describes. */
+declare const WIRE_KINDS: readonly ["workspace", "capability", "skill", "automation", "view"];
+type WireKind = (typeof WIRE_KINDS)[number];
+/**
+ * Other names the same kinds go by: the pod's `market.install` says
+ * `template`, the CP category for an automation is `workflow`, and a pack is
+ * a workspace-shaped definition.
+ */
+declare const WIRE_KIND_ALIASES: {
+    readonly template: "workspace";
+    readonly pack: "workspace";
+    readonly workflow: "automation";
+};
+type WireKindName = WireKind | keyof typeof WIRE_KIND_ALIASES;
+/** `template` → `workspace`, `workflow` → `automation`; `null` for a kind with no wire contract here (e.g. `cell`). */
+declare function toWireKind(kind: string): WireKind | null;
+/**
+ * `definition._meta` as served: the CP stamps `slug` on every row (the pod
+ * keys "which space is this template's?" on it); the CLI adds the `version`
+ * label it installs.
+ */
+interface WireMeta {
+    slug?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+/** `meta.icon` / `color` / `domain`, mirrored onto the definition by every publish builder. */
+interface WireIdentity {
+    icon?: string;
+    color?: string;
+    domain?: string;
+}
+/** A composition dependency. */
+interface WireDependency {
+    slug: string;
+    kind?: "workspace" | "capability" | "skill" | "workflow" | "view" | "cell" | "automation";
+    relation?: "compose" | "require";
+    reason?: string;
+}
+interface WireEnvelope extends WireIdentity {
+    _meta?: WireMeta;
+    dependencies?: WireDependency[];
+}
+/** The capability itself (`CapabilityDefinition`). */
+interface CapabilityElement {
+    key: string;
+    name: string;
+    description?: string;
+    params?: Array<Record<string, unknown>>;
+    vault?: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>>;
+    skills?: Array<Record<string, unknown>>;
+    provides?: string[];
+    playbooks?: Array<Record<string, unknown>>;
+    /** Stamped by the CP on publish; the pod's drift marker. */
+    contentHash?: string;
+    automations?: Array<Record<string, unknown>>;
+    mcpServers?: unknown;
+    metadata?: Record<string, unknown>;
+    _generated?: unknown;
+}
+/** capability: `{ profiles: [], description, capability }`. */
+interface CapabilityWire extends WireEnvelope {
+    profiles: unknown[];
+    description?: string;
+    capability: CapabilityElement;
+}
+/** ONE standalone skill. Not a workspace's `skills[]` link list. */
+interface SkillElement {
+    /** The pod-side `load_skill` ref — its own identity, not the package slug. */
+    slug?: string;
+    name?: string;
+    displayName?: string;
+    description?: string;
+    kind?: "instruction" | "code" | "declarative" | "builtin";
+    scope?: "pod" | "user" | "workspace";
+    agentTypes?: string[];
+    body?: string;
+    code?: string;
+    providerSpec?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+    category?: string;
+    executionMode?: "sync" | "async";
+    timeoutSeconds?: number;
+    intent?: string;
+    [key: string]: unknown;
+}
+/** skill: `{ skill, icon?, color?, domain?, dependencies? }`. */
+interface SkillWire extends WireEnvelope {
+    skill: SkillElement;
+}
+/** One graph automation (= `PackageAutomationWire`): `flowDefinition`, not the authored `flow`. */
+interface AutomationElement {
+    key?: string;
+    name: string;
+    description?: string;
+    triggerType: "event" | "cron" | "webhook" | "manual";
+    triggerConfig?: Record<string, unknown>;
+    flowDefinition?: {
+        nodes: unknown[];
+        edges: unknown[];
+        precondition?: string;
+    };
+    status?: "draft" | "active" | "paused";
+}
+/** automation (CP category `workflow`): `{ profiles: [], automations: [one] }`. */
+interface AutomationWire extends WireEnvelope {
+    profiles: unknown[];
+    automations: AutomationElement[];
+}
+/** One view, as the pod's view install and update doors read it. */
+interface ViewElement {
+    slug?: string;
+    name?: string;
+    displayName?: string;
+    description?: string;
+    type?: string;
+    config?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    scopeProfileSlugs?: string[];
+    scopeProfileIds?: string[];
+    [key: string]: unknown;
+}
+/** view: `{ views: [...] }`, or a legacy single view with its fields on top (has its own `type`). No catalog producer today. */
+type ViewWire = (WireEnvelope & {
+    views: ViewElement[];
+}) | ViewElement;
+/**
+ * What {@link unwrapPackage} returns per kind. `workspace` is the definition
+ * itself; `./wire` narrows it to `WorkspaceWire`.
+ */
+interface PackageElementByKind<W = Record<string, unknown>> {
+    workspace: W;
+    capability: CapabilityElement;
+    skill: SkillElement;
+    automation: AutomationElement[];
+    view: ViewElement[];
+}
+type ElementOf<K extends WireKindName, W = Record<string, unknown>> = PackageElementByKind<W>[K extends WireKind ? K : K extends keyof typeof WIRE_KIND_ALIASES ? (typeof WIRE_KIND_ALIASES)[K] : never];
+
+/**
+ * @synap-core/workspace-templates/wire — ONE wire contract per package kind.
+ *
+ * The per-kind envelopes and `unwrapPackage` live in `./wire-core` (import-free,
+ * so it can be mirrored byte-for-byte by consumers still pinned to an older npm
+ * copy). This adds what needs the rest of the package: the workspace envelope,
+ * derived from `PackageDefinitionOutput` instead of re-declared, and the one
+ * workspace wire → create-input translation.
+ */
+
+/**
+ * workspace / pack: `toPackageDefinition()` output — re-used, not re-declared.
+ * As served it is `toOfficialPublishBody().definition` (identity mirrored on
+ * top, `sourcePackage`) with `_meta` cut down to what the CP stamps; a bundled
+ * `PackageDefinitionOutput` is assignable to it as is.
+ */
+type WorkspaceWire = Omit<PackageDefinitionOutput, "_meta"> & WireIdentity & {
+    _meta?: Partial<PackageDefinitionOutput["_meta"]> & WireMeta;
+    /** Which build of this package generated the row (official rows only). */
+    sourcePackage?: {
+        name: string;
+        version: string;
+    };
+};
+/** The served definition, keyed by kind. */
+interface PackageWireByKind {
+    workspace: WorkspaceWire;
+    capability: CapabilityWire;
+    skill: SkillWire;
+    automation: AutomationWire;
+    view: ViewWire;
+}
+type PackageWire = PackageWireByKind[WireKind];
+/** `./wire-core`'s `unwrapPackage`, with the workspace element typed as {@link WorkspaceWire}. */
+declare function unwrapPackage<K extends WireKindName>(kind: K, definition: unknown): ElementOf<K, WorkspaceWire>;
+/**
+ * The served workspace definition → the input the pod's create/reconcile door
+ * takes (`WorkspaceDefinitionInput`). The two renames live here and only here:
+ * `suggestedEntities` → `seedEntities` and `automations` (graph flows) →
+ * `flowAutomations`.
+ *
+ * A 1:1 copy of the pod's `toWorkspaceDefinitionInput`
+ * (synap-backend `services/capabilities/resolve-workspace-template.ts`), so the
+ * pod can import this instead. Like it, it does NOT carry `taskIntents`,
+ * `capabilities`, `playbooks`, `actionPlacements`, `rules` or `skills`: the
+ * post-workspace layer reads the last five off the package definition itself;
+ * `taskIntents` is a gap on that path today. `wire.test.ts` pins every
+ * difference from `toWorkspaceDefinition`.
+ */
+declare function toWorkspaceInput(pkg: WorkspaceWire): WorkspaceDefinitionInput;
+
+export { type AutomationElement, type AutomationWire, type CapabilityElement, type CapabilityWire, type PackageElementByKind, type PackageWire, type PackageWireByKind, type SkillElement, type SkillWire, type ViewElement, type ViewWire, WIRE_KINDS, WIRE_KIND_ALIASES, type WireDependency, type WireEnvelope, type WireIdentity, type WireKind, type WireKindName, type WireMeta, type WorkspaceWire, toWireKind, toWorkspaceInput, unwrapPackage };

package/dist/wire.js

@@ -0,0 +1,77 @@
+// src/wire-core.ts
+var WIRE_KINDS = ["workspace", "capability", "skill", "automation", "view"];
+var WIRE_KIND_ALIASES = {
+  template: "workspace",
+  pack: "workspace",
+  workflow: "automation"
+};
+function toWireKind(kind) {
+  if (WIRE_KINDS.includes(kind)) return kind;
+  return WIRE_KIND_ALIASES[kind] ?? null;
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function unwrapPackage(kind, definition) {
+  const wireKind = toWireKind(kind);
+  if (!wireKind) throw new Error(`unwrapPackage: "${kind}" has no wire contract`);
+  if (!isRecord(definition)) {
+    throw new TypeError(
+      `unwrapPackage(${kind}): the definition is not an object (${definition === null ? "null" : Array.isArray(definition) ? "array" : typeof definition})`
+    );
+  }
+  switch (wireKind) {
+    case "skill":
+      return isRecord(definition.skill) ? definition.skill : definition;
+    case "capability":
+      return isRecord(definition.capability) ? definition.capability : definition;
+    case "automation":
+      return Array.isArray(definition.automations) ? definition.automations : [];
+    case "view":
+      if (Array.isArray(definition.views) && definition.views.length > 0) return definition.views;
+      return definition.type ? [definition] : [];
+    case "workspace":
+      return definition;
+  }
+}
+
+// src/wire.ts
+function unwrapPackage2(kind, definition) {
+  return unwrapPackage(kind, definition);
+}
+function toWorkspaceInput(pkg) {
+  return {
+    workspaceName: pkg.workspaceName,
+    description: pkg.description,
+    proposalId: pkg._meta?.slug,
+    profiles: pkg.profiles,
+    views: pkg.views ?? [],
+    entityLinks: pkg.entityLinks ?? [],
+    seedEntities: pkg.suggestedEntities ?? [],
+    suggestedRelations: pkg.suggestedRelations,
+    displayTemplates: pkg.displayTemplates,
+    layoutConfig: pkg.layoutConfig,
+    bentoViewName: pkg.bentoViewName,
+    bentoLayout: pkg.bentoLayout,
+    bentoViewBlocks: pkg.bentoViewBlocks,
+    profileEntityBentoTemplates: pkg.profileEntityBentoTemplates,
+    workspaceSubtype: pkg.workspaceSubtype,
+    workspaceType: pkg.workspaceType,
+    workspaceVisibility: pkg.workspaceVisibility,
+    workspaceCapabilities: pkg.workspaceCapabilities,
+    intent: pkg.intent,
+    sourceRoles: pkg.sourceRoles,
+    defaultSources: pkg.defaultSources,
+    onboarding: pkg.onboarding,
+    dependencies: pkg.dependencies,
+    flowAutomations: pkg.automations ?? [],
+    commands: pkg.commands ?? [],
+    relationDefs: pkg.relationDefs ?? []
+  };
+}
+export {
+  WIRE_KINDS,
+  WIRE_KIND_ALIASES,
+  toWireKind,
+  toWorkspaceInput,
+  unwrapPackage2 as unwrapPackage
+};
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wire-core.ts","../src/wire.ts"],"sourcesContent":["/**\n * The per-kind wire envelopes and the ONE unwrap — import-free on purpose.\n *\n * Re-exported (with the workspace types) by `./wire`, the public subpath\n * `@synap-core/workspace-templates/wire`. It has no imports so a consumer that\n * still resolves an older npm copy of this package (the CLI, the CP, the pod)\n * can carry it as a BYTE-IDENTICAL mirror pinned by a tripwire until it can\n * import the subpath. Edit it here; the mirror copies it.\n *\n * What `GET {CP}/api/packages/:slug` serves as `package.definition`, per kind:\n * the outputs of this package's producers (`scripts/catalog-lib.mjs`\n * `toPublishBody`; `toOfficialPublishBody` for workspaces) plus what the CP\n * adds on store/serve (`_meta.slug` via `withTemplateSlug`,\n * `capability.contentHash`).\n *\n * WHY: a skill package is served as `{ _meta, skill: {…} }`. Read flat, every\n * field is `undefined`: install refused a \"bodiless\" skill and the update door\n * reported \"no drift\" forever (founder pod 2026-10-13, creative-director). Each\n * consumer had its own cast; this is the one place the envelope is known.\n *\n * Element fields are pinned to the catalog schema (`SKILL_FIELDS`,\n * `CapabilitySpec`) and `AutomationElement` to `PackageAutomationWire` by\n * `schema/wire.parity.test.ts` (compile time).\n */\n\n// ─── Kinds ──────────────────────────────────────────────────────────────────\n\n/** The kinds whose served definition this module describes. */\nexport const WIRE_KINDS = [\"workspace\", \"capability\", \"skill\", \"automation\", \"view\"] as const;\nexport type WireKind = (typeof WIRE_KINDS)[number];\n\n/**\n * Other names the same kinds go by: the pod's `market.install` says\n * `template`, the CP category for an automation is `workflow`, and a pack is\n * a workspace-shaped definition.\n */\nexport const WIRE_KIND_ALIASES = {\n  template: \"workspace\",\n  pack: \"workspace\",\n  workflow: \"automation\",\n} as const satisfies Record<string, WireKind>;\nexport type WireKindName = WireKind | keyof typeof WIRE_KIND_ALIASES;\n\n/** `template` → `workspace`, `workflow` → `automation`; `null` for a kind with no wire contract here (e.g. `cell`). */\nexport function toWireKind(kind: string): WireKind | null {\n  if ((WIRE_KINDS as readonly string[]).includes(kind)) return kind as WireKind;\n  return (WIRE_KIND_ALIASES as Record<string, WireKind>)[kind] ?? null;\n}\n\n// ─── Envelope pieces every kind shares ──────────────────────────────────────\n\n/**\n * `definition._meta` as served: the CP stamps `slug` on every row (the pod\n * keys \"which space is this template's?\" on it); the CLI adds the `version`\n * label it installs.\n */\nexport interface WireMeta {\n  slug?: string;\n  version?: string;\n  [key: string]: unknown;\n}\n\n/** `meta.icon` / `color` / `domain`, mirrored onto the definition by every publish builder. */\nexport interface WireIdentity {\n  icon?: string;\n  color?: string;\n  domain?: string;\n}\n\n/** A composition dependency. */\nexport interface WireDependency {\n  slug: string;\n  kind?: \"workspace\" | \"capability\" | \"skill\" | \"workflow\" | \"view\" | \"cell\" | \"automation\";\n  relation?: \"compose\" | \"require\";\n  reason?: string;\n}\n\nexport interface WireEnvelope extends WireIdentity {\n  _meta?: WireMeta;\n  dependencies?: WireDependency[];\n}\n\n// ─── Elements and envelopes, per kind ───────────────────────────────────────\n\n/** The capability itself (`CapabilityDefinition`). */\nexport interface CapabilityElement {\n  key: string;\n  name: string;\n  description?: string;\n  params?: Array<Record<string, unknown>>;\n  vault?: Array<Record<string, unknown>>;\n  tools?: Array<Record<string, unknown>>;\n  skills?: Array<Record<string, unknown>>;\n  provides?: string[];\n  playbooks?: Array<Record<string, unknown>>;\n  /** Stamped by the CP on publish; the pod's drift marker. */\n  contentHash?: string;\n  automations?: Array<Record<string, unknown>>;\n  mcpServers?: unknown;\n  metadata?: Record<string, unknown>;\n  _generated?: unknown;\n}\n\n/** capability: `{ profiles: [], description, capability }`. */\nexport interface CapabilityWire extends WireEnvelope {\n  profiles: unknown[];\n  description?: string;\n  capability: CapabilityElement;\n}\n\n/** ONE standalone skill. Not a workspace's `skills[]` link list. */\nexport interface SkillElement {\n  /** The pod-side `load_skill` ref — its own identity, not the package slug. */\n  slug?: string;\n  name?: string;\n  displayName?: string;\n  description?: string;\n  kind?: \"instruction\" | \"code\" | \"declarative\" | \"builtin\";\n  scope?: \"pod\" | \"user\" | \"workspace\";\n  agentTypes?: string[];\n  body?: string;\n  code?: string;\n  providerSpec?: Record<string, unknown>;\n  parameters?: Record<string, unknown>;\n  category?: string;\n  executionMode?: \"sync\" | \"async\";\n  timeoutSeconds?: number;\n  intent?: string;\n  [key: string]: unknown;\n}\n\n/** skill: `{ skill, icon?, color?, domain?, dependencies? }`. */\nexport interface SkillWire extends WireEnvelope {\n  skill: SkillElement;\n}\n\n/** One graph automation (= `PackageAutomationWire`): `flowDefinition`, not the authored `flow`. */\nexport interface AutomationElement {\n  key?: string;\n  name: string;\n  description?: string;\n  triggerType: \"event\" | \"cron\" | \"webhook\" | \"manual\";\n  triggerConfig?: Record<string, unknown>;\n  flowDefinition?: { nodes: unknown[]; edges: unknown[]; precondition?: string };\n  status?: \"draft\" | \"active\" | \"paused\";\n}\n\n/** automation (CP category `workflow`): `{ profiles: [], automations: [one] }`. */\nexport interface AutomationWire extends WireEnvelope {\n  profiles: unknown[];\n  automations: AutomationElement[];\n}\n\n/** One view, as the pod's view install and update doors read it. */\nexport interface ViewElement {\n  slug?: string;\n  name?: string;\n  displayName?: string;\n  description?: string;\n  type?: string;\n  config?: Record<string, unknown>;\n  query?: Record<string, unknown>;\n  metadata?: Record<string, unknown>;\n  scopeProfileSlugs?: string[];\n  scopeProfileIds?: string[];\n  [key: string]: unknown;\n}\n\n/** view: `{ views: [...] }`, or a legacy single view with its fields on top (has its own `type`). No catalog producer today. */\nexport type ViewWire = (WireEnvelope & { views: ViewElement[] }) | ViewElement;\n\n/**\n * What {@link unwrapPackage} returns per kind. `workspace` is the definition\n * itself; `./wire` narrows it to `WorkspaceWire`.\n */\nexport interface PackageElementByKind<W = Record<string, unknown>> {\n  workspace: W;\n  capability: CapabilityElement;\n  skill: SkillElement;\n  automation: AutomationElement[];\n  view: ViewElement[];\n}\n\nexport type ElementOf<K extends WireKindName, W = Record<string, unknown>> = PackageElementByKind<W>[K extends WireKind\n  ? K\n  : K extends keyof typeof WIRE_KIND_ALIASES\n    ? (typeof WIRE_KIND_ALIASES)[K]\n    : never];\n\n// ─── The ONE unwrap ─────────────────────────────────────────────────────────\n\nconst isRecord = (v: unknown): v is Record<string, unknown> =>\n  typeof v === \"object\" && v !== null && !Array.isArray(v);\n\n/**\n * The installable element(s) inside a served definition:\n *\n *   skill      → the `skill` object (a legacy flat definition is the skill itself)\n *   capability → the `capability` object (a flat `CapabilityDefinition` — the\n *                pod cache / CP by-key shape — passes through)\n *   automation → `automations[]` (`[]` when the definition declares none)\n *   view       → `views[]`, or a legacy flat view (top-level `type`) as `[def]`, else `[]`\n *   workspace  → the definition itself\n *\n * An empty array means the definition declares none; the install doors refuse\n * that themselves. A definition that is not an object is a failed read, never\n * an empty one: it throws.\n */\nexport function unwrapPackage<K extends WireKindName>(kind: K, definition: unknown): ElementOf<K>;\nexport function unwrapPackage(kind: string, definition: unknown): unknown {\n  const wireKind = toWireKind(kind);\n  if (!wireKind) throw new Error(`unwrapPackage: \"${kind}\" has no wire contract`);\n  if (!isRecord(definition)) {\n    throw new TypeError(\n      `unwrapPackage(${kind}): the definition is not an object (${definition === null ? \"null\" : Array.isArray(definition) ? \"array\" : typeof definition})`,\n    );\n  }\n  switch (wireKind) {\n    case \"skill\":\n      return isRecord(definition.skill) ? definition.skill : definition;\n    case \"capability\":\n      return isRecord(definition.capability) ? definition.capability : definition;\n    case \"automation\":\n      return Array.isArray(definition.automations) ? definition.automations : [];\n    case \"view\":\n      if (Array.isArray(definition.views) && definition.views.length > 0) return definition.views;\n      return definition.type ? [definition] : [];\n    case \"workspace\":\n      return definition;\n  }\n}\n","/**\n * @synap-core/workspace-templates/wire — ONE wire contract per package kind.\n *\n * The per-kind envelopes and `unwrapPackage` live in `./wire-core` (import-free,\n * so it can be mirrored byte-for-byte by consumers still pinned to an older npm\n * copy). This adds what needs the rest of the package: the workspace envelope,\n * derived from `PackageDefinitionOutput` instead of re-declared, and the one\n * workspace wire → create-input translation.\n */\n\nimport type { PackageDefinitionOutput, WorkspaceDefinitionInput } from \"./define\";\nimport { unwrapPackage as unwrapCore, type ElementOf, type WireIdentity, type WireKindName, type WireMeta } from \"./wire-core\";\n\nexport {\n  WIRE_KINDS,\n  WIRE_KIND_ALIASES,\n  toWireKind,\n  type WireKind,\n  type WireKindName,\n  type WireMeta,\n  type WireIdentity,\n  type WireDependency,\n  type WireEnvelope,\n  type CapabilityElement,\n  type CapabilityWire,\n  type SkillElement,\n  type SkillWire,\n  type AutomationElement,\n  type AutomationWire,\n  type ViewElement,\n  type ViewWire,\n  type PackageElementByKind,\n} from \"./wire-core\";\nimport type { AutomationWire, CapabilityWire, SkillWire, ViewWire, WireKind } from \"./wire-core\";\n\n/**\n * workspace / pack: `toPackageDefinition()` output — re-used, not re-declared.\n * As served it is `toOfficialPublishBody().definition` (identity mirrored on\n * top, `sourcePackage`) with `_meta` cut down to what the CP stamps; a bundled\n * `PackageDefinitionOutput` is assignable to it as is.\n */\nexport type WorkspaceWire = Omit<PackageDefinitionOutput, \"_meta\"> &\n  WireIdentity & {\n    _meta?: Partial<PackageDefinitionOutput[\"_meta\"]> & WireMeta;\n    /** Which build of this package generated the row (official rows only). */\n    sourcePackage?: { name: string; version: string };\n  };\n\n/** The served definition, keyed by kind. */\nexport interface PackageWireByKind {\n  workspace: WorkspaceWire;\n  capability: CapabilityWire;\n  skill: SkillWire;\n  automation: AutomationWire;\n  view: ViewWire;\n}\nexport type PackageWire = PackageWireByKind[WireKind];\n\n/** `./wire-core`'s `unwrapPackage`, with the workspace element typed as {@link WorkspaceWire}. */\nexport function unwrapPackage<K extends WireKindName>(kind: K, definition: unknown): ElementOf<K, WorkspaceWire> {\n  return unwrapCore(kind, definition) as ElementOf<K, WorkspaceWire>;\n}\n\n/**\n * The served workspace definition → the input the pod's create/reconcile door\n * takes (`WorkspaceDefinitionInput`). The two renames live here and only here:\n * `suggestedEntities` → `seedEntities` and `automations` (graph flows) →\n * `flowAutomations`.\n *\n * A 1:1 copy of the pod's `toWorkspaceDefinitionInput`\n * (synap-backend `services/capabilities/resolve-workspace-template.ts`), so the\n * pod can import this instead. Like it, it does NOT carry `taskIntents`,\n * `capabilities`, `playbooks`, `actionPlacements`, `rules` or `skills`: the\n * post-workspace layer reads the last five off the package definition itself;\n * `taskIntents` is a gap on that path today. `wire.test.ts` pins every\n * difference from `toWorkspaceDefinition`.\n */\nexport function toWorkspaceInput(pkg: WorkspaceWire): WorkspaceDefinitionInput {\n  return {\n    workspaceName: pkg.workspaceName,\n    description: pkg.description,\n    proposalId: pkg._meta?.slug,\n    profiles: pkg.profiles,\n    views: pkg.views ?? [],\n    entityLinks: pkg.entityLinks ?? [],\n    seedEntities: pkg.suggestedEntities ?? [],\n    suggestedRelations: pkg.suggestedRelations,\n    displayTemplates: pkg.displayTemplates,\n    layoutConfig: pkg.layoutConfig,\n    bentoViewName: pkg.bentoViewName,\n    bentoLayout: pkg.bentoLayout,\n    bentoViewBlocks: pkg.bentoViewBlocks,\n    profileEntityBentoTemplates: pkg.profileEntityBentoTemplates,\n    workspaceSubtype: pkg.workspaceSubtype,\n    workspaceType: pkg.workspaceType,\n    workspaceVisibility: pkg.workspaceVisibility,\n    workspaceCapabilities: pkg.workspaceCapabilities,\n    intent: pkg.intent,\n    sourceRoles: pkg.sourceRoles,\n    defaultSources: pkg.defaultSources,\n    onboarding: pkg.onboarding,\n    dependencies: pkg.dependencies,\n    flowAutomations: pkg.automations ?? [],\n    commands: pkg.commands ?? [],\n    relationDefs: pkg.relationDefs ?? [],\n  };\n}\n"],"mappings":";AA4BO,IAAM,aAAa,CAAC,aAAa,cAAc,SAAS,cAAc,MAAM;AAQ5E,IAAM,oBAAoB;AAAA,EAC/B,UAAU;AAAA,EACV,MAAM;AAAA,EACN,UAAU;AACZ;AAIO,SAAS,WAAW,MAA+B;AACxD,MAAK,WAAiC,SAAS,IAAI,EAAG,QAAO;AAC7D,SAAQ,kBAA+C,IAAI,KAAK;AAClE;AAgJA,IAAM,WAAW,CAAC,MAChB,OAAO,MAAM,YAAY,MAAM,QAAQ,CAAC,MAAM,QAAQ,CAAC;AAiBlD,SAAS,cAAc,MAAc,YAA8B;AACxE,QAAM,WAAW,WAAW,IAAI;AAChC,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,mBAAmB,IAAI,wBAAwB;AAC9E,MAAI,CAAC,SAAS,UAAU,GAAG;AACzB,UAAM,IAAI;AAAA,MACR,iBAAiB,IAAI,uCAAuC,eAAe,OAAO,SAAS,MAAM,QAAQ,UAAU,IAAI,UAAU,OAAO,UAAU;AAAA,IACpJ;AAAA,EACF;AACA,UAAQ,UAAU;AAAA,IAChB,KAAK;AACH,aAAO,SAAS,WAAW,KAAK,IAAI,WAAW,QAAQ;AAAA,IACzD,KAAK;AACH,aAAO,SAAS,WAAW,UAAU,IAAI,WAAW,aAAa;AAAA,IACnE,KAAK;AACH,aAAO,MAAM,QAAQ,WAAW,WAAW,IAAI,WAAW,cAAc,CAAC;AAAA,IAC3E,KAAK;AACH,UAAI,MAAM,QAAQ,WAAW,KAAK,KAAK,WAAW,MAAM,SAAS,EAAG,QAAO,WAAW;AACtF,aAAO,WAAW,OAAO,CAAC,UAAU,IAAI,CAAC;AAAA,IAC3C,KAAK;AACH,aAAO;AAAA,EACX;AACF;;;AC3KO,SAASA,eAAsC,MAAS,YAAkD;AAC/G,SAAO,cAAW,MAAM,UAAU;AACpC;AAgBO,SAAS,iBAAiB,KAA8C;AAC7E,SAAO;AAAA,IACL,eAAe,IAAI;AAAA,IACnB,aAAa,IAAI;AAAA,IACjB,YAAY,IAAI,OAAO;AAAA,IACvB,UAAU,IAAI;AAAA,IACd,OAAO,IAAI,SAAS,CAAC;AAAA,IACrB,aAAa,IAAI,eAAe,CAAC;AAAA,IACjC,cAAc,IAAI,qBAAqB,CAAC;AAAA,IACxC,oBAAoB,IAAI;AAAA,IACxB,kBAAkB,IAAI;AAAA,IACtB,cAAc,IAAI;AAAA,IAClB,eAAe,IAAI;AAAA,IACnB,aAAa,IAAI;AAAA,IACjB,iBAAiB,IAAI;AAAA,IACrB,6BAA6B,IAAI;AAAA,IACjC,kBAAkB,IAAI;AAAA,IACtB,eAAe,IAAI;AAAA,IACnB,qBAAqB,IAAI;AAAA,IACzB,uBAAuB,IAAI;AAAA,IAC3B,QAAQ,IAAI;AAAA,IACZ,aAAa,IAAI;AAAA,IACjB,gBAAgB,IAAI;AAAA,IACpB,YAAY,IAAI;AAAA,IAChB,cAAc,IAAI;AAAA,IAClB,iBAAiB,IAAI,eAAe,CAAC;AAAA,IACrC,UAAU,IAAI,YAAY,CAAC;AAAA,IAC3B,cAAc,IAAI,gBAAgB,CAAC;AAAA,EACrC;AACF;","names":["unwrapPackage"]}

package/package.json

@@ -1,25 +1,46 @@
 {
   "name": "@synap-core/workspace-templates",
-  "version": "0.12.0",
+  "version": "0.24.0",
   "type": "module",
   "description": "Canonical workspace definitions — YAML source + typed exports for browser, backend, CLI, and marketplace",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Synap-core/app-bases.git",
+    "directory": "packages/workspace-templates"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./wire": {
+      "types": "./dist/wire.d.ts",
+      "default": "./dist/wire.js"
+    },
+    "./capabilities/*": "./capabilities/*",
+    "./skills/*": "./skills/*",
+    "./automations/*": "./automations/*",
+    "./views/*": "./views/*",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "capabilities",
+    "skills",
+    "automations",
+    "views",
+    "retired.yaml"
   ],
   "dependencies": {
+    "@synap-core/types": "^1.12.0",
     "zod": "^3.0.0",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
+    "esbuild": "^0.27.3",
     "tsup": "^8.0.0",
     "typescript": "^5.5.0"
   },
@@ -28,8 +49,10 @@
     "access": "public"
   },
   "scripts": {
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc -p tsconfig.catalog.json && tsc --noEmit",
+    "type-check:catalog": "tsc -p tsconfig.catalog.json",
     "build:yaml": "node --experimental-strip-types build.mjs",
+    "build:space-packages": "node scripts/build-space-packages.mjs",
     "check:converters": "node scripts/check-converters.mjs",
     "check:concepts": "node scripts/check-concepts.mjs",
     "build": "node --experimental-strip-types build.mjs && tsup && node scripts/check-converters.mjs && node scripts/check-concepts.mjs",

package/retired.yaml

@@ -0,0 +1,136 @@
+# Retired templates: the tombstone registry (schema: schema/retired.ts).
+#
+# A template that leaves the catalog stays KNOWN here. `synap catalog publish`
+# sends each entry to the control plane (POST /api/packages/retire) after the
+# live publishes, so a pod can tell "retired, replaced by X" from "never heard
+# of it" and offer the person a safe move to X. Removing an entry does NOT
+# un-retire the row on the CP.
+#
+#   slug        the retired slug
+#   kind        workspace (default) · capability · skill · pack · automation
+#   replacedBy  a LIVE catalog slug of the same kind, or absent when nothing replaces it
+#   reason      one plain sentence a person reads
+#   since       the date it left the catalog (YYYY-MM-DD)
+#
+# Validation (`synap catalog validate`): replacedBy is live and not retired; no
+# slug is both live and retired in the same category; reasons are not empty.
+# The evidence behind each entry is in pod file 00c1b2fe-ef98-41fa-86cf-801dfab12cd1 ("Template lifecycle: decisions wave + lane catalog").
+
+apiVersion: synap/v1
+retired:
+  # c64ec2fe: "ecosystem (absorbs radar+content-os per ratified merge)". Every
+  # radar kind (competitor, market-segment, trend, inspiration) is declared by ecosystem.
+  - slug: radar
+    kind: workspace
+    replacedBy: ecosystem
+    reason: Radar was merged into Ecosystem, which tracks competitors, market segments, trends and inspiration in one place.
+    since: "2026-07-16"
+
+  # 2026-07-22 (b12efb1b). Second Brain (life-os) declares every kind Personal
+  # held (note, bookmark, article; projects are the pod's own).
+  - slug: personal
+    kind: workspace
+    replacedBy: life-os
+    reason: Personal was replaced by Second Brain, which keeps your notes, bookmarks and articles together.
+    since: "2026-07-22"
+
+  # R7 2026-09-27 (src/builder-dev-fold.template.test.ts): the four views worth
+  # keeping were rebuilt over Builder's own kinds (slug builder-workspace, shown as "Dev"). credential, vendor, repository,
+  # service and environment were NOT ported.
+  - slug: dev-dashboard
+    kind: workspace
+    replacedBy: builder-workspace
+    reason: Dev Dashboard was folded into the Dev space, where its service health, deploy and cost views now live.
+    since: "2026-09-27"
+
+  # R7 2026-09-27: retired as a template, its `agent` kind deliberately not
+  # ported anywhere. Not a system space (only pod-admin carries a system_slug).
+  - slug: agent-fleet
+    kind: workspace
+    reason: Agent Fleet is no longer offered; your agents belong to the pod itself, not to a space.
+    since: "2026-09-27"
+
+  # eaf49166: it declared no profiles, only tools, skills and vault. It lives on
+  # as the capability `posthog-analytics` (capabilities/), a different category.
+  - slug: posthog-analytics
+    kind: workspace
+    reason: PostHog Analytics is now a capability you connect, not a space.
+    since: "2026-10-06"
+
+  # relay-app's private template (relay-app/src/lib/workspace-templates/relay.ts).
+  # Never in the catalog, but pods hold it. person and company move to CRM;
+  # event and task are pod-wide; campaign and contact have no home in CRM.
+  - slug: relay
+    kind: workspace
+    replacedBy: crm
+    reason: Relay was replaced by CRM, which keeps the people and companies you track.
+    since: "2026-10-11"
+
+  # relay-app's private template (relay-app/src/lib/workspace-templates/pkm.ts).
+  # life-os.yaml says it was consolidated from the CP pkm-template; it declares
+  # note, bookmark and highlight.
+  - slug: pkm
+    kind: workspace
+    replacedBy: life-os
+    reason: Knowledge was replaced by Second Brain, which keeps your notes, bookmarks and highlights.
+    since: "2026-10-11"
+
+  # Founder decision 2026-10-12 (pod file 00c1b2fe-ef98-41fa-86cf-801dfab12cd1, decisions wave item 1).
+  # Its lead/client fields, the campaign kind and "Qualify a lead" folded into
+  # crm.yaml; "Advance a commercial proposal" was dropped for CRM's "Win a
+  # deal"; the Synap-fee + commission model moved to the private arch-sales.yaml,
+  # itself retired the same day (below).
+  - slug: business-developer
+    kind: workspace
+    replacedBy: crm
+    reason: Business Developer was folded into CRM, which now qualifies your leads and runs your campaigns.
+    since: "2026-10-12"
+
+  # Founder decision 2026-10-12: The Arch (project + pod) is no longer in use.
+  # Both were private. Their sources are kept, never loaded, in retired-sources/.
+  # Existing pods keep their spaces and data; nothing offers them again.
+  - slug: arch-sales
+    kind: workspace
+    reason: Arch Sales was The Arch's own business-developer commission model, and that project is no longer in use.
+    since: "2026-10-12"
+
+  - slug: the-arch
+    kind: workspace
+    reason: The Arch was a private suite for a project that is no longer in use.
+    since: "2026-10-12"
+
+  # 2026-10-15, "Any link → data": every pod reads a
+  # public link itself (the builtin web read verb in Synap Core), so this pack
+  # and its capture_public_url twin are no longer offered. Nothing replaces it:
+  # nothing needs installing.
+  - slug: web.read
+    kind: capability
+    reason: Reading a public link is built into every pod.
+    since: "2026-10-15"
+
+  # Founder decision 2026-10-23: one space per domain. For a founder-led company
+  # outreach is part of the commercial job, so the CRM absorbs it: the
+  # `outreach-touch` kind (same slug and lifecycle keys), `sent_to` / `part_of`,
+  # the two views, "Personalized Outreach" and the LinkedIn ingest live in
+  # crm.yaml. `outreach-campaign` folded into CRM's `campaign` (campaign-type
+  # outreach); "Send an outreach message" became "Read the reply to an outreach
+  # message" (the agent drafts, a person sends). No pod had it installed.
+  - slug: outreach-comms
+    kind: workspace
+    replacedBy: crm
+    reason: Outreach & Comms was folded into CRM, which now keeps your outreach campaigns and the messages drafted for you to send.
+    since: "2026-10-23"
+
+  # Static edit loop W5 (build plan ab3e0a5a §4, founder D0-D1, 2 Nov 2026).
+  # Superseded since 2026-10-06: Content OS re-declared its three video kinds
+  # (content-composition, content-asset, render-job) verbatim, their views and
+  # pipeline links; brand-library folded its production-recipe into
+  # brand-template. The edit loop (edit-loop skill, video-toolbox routing)
+  # replaced its render pipeline. The founder's pod holds no Content Studio
+  # space (2026-11-03); a pod that does keeps it as it is (the resolver
+  # refuses a new install and leaves an installed space alone).
+  - slug: content-studio
+    kind: workspace
+    replacedBy: content-os
+    reason: Content Studio was folded into Content OS, which now keeps your videos, carousels and other visual posts with the rest of your content.
+    since: "2026-11-03"

package/skills/app-factory-build-slice/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: app-factory-build-slice
+description: Build one slice of a new app from its approved design boards — scope by board files, data read server-side only through the person's sign-in, governed writes, the Website Factory gates, an independent re-run of every gate by the orchestrator, and a stop for the person's first look after slice 1. Use in the Build stage of "Build an app (App Factory)", or when handing an approved design to a coding agent.
+metadata:
+  synap_native: true
+  auto_load: false
+---
+
+# App Factory: build a slice
+
+A slice is a set of approved boards built pixel for pixel, gate-green, in a pull request. It never starts before the
+person approved the design, and never starts while a gap it depends on is open without a labelled bridge. Content
+Studio's slice S1 (Home + idea bank, read-only, real data) is the reference.
+
+## 1. Write the slice brief (in the app repo, e.g. `BUILD-S1.md`)
+
+The builder reads it fully, then `AGENTS.md`, `.claude/skills/build-site/SKILL.md`, the plan document (sections it
+names) and the boards. The brief says:
+
+- **Scope, by boards.** Each route with the board files it must match (desktop 1280, phone 390, every state board).
+  Shell items outside the slice link to ONE "coming next" page drawn with the kit's `StatePanel`, never a dead link.
+- **Rules computed on the server**, written once (e.g. Home's one line: open interview with unanswered questions →
+  owed asks → pending proposals → the most overdue item). The counts that must agree across pages come from one
+  function.
+- **Not in this slice**, explicitly (writes, sign-in, the pages of later slices).
+- **Data.** The read set per page (route, `workspaceId` always passed, what it returns), the request budget per page
+  against the key's rate limit, cache per request only (no shared cache across people). A failed read renders the
+  error state with retry, never an empty list.
+- **Sign-in, never a key.** The app is a pod-app site (`create-site --path pod-app`): the person signs in to their pod
+  and the server reads through `@synap-core/sdk/connect` (`createPodAppAuth`); follow the kit's AGENTS.md. Never an app
+  key; the session secret stays server-only, never in client code, never `NEXT_PUBLIC_*`, never logged or committed.
+  Not connected → the kit's "not connected" state. What a pod app can see and do (spaces, roles, pod-wide records,
+  writes): `node_modules/@synap-core/sdk/AGENTS.md`, section "What a pod app can see and do". It wins over anything
+  here. If something the app needs is not supported yet, that is a recorded gap with an owner — never edit
+  `synap-check.mjs` to pass.
+- **Writes are governed.** A write from a pod app is a proposal in a granted space (`proposed` is success: link the
+  review, label it in the UI "Proposed · in your pod", never retry it); a person connection applies directly.
+- **Look.** `design-kit/tokens.css` decisions copied into `app/brand.css` (shadcn token names), fonts self-hosted
+  (`next/font/local` or `@fontsource*`, never Google at build time), sizes = shadcn base-nova plus only the sizes the
+  design decisions added (as cva variants). Private app: `app/robots.ts` disallows all, pages carry `noindex`, and any
+  cookie (e.g. the sidebar's `sidebar_state`) is named on the privacy page.
+
+## 2. Gates (the builder runs them, quotes them, fixes until green)
+
+- `pnpm verify` green (typecheck, lint, arc / extensions / synap / registry checks, build, smoke).
+- `pnpm shots` and READ the PNGs and `.shots/REPORT.md` at 375 / 768 / 1280 (and dark, if designed): zero serious or
+  critical axe issues; compare each page with its board and list every remaining difference.
+- Credential grep: the key's variable name appears only in server files
+  (`grep -rn "<KEY_VAR>" app components lib`).
+- Mutation grep (read-only slices): no write call anywhere
+  (`grep -rnE 'method: ?"(POST|PATCH|PUT|DELETE)"|\.create\(|\.update\(|\.transition\(' app components lib` is empty).
+- Small commits on a branch `s<N>-<slug>`, pushed, a pull request to main. Never push to main, never deploy
+  production; a preview deploy only when `VERCEL_TOKEN` is set (if not, say so and skip).
+
+## 3. Independent verification (the orchestrator, not the builder)
+
+Never accept "done" from the builder's report. On the devbox (heavy gates never on the Mac; take the gate lock):
+check out the PR head, run `pnpm verify` and the two greps yourself, read the screenshots, and quote the outputs.
+Look for green-by-accident: a verify that passed only through a temporary proxy or a cached font, a flag that does not
+exist or is not the pod-app path (`create-site --path pod-app`), ids in the brief that drifted from the pod. Record each trap you find as a lesson.
+
+## 4. Report and stop
+
+Post in the slice's session room: what was built (routes, boards matched), the quoted gates, screenshot findings by
+severity (VERIFIED), what only the person can judge (NEEDS-DOGFOOD), and the gaps still open with owners. After
+**slice 1, STOP**: the person's first look on the preview (or the screenshots) decides the next slice. Later slices
+continue in order unless the person stops them; each ends with the same report.
+
+Done when: the PR is open, every gate is quoted by the orchestrator's own run, the differences from the boards are
+listed, and (after slice 1) the person has been asked for their first look.

package/skills/app-factory-build-slice.catalog.json

@@ -0,0 +1,17 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "skill",
+  "meta": {
+    "slug": "app-factory-build-slice",
+    "name": "App Factory: build a slice",
+    "description": "Build one slice of an app from its approved boards: server-side reads through the person's sign-in, governed writes, the Website Factory gates, an independent re-run of every gate, and a stop for the person's first look after slice 1.",
+    "tags": [
+      "skill",
+      "app-factory",
+      "build",
+      "builder"
+    ],
+    "isPublic": true
+  },
+  "dependencies": []
+}