@synap-core/workspace-templates 0.23.0 → 0.24.0

package/capabilities/unipile-linkedin.capability.json

@@ -14,7 +14,7 @@
   "spec": {
     "key": "unipile-linkedin",
     "name": "Unipile — Messaging & LinkedIn",
-    "description": "Unified messaging + LinkedIn outreach via Unipile API v2 (API-key connector). Stores the Unipile v2 API key in the vault and registers one HTTP tool against the SINGLE global v2 host https://api.unipile.com/v2 (no per-tenant DSN — v2 removed it), authenticating with the X-API-KEY header. Skills: (a) provider-agnostic messaging — list accounts, list conversations, list messages, send into an existing thread, start a chat with one person on any account (unipile_start_chat) (works for LinkedIn/WhatsApp/Telegram/Instagram); (b) LinkedIn-specific — search people (read + persist variants), get a profile, send a connection request (v2 relation-request), start a NEW conversation (cold outreach via the CLASSIC_PRIMARY inbox), list relations + sent invitations, list the company pages an account administers (linkedin_list_company_pages), publish a post now (unipile_publish_post, the publish_post intent, one action per account from unipile_list_accounts). v2 notes baked in: account_id is a PATH segment (/{account_id}/...), send endpoints carry a /send suffix, LinkedIn cold-outreach uses /inboxes/CLASSIC_PRIMARY/chats/send with users_ids, invitations are /users/me/relation-requests, search is split per resource, and list envelopes are { data, total_count, next_cursor }. PRECONDITION: a Unipile v2 account (dashboardv2.unipile.com — v1 keys do NOT authenticate) with at least one connected provider account. Provider-agnostic skills take an explicit accountId (call unipile_list_accounts first). A pod app reaches unipile_send_message, unipile_start_chat, linkedin_send_first_message (send_message; the last one by the person's LinkedIn profile, 1st-degree connections only), linkedin_send_invite (request_connection, by their profile) and unipile_publish_post (publish_post) through their inputMaps: one action per account unipile_list_accounts lists, the recipient resolved by the pod ($to). LinkedIn skills take an accountId too: no skill code carries an install-time value, so the pod can update every install to a new version of this template. Skills call the tool by NAME via callProvider('unipile_linkedin', ...); the dispatcher injects the vaulted X-API-KEY server-side. key/tool name kept as unipile-linkedin/unipile_linkedin for backward compat with existing installs.",
+    "description": "Unified messaging + LinkedIn outreach via Unipile API v2 (API-key connector). Stores the Unipile v2 API key in the vault and registers one HTTP tool against the SINGLE global v2 host https://api.unipile.com/v2 (no per-tenant DSN — v2 removed it), authenticating with the X-API-KEY header. Skills: (a) provider-agnostic messaging — list accounts, list conversations, list messages, send into an existing thread, start a chat with one person on any account (unipile_start_chat) (works for LinkedIn/WhatsApp/Telegram/Instagram); (b) LinkedIn-specific — search people (read + persist variants, paged by cursor), find one known person's profile on a strict name and company match (linkedin_find_profile), get a profile, send a connection request (v2 relation-request), start a NEW conversation (cold outreach via the CLASSIC_PRIMARY inbox), list relations + sent invitations, list the company pages an account administers (linkedin_list_company_pages), publish a post now (unipile_publish_post, the publish_post intent, one action per account from unipile_list_accounts). v2 notes baked in: account_id is a PATH segment (/{account_id}/...), send endpoints carry a /send suffix, LinkedIn cold-outreach uses /inboxes/CLASSIC_PRIMARY/chats/send with users_ids, invitations are /users/me/relation-requests, search is split per resource, and list envelopes are { data, total_count, next_cursor }. PRECONDITION: a Unipile v2 account (dashboardv2.unipile.com — v1 keys do NOT authenticate) with at least one connected provider account. Provider-agnostic skills take an explicit accountId (call unipile_list_accounts first). A pod app reaches unipile_send_message, unipile_start_chat, linkedin_send_first_message (send_message; the last one by the person's LinkedIn profile, 1st-degree connections only), linkedin_send_invite (request_connection, by their profile) and unipile_publish_post (publish_post) through their inputMaps: one action per account unipile_list_accounts lists, the recipient resolved by the pod ($to). LinkedIn skills take an accountId too: no skill code carries an install-time value, so the pod can update every install to a new version of this template. Skills call the tool by NAME via callProvider('unipile_linkedin', ...); the dispatcher injects the vaulted X-API-KEY server-side. key/tool name kept as unipile-linkedin/unipile_linkedin for backward compat with existing installs.",
     "params": [
       {
         "name": "unipileApiKey",
@@ -224,7 +224,7 @@
         "intent": "capture_into_pod",
         "kind": "code",
         "scope": "pod",
-        "description": "Searches LinkedIn people via Unipile and PROPOSES each match as a person entity (proposal-gated). Use linkedin_search_people to read without persisting. Args: { keywords: string, accountId: string (from unipile_list_accounts), limit?: number, profileSlug?: string (default person) }.",
+        "description": "Searches LinkedIn people via Unipile and PROPOSES each match as a person entity (proposal-gated). Use linkedin_search_people to read without persisting. Args: { keywords: string, accountId: string (from unipile_list_accounts), limit?: number, profileSlug?: string (default person), cursor?: string (the cursor a previous page returned) }. Returns { proposed, keywords, cursor } (cursor null on the last page).",
         "requires": [
           "unipile_linkedin"
         ],
@@ -234,9 +234,10 @@
           "keywords": "string",
           "accountId": "string",
           "limit": "number?",
-          "profileSlug": "string?"
+          "profileSlug": "string?",
+          "cursor": "string?"
         },
-        "code": "// LinkedIn people search via Unipile, proposed as person entities. See\n// linkedin_search_people for the v2 endpoint shape; this variant PERSISTS each\n// match (so its name carries no read token -> classified `write` -> proposed).\nconst accountId = String(args?.accountId ?? '').trim();\nconst keywords = String(args?.keywords ?? '').trim();\nconst limit = Number(args?.limit ?? 10);\nif (!accountId) throw new Error('linkedin_capture_profiles: accountId is required — call unipile_list_accounts first to find yours, then pass it as accountId.');\nif (!keywords) throw new Error('linkedin_capture_profiles: keywords is required');\n\nconst qs = new URLSearchParams({ offset: '0', limit: String(limit) });\nconst res = await callProvider('unipile_linkedin', 'POST', `/${encodeURIComponent(accountId)}/linkedin/search/people?${qs.toString()}`, { keywords });\nconst payload = res?.body ?? res;\nconst items = Array.isArray(payload?.data) ? payload.data : (Array.isArray(payload) ? payload : []);\n\nconst profileSlug = String(args?.profileSlug ?? '').trim() || 'person';\nlet proposed = 0;\nfor (const p of items.slice(0, limit)) {\n  // v2 PeopleSearchResult: display_name, id (provider-native), public_identifier,\n  // headline, location, profile_url.\n  const name = String(p?.display_name ?? [p?.first_name, p?.last_name].filter(Boolean).join(' ') ?? 'LinkedIn profile').trim() || 'LinkedIn profile';\n  await propose.entity({\n    profileSlug,\n    title: name,\n    properties: {\n      headline: p?.headline ?? null,\n      location: p?.location ?? null,\n      linkedinProviderId: p?.id ?? null,\n      publicIdentifier: p?.public_identifier ?? null,\n      profileUrl: p?.profile_url ?? null,\n      provenance: 'connector', provider: 'unipile'\n    },\n    reasoning: `LinkedIn profile matched search \"${keywords}\" via Unipile.`\n  });\n  proposed += 1;\n}\nreturn { proposed, keywords };\n"
+        "code": "// LinkedIn people search via Unipile, proposed as person entities. See\n// linkedin_search_people for the v2 endpoint shape; this variant PERSISTS each\n// match (so its name carries no read token -> classified `write` -> proposed).\n// Pages by `cursor` like linkedin_search_people: `limit` caps one page.\nconst accountId = String(args?.accountId ?? '').trim();\nconst keywords = String(args?.keywords ?? '').trim();\nconst limit = Number(args?.limit ?? 10);\nconst cursor = String(args?.cursor ?? '').trim();\nif (!accountId) throw new Error('linkedin_capture_profiles: accountId is required — call unipile_list_accounts first to find yours, then pass it as accountId.');\nif (!keywords) throw new Error('linkedin_capture_profiles: keywords is required');\n\nconst qs = cursor ? `?${new URLSearchParams({ cursor }).toString()}` : '';\nconst res = await callProvider('unipile_linkedin', 'POST', `/${encodeURIComponent(accountId)}/linkedin/search/people${qs}`, { keywords });\nconst payload = res?.body ?? res;\nconst items = Array.isArray(payload?.data) ? payload.data : (Array.isArray(payload) ? payload : []);\n\nconst profileSlug = String(args?.profileSlug ?? '').trim() || 'person';\nlet proposed = 0;\nfor (const p of items.slice(0, limit)) {\n  // v2 PeopleSearchResult: display_name, id (provider-native), public_identifier,\n  // headline, location, profile_url.\n  const name = String(p?.display_name ?? [p?.first_name, p?.last_name].filter(Boolean).join(' ') ?? 'LinkedIn profile').trim() || 'LinkedIn profile';\n  await propose.entity({\n    profileSlug,\n    title: name,\n    properties: {\n      headline: p?.headline ?? null,\n      location: p?.location ?? null,\n      linkedinProviderId: p?.id ?? null,\n      publicIdentifier: p?.public_identifier ?? null,\n      profileUrl: p?.profile_url ?? null,\n      provenance: 'connector', provider: 'unipile'\n    },\n    reasoning: `LinkedIn profile matched search \"${keywords}\" via Unipile.`\n  });\n  proposed += 1;\n}\nconst next = typeof payload?.next_cursor === 'string' && payload.next_cursor ? payload.next_cursor : null;\nreturn { proposed, keywords, cursor: next };\n"
       },
       {
         "name": "linkedin_send_invite",
@@ -274,7 +275,7 @@
         "intent": "find_people",
         "kind": "code",
         "scope": "pod",
-        "description": "Searches LinkedIn people via Unipile and RETURNS the matches inline. Pure read -> runs INSTANTLY (no approval). Use to qualify/enrich a lead in-flow; use linkedin_capture_profiles to persist. Args: { keywords: string, accountId: string (from unipile_list_accounts), limit?: number }.",
+        "description": "Searches LinkedIn people via Unipile and RETURNS the matches inline. Pure read -> runs INSTANTLY (no approval). Use to qualify/enrich a lead in-flow; use linkedin_capture_profiles to persist, and linkedin_find_profile to find ONE known person's profile. Args: { keywords: string, accountId: string (from unipile_list_accounts), limit?: number, cursor?: string (the cursor a previous page returned) }. Returns { count, keywords, results, cursor } (cursor null on the last page).",
         "requires": [
           "unipile_linkedin"
         ],
@@ -283,9 +284,31 @@
         "parameters": {
           "keywords": "string",
           "accountId": "string",
-          "limit": "number?"
+          "limit": "number?",
+          "cursor": "string?"
+        },
+        "code": "// Pure-read LinkedIn people search — returns raw v2 rows, writes NOTHING (keeps\n// it classified `read` -> governance `auto`, so an agent enriches a lead inline).\n// v2: search is split per resource (/linkedin/search/people); account_id is a\n// path segment; filters go in the JSON body; pages by `cursor` (the query\n// param, from the reply's next_cursor): the endpoint takes no offset or limit,\n// so `limit` caps the rows returned from one page.\nconst accountId = String(args?.accountId ?? '').trim();\nconst keywords = String(args?.keywords ?? '').trim();\nconst limit = Number(args?.limit ?? 10);\nconst cursor = String(args?.cursor ?? '').trim();\nif (!accountId) throw new Error('linkedin_search_people: accountId is required — call unipile_list_accounts first to find yours.');\nif (!keywords) throw new Error('linkedin_search_people: keywords is required');\n\nconst qs = cursor ? `?${new URLSearchParams({ cursor }).toString()}` : '';\nconst res = await callProvider('unipile_linkedin', 'POST', `/${encodeURIComponent(accountId)}/linkedin/search/people${qs}`, { keywords });\nconst payload = res?.body ?? res;\n// v2 envelope: { data: [...], total_count, next_cursor }.\nconst items = Array.isArray(payload?.data) ? payload.data : (Array.isArray(payload) ? payload : []);\nconst results = items.slice(0, limit);\nconst next = typeof payload?.next_cursor === 'string' && payload.next_cursor ? payload.next_cursor : null;\nreturn { count: results.length, keywords, results, cursor: next };\n"
+      },
+      {
+        "name": "linkedin_find_profile",
+        "intent": "enrich_entity",
+        "kind": "code",
+        "scope": "pod",
+        "description": "Finds ONE person's LinkedIn profile by their full name and company, on a STRICT match only: the result's name equals the full name (case- and accent-insensitive), the company is in its headline, and exactly one result is both. Pure read -> runs instantly; it writes nothing. A match returns { matched: true, profile, properties: { linkedinUrl, linkedinProviderId } }: propose those properties on the person for a person to approve, never write them directly. No match, several, or more results than it read returns { matched: false, reason: none | several | more_results, candidates } with up to 3 candidates for a person to choose from. Args: { fullName: string, company: string, accountId: string (from unipile_list_accounts) }.",
+        "requires": [
+          "unipile_linkedin"
+        ],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "metadata": {
+          "verbType": "read"
+        },
+        "parameters": {
+          "fullName": "string",
+          "company": "string",
+          "accountId": "string"
         },
-        "code": "// Pure-read LinkedIn people search — returns raw v2 rows, writes NOTHING (keeps\n// it classified `read` -> governance `auto`, so an agent enriches a lead inline).\n// v2: search is split per resource (/linkedin/search/people); account_id is a\n// path segment; offset+limit are query params; filters go in the JSON body.\nconst accountId = String(args?.accountId ?? '').trim();\nconst keywords = String(args?.keywords ?? '').trim();\nconst limit = Number(args?.limit ?? 10);\nif (!accountId) throw new Error('linkedin_search_people: accountId is required — call unipile_list_accounts first to find yours.');\nif (!keywords) throw new Error('linkedin_search_people: keywords is required');\n\nconst qs = new URLSearchParams({ offset: '0', limit: String(limit) });\nconst res = await callProvider('unipile_linkedin', 'POST', `/${encodeURIComponent(accountId)}/linkedin/search/people?${qs.toString()}`, { keywords });\nconst payload = res?.body ?? res;\n// v2 envelope: { data: [...], total_count, next_cursor }.\nconst items = Array.isArray(payload?.data) ? payload.data : (Array.isArray(payload) ? payload : []);\nconst results = items.slice(0, limit);\nreturn { count: results.length, keywords, results };\n"
+        "code": "// Find ONE person's LinkedIn profile by their full name and company: a STRICT\n// match or none (CRM wave 2, S4b). A pure read: it writes nothing, so it runs at\n// once. Writing the match onto the person (linkedinUrl, linkedinProviderId) is\n// the caller's write, proposed for a person to approve (founder decision 7).\n// STRICT: the result's name equals the full name (case- and accent-insensitive,\n// spaces collapsed), the company is in its headline as whole words (a v2\n// PeopleSearchResult has no company field), and exactly one result is both.\n// None, several, or a third page left unread (so one more could exist): no\n// match, with up to 3 candidates (the closest first) for a person to choose.\n// v2: POST /{account_id}/linkedin/search/people, paged by `cursor` (the reply's\n// next_cursor); the company also narrows the search (advanced_keywords).\nconst accountId = String(args?.accountId ?? '').trim();\nconst fullName = String(args?.fullName ?? '').trim();\nconst company = String(args?.company ?? '').trim();\nif (!accountId) throw new Error('linkedin_find_profile: accountId is required — call unipile_list_accounts first to find yours.');\nif (!fullName) throw new Error('linkedin_find_profile: fullName (the person\\'s first and last name) is required');\nif (!company) throw new Error('linkedin_find_profile: company is required: without it a name alone is never a strict match');\n\nconst fold = (s) => String(s ?? '').normalize('NFD').replace(/\\p{M}+/gu, '').toLowerCase();\nconst nameKey = (s) => fold(s).replace(/\\s+/g, ' ').trim();\nconst words = (s) => fold(s).split(/[^\\p{L}\\p{N}]+/u).filter(Boolean);\nconst hasWords = (text, part) => {\n  if (!part.length) return false;\n  for (let i = 0; i + part.length <= text.length; i++) {\n    if (part.every((w, j) => text[i + j] === w)) return true;\n  }\n  return false;\n};\nconst wanted = nameKey(fullName);\nconst companyWords = words(company);\nconst nameMatches = (p) => nameKey(p?.display_name) === wanted;\nconst companyInHeadline = (p) => hasWords(words(p?.headline), companyWords);\n\nconst MAX_PAGES = 2;\nconst account = encodeURIComponent(accountId);\nconst body = { keywords: fullName, advanced_keywords: { company } };\nconst byId = new Map();\nlet cursor = null;\nlet pages = 0;\ndo {\n  const qs = cursor ? `?${new URLSearchParams({ cursor }).toString()}` : '';\n  const res = await callProvider('unipile_linkedin', 'POST', `/${account}/linkedin/search/people${qs}`, body);\n  if (res?.proposed === true) {\n    return { matched: false, reason: 'proposed', proposed: true, proposalId: res?.proposalId ?? null, candidates: [] };\n  }\n  if (res?.status && (res.status < 200 || res.status >= 300)) throw new Error(`linkedin_find_profile: the LinkedIn search failed (status ${res.status}).`);\n  const payload = res?.body ?? res;\n  const items = Array.isArray(payload?.data) ? payload.data : [];\n  for (const p of items) {\n    const key = String(p?.id ?? p?.public_identifier ?? `row-${byId.size}`);\n    if (!byId.has(key)) byId.set(key, p);\n  }\n  pages += 1;\n  const next = typeof payload?.next_cursor === 'string' && payload.next_cursor ? payload.next_cursor : null;\n  cursor = next && next !== cursor ? next : null;\n} while (cursor && pages < MAX_PAGES);\nconst moreUnread = Boolean(cursor);\n\nconst view = (p) => {\n  const publicIdentifier = p?.public_identifier ?? null;\n  return {\n    name: String(p?.display_name ?? '').trim() || null,\n    headline: p?.headline ?? null,\n    location: p?.location ?? null,\n    providerId: p?.id ?? null,\n    publicIdentifier,\n    profileUrl: p?.profile_url ?? (publicIdentifier ? `https://www.linkedin.com/in/${publicIdentifier}` : null),\n    networkDistance: p?.network_distance ?? null,\n    nameMatches: nameMatches(p),\n    companyInHeadline: companyInHeadline(p),\n  };\n};\nconst rows = [...byId.values()].map(view);\nconst strict = rows.filter((r) => r.nameMatches && r.companyInHeadline);\nconst searched = { fullName, company, results: rows.length, pages, moreUnread };\n\nif (strict.length === 1 && !moreUnread) {\n  const profile = strict[0];\n  return {\n    matched: true,\n    profile,\n    properties: { linkedinUrl: profile.profileUrl, linkedinProviderId: profile.providerId },\n    candidates: [],\n    searched,\n  };\n}\nconst rank = (r) => (r.nameMatches ? 2 : 0) + (r.companyInHeadline ? 1 : 0);\nconst candidates = rows\n  .map((r, i) => ({ r, i }))\n  .sort((a, b) => rank(b.r) - rank(a.r) || a.i - b.i)\n  .slice(0, 3)\n  .map(({ r }) => r);\nconst reason = strict.length > 1 ? 'several' : strict.length === 1 ? 'more_results' : 'none';\nreturn { matched: false, reason, candidates, searched };\n"
       },
       {
         "name": "linkedin_get_profile",

package/dist/{define-CPS0n8BV.d.ts → define-DqoItRiR.d.ts}

@@ -215,6 +215,25 @@ interface TemplateView {
     description?: string;
     groupBy?: string;
 }
+/**
+ * A document a template carries. Mirrors `WorkspaceDocumentInput`
+ * (synap-backend `@synap-core/types/workspaces/definition`) VERBATIM; the pod
+ * installs it through `utils/template-documents.ts` (the one create door,
+ * system-authored, owned by the installer, identified in the space by `slug`).
+ */
+interface TemplateDocument {
+    /** Stable id inside the template, kebab-case. Never rename it: the space knows the document by it. */
+    slug: string;
+    /** The document's name (its one title). */
+    title: string;
+    /** Markdown body; may carry `synap-cell` / `synap-section` embeds. */
+    content: string;
+    /**
+     * What its embeds read (a living document's scope): `space` = the space it
+     * is installed in, `pod` = the whole pod. Absent = no scope.
+     */
+    scope?: "space" | "pod";
+}
 interface TemplateEntityLink {
     sourceProfileSlug: string;
     targetProfileSlug: string;
@@ -297,10 +316,12 @@ interface TemplateSidebarSurface {
     meta?: Record<string, unknown>;
 }
 interface TemplateSidebarItem {
-    kind: "app" | "view" | "profile" | "external" | "cell";
+    kind: "app" | "view" | "profile" | "external" | "cell" | "document";
     appId?: string;
     viewName?: string;
     viewId?: string;
+    /** kind "document": the `documents[].slug` it opens (the pod stores its id beside it). */
+    documentSlug?: string;
     profileSlug?: string;
     url?: string;
     cellKey?: string;
@@ -887,6 +908,14 @@ interface WorkspaceYaml {
     profiles: TemplateProfile[];
     /** Curated views — only the ones that add value */
     views?: TemplateView[];
+    /**
+     * Documents the space carries (plan 9ad4b2fc §5 lane 12, P4: a pinned set of
+     * documents hosts a space package). Installed by the pod with the views:
+     * created once per `slug` in the space, never rewritten by an update. A
+     * sidebar item `{kind: "document", documentSlug}` opens one. See
+     * {@link TemplateDocument}.
+     */
+    documents?: TemplateDocument[];
     /** Schema-level links between entity types */
     entityLinks?: TemplateEntityLink[];
     /**
@@ -1107,6 +1136,8 @@ interface WorkspaceDefinitionInput {
     proposalId?: string;
     profiles: WorkspaceYaml['profiles'];
     views: NonNullable<WorkspaceYaml['views']>;
+    /** Template documents — created by the pod with the views (`utils/template-documents.ts`). */
+    documents?: WorkspaceYaml['documents'];
     entityLinks: NonNullable<WorkspaceYaml['entityLinks']>;
     seedEntities: NonNullable<WorkspaceYaml['seedEntities']>;
     suggestedRelations?: WorkspaceYaml['suggestedRelations'];
@@ -1263,6 +1294,14 @@ interface PackageDefinitionOutput {
     defaultSources?: WorkspaceYaml['workspace']['defaultSources'];
     profiles: WorkspaceYaml['profiles'];
     views: NonNullable<WorkspaceYaml['views']>;
+    /**
+     * Template documents — created by the pod with the views
+     * (`utils/template-documents.ts`); the Hub `PackageApplySchema` slots them.
+     * The CP publish door does NOT yet (it strips the field and refuses a
+     * `kind: "document"` sidebar item), so no official template may declare
+     * documents until it does.
+     */
+    documents?: WorkspaceYaml['documents'];
     suggestedEntities: NonNullable<WorkspaceYaml['seedEntities']>;
     suggestedRelations?: WorkspaceYaml['suggestedRelations'];
     displayTemplates?: WorkspaceYaml['displayTemplates'];

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { W as WorkspaceYaml, T as TemplateDependency, a as TemplateLifecycleOption, b as TemplateLifecycleOptionWaits } from './define-CPS0n8BV.js';
-export { B as BentoViewBlockWire, c as BentoWidgetBlockWire, d as BuiltSpacePackage, e as BuiltSpacePackageCell, I as INTENT_LABEL_MAX, P as PACKAGE_DEPENDENCY_KINDS, f as PackageAutomationWire, g as PackageDefinitionOutput, h as PackageDependencyKind, S as START_EXAMPLE_RANGE, i as START_STARTERS_RANGE, j as START_VIEWS_MAX, k as SpacePackageCellWire, l as SplitBentoBlocks, m as TemplateActionPlacement, n as TemplateAppKind, o as TemplateAppRef, p as TemplateAutomation, q as TemplateBentoBlock, r as TemplateDefaultSource, s as TemplateDisplayTemplate, t as TemplateEntityLink, u as TemplateExtendsRef, v as TemplateIntegration, w as TemplateIntent, x as TemplateLayoutConfig, y as TemplateMeta, z as TemplateOnboarding, A as TemplateOnboardingCollectTarget, C as TemplatePlaybook, D as TemplatePlaybookParam, E as TemplatePrimarySurface, F as TemplateProfile, G as TemplateProfileEntityBentoTemplates, H as TemplateProperty, J as TemplateSeedEntity, K as TemplateSidebarItem, L as TemplateSidebarSurface, M as TemplateSourceRole, N as TemplateSpacePackage, O as TemplateSpacePackageCell, Q as TemplateStart, R as TemplateSuggestedRelation, U as TemplateView, V as ToDefinitionResult, X as WorkspaceDefinitionInput, Y as WorkspaceJsonValue, Z as WorkspacePrimarySurface, _ as WorkspacePrimarySurfaceViewReference, $ as normalizeTemplateLayout, a0 as spacePackageCells, a1 as splitBentoBlocks, a2 as toAutomationWire, a3 as toPackageDefinition, a4 as toWorkspaceDefinition } from './define-CPS0n8BV.js';
+import { W as WorkspaceYaml, T as TemplateDependency, a as TemplateLifecycleOption, b as TemplateLifecycleOptionWaits } from './define-DqoItRiR.js';
+export { B as BentoViewBlockWire, c as BentoWidgetBlockWire, d as BuiltSpacePackage, e as BuiltSpacePackageCell, I as INTENT_LABEL_MAX, P as PACKAGE_DEPENDENCY_KINDS, f as PackageAutomationWire, g as PackageDefinitionOutput, h as PackageDependencyKind, S as START_EXAMPLE_RANGE, i as START_STARTERS_RANGE, j as START_VIEWS_MAX, k as SpacePackageCellWire, l as SplitBentoBlocks, m as TemplateActionPlacement, n as TemplateAppKind, o as TemplateAppRef, p as TemplateAutomation, q as TemplateBentoBlock, r as TemplateDefaultSource, s as TemplateDisplayTemplate, t as TemplateEntityLink, u as TemplateExtendsRef, v as TemplateIntegration, w as TemplateIntent, x as TemplateLayoutConfig, y as TemplateMeta, z as TemplateOnboarding, A as TemplateOnboardingCollectTarget, C as TemplatePlaybook, D as TemplatePlaybookParam, E as TemplatePrimarySurface, F as TemplateProfile, G as TemplateProfileEntityBentoTemplates, H as TemplateProperty, J as TemplateSeedEntity, K as TemplateSidebarItem, L as TemplateSidebarSurface, M as TemplateSourceRole, N as TemplateSpacePackage, O as TemplateSpacePackageCell, Q as TemplateStart, R as TemplateSuggestedRelation, U as TemplateView, V as ToDefinitionResult, X as WorkspaceDefinitionInput, Y as WorkspaceJsonValue, Z as WorkspacePrimarySurface, _ as WorkspacePrimarySurfaceViewReference, $ as normalizeTemplateLayout, a0 as spacePackageCells, a1 as splitBentoBlocks, a2 as toAutomationWire, a3 as toPackageDefinition, a4 as toWorkspaceDefinition } from './define-DqoItRiR.js';
 import '@synap-core/types/presentation';
 import '@synap-core/types/space-brief';
 import '@synap-core/types/capability-intents';

package/dist/index.js

@@ -11144,6 +11144,31 @@ var DATA = {
         "executor": "is-agent",
         "status": "active"
       },
+      {
+        "name": "Write the caption",
+        "description": "Draft the caption of one post from its brief and its script, as a draft in its script document that the person edits and saves.",
+        "goalTemplate": `Draft the caption of this post ({post}). Read the post: its hook (post-hook), its call to action (post-cta), its pillar, its journey stage, its platform (post-platform) and its format. Read its script, the post's own document: its slides (the S1, S2 lines or the slide table) and any caption already written under "## Caption". Write ONE caption in the brand voice (the pod's brand kit) that says what the slides leave out: a first line that stands on its own before the platform cuts it (Instagram shows about 125 characters before "more", LinkedIn about 210 before "see more"), then two or three short lines, and the call to action last. No hashtag wall, no emoji run, no claim the script does not make, and no line that starts with "##". Put it in the script document as its "## Caption draft" section: replace that section if it is there, else add it at the end, and change no other line (synap_update_document with the revision you read). Never write or change the "## Caption" section on your own: it is the person's. Then ask the person to approve your draft: ONE confirm ask on this session (owner the person), its prompt the caption itself, "Use this caption" recommended. On yes, put the draft in the "## Caption" section (replace its words, or add it) and remove the "## Caption draft" section, nothing else. On no, leave the draft where it is (they may edit it and save it on the post's page in Content Studio, which also makes it the caption). Never move the post's status. Close this session once the person answered.`,
+        "subjectProfile": {
+          "profileSlug": "post"
+        },
+        "expectedOutputs": [
+          {
+            "kind": "document",
+            "label": "Caption draft",
+            "relationToSubject": "none"
+          }
+        ],
+        "params": [
+          {
+            "name": "post",
+            "type": "entity",
+            "label": "Post",
+            "required": true
+          }
+        ],
+        "executor": "is-agent",
+        "status": "active"
+      },
       {
         "name": "Repurpose",
         "description": "Turn a published post into new posts for other formats and platforms, each linked to the original.",
@@ -13599,7 +13624,7 @@ var DATA = {
       {
         "name": "Draft a first message",
         "description": "Draft one personal first message for a lead, citing its buying signal or a past exchange, in the person's language, as a proposed message in their channel for a person to approve; the agent never sends.",
-        "goalTemplate": `Draft the first message to the lead {lead} on {channel}. READ: the lead's score fields (icpScore, buyingSignal, buyingSignalSource, qualificationNotes) as they are, never rescoring them; its channels, past messages and notes in the pod; and the outreach campaign given ({campaign}), if any: its value proposition and call to action are the angle. WHO: a person lead is written to directly; for a company lead, write to the person who decides there (from the pod, else its public decider), and when no decider is known ask the person who to write to. DRAFT: one first message on channel {channel}, in the campaign's angle when one is given. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. Its message is personal: it cites the buying signal and what it showed, or a past exchange, never a generic template; short; in the person's language, French by default, and in French it says vous. It offers one useful next step, never pressure. Draft one message only: a person reviews it in the channel, edits it if needed and approves it. NEXT ACTION: set the lead's nextAction to "Send the first message to <name> on LinkedIn" ("Send the first message to <name> by email" on email), naming the person written to, and its nextActionAt to today. Never move the lead's stage while drafting. SENT: once the message is sent, follow the cadence, so "Follow up on leads in outreach" drafts the next one. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step.`,
+        "goalTemplate": `Draft the first message to the lead {lead} on {channel}. READ: the lead's score fields (icpScore, buyingSignal, buyingSignalSource, qualificationNotes) as they are, never rescoring them; its channels, past messages and notes in the pod; and the outreach campaign given ({campaign}), if any: its value proposition and call to action are the angle. WHO: a person lead is written to directly; for a company lead, write to the person who decides there (from the pod, else its public decider), and when no decider is known ask the person who to write to. DRAFT: one first message on channel {channel}, in the campaign's angle when one is given. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. A LinkedIn message is drafted whatever their reach: the pod holds a draft to someone who is not a connection yet, shows it with the next step and lets it go out once they connect, so never hold a draft back for want of a connection. Draft it, then, in this order: (1) a person with no linkedinUrl: find their profile with linkedin_find_profile (their full name and company); on a match, propose its linkedinUrl and linkedinProviderId on the person for a person to approve; on none or several, ask the person to choose among its candidates (the process "Find their LinkedIn" does this for one lead). (2) Read their linkedinConnection, which only the pod writes (never set it or linkedinInvitedAt): connected, nothing more; none or not set, ask to connect with linkedin_send_invite (it refuses someone already connected or already invited: then nothing more); pending, the draft waits for them; ignored, draft by email instead when they have an email address. While the draft waits for them to connect, set the lead's nextAction to "Wait for <name> to accept the LinkedIn request" and its nextActionAt 7 days later. An email message needs none of this. Its message is personal: it cites the buying signal and what it showed, or a past exchange, never a generic template; short; in the person's language, French by default, and in French it says vous. It offers one useful next step, never pressure. Draft one message only: a person reviews it in the channel, edits it if needed and approves it. NEXT ACTION: set the lead's nextAction to "Send the first message to <name> on LinkedIn" ("Send the first message to <name> by email" on email), naming the person written to, and its nextActionAt to today. Never move the lead's stage while drafting. SENT: once the message is sent, follow the cadence, so "Follow up on leads in outreach" drafts the next one. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step.`,
         "subjectProfile": {
           "profileSlug": "lead"
         },
@@ -13653,7 +13678,7 @@ var DATA = {
             "criteria": [
               {
                 "key": "first-message-one-draft",
-                "statement": "One proposed message, filed through messaging.send to the person written to (for a company, its decider), waits for review in that person's channel, holds the message text, and follows the campaign's angle when one was given.",
+                "statement": "One proposed message, filed through messaging.send to the person written to (for a company, its decider), waits for review in that person's channel, holds the message text, and follows the campaign's angle when one was given, whatever the person's LinkedIn reach; on LinkedIn to someone not yet a connection, the pod holds it, and their profile is found and the connection asked for or awaited, in the DRAFT RULES order.",
                 "check": {
                   "kind": "judge"
                 }
@@ -13702,10 +13727,73 @@ var DATA = {
           }
         ]
       },
+      {
+        "name": "Find their LinkedIn",
+        "description": "Find one lead's LinkedIn profile by their full name and company and propose its URL and member id on the person for a person to approve, or offer up to 3 candidates to choose from; nothing is sent.",
+        "goalTemplate": "Find the LinkedIn profile of the lead {lead}. WHO: a person lead is looked up themselves; for a company lead, the person who decides there, from the pod; when no decider is known, ask the person who it is. When that person already has a linkedinUrl, say so and stop. FIND: run linkedin_find_profile with their full name, their company and the LinkedIn account unipile_list_accounts lists (when several are connected, ask the person which one reads). On a match, propose its linkedinUrl and linkedinProviderId on the person through the entity door, for a person to approve; never write them directly, and never set linkedinConnection or linkedinInvitedAt, which only the pod writes. On none, several or more results than it read, ask the person to choose among its candidates (at most 3, each with its name, headline and profile URL) or to give the URL themselves, then propose the one chosen the same way. Never send a message or a connection request, never draft one, and never move the lead's stage.",
+        "subjectProfile": {
+          "profileSlug": "lead"
+        },
+        "activators": [
+          {
+            "on": "manual",
+            "mode": "propose"
+          }
+        ],
+        "params": [
+          {
+            "name": "lead",
+            "type": "entity",
+            "label": "Lead",
+            "required": true
+          }
+        ],
+        "executor": "is-agent",
+        "status": "active",
+        "requiredIntents": [
+          "enrich_entity"
+        ],
+        "stages": [
+          {
+            "key": "find",
+            "name": "Find the profile",
+            "category": "started",
+            "goal": "Run linkedin_find_profile for the lead (a company lead's decider) with their full name and company; on a match propose linkedinUrl and linkedinProviderId on the person, otherwise ask the person to choose among up to 3 candidates or give the URL.",
+            "criteria": [
+              {
+                "key": "find-linkedin-proposed",
+                "statement": "The person's linkedinUrl and linkedinProviderId are proposed on them for a person to approve (a strict match, or the candidate the person chose), or the person was asked to choose among at most 3 candidates; nothing was written directly.",
+                "check": {
+                  "kind": "judge"
+                }
+              },
+              {
+                "key": "find-linkedin-reader-only",
+                "statement": "No message or connection request was sent or drafted, linkedinConnection and linkedinInvitedAt were not set, and the lead's stage was not moved.",
+                "check": {
+                  "kind": "judge"
+                }
+              }
+            ]
+          },
+          {
+            "key": "confirm",
+            "name": "Person confirms",
+            "category": "completed",
+            "goal": "The person approves the proposed profile, or picks a candidate or gives the URL, and the pod stores linkedinUrl and linkedinProviderId on the person; the lead's next step is then to ask to connect.",
+            "gate": {
+              "kind": "human"
+            },
+            "onFail": {
+              "toStage": "find"
+            }
+          }
+        ]
+      },
       {
         "name": "Follow up on leads in outreach",
         "description": "Each weekday, read the channels of the leads in outreach; summarise a reply and propose the next step, or, when the follow-up is due with no reply, draft the next message in the angle of its outreach campaign as a proposed message for a person to approve; the agent never sends.",
-        "goalTemplate": `Follow up on the leads in outreach. For each, read its channels (synap_get_channel, mode person: for a company lead, the channels of the person who decides there) and its notes. A REPLY is an inbound message after our last outbound one in a channel. With a reply, draft nothing: summarise it for a person; when they show interest, propose the next step (prepare the free estimate, "Prepare a pre-sale estimate", or book a meeting) and propose moving the lead to engaged; when they decline, propose nurturing or disqualified with their reason (in disqualificationReason). Unless you propose dropping them, write the next step on the lead as nextAction, one imperative line, and nextActionAt, the date they named or today. Never open a deal and never answer the reply yourself; a person does. With no reply, and only when the lead's next action date is today or past and no proposed message to it is still waiting, draft the next message, to the lead (for a company, the person who decides there) and in the angle of the lead's outreach campaign: follow its value proposition and call to action, short and in the lead's language, offering the next useful step, never pressure. For a lead with no campaign, ask the person which one. Draft at most two follow-ups per lead: a lead already sent two follow-ups gets no draft, never a third follow-up; when its last date passes in silence, propose moving it to nurturing through the status door, with its expected status. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. For each draft, set the lead's \`nextAction\` to send it (e.g. "Send the drafted message to Ana on LinkedIn") and \`nextActionAt\` to today. The person reviews each proposed message in its channel, edits it if needed and approves it; the agent never sends. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step.`,
+        "goalTemplate": `Follow up on the leads in outreach. For each, read its channels (synap_get_channel, mode person: for a company lead, the channels of the person who decides there) and its notes. A REPLY is an inbound message after our last outbound one in a channel. With a reply, draft nothing: summarise it for a person; when they show interest, propose the next step (prepare the free estimate, "Prepare a pre-sale estimate", or book a meeting) and propose moving the lead to engaged; when they decline, propose nurturing or disqualified with their reason (in disqualificationReason). Unless you propose dropping them, write the next step on the lead as nextAction, one imperative line, and nextActionAt, the date they named or today. Never open a deal and never answer the reply yourself; a person does. With no reply, and only when the lead's next action date is today or past and no proposed message to it is still waiting, draft the next message, to the lead (for a company, the person who decides there) and in the angle of the lead's outreach campaign: follow its value proposition and call to action, short and in the lead's language, offering the next useful step, never pressure. For a lead with no campaign, ask the person which one. Draft at most two follow-ups per lead: a lead already sent two follow-ups gets no draft, never a third follow-up; when its last date passes in silence, propose moving it to nurturing through the status door, with its expected status. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. A LinkedIn message is drafted whatever their reach: the pod holds a draft to someone who is not a connection yet, shows it with the next step and lets it go out once they connect, so never hold a draft back for want of a connection. Draft it, then, in this order: (1) a person with no linkedinUrl: find their profile with linkedin_find_profile (their full name and company); on a match, propose its linkedinUrl and linkedinProviderId on the person for a person to approve; on none or several, ask the person to choose among its candidates (the process "Find their LinkedIn" does this for one lead). (2) Read their linkedinConnection, which only the pod writes (never set it or linkedinInvitedAt): connected, nothing more; none or not set, ask to connect with linkedin_send_invite (it refuses someone already connected or already invited: then nothing more); pending, the draft waits for them; ignored, draft by email instead when they have an email address. While the draft waits for them to connect, set the lead's nextAction to "Wait for <name> to accept the LinkedIn request" and its nextActionAt 7 days later. An email message needs none of this. For each draft, set the lead's \`nextAction\` to send it (e.g. "Send the drafted message to Ana on LinkedIn") and \`nextActionAt\` to today. The person reviews each proposed message in its channel, edits it if needed and approves it; the agent never sends. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step.`,
         "subjectProfile": {
           "profileSlug": "lead",
           "statusProperty": "leadStage"
@@ -13792,7 +13880,7 @@ var DATA = {
       {
         "name": "Personalized Outreach",
         "description": "Run one outreach campaign \u2014 write the angle and its offer, pick the people, draft one personal first message each as a proposed message in their channel; a person approves the list, then approves each message, which the pod sends.",
-        "goalTemplate": `Run this outreach campaign ({campaign}) on {channel}; each stage moves its status. If its type is not outreach, stop and say so. PREPARE: write the target audience, the value proposition and the call to action. Pick the people to reach from the pod (and public sources when the pod has too few), resolving each one before creating anything, link each as a member of the campaign with the lead role (lead source cold-outreach when it has none), and for each draft one first message to that person in this campaign's angle, specific to them \u2014 their company, role and any past message \u2014 never a generic template. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. START: a person approves the audience, the offer and the list, then reviews each proposed message in its channel and approves it; nothing goes out before they approve it, and the agent never sends. Once a message is sent, follow the cadence, so "Follow up on leads in outreach" drafts the next one. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step. FINISH: when every person written to has replied or their follow-ups ended in silence, record in the campaign notes how many messages were sent (the outbound messages in their channels), how many got a reply and how many led to a booked meeting. Pausing or cancelling is a person's call.`,
+        "goalTemplate": `Run this outreach campaign ({campaign}) on {channel}; each stage moves its status. If its type is not outreach, stop and say so. PREPARE: write the target audience, the value proposition and the call to action. Pick the people to reach from the pod (and public sources when the pod has too few), resolving each one before creating anything, link each as a member of the campaign with the lead role (lead source cold-outreach when it has none), and for each draft one first message to that person in this campaign's angle, specific to them \u2014 their company, role and any past message \u2014 never a generic template. DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send. A LinkedIn message is drafted whatever their reach: the pod holds a draft to someone who is not a connection yet, shows it with the next step and lets it go out once they connect, so never hold a draft back for want of a connection. Draft it, then, in this order: (1) a person with no linkedinUrl: find their profile with linkedin_find_profile (their full name and company); on a match, propose its linkedinUrl and linkedinProviderId on the person for a person to approve; on none or several, ask the person to choose among its candidates (the process "Find their LinkedIn" does this for one lead). (2) Read their linkedinConnection, which only the pod writes (never set it or linkedinInvitedAt): connected, nothing more; none or not set, ask to connect with linkedin_send_invite (it refuses someone already connected or already invited: then nothing more); pending, the draft waits for them; ignored, draft by email instead when they have an email address. While the draft waits for them to connect, set the lead's nextAction to "Wait for <name> to accept the LinkedIn request" and its nextActionAt 7 days later. An email message needs none of this. START: a person approves the audience, the offer and the list, then reviews each proposed message in its channel and approves it; nothing goes out before they approve it, and the agent never sends. Once a message is sent, follow the cadence, so "Follow up on leads in outreach" drafts the next one. CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead's lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead's next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step. FINISH: when every person written to has replied or their follow-ups ended in silence, record in the campaign notes how many messages were sent (the outbound messages in their channels), how many got a reply and how many led to a booked meeting. Pausing or cancelling is a person's call.`,
         "subjectProfile": {
           "profileSlug": "campaign",
           "statusProperty": "campaign-status"
@@ -33443,6 +33531,19 @@ function collectBaseProfileSlugs(data, resolveDep, seen = /* @__PURE__ */ new Se
   }
   return out;
 }
+var TEMPLATE_DOCUMENT_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function composeBaseDocumentSlugs(data, resolveDep, seen = /* @__PURE__ */ new Set()) {
+  const out = /* @__PURE__ */ new Set();
+  for (const dep of data.dependencies || []) {
+    if (dep.relation !== "compose" || seen.has(dep.slug)) continue;
+    seen.add(dep.slug);
+    const base = resolveDep(dep.slug);
+    if (!base) continue;
+    for (const d of base.documents || []) if (d?.slug) out.add(d.slug);
+    for (const s of composeBaseDocumentSlugs(base, resolveDep, seen)) out.add(s);
+  }
+  return out;
+}
 function collectProfileSlugRefs(node, path, out) {
   if (node == null || typeof node !== "object") return;
   if (Array.isArray(node)) {
@@ -34625,6 +34726,56 @@ function validateTemplate(authored, authoredOpts = {}) {
       );
     }
   }
+  const documentSlugs = /* @__PURE__ */ new Set();
+  for (const [i, d] of (tpl.documents || []).entries()) {
+    const where = `documents[${i}]`;
+    if (typeof d?.slug !== "string" || !TEMPLATE_DOCUMENT_SLUG_RE.test(d.slug)) {
+      add(
+        "document-slug-invalid",
+        `${where}.slug`,
+        `${where}.slug "${d?.slug ?? ""}" must be kebab-case (a-z, 0-9, -): the space knows the document by it`
+      );
+      continue;
+    }
+    if (documentSlugs.has(d.slug))
+      add(
+        "document-slug-duplicate",
+        `${where}.slug`,
+        `document slug "${d.slug}" is declared twice`
+      );
+    documentSlugs.add(d.slug);
+    if (typeof d.title !== "string" || !d.title.trim())
+      add(
+        "document-title-required",
+        `${where}.title`,
+        `document "${d.slug}" needs a title (its name)`
+      );
+    if (typeof d.content !== "string")
+      add(
+        "document-content-required",
+        `${where}.content`,
+        `document "${d.slug}" needs a markdown content (it may be empty)`
+      );
+    if (d.scope !== void 0 && d.scope !== "space" && d.scope !== "pod")
+      add(
+        "document-scope-unknown",
+        `${where}.scope`,
+        `document "${d.slug}" scope "${String(d.scope)}" is not one of: space, pod`
+      );
+  }
+  const reachableDocumentSlugs = /* @__PURE__ */ new Set([
+    ...documentSlugs,
+    ...composeBaseDocumentSlugs(tpl, resolveDepFrom(opts))
+  ]);
+  for (const [i, si] of (tpl.layout?.sidebarItems || []).entries()) {
+    if (si.kind !== "document") continue;
+    if (!si.documentSlug || !reachableDocumentSlugs.has(si.documentSlug))
+      add(
+        "sidebar-document-unknown",
+        `layout.sidebarItems[${i}]`,
+        `layout.sidebarItems ("${si.label ?? si.documentSlug ?? "document"}") names document "${si.documentSlug ?? ""}", which this template (or a base it composes onto) does not declare in documents[]`
+      );
+  }
   for (const dt of tpl.displayTemplates || []) {
     if (dt.entityType && !known(dt.entityType)) {
       add(
@@ -34932,6 +35083,9 @@ function toWorkspaceDefinition(slugOrYaml, nameOverride) {
     proposalId,
     profiles: tpl.profiles,
     views: tpl.views ?? [],
+    // Absent when the template has none, so a template without documents
+    // compiles to the same definition (and content hash) as before.
+    ...tpl.documents?.length ? { documents: tpl.documents } : {},
     entityLinks: tpl.entityLinks ?? [],
     seedEntities: tpl.seedEntities ?? [],
     suggestedRelations: tpl.suggestedRelations,
@@ -35017,6 +35171,7 @@ function toPackageDefinition(slugOrYaml) {
     defaultSources: ws.defaultSources,
     profiles: tpl.profiles,
     views: tpl.views ?? [],
+    ...tpl.documents?.length ? { documents: tpl.documents } : {},
     suggestedEntities: tpl.seedEntities ?? [],
     suggestedRelations: tpl.suggestedRelations,
     displayTemplates: tpl.displayTemplates,