# Rutinas y grupos

Tu equipo de Mets no solo responde: **aprende rutinas**. Una rutina es un proceso del negocio
—crear y publicar en tus redes, anunciar lo que vendes, hacer seguimiento a tus clientes— que
el equipo repite cada vez: tres pasos y, en cada paso, dos caminos para elegir. Esas rutinas
corren en **grupos**, donde las personas del negocio y sus Mets conversan y trabajan juntos (en
Met, «Conversaciones» → «Grupos»). Y cada vez que una rutina corre, deja una **tarea**.

Con la API **lees** las tres cosas. Empezar una rutina, elegir un camino, crear un grupo o sumar
a alguien se hace en Met.

## Antes de empezar

Tu key necesita `routines:read` para las rutinas y `groups:read` para los grupos. Las keys
emitidas antes de que existieran no los traen: agrégalos en **Ajustes › Desarrolladores** o
emite una nueva. Funcionan también con una key de test (`met_test_`), porque solo leen. El campo
`origin` de las tareas no pide nada nuevo: va con `tasks:read`, como el resto de la tarea.

## Las rutinas del negocio

```ts
import { Met } from '@meteor.ia/sdk';

const met = new Met(process.env.METEOR_API_KEY!);

const { data: rutinas } = await met.routines.list();
for (const r of rutinas) {
  console.log(r.id, '—', r.name);
  for (const paso of r.steps) {
    console.log(`  ${paso.number}. ${paso.title}:`, paso.paths.map((c) => `${c.title} (${c.done_by})`).join(' / '));
  }
}
```

Cada rutina trae:

- `id`, `name` y `achieves` (qué logra, en una o dos frases).
- `steps`: los pasos, en orden, con la pregunta que le hace el Met a la persona en cada uno.
- `paths` en cada paso: los caminos para elegir, con `done_by` —`met` lo hace un Met
  (`met_name` dice cuál), `person` lo hace la persona, `automatic` lo hace Meteor sin IA— .

**Solo salen las rutinas disponibles en tu negocio.** Algunas se abren de a poco: mientras una
no esté disponible para ti, no aparece en la lista y `met.routines.retrieve(id)` responde 404.

**Los ids son texto, no una lista cerrada.** Hoy las rutinas abiertas son `redes`, `anuncios`
y `seguimiento` (y hay otras en piloto), pero el producto suma rutinas y caminos cada semana.
Trata un id que no conoces como uno más, no como un error.

## Los grupos

```ts
for await (const g of met.groups.iterate()) {
  const personas = g.members.people.map((p) => `${p.name} (${p.role})`);
  const mets = g.members.mets.map((m) => (m.main ? `${m.name} ★` : m.name));
  console.log(g.title, '·', g.purpose ?? 'sin propósito', '·', personas.join(', '), '·', mets.join(', '));
}
```

Cada grupo trae para qué es (`purpose`), la rutina que corre en él (`routine`, el `id` de una
rutina, o `null`) y sus miembros, **separados**:

- `members.people`: las personas, con su `role` —`owner` lo creó, `approver` aprueba lo que los
  Mets del grupo dejan esperando, `member` el resto—.
- `members.mets`: los Mets. El Met principal del negocio llega primero, con `main: true`; un
  grupo solo de personas no lo trae.

**Solo ves tus grupos.** La lista trae los grupos de los que eres parte —o de los que es parte
la persona que representa tu key—. Los de otras personas no se ven, tampoco con una key de
administrador: es la misma regla de las conversaciones.

**Una conversación de a dos no es un grupo.** Si solo están dos personas, sin propósito ni
rutina, la app la muestra como la conversación con esa persona, y aquí no aparece: ni en la
lista ni en el detalle (`404`). Basta con darle un propósito, sumar a alguien más o a un Met para
que sea un grupo.

La lista es siempre `{ data, has_more, next_cursor }`, del grupo más nuevo al más viejo: pasa
`next_cursor` en `starting_after` hasta que `has_more` sea `false`, o usa `iterate()`.

## De dónde nació una tarea

Cada tarea suma `origin`:

```ts
const tarea = await met.tasks.retrieve('b3e1c0d2-4f5a-4e6b-8c7d-9a0b1c2d3e4f');
if (tarea.origin?.type === 'routine') {
  console.log('La dejó la rutina', tarea.origin.routine, 'en el grupo', tarea.origin.group_id);
}
```

| `origin.type` | Qué quiere decir |
|---|---|
| `routine` | La corrida de una rutina (o su programación semanal). `routine` dice cuál. |
| `group` | La dejó un Met mientras trabajaba en un grupo. |
| `conversation` | La dejó un Met en una conversación con Mets. |

`group_id` y `conversation_id` solo llegan si **puedes ver** ese grupo o esa conversación; si
no, llegan `null` y el resto del origen se mantiene. `origin: null` quiere decir que la tarea no
guarda de dónde nació: la creó una persona, la API o una automatización. Si en una respuesta no
se pudo averiguar, el campo no viene. `type` también crece: trata un valor que no conoces como
«otro origen».

## Desde el conector MCP

El conector tiene `met_list_routines`, `met_list_groups` y `met_get_group`. Sus scopes no se
piden solos al conectar Claude: una app que las quiera tiene que pedir `routines:read` y
`groups:read` al registrarse.

## Lo que no se puede (todavía)

- Empezar una rutina, elegir un camino o programarla.
- Crear un grupo, sumar o sacar a alguien.
- Leer los mensajes de un grupo.

Todo eso sigue en Met.