# Ejecuta tareas recurrentes con tu agente

Reutiliza el acceso aprobado, haz una búsqueda por ejecución programada y recupera el trabajo sin enviarlo de nuevo por accidente.

Referencia canónica: https://flashdata.dev/es/docs/guides/recurring-tasks
Revisado: 2026-11-05 por FlashData

<a id="choose"></a>

## Elija cómo funciona la tarea

Su agente host o programador OS proporciona el tiempo. FlashData suministra los datos. Elija un camino de ejecución y probarlo en el ambiente que se ejecutará sin supervisión.

| Uso | Para | State to preserve |
| --- | --- | --- |
| CLI | Un agente con acceso terminal, cron o un script programado. | El perfil CLI, directorio estatal y ejecución original ID. |
| MCP | Un host de agente con un servidor FlashData conectado. | Las credenciales del anfitrión, registro de eventos, trabajo IDs y resultados. |

- [Tareas CLI](https://flashdata.dev/es/docs/guides/recurring-tasks/reference.md#input)
- [Tareas MCP](https://flashdata.dev/es/docs/guides/recurring-tasks/reference.md#mcp)
- [Construir una sesión informativa diaria](https://flashdata.dev/es/docs/guides/daily-research-briefing/reference.md)

<a id="prepare"></a>

## Consultar el acceso en el entorno programado

Reutilizar una conexión de propietario existente con el permiso google_search. Reclamar acceso temporal antes de uso recurrente. Prueba desde un proceso o sesión programado fresco, no sólo interactivo.

### CLI

Utilice Bash y jq (Git Bash en Windows), bajo el usuario OS que guardó la llave. Establezca su nombre de perfil existente y el directorio de estado absoluto a continuación. Ejecute ambos bloques en la misma terminal; el corredor reutiliza estos ajustes.

El cheque de acceso debe imprimir verdadero. Compare availableCredits con estimatedCredits antes de la primera búsqueda. Estos cheques no envían una consulta.

#### Establezca su conexión guardada

```bash
# Use the profile and state directory that already hold your owner key.
export FLASHDATA_PROFILE='research'
export FLASHDATA_STATE_DIR='/absolute/path/to/existing/flashdata-state'
export FLASHDATA_BIN="$(command -v flashdata)"
unset FLASHDATA_API_KEY
```

#### Acceso gratuito, saldo y cheques de precios

```bash
set -euo pipefail
export FLASHDATA_BIN="${FLASHDATA_BIN:-$(command -v flashdata)}"
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
test -d "$FLASHDATA_STATE_DIR" || { echo 'Existing state directory not found.' >&2; exit 1; }
"$FLASHDATA_BIN" --version
jq --version
"$FLASHDATA_BIN" auth status --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
  jq -e '.ok and .data.accessVerified
    and (.data.identity.identity.recurringAllowed == true)
    and (.data.identity.permittedSources | index("google_search") != null)'
"$FLASHDATA_BIN" account balance --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
"$FLASHDATA_BIN" account pricing --source google_search --request-count 1 \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
```


### MCP

Ejecutar esto en una sesión programada fresca. Deje que el anfitrión reutiliza y refrescar sus credenciales OAuth aprobadas. Debe ser capaz de llegar a FlashData sin un login interactivo en cada carrera.

#### Control de host gratuito

```text
Reutiliza la conexión FlashData MCP existente en este entorno programado.
Llama a get_balance con {}.
Llame a get_pricing con {"source":"google_search","request_count":1}.
Informar el equilibrio y el precio estimado. No busque ni cree nuevo acceso.
```


- [Instalar el CLI](https://flashdata.dev/es/docs/guides/flashdata-cli/reference.md#install)
- [Conectar MCP](https://flashdata.dev/es/docs/integrations/mcp-clients/reference.md)
- [Vincula el acceso de prueba](https://flashdata.dev/es/docs/guides/agent-onboarding/reference.md#claim)

<a id="input"></a>

## CLI: Guardar una tarea por ocurrencia

Cree la carpeta de tareas a continuación, ahorre request.json y run-research.sh dentro de ella. Mantenga esta carpeta separada del directorio de estado credencial existente. Una fecha representa una consulta Google; num establece el número de resultados. Dar un flujo de trabajo diferente su propio prefijo run-ID antes de su primera ejecución.

### Crear la carpeta de tareas

```bash
mkdir -p flashdata-research
cd flashdata-research
```

### request.json

```json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
```


<a id="runner"></a>

### Guardar run-research.sh

Crear run-research.sh junto a request.json en la carpeta de tareas. Copiar el script completo a continuación y guardarlo antes de ejecutar o programar la tarea.

El script congela la entrada para cada fecha y mantiene un archivo de recibo, resultado y error para cada intento. Sólo intentos exitosos publican result.json y receipt.json en el nivel superior de la carpeta fechada. --recurring verifica el acceso del propietario; no crea un calendario.

#### run-research.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
slot=${1:?Pass the scheduled date as YYYY-MM-DD}
[[ "$slot" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || exit 2
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
cd -- "$(dirname -- "$0")"
dir="runs/$slot"
mkdir -p "$dir"
if [[ -e "$dir/request.json" ]]; then
  cmp -s request.json "$dir/request.json" || {
    echo 'Input changed for this slot. Inspect its saved run.' >&2; exit 1;
  }
else
  (set -C; cat request.json > "$dir/request.json")
fi
attempt=$(mktemp -d "$dir/attempt.XXXXXX")
if ! "$FLASHDATA_BIN" query --input "$dir/request.json" --recurring \
  --run-id "scheduled-research:$slot:Asia-Shanghai" \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" \
  --output "$attempt/result.json" --timeout 2m --json --non-interactive \
  > "$attempt/receipt.json" 2> "$attempt/error.json"; then
  cat "$attempt/error.json" >&2
  exit 1
fi
jq -e '.ok == true' "$attempt/receipt.json" >/dev/null
jq -e '.source == "google_search" and .status == "done"
  and (.results[0].organic | type == "array")' "$attempt/result.json" >/dev/null
# Publish a stable path only after the query and its receipt both succeed.
cp "$attempt/result.json" "$dir/result.next.json"
mv "$dir/result.next.json" "$dir/result.json"
cp "$attempt/receipt.json" "$dir/receipt.next.json"
mv "$dir/receipt.next.json" "$dir/receipt.json"
jq '{runId, cached, usage}' "$attempt/receipt.json"
printf 'Saved result: %s\n' "$dir/result.json"
```


<a id="slot"></a>

### Ejecute una vez, luego prueba una nueva prueba de proceso

Corre desde la carpeta de tarea. El primer comando envía una búsqueda. El segundo utiliza la misma cuenta, entrada, perfil y estado para leer el resultado guardado después de comprobar que el acceso sigue siendo válido.

#### Una ocurrencia · dos inicios de proceso

```bash
# Use the date of the intended occurrence, including on retries.
bash run-research.sh 2026-11-04

# Same account, input, profile and state: reuse the completed run.
bash run-research.sh 2026-11-04
```


<a id="result"></a>

### Confirmación del resultado fue reutilizado

El segundo recibo debe mostrar caché: verdadero. Su uso pertenece a la búsqueda original. Un array orgánico vacío todavía puede ser un resultado exitoso.

#### Inspeccione el resultado guardado y la recepción

```bash
jq '{ok, runId, cached, usage}' runs/2026-11-04/receipt.json
jq '.results[0].organic | map({title, link})' runs/2026-11-04/result.json
```

#### Segundo recibo · extracto

```json
{
  "schemaVersion": 1,
  "ok": true,
  "runId": "scheduled-research:2026-11-04:Asia-Shanghai",
  "cached": true
}
```


<a id="files"></a>

### Mantenga los archivos entre las carreras

| Archivo | Uso |
| --- | --- |
| runs/DATE/request.json | Exacta entrada para esa ocurrencia; cambiarlo hace que el corredor pare. |
| runs/DATE/result.json + receipt.json | El último intento exitoso. Únicamente consumirlos después de que el comando actual salga con éxito. |
| runs/DATE/attempt.*/ | Resultado, recibo y error para cada intento, incluyendo fallos. |
| FLASHDATA_STATE_DIR | Las credenciales protegidas y los registros de ejecución CLI. Mantenga el mismo perfil y usuario de OS. |

- [Recuperar una carrera interrumpida](https://flashdata.dev/es/docs/guides/agent-recovery/reference.md)

<a id="mcp"></a>

## MCP: persiste la ocurrencia y el trabajo ID

Utilice este cuerpo de tareas con un anfitrión que mantiene el estado de tarea duradero y permite una ejecución activa por ocurrencia. Guardar el trabajo devuelto ID inmediatamente; después de un reinicio, leer el trabajo aceptado en lugar de buscar de nuevo.

### tarea recurrente de MCP · Guardar como recurring-task.txt

```text
Utilice la ocurrencia original del programador ID y el tiempo programado.
Reutiliza la conexión FlashData MCP existente y guarda registro de ocurrencias.
1. Si esta ocurrencia está completa, devuelva su resultado salvado sin buscar.
2. Si tiene un trabajo ID, llame a get_job con ese job_id para leer el trabajo existente.
3. Si una presentación comenzó pero no tiene ningún resultado o trabajo ID, deténgase para su revisión.
4. Para una nueva ocurrencia, consulte get_balance y get_pricing para un google_search.
   Continúe únicamente con el presupuesto aprobado por partida y el saldo disponible.
5. Persist submission_started antes de llamar a google_search una vez con:
   {"query":"battery recycling pilot plant announcements","num":5,"gl":"us","hl":"en","tbs":"qdr:w","mode":"async"}
6. Guardar el trabajo devuelto ID inmediatamente. Léalo con get_job hasta la terminal; parar en el fallo.
   Mantenga el ID a través de los plazos y deje de esperar en el plazo del anfitrión.
7. Guardar el resultado, fuente URLs y uso, luego marcar este evento completo.
En 401, 403, 402, 429 o un resultado desconocido, detenga e informe del registro guardado.
Honor Retry-After. No cree acceso de reemplazo u otra consulta pagada.
Mantenga el informe local; use un destino de entrega sólo si está configurado por separado.
```

- [Herramientas MCP](https://flashdata.dev/es/docs/mcp/reference.md)
- [Lea un trabajo aceptado](https://flashdata.dev/es/docs/mcp/reference.md#jobs)

<a id="mcp-retries"></a>

### Lo que debe persistir el anfitrión

Un solo impulso no puede evitar duplicados. MCP las llamadas no heredan CLI Corre...ID protección. Su anfitrión debe persistir la ocurrencia original, estado de presentación y trabajo ID. Si no puede, use el CLI corredor para el paso de datos. Este registro de ejemplo pertenece a su anfitrión; no es un MCP petición.

#### Grabación de host · ilustrativo

```json
{
  "occurrence": "research:2026-11-04:Asia-Shanghai",
  "state": "accepted",
  "job_id": "<returned job ID>",
  "output": null
}
```


<a id="schedule"></a>

## Programar la tarea probada

El ejemplo a continuación utiliza OpenClaw en 09:00 Asia/Shanghai. Crear el trabajo desactivado, ejecutar ese trabajo guardado manualmente, inspeccionar su salida, y luego activarlo. Para otro programador, siga la misma secuencia con sus controles de gestión de pruebas.

| Configuración | Uso |
| --- | --- |
| Concurrencia | Una ejecución activa para este flujo de trabajo, con estado duradero. |
| Hora de correr | Utilice el mismo usuario de OS y caminos absolutos para el CLI, carpeta de tareas y estado credencial. Las exportaciones de terminales no son heredadas automáticamente por una pasarela. |
| Retries | Mantenga la ocurrencia original y la fecha programada, incluso después de la medianoche. Una prueba manual utiliza su fecha de invocación en Asia/Shanghai. |
| Sucesos perdidos | Elija si saltar o ponerse al día. Un registro de hoy devuelve los datos actuales, incluso si se etiqueta con la fecha de ayer. |
| Entrega | Guardar localmente primero. Configurar una política de destino y notificación antes de enviar informes. |

- [Prepare un servidor o contenedor](https://flashdata.dev/es/docs/guides/production-deployment/reference.md)

<a id="cli-task"></a>

### CLI órgano de tareas para un anfitrión de agente

Reemplazar el perfil y los propietarios de caminos, a continuación, guardar recurring-task.txt en la carpeta de tareas. Utilice este cuerpo para CLI ejecución, o MCP cuerpo arriba para MCP ejecución directa OS El programador puede ejecutar el Bash script con estas variables de entorno sin un modelo.

#### recurring-task.txt

```text
Ejecute la tarea de investigación FlashData aprobada bajo el usuario OS que guardó la clave.
Corredor: camino a run-research.shConferencia
Establecer estas variables de entorno para el proceso del corredor:
FLASHDATA_BIN: <unk>absolute path to flashdata confianza
FLASHDATA_PROFILE: Identificando el nombre de perfil
FLASHDATA_STATE_DIR: Identificando el directorio de estado absoluto
Mantenga FLASHDATA_API_KEY unset para reutilizar la credencial salvada.
Utilice la fecha programada original en Asia/Shanghai, como YYYY-MM-DD.
Para una ejecución manual, guarde su fecha de invocación antes de la ejecución.
Corre: Bash "<absolute path to run-research.sh>" YYYY-MM-DD
Mantenga esa fecha en los registros, incluso después de la medianoche. Permitir una ejecución activa.
Mantenga el mismo perfil, request.json y directorio estatal.
Sólo lea la fecha result.json después de que el comando sale con éxito.
Informar enlaces fuente, ejecutar ID y uso. Mantener salidas locales.
En caso de error, deténgase e informe del error guardado. No inicie el trabajo de reemplazo o cree nuevo acceso.
```


<a id="openclaw-schedule"></a>

### 1. Cree un trabajo OpenClaw deshabilitado

Utilice una pasarela y un agente existente que pasó el cheque de acceso. OpenClaw 2026.10.10; actualizar clientes mayores si --wait no está disponible. En la carpeta que contiene recurring-task.txt, set OPENCLAW_AGENT_ID a ese agente ID.

El comando guarda openclaw-job.json sin sobrescribir un archivo existente. Léalo y establece OPENCLAW_JOB_ID al trabajo devuelto ID. Si la creación pierde su respuesta, lista de automatizaciones de inspección --all --json antes de crear otro trabajo. --no-deliver deshabilita el anuncio automático; el cuerpo de tareas también mantiene informes locales.

#### Bash · crea un trabajo discapacitado

```bash
: "${OPENCLAW_AGENT_ID:?Set the existing OpenClaw agent ID}"
test -s recurring-task.txt || exit 1
# Keep the receipt. An existing file blocks accidental recreation.
(
  set -o noclobber
  openclaw automations add --name flashdata-daily-research \
    --agent "$OPENCLAW_AGENT_ID" \
    --cron "0 9 * * *" --tz Asia/Shanghai --exact \
    --session isolated --disabled --no-deliver \
    --message "$(cat recurring-task.txt)" --json > openclaw-job.json
)
```

- [Configuración OpenClaw](https://flashdata.dev/es/docs/integrations/openclaw/reference.md)
- [Referencia de programación OpenClaw](https://docs.openclaw.ai/cli/cron)

<a id="test-schedule"></a>

### 2. Pruebe el trabajo guardado antes de habilitarlo

Ejecute el trabajo guardado una vez mientras su horario se mantiene deshabilitado. Presupuesto para una búsqueda de prueba y costos de modelo; una ocurrencia CLI completada puede reutilizar su resultado. Este comando espera hasta 10 minutos.

Espera completionStatus: succeeded y comprueba el resultado guardado, los enlaces a fuentes y el consumo. En la CLI, consulta runs/DATE/result.json y receipt.json; en MCP, consulta el registro de la ejecución y el resultado del trabajo guardados por el agente. enqueued: true por sí solo indica que se ha aceptado, no que se haya completado.

#### Correr una vez · guardar el recibo de prueba

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
# Run the saved job once; its schedule stays disabled.
(
  set -o noclobber
  openclaw automations run "$OPENCLAW_JOB_ID" \
    --wait --wait-timeout 10m --json > openclaw-test-run.json
)
```

#### Lea el recibo de la prueba

```bash
cat openclaw-test-run.json
```


<a id="inspect-test"></a>

### Inspeccione una prueba temporal o fallada

Un timeout deja de esperar, no la tarea Gateway. Lea la historia reciente si el recibo está vacío. Establecer OPENCLAW_RUN_ID al OpenClaw runId desde el recibo o la historia, a continuación, inspeccionar esa ejecución. No repita el comando de ejecución para comprobar el progreso.

Esta es la ejecución del programador ID, no el FlashData recurriendo a la carrera ID o un MCP Trabajo de datos ID. Si el agente no puede iniciar sesión o ejecutar la tarea de datos, mantenga el horario desactivado y repare ese paso primero.

#### Inspeccionar la misma ejecución

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
cat openclaw-test-run.json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json

# Set this from the receipt or history; this is OpenClaw's run ID.
: "${OPENCLAW_RUN_ID:?Set the OpenClaw test run ID}"
openclaw automations runs "$OPENCLAW_JOB_ID" \
  --run-id "$OPENCLAW_RUN_ID" --json
```

- [Recuperar el paso de datos FlashData](https://flashdata.dev/es/docs/guides/agent-recovery/reference.md)

<a id="manage-schedule"></a>

### 3. Permite después de comprobar la salida

Revise el agente salvado, el horario, la zona horaria y la prueba finalizada. Hágalo sólo después de que la salida sea correcta y se apruebe el costo recurrente. Desactivar más adelante detiene futuras invocaciones; no cancela una consulta ya presentada.

#### Revisar el trabajo guardado y la historia de la prueba

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
openclaw automations show "$OPENCLAW_JOB_ID" --json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json
```

#### Habilitar el horario diario

```bash
openclaw automations enable "$OPENCLAW_JOB_ID"
```

#### Pausa futuros se ejecuta cuando es necesario

```bash
openclaw automations disable "$OPENCLAW_JOB_ID"
```


<a id="budget"></a>

## Establecer reglas de costo y fracaso

| Situación | Medida |
| --- | --- |
| Planificación de costos | Precio por consulta × ocurrencias planificadas. Añadir modelo y host cuesta por separado; el recuento del resultado no es el recuento de la consulta. |
| Saldo de cuenta compartido | Ejecute su presupuesto en el programador o host. Estos ejemplos no imponen una tapa de gasto clave separada. |
| 401 / 403 / 402 | Pausa futuros envíos. Arreglar credenciales, permiso o equilibrio; reanudar con la ocurrencia original y estado guardado. |
| 429 | Respetar Retry-After. Inspeccione la carrera CLI o la ocurrencia MCP antes de decidir si una nueva presentación es segura. |
| Resultado de la presentación desconocida | Mantenga el estado salvado y deténgase. Recuperar un trabajo conocido ID; no crear un ID de nuevo para evitar la incertidumbre. |

- [Tasas actuales](https://flashdata.dev/es/pricing)
- [Decisiones de recuperación](https://flashdata.dev/es/docs/guides/agent-recovery/reference.md)

<a id="stop"></a>

## Parar el horario y revocar el acceso por separado

1. Pausa al programador para detener futuras invocaciones.
2. Revoque la conexión de agente, la aplicación OAuth o la tecla API en la consola. La revocación bloquea el nuevo uso autenticado; no borra los archivos exportados.
3. Repita el cheque de acceso gratuito de un proceso fresco. Debe fallar después de la revocación. CLI auth logout sólo elimina las credenciales locales; no revoca el acceso remoto.

- [Aplicaciones y agentes conectados](https://flashdata.dev/app/settings/connections)
- [Claves API](https://flashdata.dev/app/api-keys)
- [Acceso al ciclo de vida](https://flashdata.dev/es/docs/guides/agent-access/reference.md)
