@lanes-sh/link 0.6.10 → 0.7.0

package/src/providers/replicate/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Replicate registers us at connect time — nothing for an operator to set up. */
+export const replicate = defineProvider({
+  id: 'replicate',
+  name: 'Replicate',
+  description: 'Models, predictions, and deployments, via Replicate\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.replicate.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/resend/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Resend registers us at connect time — nothing for an operator to set up. */
+export const resend = defineProvider({
+  id: 'resend',
+  name: 'Resend',
+  description: 'Transactional email, domains, and delivery events, via Resend\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.resend.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/riverside/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Riverside registers us at connect time — nothing for an operator to set up. */
+export const riverside = defineProvider({
+  id: 'riverside',
+  name: 'Riverside',
+  description: 'Recordings, transcripts, and clips, via Riverside\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.riverside.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/rootly/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Rootly registers us at connect time — nothing for an operator to set up. */
+export const rootly = defineProvider({
+  id: 'rootly',
+  name: 'Rootly',
+  description: 'Incidents, alerts, retrospectives, and on-call schedules, via Rootly\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.rootly.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/rudderstack/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** RudderStack registers us at connect time — nothing for an operator to set up. */
+export const rudderstack = defineProvider({
+  id: 'rudderstack',
+  name: 'RudderStack',
+  description: 'Sources, destinations, and event streams, via RudderStack\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.rudderstack.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/salesloft/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Salesloft registers us at connect time — nothing for an operator to set up. */
+export const salesloft = defineProvider({
+  id: 'salesloft',
+  name: 'Salesloft',
+  description: 'Cadences, people, and sales activity, via Salesloft\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.salesloft.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/sanity/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Sanity registers us at connect time — nothing for an operator to set up. */
+export const sanity = defineProvider({
+  id: 'sanity',
+  name: 'Sanity',
+  description: 'Documents, datasets, schema, and content releases, via Sanity\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.sanity.io/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/scopes.ts

@@ -1,5 +1,6 @@
 import { GOOGLE_SCOPE_MEANINGS } from './google/shared/scopes.ts';
 import { LINEAR_SCOPE_MEANINGS } from './linear/scopes.ts';
+import { MICROSOFT_SCOPE_MEANINGS } from './microsoft/shared/scopes.ts';
 import { REDDIT_SCOPE_MEANINGS } from './reddit/scopes.ts';
 import { SLACK_SCOPE_MEANINGS } from './slack/scopes.ts';
 
@@ -25,6 +26,7 @@ export interface ScopeMeaning {
 export const SCOPE_MEANINGS: Record<string, ScopeMeaning> = {
   ...GOOGLE_SCOPE_MEANINGS,
   ...LINEAR_SCOPE_MEANINGS,
+  ...MICROSOFT_SCOPE_MEANINGS,
   ...REDDIT_SCOPE_MEANINGS,
   ...SLACK_SCOPE_MEANINGS,
 };

package/src/providers/sentry/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Sentry registers us at connect time — nothing for an operator to set up. */
+export const sentry = defineProvider({
+  id: 'sentry',
+  name: 'Sentry',
+  description: 'Issues, events, stack traces, and releases, via Sentry\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.sentry.dev/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/setup/plan.ts

@@ -16,6 +16,13 @@ import { hasOwnClientPath, RESERVED_PROVIDER_IDS, setupRequirements, type SetupR
  */
 
 export interface ProviderPlan {
+  /** Where the service is, for a provider whose address the connection supplies. */
+  readonly variables: readonly {
+    readonly key: string;
+    readonly label: string;
+    readonly description: string;
+    readonly example: string;
+  }[];
   readonly id: string;
   readonly name: string;
   readonly description: string;
@@ -145,6 +152,10 @@ export function planFor(
     ...(manifest.setup?.docs_url ? { docsUrl: manifest.setup.docs_url } : {}),
     steps: manifest.setup?.steps ?? [],
     requires: requirements,
+    // Not a `requires` entry, and the difference is the point: a variable is not
+    // a secret, has no ref, and no `secrets set` line would place it. It is
+    // asked for at connect and written to the connection's own row.
+    variables: manifest.variables,
     needsId,
     command,
     brokered,

package/src/providers/setup/provider.ts

@@ -305,6 +305,18 @@ function renderProvider(plan: ProviderPlan): string {
     for (const requirement of plan.requires) lines.push(`  ${requirement.label}`);
   }
 
+  // Listed alongside the credentials, because to the person answering they are
+  // the same thing — another question `connect` will ask. Omitted here would be
+  // worse than for a credential: an agent relaying a setup plan for Nextcloud
+  // would say "your username and password" and never mention the one value that
+  // provider cannot be connected without.
+  if (plan.variables.length > 0) {
+    lines.push('', 'And where the service is:');
+    for (const variable of plan.variables) {
+      lines.push(`  ${variable.label} — ${variable.description} For example: ${variable.example}`);
+    }
+  }
+
   if (plan.needsId) {
     lines.push(
       '',

package/src/providers/shared/openapi.ts

@@ -62,6 +62,76 @@ export function referenced(root: unknown, schemas: Record<string, unknown>): Set
   return found;
 }
 
+/**
+ * Every component the document actually reaches, section by section.
+ *
+ * `referenced` above answers the same question for `schemas` alone, which was
+ * enough while every vendored document kept its other component sections small.
+ * Microsoft Graph does not: its published OpenAPI carries 726 shared responses
+ * and 1,419 examples, and copying those through untouched left a seven-operation
+ * spec at 962 KB with **733 dangling references** — because the responses that
+ * survived pointed at schemas the trim had just removed. The generator answered
+ * that with `Invalid OpenAPI document` and no tools at all.
+ *
+ * So reachability has to cross sections rather than stop at schemas: a path
+ * reaches a response, which reaches a schema, which reaches another. One walk,
+ * following `#/components/<section>/<name>` wherever it points, and whatever is
+ * not reached is not carried.
+ *
+ * `securitySchemes` is the exception and is never returned here — it is named by
+ * the `security` array rather than by `$ref`, so a reachability walk cannot see
+ * it and its caller keeps it whole.
+ */
+export function reachableComponents(
+  root: unknown,
+  components: Record<string, unknown>,
+): Record<string, Set<string>> {
+  const found: Record<string, Set<string>> = {};
+  const queue: unknown[] = [root];
+
+  const resolve = (pointer: string): unknown => {
+    const rest = pointer.slice('#/components/'.length);
+    const slash = rest.indexOf('/');
+    if (slash < 0) return undefined;
+
+    const section = rest.slice(0, slash);
+    // JSON Pointer escaping. Component names rarely need it, and a name that
+    // does would otherwise be recorded under a spelling the filter never matches.
+    const name = rest.slice(slash + 1).replace(/~1/g, '/').replace(/~0/g, '~');
+
+    const entries = components[section];
+    if (entries === null || typeof entries !== 'object') return undefined;
+    if (!(name in (entries as Record<string, unknown>))) return undefined;
+
+    const seen = (found[section] ??= new Set());
+    if (seen.has(name)) return undefined;
+    seen.add(name);
+
+    return (entries as Record<string, unknown>)[name];
+  };
+
+  while (queue.length > 0) {
+    const node = queue.pop();
+    if (node === null || typeof node !== 'object') continue;
+
+    if (Array.isArray(node)) {
+      queue.push(...node);
+      continue;
+    }
+
+    for (const [key, value] of Object.entries(node)) {
+      if (key === '$ref' && typeof value === 'string' && value.startsWith('#/components/')) {
+        const target = resolve(value);
+        if (target !== undefined) queue.push(target);
+        continue;
+      }
+      queue.push(value);
+    }
+  }
+
+  return found;
+}
+
 /**
  * Cut reference cycles, replacing the back-edge with an open object.
  *

package/src/providers/shared/slug.ts

@@ -0,0 +1,28 @@
+/**
+ * A stable id from something the owner typed, so writing does not demand one be
+ * invented.
+ *
+ * Three owner-layer stores derive an id this way — a memory entry from its
+ * title, a task from its title, an entity from its name — and they must derive
+ * it *identically*, because the id is the filename and a person who has learned
+ * what one store does with an apostrophe has learned what all three do.
+ *
+ * The 60-character cap is the whole of the length policy. It is not about any
+ * filesystem limit: it is that an id appears in a policy rule, a resource URI
+ * and an audit line, and a title-length one is unreadable in all three.
+ *
+ * `fallback` is the prefix for a name that slugifies to nothing — a title of
+ * only punctuation, or of a script this transliterates away. Producing
+ * `entry-14` rather than throwing is deliberate: the caller has content to
+ * store, and refusing it because its title is CJK would be a worse answer than
+ * an ugly id the owner can rename.
+ */
+export function slugify(text: string, fallback: string): string {
+  const slug = text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60);
+
+  return slug.length > 0 ? slug : `${fallback}-${text.length}`;
+}

package/src/providers/shared/vendor-operations.ts

@@ -127,6 +127,48 @@ export function narrowRequestBody(
  * Apply before reachability, so a schema the projection no longer reaches leaves
  * the document rather than lingering unused.
  */
+/**
+ * Every property a schema describes, including the ones it inherits.
+ *
+ * OpenAPI spells inheritance `allOf: [{ $ref: parent }, { properties: … }]`, and
+ * a schema written that way has no `properties` of its own at the top level.
+ * Microsoft Graph uses it for every entity: `microsoft.graph.message` declares
+ * thirty-one properties and inherits `categories` from `outlookItem`, so reading
+ * `properties` off the schema alone reports a field the vendor plainly does
+ * describe as missing — and the refusal that exists to catch a rename fires on a
+ * document that never changed.
+ *
+ * Nearest definition wins, which is what `allOf` means: a later member overrides
+ * an earlier one, and the schema's own `properties` override everything it
+ * inherits. `seen` is against a cycle in the inheritance chain rather than in the
+ * data — `cutCycles` handles the other kind, and this walk would not reach it.
+ */
+function describedProperties(
+  schema: unknown,
+  schemas: Record<string, unknown>,
+  seen: Set<string> = new Set(),
+): Record<string, unknown> {
+  if (schema === null || typeof schema !== 'object') return {};
+  const record = schema as Record<string, unknown>;
+
+  const reference = record['$ref'];
+  if (typeof reference === 'string') {
+    if (!reference.startsWith('#/components/schemas/')) return {};
+    const name = reference.slice('#/components/schemas/'.length);
+    if (seen.has(name)) return {};
+    seen.add(name);
+    return describedProperties(schemas[name], schemas, seen);
+  }
+
+  const collected: Record<string, unknown> = {};
+  for (const member of (record['allOf'] as unknown[] | undefined) ?? []) {
+    Object.assign(collected, describedProperties(member, schemas, seen));
+  }
+  Object.assign(collected, (record['properties'] as Record<string, unknown> | undefined) ?? {});
+
+  return collected;
+}
+
 export function projectRequestBody(
   operation: Record<string, unknown>,
   operationId: string,
@@ -154,7 +196,7 @@ export function projectRequestBody(
   }
 
   const name = reference.slice('#/components/schemas/'.length);
-  const source = (schemas[name] as { properties?: Record<string, unknown> } | undefined)?.properties ?? {};
+  const source = describedProperties(schemas[name], schemas);
 
   const properties: Record<string, unknown> = {};
   for (const field of fields) {

package/src/providers/shared/vendor-spec.ts

@@ -16,15 +16,16 @@
  * provider that has that shape.
  */
 
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { OpenAPIToolGenerator, type McpOpenAPITool } from 'mcp-from-openapi';
-import { cutCycles, makeOpaque, referenced, type Spec } from './openapi.ts';
+import { cutCycles, makeOpaque, reachableComponents, type Spec } from './openapi.ts';
 import {
   METHODS,
   dropSystemParameters,
   hoistParameters,
   narrowRequestBody,
+  projectRequestBody,
 } from './vendor-operations.ts';
 
 /** Kept in step with `BUDGET_KB` in `src/cli/tools.test.ts`, which enforces it. */
@@ -98,6 +99,23 @@ export interface VendorSpecOptions {
    * the document rather than lingering unused.
    */
   readonly rewriteRequestBody?: Readonly<Record<string, unknown>>;
+  /**
+   * Narrow an operation's request body to named fields, keeping the vendor's own
+   * types and descriptions.
+   *
+   * The remedy for a body that references a wide entity. Microsoft Graph's
+   * `PATCH /me/messages/{id}` takes a whole `microsoft.graph.message`, which
+   * inlines to 346 KB against a 64 KB budget — and almost all of it is fields
+   * the server computes and ignores on a write.
+   *
+   * Preferred over `rewriteRequestBody` wherever the body is a schema reference,
+   * because it is checked: a field the vendor has renamed, removed, or made
+   * read-only fails the refresh instead of becoming an argument the API quietly
+   * discards. Reach for the rewrite only where there is no schema to project.
+   */
+  readonly projectRequestBody?: Readonly<Record<string, readonly string[]>>;
+  /** What a projected body says about itself. One sentence, baked into the spec. */
+  readonly projectionNote?: string;
 }
 
 export async function vendorSpec(id: string, options: VendorSpecOptions): Promise<void> {
@@ -161,6 +179,7 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
   }
 
   let narrowed = 0;
+  let projected = 0;
   for (const item of Object.values(paths)) {
     for (const [method, operation] of Object.entries(item)) {
       if (!METHODS.includes(method)) continue;
@@ -174,13 +193,44 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
         );
       }
 
+      const fields = operation.operationId
+        ? options.projectRequestBody?.[operation.operationId]
+        : undefined;
+      if (fields && operation.operationId) {
+        projectRequestBody(
+          holder,
+          operation.operationId,
+          (spec.components?.schemas ?? {}) as Record<string, unknown>,
+          fields,
+          options.projectionNote ??
+            'The fields this call actually writes. The entity it shares a schema with is far wider, ' +
+              'and the rest of it is computed by the service rather than set here.',
+        );
+        projected += 1;
+      }
+
       const replacement = operation.operationId
         ? options.rewriteRequestBody?.[operation.operationId]
         : undefined;
       if (replacement) {
-        const body = holder['requestBody'] as { content?: Record<string, unknown> } | undefined;
-        for (const type of Object.keys(body?.content ?? {})) {
-          (body!.content![type] as Record<string, unknown>)['schema'] = replacement;
+        const body = holder['requestBody'] as
+          | { $ref?: string; content?: Record<string, unknown> }
+          | undefined;
+
+        // A body declared as a shared `requestBodies` component has no `content`
+        // here to overwrite — Microsoft Graph's `sendMail` is one, and the
+        // rewrite silently did nothing, leaving the 346 KB entity it was meant
+        // to replace. Replacing the whole node is the only way in, and it also
+        // detaches the operation from a component the trim would otherwise carry.
+        if (!body || typeof body.$ref === 'string' || !body.content) {
+          holder['requestBody'] = {
+            required: true,
+            content: { 'application/json': { schema: replacement } },
+          };
+        } else {
+          for (const type of Object.keys(body.content)) {
+            (body.content[type] as Record<string, unknown>)['schema'] = replacement;
+          }
         }
       }
     }
@@ -212,10 +262,33 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
 
   const schemas = spec.components?.schemas ?? {};
   const opaqued = makeOpaque(schemas, options.opaque ?? [], options.opaqueNote ?? '');
-  const keep = referenced(paths, schemas);
-  const trimmedSchemas = Object.fromEntries(
-    Object.entries(schemas).filter(([name]) => keep.has(name)),
-  );
+
+  // Reachability across *every* component section, not just schemas. A shared
+  // response that survives while the schema it points at is trimmed away is a
+  // dangling reference, and a document full of those is one the generator
+  // refuses outright — see `reachableComponents`.
+  const reach = reachableComponents(paths, (spec.components ?? {}) as Record<string, unknown>);
+
+  const carried: Record<string, unknown> = {};
+  for (const [section, entries] of Object.entries(spec.components ?? {})) {
+    if (entries === null || typeof entries !== 'object') continue;
+
+    // Named by the `security` array rather than by `$ref`, so no walk can see
+    // it and dropping it would leave operations declaring auth that resolves to
+    // nothing.
+    if (section === 'securitySchemes') {
+      carried[section] = entries;
+      continue;
+    }
+
+    const keep = reach[section];
+    if (!keep || keep.size === 0) continue;
+    carried[section] = Object.fromEntries(
+      Object.entries(entries as Record<string, unknown>).filter(([name]) => keep.has(name)),
+    );
+  }
+
+  const trimmedSchemas = (carried['schemas'] ?? {}) as Record<string, unknown>;
   const cuts = cutCycles(trimmedSchemas);
 
   const trimmed: Spec = {
@@ -227,19 +300,18 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
     },
     ...(spec.servers ? { servers: spec.servers } : {}),
     paths,
-    components: { ...spec.components, schemas: trimmedSchemas },
+    components: carried,
   };
 
   await mkdir(options.outputDirectory, { recursive: true });
-  await writeFile(
-    join(options.outputDirectory, options.out),
-    `${JSON.stringify(trimmed, null, 2)}\n`,
-  );
+  const outputPath = join(options.outputDirectory, options.out);
+  await writeFile(outputPath, `${JSON.stringify(trimmed, null, 2)}\n`);
 
   const size = Math.round(JSON.stringify(trimmed).length / 1024);
   const extra = [
     options.hoistPathParameters ? `${hoisted} params hoisted` : '',
     narrowed > 0 ? `${narrowed} body types dropped` : '',
+    projected > 0 ? `${projected} bodies projected` : '',
   ].filter(Boolean);
   console.log(
     `  ${id.padEnd(6)} ${String(Object.keys(paths).length).padStart(2)} paths, ` +
@@ -249,7 +321,7 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
       (extra.length > 0 ? `, ${extra.join(', ')}` : ''),
   );
 
-  await reportLargestTools(id, trimmed, seen.size);
+  await reportLargestTools(id, outputPath, seen.size);
 }
 
 /**
@@ -265,17 +337,26 @@ export async function vendorSpec(id: string, options: VendorSpecOptions): Promis
  * Printed here so the refresh that adds an operation shows its cost, rather than
  * leaving it to a test failure to say so after the fact.
  *
+ * Measured by reading back the file that was just written, rather than the
+ * object it was written from. Those are not reliably the same document — a key
+ * holding `undefined` is present in memory and gone through `JSON.stringify` —
+ * and the validator refused an in-memory shape whose committed form it accepted,
+ * reporting "could not measure" against a spec that was in fact fine. The
+ * artifact is what the budget is about, so the artifact is what is measured.
+ *
  * The count is the other half. The generator answers an unresolvable reference by
  * logging to the console and omitting that one tool, so a document can trim
  * cleanly, write successfully, and quietly advertise less than it selected.
  * `tools.test.ts` only asserts the surface is non-empty, so nothing downstream
  * would notice.
  */
-async function reportLargestTools(id: string, trimmed: Spec, expected: number): Promise<void> {
+async function reportLargestTools(id: string, path: string, expected: number): Promise<void> {
   let measured: Array<{ name: string; kb: number }>;
 
   try {
-    const generator = await OpenAPIToolGenerator.fromJSON(trimmed);
+    const generator = await OpenAPIToolGenerator.fromJSON(
+      JSON.parse(await readFile(path, 'utf8')) as Spec,
+    );
     const tools = await generator.generateTools();
 
     if (tools.length !== expected) {

package/src/providers/shortcut/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Shortcut registers us at connect time — nothing for an operator to set up. */
+export const shortcut = defineProvider({
+  id: 'shortcut',
+  name: 'Shortcut',
+  description: 'Stories, epics, iterations, and workflows, via Shortcut\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.shortcut.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/slack/index.ts

@@ -98,11 +98,11 @@ export const slack = defineProvider({
       'Slack normally needs nothing set up — one browser round trip against the app Lanes ' +
       'registered. Pasting a token is the way past a workspace whose admin has not approved ' +
       'that app, using one from an app the workspace already trusts.',
-    docs: 'docs/detailed/setup/slack.md',
+    docs: 'https://lanes.sh/docs/link/slack',
     docs_url: 'https://api.slack.com/apps',
     steps: [
       'Open https://api.slack.com/apps and choose "Create New App" → "From scratch". Name it and pick the workspace.',
-      'Open "OAuth & Permissions" and add the scopes you need under USER TOKEN SCOPES — not Bot Token Scopes; the MCP server reads the user token. The full set this provider asks for in the browser is listed in docs/detailed/setup/slack.md.',
+      'Open "OAuth & Permissions" and add the scopes you need under USER TOKEN SCOPES — not Bot Token Scopes; the MCP server reads the user token. The full set this provider asks for in the browser is listed in https://lanes.sh/docs/link/slack.',
       'Choose "Install to Workspace" and approve. A Slack admin may have to approve it for you.',
       'Copy the "User OAuth Token". It starts with xoxp- — not the bot token, which starts with xoxb- and will not work here.',
       'The token does not expire unless you enable token rotation on the app. If you rotate or reinstall, run: lanes link connect slack --profile personal --target local --auth pasted_token --replace.',

package/src/providers/square/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Square registers us at connect time — nothing for an operator to set up. */
+export const square = defineProvider({
+  id: 'square',
+  name: 'Square',
+  description: 'Payments, orders, catalog, inventory, and customers, via Square\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.squareup.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/storyblok/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Storyblok registers us at connect time — nothing for an operator to set up. */
+export const storyblok = defineProvider({
+  id: 'storyblok',
+  name: 'Storyblok',
+  description: 'Stories, components, assets, and spaces, via Storyblok\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.storyblok.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/stripe/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Stripe registers us at connect time — nothing for an operator to set up. */
+export const stripe = defineProvider({
+  id: 'stripe',
+  name: 'Stripe',
+  description: 'Payments, customers, invoices, subscriptions, and balances, via Stripe\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.stripe.com' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/supabase/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Supabase registers us at connect time — nothing for an operator to set up. */
+export const supabase = defineProvider({
+  id: 'supabase',
+  name: 'Supabase',
+  description: 'Projects, database schema, SQL, edge functions, and docs, via Supabase\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.supabase.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/tasks/store.ts

@@ -4,6 +4,7 @@ import {
   stringList,
   withFrontmatter,
 } from '#providers/shared/frontmatter.ts';
+import { slugify as slugifyText } from '#providers/shared/slug.ts';
 
 /**
  * How a task is stored, and the only place that knows.
@@ -99,13 +100,7 @@ export function assertTaskId(id: string): void {
 
 /** A stable id from a title, so adding a task does not demand one be invented. */
 export function slugify(title: string): string {
-  const slug = title
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 60);
-
-  return slug.length > 0 ? slug : `task-${title.length}`;
+  return slugifyText(title, 'task');
 }
 
 /**

package/src/providers/tavily/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Tavily registers us at connect time — nothing for an operator to set up. */
+export const tavily = defineProvider({
+  id: 'tavily',
+  name: 'Tavily',
+  description: 'Web search and page content extraction, via Tavily\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://mcp.tavily.com/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});

package/src/providers/todoist/index.ts

@@ -0,0 +1,10 @@
+import { defineProvider } from '#connectivity';
+
+/** Todoist registers us at connect time — nothing for an operator to set up. */
+export const todoist = defineProvider({
+  id: 'todoist',
+  name: 'Todoist',
+  description: 'Tasks, projects, sections, labels, and filters, via Todoist\'s official MCP server.',
+  connector: { kind: 'mcp', endpoint: 'https://ai.todoist.net/mcp' },
+  auth: { kind: 'oauth', registration: 'dynamic' },
+});