@synap-core/workspace-templates 0.23.0 → 0.24.0

package/src/unipile-linkedin-find-profile.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Unipile — finding ONE known person's LinkedIn profile, and paging the people
+ * search (CRM wave 2, S4b, build map 6f6c197f).
+ *
+ *  - `linkedin_find_profile` answers a profile only on a STRICT match: the
+ *    result's name equals the full name (case- and accent-insensitive), the
+ *    company is in its headline as whole words, and exactly one result is
+ *    both. Otherwise no match, with up to 3 candidates for a person to choose
+ *    from. It writes nothing: the match's fields are the caller's proposal
+ *    (founder decision 7).
+ *  - `linkedin_search_people` and `linkedin_capture_profiles` page by
+ *    `cursor`, the reply's `next_cursor` (Unipile v2 performClassicPeopleSearch
+ *    takes a `cursor` query param and no offset or limit).
+ *
+ * SEAM: each verb's REAL `code` body, run the way the pod's executor wraps it
+ * (`async (args, context) => { <code> }` with `callProvider` and `propose` in
+ * scope), against a recorded `callProvider` that answers page by page.
+ *
+ * NOT covered: what a live LinkedIn search returns (ranking, how the
+ * `advanced_keywords.company` filter matches, headline wording), and the pod's
+ * governance of the read (finding 4c31855b: a read once came back proposed;
+ * the verb then returns `proposed`, tested below with a stubbed answer).
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const capability = JSON.parse(
+  readFileSync(join(import.meta.dirname, "..", "capabilities", "unipile-linkedin.capability.json"), "utf8"),
+) as { spec: { skills: Array<Record<string, any>> } };
+const skill = (name: string) => capability.spec.skills.find((s) => s.name === name)!;
+
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as new (
+  ...args: string[]
+) => (...a: unknown[]) => Promise<any>;
+
+type Call = { tool: string; method: string; path: string; body: Record<string, unknown> };
+type Page = { data: Array<Record<string, unknown>>; next_cursor?: string | null };
+
+/** Runs `name`'s code; `pages` answers the provider calls in order (the last one repeats). */
+async function run(name: string, args: Record<string, unknown>, pages: Array<Page | Record<string, unknown>>) {
+  const calls: Call[] = [];
+  const proposals: Array<Record<string, unknown>> = [];
+  const callProvider = async (tool: string, method: string, path: string, body: Record<string, unknown>) => {
+    calls.push({ tool, method, path, body });
+    const reply = pages[Math.min(calls.length - 1, pages.length - 1)];
+    return "proposed" in reply ? reply : { status: 200, body: reply };
+  };
+  const propose = { entity: async (input: Record<string, unknown>) => (proposals.push(input), { status: "proposed" }) };
+  const body = new AsyncFunction("args", "context", "callProvider", "propose", skill(name).code);
+  const result = await body(args, {}, callProvider, propose);
+  return { result, calls, proposals };
+}
+
+const row = (id: string, display_name: string, headline: string) => ({
+  object: "PeopleSearchResult",
+  id,
+  display_name,
+  headline,
+  public_identifier: `${id}-slug`,
+  profile_url: `https://www.linkedin.com/in/${id}-slug`,
+  network_distance: "SECOND_DEGREE",
+});
+const ADA = row("u-ada", "Adèle Lovelace", "CEO at Analytical Engines · Paris");
+const ARGS = { accountId: "acc_1", fullName: "adele  LOVELACE", company: "Analytical Engines" };
+
+describe("linkedin_find_profile — a strict match or none", () => {
+  const verb = skill("linkedin_find_profile");
+
+  it("is a read the pod runs at once, routed by enrich_entity, and carries no install-time value", () => {
+    expect(verb.kind).toBe("code");
+    expect(verb.intent).toBe("enrich_entity");
+    expect(verb.metadata).toEqual({ verbType: "read" });
+    expect(verb.parameters).toEqual({ fullName: "string", company: "string", accountId: "string" });
+    expect(verb.requires).toEqual(["unipile_linkedin"]);
+    expect(verb.code).not.toMatch(/\{\{\w+\}\}/);
+    // It writes nothing: the match is the caller's proposal (decision 7).
+    expect(verb.code).not.toMatch(/propose\.entity|callProvider\([^)]*'(PATCH|PUT|DELETE)'/);
+  });
+
+  it("one result with the same name (case and accents aside) and the company in its headline: the match", async () => {
+    const other = row("u-2", "Ada Byron", "Engineer at Analytical Engines");
+    const { result, calls, proposals } = await run("linkedin_find_profile", ARGS, [{ data: [other, ADA], next_cursor: null }]);
+    expect(result.matched).toBe(true);
+    expect(result.profile).toMatchObject({ name: "Adèle Lovelace", providerId: "u-ada", publicIdentifier: "u-ada-slug" });
+    expect(result.properties).toEqual({ linkedinUrl: "https://www.linkedin.com/in/u-ada-slug", linkedinProviderId: "u-ada" });
+    expect(result.candidates).toEqual([]);
+    expect(proposals).toEqual([]);
+    expect(calls).toEqual([
+      {
+        tool: "unipile_linkedin",
+        method: "POST",
+        path: "/acc_1/linkedin/search/people",
+        body: { keywords: "adele  LOVELACE", advanced_keywords: { company: "Analytical Engines" } },
+      },
+    ]);
+  });
+
+  it("two results that both match: no match, both offered as candidates", async () => {
+    const twin = row("u-twin", "Adele Lovelace", "Analytical Engines, board member");
+    const { result } = await run("linkedin_find_profile", ARGS, [{ data: [ADA, twin] }]);
+    expect(result).toMatchObject({ matched: false, reason: "several" });
+    expect(result.candidates.map((c: any) => c.providerId)).toEqual(["u-ada", "u-twin"]);
+    expect(result.properties).toBeUndefined();
+  });
+
+  it("the name matches but the company is not in the headline, or only inside another word: no match", async () => {
+    const elsewhere = row("u-3", "Adèle Lovelace", "Founder at Difference Engines");
+    const inside = row("u-4", "Adèle Lovelace", "CTO at AnalyticalEnginesCo");
+    const { result } = await run("linkedin_find_profile", ARGS, [{ data: [elsewhere, inside] }]);
+    expect(result).toMatchObject({ matched: false, reason: "none" });
+    expect(result.candidates.map((c: any) => [c.providerId, c.nameMatches, c.companyInHeadline])).toEqual([
+      ["u-3", true, false],
+      ["u-4", true, false],
+    ]);
+  });
+
+  it("a different name with the right company is never a match, and at most 3 candidates come back, closest first", async () => {
+    const rows = [
+      row("a", "Ada Lovelace", "CEO at Analytical Engines"),
+      row("b", "Bob Smith", "Sales"),
+      row("c", "Adèle Lovelace", "Poet"),
+      row("d", "Carol King", "Analytical Engines"),
+    ];
+    const { result } = await run("linkedin_find_profile", ARGS, [{ data: rows }]);
+    expect(result).toMatchObject({ matched: false, reason: "none" });
+    expect(result.candidates.map((c: any) => c.providerId)).toEqual(["c", "a", "d"]);
+  });
+
+  it("pages by cursor: a match on page 2 with no page after it is the match", async () => {
+    const { result, calls } = await run("linkedin_find_profile", ARGS, [
+      { data: [row("x", "Someone Else", "Analytical Engines")], next_cursor: "c2" },
+      { data: [ADA], next_cursor: null },
+    ]);
+    expect(result.matched).toBe(true);
+    expect(calls.map((c) => c.path)).toEqual(["/acc_1/linkedin/search/people", "/acc_1/linkedin/search/people?cursor=c2"]);
+  });
+
+  it("a third page left unread could hold another match: no match (more_results), and it stops after 2 pages", async () => {
+    const { result, calls } = await run("linkedin_find_profile", ARGS, [
+      { data: [ADA], next_cursor: "c2" },
+      { data: [row("y", "Other", "x")], next_cursor: "c3" },
+    ]);
+    expect(result).toMatchObject({ matched: false, reason: "more_results" });
+    expect(result.searched).toMatchObject({ pages: 2, moreUnread: true });
+    expect(calls).toHaveLength(2);
+  });
+
+  it("a search the pod held for review is no match and says so", async () => {
+    const { result } = await run("linkedin_find_profile", ARGS, [{ proposed: true, proposalId: "p-1" }]);
+    expect(result).toEqual({ matched: false, reason: "proposed", proposed: true, proposalId: "p-1", candidates: [] });
+  });
+
+  it("a failed search throws; a missing company or name is refused before any call", async () => {
+    await expect(run("linkedin_find_profile", ARGS, [{ proposed: false, status: 429 } as any])).rejects.toThrow(/status 429/);
+    await expect(run("linkedin_find_profile", { ...ARGS, company: " " }, [{ data: [] }])).rejects.toThrow(/company is required/);
+    await expect(run("linkedin_find_profile", { ...ARGS, fullName: "" }, [{ data: [] }])).rejects.toThrow(/fullName/);
+  });
+});
+
+describe("the people search pages by cursor", () => {
+  it.each(["linkedin_search_people", "linkedin_capture_profiles"])("%s takes a cursor and returns the next one", async (name) => {
+    expect(skill(name).parameters.cursor).toBe("string?");
+    const first = await run(name, { accountId: "acc_1", keywords: "founders lyon" }, [{ data: [ADA], next_cursor: "n2" }]);
+    expect(first.calls[0].path).toBe("/acc_1/linkedin/search/people");
+    expect(first.calls[0].body).toEqual({ keywords: "founders lyon" });
+    expect(first.result.cursor).toBe("n2");
+
+    const second = await run(name, { accountId: "acc_1", keywords: "founders lyon", cursor: "n2" }, [{ data: [ADA], next_cursor: null }]);
+    expect(second.calls[0].path).toBe("/acc_1/linkedin/search/people?cursor=n2");
+    expect(second.result.cursor).toBeNull();
+    // v2 takes no offset or limit: page 2 is reached by the cursor alone (the
+    // exact paths above carry no other query param).
+  });
+
+  it("capture still proposes each row of the page, and search still returns them", async () => {
+    const capture = await run("linkedin_capture_profiles", { accountId: "acc_1", keywords: "k", cursor: "n2" }, [{ data: [ADA] }]);
+    expect(capture.proposals).toHaveLength(1);
+    expect(capture.proposals[0]).toMatchObject({ profileSlug: "person", title: "Adèle Lovelace" });
+    const search = await run("linkedin_search_people", { accountId: "acc_1", keywords: "k", limit: 1 }, [{ data: [ADA, ADA] }]);
+    expect(search.result.count).toBe(1);
+  });
+});

