@synap-core/workspace-templates 0.7.0 → 0.7.2

package/dist/index.js

@@ -6798,6 +6798,7 @@ var DATA = {
         "description": "A person or company actively being qualified or contacted by this CRM workspace.",
         "scope": "WORKSPACE",
         "profileKind": "role",
+        "semanticSlug": "crm.lead",
         "applicableKinds": [
           "person",
           "company"
@@ -6905,6 +6906,7 @@ var DATA = {
         "description": "A CRM lead converted by a won commercial proposal and ready for handoff.",
         "scope": "WORKSPACE",
         "profileKind": "role",
+        "semanticSlug": "crm.client",
         "applicableKinds": [
           "person",
           "company"
@@ -13260,7 +13262,7 @@ var DATA = {
       ]
     },
     "bento": {
-      "viewName": "Ecosystem Map",
+      "viewName": "Ecosystem Home",
       "blocks": [
         {
           "kind": "view",
@@ -22507,18 +22509,92 @@ var DATA = {
     },
     "profiles": [
       {
-        "slug": "meeting",
-        "displayName": "Meeting",
-        "icon": "video",
+        "slug": "person",
+        "displayName": "Person",
+        "icon": "user",
+        "color": "amber",
+        "description": "A meeting attendee.",
+        "properties": [
+          {
+            "slug": "email",
+            "label": "Email",
+            "valueType": "string",
+            "inputType": "email"
+          }
+        ]
+      },
+      {
+        "slug": "task",
+        "displayName": "Task",
+        "icon": "check-square",
+        "color": "blue",
+        "description": "An action item that came out of a meeting.",
+        "properties": [
+          {
+            "slug": "status",
+            "label": "Status",
+            "valueType": "string",
+            "inputType": "select",
+            "enumValues": [
+              "todo",
+              "in-progress",
+              "done",
+              "cancelled"
+            ],
+            "constraints": {
+              "defaultValue": "todo"
+            }
+          },
+          {
+            "slug": "dueDate",
+            "label": "Due",
+            "valueType": "date",
+            "inputType": "date"
+          }
+        ]
+      },
+      {
+        "slug": "note",
+        "displayName": "Note",
+        "icon": "file-text",
         "color": "violet",
-        "description": "A meeting \u2014 its date, attendees, and what came out of it.",
+        "description": "A note or summary captured from a meeting.",
         "properties": [
           {
-            "slug": "meetingDate",
-            "label": "Date",
+            "slug": "content",
+            "label": "Content",
+            "valueType": "string",
+            "inputType": "textarea"
+          }
+        ]
+      },
+      {
+        "slug": "event",
+        "displayName": "Event",
+        "icon": "calendar",
+        "color": "sky",
+        "description": "A calendar event \u2014 the thing a meeting actually is.",
+        "properties": [
+          {
+            "slug": "startDate",
+            "label": "Start",
             "valueType": "date",
             "inputType": "date"
-          },
+          }
+        ]
+      },
+      {
+        "slug": "meeting",
+        "displayName": "Meeting",
+        "icon": "video",
+        "color": "violet",
+        "scope": "shared",
+        "profileKind": "role",
+        "applicableKinds": [
+          "event"
+        ],
+        "description": "The meeting hat an event wears \u2014 platform, transcript, and what came out of it.",
+        "properties": [
           {
             "slug": "platform",
             "label": "Platform",
@@ -22532,12 +22608,6 @@ var DATA = {
               "other"
             ]
           },
-          {
-            "slug": "attendees",
-            "label": "Attendees",
-            "valueType": "array",
-            "inputType": "text"
-          },
           {
             "slug": "status",
             "label": "Status",
@@ -22577,19 +22647,44 @@ var DATA = {
         "config": {
           "columns": [
             "title",
-            "meetingDate",
+            "startDate",
             "platform",
             "status"
           ]
+        }
+      },
+      {
+        "name": "Needs Processing",
+        "slug": "meetings-unprocessed",
+        "type": "list",
+        "scopeProfileSlug": "meeting",
+        "description": "Meetings that happened but haven't been imported and summarized yet.",
+        "config": {
+          "filterBy": {
+            "field": "status",
+            "operator": "is",
+            "value": "completed"
+          }
         },
         "defaultView": true
       },
+      {
+        "name": "Meeting Notes",
+        "slug": "meeting-notes",
+        "type": "list",
+        "scopeProfileSlug": "note",
+        "description": "Summaries and notes produced from meetings."
+      },
       {
         "name": "Meetings Calendar",
         "slug": "meetings-calendar",
         "type": "calendar",
         "scopeProfileSlug": "meeting",
-        "description": "Meetings on a calendar, keyed on their date."
+        "description": "Meetings on a calendar, keyed on their date.",
+        "config": {
+          "dateField": "properties.startDate",
+          "colorBy": "status"
+        }
       },
       {
         "name": "Action Items",
@@ -22673,27 +22768,29 @@ var DATA = {
         ],
         "blindSpots": [
           `Recurring meetings (standups, 1:1s) get skipped because they feel routine \u2014 but their action items are exactly what falls through the cracks. Don't let "it's just a standup" excuse skipping capture.
-`
+`,
+          `"Attendees" as a list of names is not attendee capture \u2014 it's a string. If the summary says "Sarah will send the deck" and Sarah isn't a tracked person linked to that task, the next meeting with Sarah starts from zero again. Resolve every attendee to a real person, or say out loud that you're choosing not to.
+`,
+          "A summary nobody re-reads is theatre. The test for a good meeting note is whether someone who missed the call could act from it alone \u2014 if it needs the transcript to make sense, it isn't a summary yet.\n"
         ],
-        "bar": "A handful of recent meetings are logged with a real summary and at least one action item each, so the Import & Summarize playbook has something concrete to run against.\n"
+        "bar": 'The PIPE is live, not the rows: transcript source and calendar connected, the Import & Summarize playbook run once end-to-end on a real recent meeting, and the output inspected together \u2014 a note a human would actually keep, tasks that are genuinely actionable, and attendees resolved to tracked people rather than name strings. If the first import produces vague tasks ("follow up"), fix the extraction bar now, not after fifty meetings.\n'
       },
       "collect": [
         {
           "profileSlug": "meeting",
-          "what": "Recent or upcoming meetings worth tracking.",
+          "what": "Which recurring meetings are worth importing every time \u2014 the standing 1:1s, the weekly ops call. A watchlist, not a backlog.\n",
           "cardinality": "few",
           "keyFields": [
-            "meetingDate",
             "platform"
           ]
         }
       ],
       "openingQuestions": [
-        "What meetings do you want tracked \u2014 recurring ones, or just the important ones?",
-        "Where do your meetings live \u2014 Zoom, Google Meet, somewhere else?",
-        "Do you already record/transcribe them, or should that start now?"
+        "Name a meeting from last week whose outcome you can't remember. What did that cost you?",
+        "When a meeting produces an action item, where does it go today \u2014 and does it survive the week?",
+        "Which recurring meeting would you cancel if you could see its action-item completion rate?"
       ],
-      "doneWhen": "A few meetings captured with a date and platform, at least one with a summary."
+      "doneWhen": "Transcript source connected and one real meeting imported end-to-end \u2014 summary note, at least one action item, and attendees resolved to people.\n"
     },
     "app": {
       "kind": "stored",
@@ -22704,7 +22801,8 @@ var DATA = {
       "defaultApp": null,
       "pinnedApps": [
         "dashboard",
-        "data"
+        "data",
+        "chat"
       ],
       "sidebarItems": [
         {
@@ -22734,7 +22832,7 @@ var DATA = {
       ]
     },
     "bento": {
-      "viewName": "Meetings",
+      "viewName": "Meetings Home",
       "blocks": [
         {
           "kind": "view",
@@ -23458,7 +23556,8 @@ var DATA = {
       "defaultApp": null,
       "pinnedApps": [
         "dashboard",
-        "data"
+        "data",
+        "chat"
       ],
       "sidebarItems": [
         {
@@ -23482,7 +23581,7 @@ var DATA = {
       ]
     },
     "bento": {
-      "viewName": "Campaigns",
+      "viewName": "Outreach Home",
       "blocks": [
         {
           "kind": "view",
@@ -26876,6 +26975,243 @@ function computeTemplateUpdates(installed, catalog, bundleVersion) {
   });
 }
 
+// src/composition-graph.ts
+function bundledEdgesOf(slug) {
+  return getWorkspaceTemplate(slug)?.dependencies ?? [];
+}
+function layerTemplateGraph(input) {
+  const { roots, edgesOf } = input;
+  const nameOf = input.nameOf ?? (() => void 0);
+  const rootSet = new Set(roots);
+  const installedBySlug = /* @__PURE__ */ new Map();
+  for (const entry of input.installed ?? []) {
+    const list = installedBySlug.get(entry.slug);
+    if (list) list.push(entry);
+    else installedBySlug.set(entry.slug, [entry]);
+  }
+  const updatesBySlug = new Map((input.updates ?? []).map((u) => [u.slug, u]));
+  const edges = [];
+  const cycles = [];
+  const touched = new Set(roots);
+  const adjacency = /* @__PURE__ */ new Map();
+  const dependentsMap = /* @__PURE__ */ new Map();
+  const composeEdges = [];
+  const discovered = /* @__PURE__ */ new Set();
+  function addAdjacency(from, to) {
+    const set = adjacency.get(from);
+    if (set) set.add(to);
+    else adjacency.set(from, /* @__PURE__ */ new Set([to]));
+  }
+  function addDependent(dependency, dependent) {
+    const set = dependentsMap.get(dependency);
+    if (set) set.add(dependent);
+    else dependentsMap.set(dependency, /* @__PURE__ */ new Set([dependent]));
+  }
+  function walk(slug, ancestors) {
+    const deps = edgesOf(slug) ?? [];
+    for (const dep of deps) {
+      const relation = dep.relation ?? "require";
+      touched.add(dep.slug);
+      if (ancestors.has(dep.slug)) {
+        cycles.push([slug, dep.slug]);
+        edges.push({ from: slug, to: dep.slug, relation, depKind: dep.kind });
+        continue;
+      }
+      edges.push({ from: slug, to: dep.slug, relation, depKind: dep.kind });
+      addAdjacency(slug, dep.slug);
+      addDependent(dep.slug, slug);
+      if (relation === "compose") {
+        composeEdges.push({ from: slug, to: dep.slug, depKind: dep.kind });
+      }
+      if (!discovered.has(dep.slug)) {
+        discovered.add(dep.slug);
+        const nextAncestors = new Set(ancestors);
+        nextAncestors.add(slug);
+        walk(dep.slug, nextAncestors);
+      }
+    }
+  }
+  for (const root of roots) {
+    if (discovered.has(root)) continue;
+    discovered.add(root);
+    walk(root, /* @__PURE__ */ new Set([root]));
+  }
+  const composeSources = new Set(composeEdges.map((e) => e.from));
+  const overlaysByBase = /* @__PURE__ */ new Map();
+  for (const e of composeEdges) {
+    const isInstalled = installedBySlug.has(e.from);
+    const overlay = { slug: e.from, name: nameOf(e.from) ?? e.from, installed: isInstalled };
+    const list = overlaysByBase.get(e.to);
+    if (list) list.push(overlay);
+    else overlaysByBase.set(e.to, [overlay]);
+  }
+  const nodeSlugs = [...touched].filter((s) => !composeSources.has(s)).sort();
+  const rootsReaching = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    const visited = /* @__PURE__ */ new Set([root]);
+    const queue = [root];
+    const addReach = (s) => {
+      const set = rootsReaching.get(s);
+      if (set) set.add(root);
+      else rootsReaching.set(s, /* @__PURE__ */ new Set([root]));
+    };
+    addReach(root);
+    while (queue.length) {
+      const cur = queue.shift();
+      for (const next of adjacency.get(cur) ?? []) {
+        if (visited.has(next)) continue;
+        visited.add(next);
+        addReach(next);
+        queue.push(next);
+      }
+    }
+  }
+  const layerMemo = /* @__PURE__ */ new Map();
+  function layerOf(slug, stack) {
+    if (rootSet.has(slug)) return 0;
+    const memoized = layerMemo.get(slug);
+    if (memoized !== void 0) return memoized;
+    if (stack.has(slug)) return 0;
+    stack.add(slug);
+    const dependents = dependentsMap.get(slug);
+    const layer = !dependents || dependents.size === 0 ? 0 : 1 + Math.max(...[...dependents].map((d) => layerOf(d, stack)));
+    stack.delete(slug);
+    layerMemo.set(slug, layer);
+    return layer;
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const slug of nodeSlugs) {
+    const installedEntries = installedBySlug.get(slug) ?? [];
+    const workspaceIds = installedEntries.map((e) => e.workspaceId).filter(Boolean);
+    const installed = workspaceIds.length > 0;
+    const update = updatesBySlug.get(slug);
+    const installedVersion = update?.installedVersion || installedEntries[0]?.version;
+    const noVersionInfo = installed && (update === void 0 || update.latestVersion === void 0);
+    nodes.set(slug, {
+      slug,
+      name: nameOf(slug) ?? slug,
+      layer: layerOf(slug, /* @__PURE__ */ new Set()),
+      dependents: [...dependentsMap.get(slug) ?? []].sort(),
+      roots: [...rootsReaching.get(slug) ?? []].sort(),
+      installed,
+      workspaceIds,
+      installedVersion,
+      latestVersion: update?.latestVersion ?? null,
+      updateAvailable: update?.updateAvailable ?? false,
+      noVersionInfo,
+      overlays: overlaysByBase.get(slug) ?? []
+    });
+  }
+  const maxLayer = Math.max(0, ...[...nodes.values()].map((n) => n.layer));
+  const layers = Array.from({ length: maxLayer + 1 }, () => []);
+  for (const node of nodes.values()) layers[node.layer].push(node);
+  for (const bucket of layers) bucket.sort((a, b) => a.slug.localeCompare(b.slug));
+  return { nodes, edges, layers, cycles };
+}
+
+// src/concept-guard.ts
+var DECLARED_DIVERGENCES = {
+  // Two-tier lead vocabulary, documented at business-developer.yaml:1-16.
+  // Foundation's `lead` is a SHARED pod-wide role: being a lead is true
+  // everywhere. `crm-lead` is a WORKSPACE-scoped role so a person can be a lead
+  // inside one CRM workspace without becoming a lead across the whole pod. The
+  // tiers are intentionally separate rows; `semanticSlug: crm.lead` records the
+  // kinship so the two are discoverable as one concept via getBySemanticSlug.
+  "crm-lead|lead": "business-developer: workspace-tier lead, deliberately NOT pod-wide foundation `lead` (two-tier CRM design)",
+  // Same reasoning for the post-sale side of the same lifecycle.
+  "client|crm-client": "business-developer: workspace-tier client, deliberately NOT pod-wide foundation `client` (two-tier CRM design)"
+};
+function effectiveSemanticSlug(profile) {
+  return profile.semanticSlug ?? profile.slug;
+}
+function conceptTerm(semanticSlug) {
+  const tokens = semanticSlug.split(/[.\-_]/).filter(Boolean);
+  return (tokens[tokens.length - 1] ?? semanticSlug).toLowerCase();
+}
+function declaredValue(profile, field) {
+  const raw = profile[field];
+  if (raw === void 0 || raw === null) return null;
+  if (field === "applicableKinds") {
+    return Array.isArray(raw) ? JSON.stringify([...raw].sort()) : null;
+  }
+  return JSON.stringify(String(raw).toLowerCase());
+}
+function pairKey(a, b) {
+  return [a, b].sort().join("|");
+}
+function findConceptViolations(templates = WORKSPACE_TEMPLATES) {
+  const violations = [];
+  const all = [];
+  for (const [templateSlug, template] of Object.entries(templates)) {
+    for (const profile of template.profiles ?? []) {
+      all.push({ template: templateSlug, profile });
+    }
+  }
+  const roles = all.filter((r) => r.profile.profileKind === "role");
+  const usedAllowlistKeys = /* @__PURE__ */ new Set();
+  const reportedPairs = /* @__PURE__ */ new Set();
+  for (let i = 0; i < roles.length; i++) {
+    for (let j = i + 1; j < roles.length; j++) {
+      const a = roles[i];
+      const b = roles[j];
+      if (a.template === b.template) continue;
+      if (a.profile.slug === b.profile.slug) continue;
+      const term = conceptTerm(effectiveSemanticSlug(a.profile));
+      if (term !== conceptTerm(effectiveSemanticSlug(b.profile))) continue;
+      const key = pairKey(a.profile.slug, b.profile.slug);
+      if (key in DECLARED_DIVERGENCES) {
+        usedAllowlistKeys.add(key);
+        continue;
+      }
+      if (reportedPairs.has(key)) continue;
+      reportedPairs.add(key);
+      violations.push({
+        rule: "concept-collision",
+        concept: term,
+        message: `two role profiles denote the concept "${term}" under different slugs: "${a.profile.slug}" (${a.template}) vs "${b.profile.slug}" (${b.template}). Either REUSE the existing slug, or \u2014 if the divergence is intentional \u2014 declare it: set an explicit \`semanticSlug\` on the new profile and add "${key}" to DECLARED_DIVERGENCES in src/concept-guard.ts with the reason.`
+      });
+    }
+  }
+  const bySemantic = /* @__PURE__ */ new Map();
+  for (const ref of all) {
+    const key = effectiveSemanticSlug(ref.profile);
+    const bucket = bySemantic.get(key);
+    if (bucket) bucket.push(ref);
+    else bySemantic.set(key, [ref]);
+  }
+  for (const [semantic, group] of bySemantic) {
+    if (new Set(group.map((r) => r.profile.slug)).size < 2) continue;
+    for (const field of ["profileKind", "scope", "applicableKinds"]) {
+      const claims = /* @__PURE__ */ new Map();
+      for (const ref of group) {
+        const value = declaredValue(ref.profile, field);
+        if (value === null) continue;
+        const existing = claims.get(value);
+        if (!existing) claims.set(value, `${ref.template}:${ref.profile.slug}`);
+      }
+      if (claims.size > 1) {
+        violations.push({
+          rule: "alias-shape-divergence",
+          concept: semantic,
+          message: `profiles aliased to semanticSlug "${semantic}" disagree on \`${field}\`: ` + [...claims].map(([v, who]) => `${who} declares ${v}`).join(", ") + `. Aliased profiles assert one concept \u2014 make the shapes agree, or drop the alias.`
+        });
+      }
+    }
+  }
+  for (const key of Object.keys(DECLARED_DIVERGENCES)) {
+    if (usedAllowlistKeys.has(key)) continue;
+    violations.push({
+      rule: "stale-allowlist",
+      concept: key,
+      message: `DECLARED_DIVERGENCES entry "${key}" no longer matches any collision \u2014 the divergence was resolved or the profiles were renamed. Delete the entry.`
+    });
+  }
+  return violations;
+}
+function formatConceptViolations(violations) {
+  return violations.map((v) => `  \u2022 [${v.rule}] ${v.message}`).join("\n");
+}
+
 // src/define.ts
 function toAutomationWire(automations) {
   return automations?.map((a) => ({
@@ -27031,12 +27367,18 @@ function toPackageDefinition(slugOrYaml) {
   };
 }
 export {
+  DECLARED_DIVERGENCES,
   PACKAGE_DEPENDENCY_KINDS,
   WORKSPACE_TEMPLATES,
   assembleCatalog,
+  bundledEdgesOf,
   computeTemplateUpdates,
+  conceptTerm,
+  findConceptViolations,
+  formatConceptViolations,
   getWorkspaceTemplate,
   isHashVersion,
+  layerTemplateGraph,
   listPublicTemplates,
   listWorkspaceTemplates,
   mergeCatalog,