longrun

Run concurrent batch processing in tmux with JSONL output to disk.

1|Updated Feb 17, 2026
One-click install
npx skills add https://github.com/snqb/my-skills --skill longrun
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: longrun
Source: https://github.com/snqb/my-skills/tree/main/longrun
Command: npx skills add https://github.com/snqb/my-skills --skill longrun

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Batch processing and long-running tasks can stall interactive sessions and create fragmented, hard-to-audit logs. longrun provides a structured pattern to run concurrent scripts inside tmux, streaming results to disk for resume and monitoring.

Core Features & Use Cases

  • Asynchronous concurrency with a configurable level of parallelism.
  • Streaming JSONL outputs for real-time monitoring and post-processing.
  • Resume capability by scanning existing outputs and skipping completed items.
  • Use cases include API data collection, large-scale scraping, and batch file processing.

Quick Start

Create a Python script that processes a list of items concurrently and streams results to /tmp/TASKNAME.jsonl.

Frequently Asked Questions about longrun

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

FAQPage Schema
How do I run batch API calls concurrently without blocking my interactive session?

Batch processing tasks like API calls or scraping are handled by running asyncio concurrency inside tmux. This streams results to disk as JSONL files, preventing session stalls and creating auditable logs for large item lists.

Can I resume a long-running web scraping task if it gets interrupted?

Yes, batch processing supports resume capability by scanning existing JSONL outputs and skipping completed items. When you restart the concurrent task, it automatically detects previously processed items and continues from where it stopped.

How do I monitor the progress of concurrent batch processing tasks in real time?

Monitor concurrent batch processing by streaming per-item results to a JSONL file. This output format allows you to watch for new entries in real time and use the structured logs for post-processing analysis.

Does this batch processing approach work for data transformations that take longer than ten seconds?

Yes, this batch processing approach is designed for data transformations and tasks that take longer than ten seconds. It uses asynchronous concurrency with a configurable level of parallelism to handle large item lists efficiently.

What is the best way to manage parallelism when processing large lists of items?

Manage parallelism when processing large lists by using an asyncio-based semaphore that provides a configurable level of concurrency. This limits simultaneous operations, preventing resource exhaustion during large-scale batch processing.