package/src/validate.ts

@@ -282,6 +282,31 @@ export function collectBaseProfileSlugs(
   return out;
 }
 
+/** A template document slug: kebab-case. Same rule as the pod's install door (`schemas/template-document.ts`). */
+export const TEMPLATE_DOCUMENT_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+/**
+ * The document slugs of every base this template COMPOSES onto, transitively —
+ * an overlay installs into its base's space, so its sidebar may name them. A
+ * `require` base keeps its own space: its documents are not reachable.
+ */
+function composeBaseDocumentSlugs(
+  data: WorkspaceYaml,
+  resolveDep: (slug: string) => WorkspaceYaml | undefined,
+  seen = new Set<string>()
+): Set<string> {
+  const out = new Set<string>();
+  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;
+}
+
 /**
  * Recursively collect every `profileSlug` string value under `node`, tagged with
  * a dotted path for error messages. Used for `automations` (whose flow-node /
@@ -2014,6 +2039,62 @@ export function validateTemplate(
       );
     }
   }
+
+  // ── Template documents (`documents[]`) ─────────────────────────────────────
+  // The pod knows a template document by its slug in the space (it never
+  // rewrites or recreates one), so a slug must be stable, unique and named by
+  // every document sidebar item. A compose overlay installs into its base's
+  // space, so it may also name a document its base carries.
+  const documentSlugs = new Set<string>();
+  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 !== undefined && 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 = 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(

package/views/bookmark-views-pack.view.json

@@ -0,0 +1,39 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "view",
+  "meta": {
+    "slug": "bookmark-views-pack",
+    "name": "Bookmark Views",
+    "description": "Three ready-made views for saved links and articles: a masonry reading feed, a gallery and an articles table.",
+    "icon": "bookmark",
+    "color": "#F59E0B",
+    "tags": ["bookmarks", "reading", "web", "views"],
+    "isPublic": true
+  },
+  "spec": {
+    "views": [
+      {
+        "slug": "reading-feed",
+        "displayName": "Reading Feed",
+        "type": "masonry",
+        "config": {},
+        "scopeProfileSlugs": ["bookmark", "website", "article"]
+      },
+      {
+        "slug": "bookmark-gallery",
+        "displayName": "Bookmark Gallery",
+        "type": "gallery",
+        "config": {},
+        "scopeProfileSlugs": ["bookmark", "website", "article"]
+      },
+      {
+        "slug": "articles-table",
+        "displayName": "Articles Table",
+        "type": "table",
+        "config": {},
+        "scopeProfileSlugs": ["article"]
+      }
+    ]
+  },
+  "dependencies": []
+}

package/views/event-views-pack.view.json

@@ -0,0 +1,45 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "view",
+  "meta": {
+    "slug": "event-views-pack",
+    "name": "Event Views",
+    "description": "Three ready-made event views: a calendar, an upcoming-events list and an events table.",
+    "icon": "calendar",
+    "color": "#10B981",
+    "tags": ["events", "calendar", "schedule", "views"],
+    "isPublic": true
+  },
+  "spec": {
+    "views": [
+      {
+        "slug": "event-calendar",
+        "displayName": "Event Calendar",
+        "type": "calendar",
+        "config": {
+          "dateField": "startDate",
+          "endDateField": "endDate"
+        },
+        "scopeProfileSlugs": ["event"]
+      },
+      {
+        "slug": "upcoming-events",
+        "displayName": "Upcoming Events",
+        "type": "list",
+        "config": {
+          "sortBy": "startDate",
+          "sortOrder": "asc"
+        },
+        "scopeProfileSlugs": ["event"]
+      },
+      {
+        "slug": "events-table",
+        "displayName": "Events Table",
+        "type": "table",
+        "config": {},
+        "scopeProfileSlugs": ["event"]
+      }
+    ]
+  },
+  "dependencies": []
+}

package/views/task-views-pack.view.json

@@ -0,0 +1,53 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "view",
+  "meta": {
+    "slug": "task-views-pack",
+    "name": "Task Views",
+    "description": "Four ready-made task views: a Kanban board by status, a priority matrix, a due-date calendar and a table of all tasks.",
+    "icon": "layout-grid",
+    "color": "#3B82F6",
+    "tags": ["tasks", "kanban", "views", "productivity"],
+    "isPublic": true
+  },
+  "spec": {
+    "views": [
+      {
+        "slug": "task-board",
+        "displayName": "Task Board",
+        "type": "kanban",
+        "config": {
+          "groupByField": "status"
+        },
+        "scopeProfileSlugs": ["task"]
+      },
+      {
+        "slug": "priority-matrix",
+        "displayName": "Priority Matrix",
+        "type": "matrix",
+        "config": {
+          "xField": "priority",
+          "yField": "status"
+        },
+        "scopeProfileSlugs": ["task"]
+      },
+      {
+        "slug": "task-calendar",
+        "displayName": "Task Calendar",
+        "type": "calendar",
+        "config": {
+          "dateField": "dueDate"
+        },
+        "scopeProfileSlugs": ["task"]
+      },
+      {
+        "slug": "all-tasks",
+        "displayName": "All Tasks",
+        "type": "table",
+        "config": {},
+        "scopeProfileSlugs": ["task"]
+      }
+    ]
+  },
+  "dependencies": []
+}

package/packs/bookmark-views-pack.json

@@ -1,33 +0,0 @@
-{
-  "_meta": {
-    "slug": "bookmark-views-pack",
-    "displayName": "Bookmark Views",
-    "icon": "bookmark",
-    "color": "#F59E0B",
-    "tags": ["bookmarks", "reading", "web", "views"],
-    "requiredTier": null,
-    "isPublic": true
-  },
-  "description": "Three ready-made views for saved links and articles: a masonry reading feed, a gallery and an articles table.",
-  "profiles": [],
-  "views": [
-    {
-      "name": "Reading Feed",
-      "type": "masonry",
-      "scopeProfileSlugs": ["bookmark", "website", "article"],
-      "config": {}
-    },
-    {
-      "name": "Bookmark Gallery",
-      "type": "gallery",
-      "scopeProfileSlugs": ["bookmark", "website", "article"],
-      "config": {}
-    },
-    {
-      "name": "Articles Table",
-      "type": "table",
-      "scopeProfileSlug": "article",
-      "config": {}
-    }
-  ]
-}

package/packs/crm-pack.json

@@ -1,76 +0,0 @@
-{
-  "_meta": {
-    "slug": "crm-pack",
-    "icon": "users",
-    "color": "#3B82F6",
-    "tags": ["crm", "sales", "contacts", "deals"],
-    "requiredTier": null,
-    "isPublic": true
-  },
-  "profiles": [
-    {
-      "slug": "contact",
-      "displayName": "Contact",
-      "icon": "user-check",
-      "color": "#06B6D4",
-      "description": "People you interact with",
-      "scope": "workspace",
-      "parentProfileSlug": "person",
-      "properties": [
-        { "slug": "role", "valueType": "string", "label": "Role / Title" },
-        { "slug": "department", "valueType": "string", "label": "Department" },
-        { "slug": "source", "valueType": "string", "label": "Lead Source", "inputType": "select", "enumValues": ["referral", "website", "event", "cold-outreach", "other"] },
-        { "slug": "last-contacted", "valueType": "date", "label": "Last Contacted" }
-      ]
-    },
-    {
-      "slug": "company",
-      "displayName": "Company",
-      "icon": "building",
-      "color": "#6366F1",
-      "description": "Organizations and businesses",
-      "scope": "workspace",
-      "properties": [
-        { "slug": "website", "valueType": "string", "label": "Website", "inputType": "url" },
-        { "slug": "industry", "valueType": "string", "label": "Industry" },
-        { "slug": "employees", "valueType": "number", "label": "Employee Count", "constraints": { "min": 0 } },
-        { "slug": "location", "valueType": "string", "label": "Location" },
-        { "slug": "revenue", "valueType": "number", "label": "Annual Revenue", "constraints": { "min": 0 } }
-      ]
-    },
-    {
-      "slug": "deal",
-      "displayName": "Deal",
-      "icon": "trending-up",
-      "color": "#EC4899",
-      "description": "Sales opportunities and pipeline",
-      "scope": "workspace",
-      "properties": [
-        { "slug": "value", "valueType": "number", "required": true, "label": "Deal Value", "constraints": { "min": 0 } },
-        { "slug": "stage", "valueType": "string", "required": true, "label": "Stage", "inputType": "select", "enumValues": ["lead", "qualified", "proposal", "negotiation", "closed-won", "closed-lost"] },
-        { "slug": "close-date", "valueType": "date", "label": "Expected Close" },
-        { "slug": "probability", "valueType": "number", "label": "Win Probability (%)", "constraints": { "min": 0, "max": 100 } },
-        { "slug": "notes", "valueType": "string", "label": "Notes", "inputType": "textarea" }
-      ]
-    }
-  ],
-  "views": [
-    {
-      "name": "Pipeline",
-      "type": "kanban",
-      "scopeProfileSlug": "deal",
-      "config": { "groupByField": "stage" }
-    },
-    {
-      "name": "Contacts",
-      "type": "table",
-      "scopeProfileSlug": "contact",
-      "config": {}
-    }
-  ],
-  "entityLinks": [
-    { "sourceProfileSlug": "contact", "targetProfileSlug": "company", "type": "works_at", "label": "Works at" },
-    { "sourceProfileSlug": "deal", "targetProfileSlug": "contact", "type": "owned_by", "label": "Owned by" },
-    { "sourceProfileSlug": "deal", "targetProfileSlug": "company", "type": "deal_for", "label": "Deal for" }
-  ]
-}

package/packs/customer-profile.json

@@ -1,28 +0,0 @@
-{
-  "_meta": {
-    "slug": "customer-profile",
-    "icon": "user-check",
-    "color": "#3B82F6",
-    "tags": ["customer", "crm", "contact"],
-    "requiredTier": null,
-    "isPublic": true
-  },
-  "profiles": [
-    {
-      "slug": "customer",
-      "displayName": "Customer",
-      "icon": "user-check",
-      "color": "#3B82F6",
-      "description": "Customer or client contact with deal tracking",
-      "scope": "workspace",
-      "properties": [
-        { "slug": "name", "valueType": "string", "required": true, "label": "Full Name" },
-        { "slug": "email", "valueType": "string", "label": "Email", "inputType": "email" },
-        { "slug": "phone", "valueType": "string", "label": "Phone" },
-        { "slug": "company", "valueType": "string", "label": "Company" },
-        { "slug": "status", "valueType": "string", "label": "Status", "inputType": "select", "enumValues": ["lead", "prospect", "active", "churned"] },
-        { "slug": "notes", "valueType": "string", "label": "Notes", "inputType": "textarea" }
-      ]
-    }
-  ]
-}

package/packs/deep-research.playbook.json

@@ -1,30 +0,0 @@
-{
-  "_meta": {
-    "slug": "deep-research",
-    "type": "playbook",
-    "icon": "search",
-    "color": "#10B981",
-    "tags": ["research", "analysis", "automation"],
-    "isPublic": true,
-    "description": "Autonomous deep research playbook. Researches a domain, finds the best tools/platforms, and produces a CSV report and entity pool."
-  },
-  "name": "Deep Research",
-  "goalTemplate": "Research {domain}. Find the best {category} and produce: {outputTypes}. Use the provided company context where relevant.",
-  "description": "Researches a domain, identifies the best tools and platforms, produces structured outputs.",
-  "params": [
-    { "name": "domain", "type": "string", "default": "AI coding tools" },
-    { "name": "category", "type": "string", "default": "platforms and frameworks" },
-    { "name": "outputTypes", "type": "string", "default": "CSV file and entity pool" },
-    { "name": "companyContext", "type": "string", "default": "" }
-  ],
-  "executor": "is-agent",
-  "grants": [
-    { "kind": "tool", "ref": "Web Search" },
-    { "kind": "skill", "ref": "Entity Creator" }
-  ],
-  "expectedOutputs": [
-    { "description": "Research findings as structured CSV", "type": "csv" },
-    { "description": "Entity pool of discovered tools and companies", "type": "entities" },
-    { "description": "Summary report with recommendations", "type": "report" }
-  ]
-}

package/packs/event-views-pack.json

@@ -1,33 +0,0 @@
-{
-  "_meta": {
-    "slug": "event-views-pack",
-    "displayName": "Event Views",
-    "icon": "calendar",
-    "color": "#10B981",
-    "tags": ["events", "calendar", "schedule", "views"],
-    "requiredTier": null,
-    "isPublic": true
-  },
-  "description": "Three ready-made event views: a calendar, an upcoming-events list and an events table.",
-  "profiles": [],
-  "views": [
-    {
-      "name": "Event Calendar",
-      "type": "calendar",
-      "scopeProfileSlug": "event",
-      "config": { "dateField": "startDate", "endDateField": "endDate" }
-    },
-    {
-      "name": "Upcoming Events",
-      "type": "list",
-      "scopeProfileSlug": "event",
-      "config": { "sortBy": "startDate", "sortOrder": "asc" }
-    },
-    {
-      "name": "Events Table",
-      "type": "table",
-      "scopeProfileSlug": "event",
-      "config": {}
-    }
-  ]
-}

package/packs/habit-profile.json

@@ -1,27 +0,0 @@
-{
-  "_meta": {
-    "slug": "habit-profile",
-    "icon": "repeat",
-    "color": "#10B981",
-    "tags": ["habit", "tracking", "wellness"],
-    "requiredTier": null,
-    "isPublic": true
-  },
-  "profiles": [
-    {
-      "slug": "habit",
-      "displayName": "Habit",
-      "icon": "repeat",
-      "color": "#10B981",
-      "description": "Habit tracker with frequency and streaks",
-      "scope": "workspace",
-      "properties": [
-        { "slug": "name", "valueType": "string", "required": true, "label": "Habit Name" },
-        { "slug": "frequency", "valueType": "string", "label": "Frequency", "inputType": "select", "enumValues": ["daily", "weekly", "monthly"] },
-        { "slug": "streak", "valueType": "number", "label": "Current Streak", "constraints": { "min": 0 } },
-        { "slug": "category", "valueType": "string", "label": "Category" },
-        { "slug": "notes", "valueType": "string", "label": "Notes", "inputType": "textarea" }
-      ]
-    }
-  ]
-}