long-waits

Chain repeated 10-minute background intervals to schedule deferred tasks and poll conditions.

6|Updated Feb 25, 2026
One-click install
npx skills add https://github.com/archibate/archibate-skills --skill long-waits
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: long-waits
Source: https://github.com/archibate/archibate-skills/tree/main/skills/long-waits
Command: npx skills add https://github.com/archibate/archibate-skills --skill long-waits

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Many automation tasks must wait for long delays or for external conditions to become true, but shells and simple timers hit limits and block progress or the agent. This Skill provides a safe, observable pattern to schedule deferred actions and poll conditions without hitting single-sleep timeouts or blocking the agent.

Core Features & Use Cases

  • Chained interval waiting: break long delays into repeated background intervals to bypass shell timeout limits and remain event-driven.
  • Condition polling and notifications: periodically check for file presence, CI/deploy completion, or log changes and trigger actions when conditions are met.
  • Calendar and wall-clock scheduling: compute time differences, verify system time, and convert target datetimes into interval counts for reliable execution.
  • Use case: wait for a staging build to succeed, checking every 10 minutes, then run integration tests and deploy when ready while reporting progress.

Quick Start

Ask the agent to check the target condition every 10 minutes and run the specified task when the condition becomes true.

Frequently Asked Questions about long-waits

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I schedule a background task to run after a long delay without hitting shell timeout limits?

To schedule long-duration waits without hitting shell timeout limits, you can chain repeated 10-minute background sleep intervals. This approach breaks extended delays into manageable chunks, verifying system time and polling conditions to remain event-driven while providing progress tracking.

How does condition polling work for deferred task execution in Unix-based automation?

Condition polling for deferred task execution works by periodically checking for specific triggers like file presence, CI completion, or log changes. The mechanism chains background sleep intervals to verify system state, triggering actions only when the target condition becomes true.

What is the best way to wait for a staging build to succeed and then automatically run integration tests?

The best way to wait for a staging build to succeed is using chained interval waiting. It checks the build condition every 10 minutes, bypassing shell timeout limits, then automatically triggers integration tests and deployment when the condition is met while reporting progress.

Can I use calendar-triggered runs to execute actions at a specific target datetime?

Yes, you can execute calendar-triggered runs by computing time differences and verifying system wall-clock time. The mechanism converts target datetimes into interval counts, ensuring reliable execution of deferred actions at specific scheduled times.

Why does my long-duration sleep block the agent and prevent progress reporting?

Long-duration sleep blocks the agent because simple timers hit single-sleep timeout limits. Using chained background intervals bypasses these limits, keeping the agent unblocked while providing observable progress tracking throughout the wait period.

When should I not use chained interval polling for background job completion waits?

You should not use chained interval polling if your environment lacks Unix-based shell support or if your tasks require sub-10-minute immediate execution. This approach is specifically designed for extended delays and deferred task execution rather than real-time event processing.