jobs

Manage durable background job lifecycles and recovery in the codegg daemon.

Updated May 6, 2026
One-click install
npx skills add https://github.com/dbowm91/codegg --skill jobs-dbowm91
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jobs
Source: https://github.com/dbowm91/codegg/tree/main/.opencode/skills/jobs
Command: npx skills add https://github.com/dbowm91/codegg --skill jobs-dbowm91

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the complexity of managing long-running, asynchronous background tasks that require persistence, idempotency, and reliable recovery in a distributed or daemonized environment.

Core Features & Use Cases

  • Durable Execution: Ensures jobs survive process restarts and system failures through SQLite-backed state management.
  • Scheduling & Idempotency: Provides robust mechanisms for recurring tasks with overlap protection and strict idempotency classes to prevent duplicate side effects.
  • Use Case: Use this skill to define a recurring subagent task that performs periodic repository health checks, ensuring the job automatically recovers its state if the daemon is interrupted.

Quick Start

Use the jobs skill to register a new recurring subagent job that executes every hour with skip-if-running overlap protection.

Frequently Asked Questions about jobs

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

FAQPage Schema
How do I manage durable background tasks that survive process restarts in Rust?

Durable background tasks require SQLite-backed state management to persist job lifecycle data. This ensures jobs survive process restarts and system failures by facilitating job stores, dispatchers, and atomic state transitions within the daemon architecture.

How does idempotency prevent duplicate side effects in recurring scheduled jobs?

Idempotency in scheduled jobs enforces strict classes to prevent duplicate side effects. It uses overlap protection mechanisms, such as skip-if-running, to ensure recurring tasks do not execute concurrently and repeat actions unnecessarily.

What's the best way to recover background job state after a daemon interruption?

Recovering background job state after a daemon interruption requires durable execution with SQLite-backed state management. The system automatically recovers state and enforces boundaries between UI, server, and core execution layers.

Can I use SQLite for job scheduling and atomic state transitions in a Rust daemon?

SQLite supports job scheduling and atomic state transitions in a Rust daemon by acting as the persistent backing store. It manages state transitions, boundary enforcement, and reliable recovery for complex asynchronous workflows.

When do I need strict idempotency classes for asynchronous background workflows?

Strict idempotency classes are needed for asynchronous background workflows when executing recurring tasks that require overlap protection. They prevent duplicate side effects during complex job dispatching and ensure reliable recovery.

Why does my background job dispatcher lose state during system failures?

Background job dispatchers lose state during system failures without durable execution. Implementing SQLite-backed state management ensures atomic state transitions and allows the dispatcher to recover jobs automatically after an interruption.