pld

Coordinate multi-lane, review-gated development with SQLite as the writable state.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/cometjc/dev-skills --skill pld
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pld
Source: https://github.com/cometjc/dev-skills/tree/main/skills/pld
Command: npx skills add https://github.com/cometjc/dev-skills --skill pld

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill solves the problem of coordinating multi-lane, review-gated development without losing track of state across workers and coordinators, by making SQLite the only writable authority and keeping the coordinator unblocked.

Core Features & Use Cases

  • Multi-lane orchestration (/pld): Runs parallel worker and reviewer flows across independent lane slots while enforcing lane lifecycle transitions.
  • Deterministic lane state via SQLite: Ensures progress, recovery, and closeout correctness are driven by .pld/executor.sqlite, not by chat summaries or ad-hoc notes.
  • Portable monitoring helper: Provides a short, token-efficient command surface (pld status, pld watch --compact, pld audit, pld monitor-bg) to observe execution while lanes run.
  • Safe repair and recovery contracts: Supports blocked/failure recovery, reviewer repair proposals, and recovery completion with evidence recorded as lifecycle events.

Quick Start

Run PLD lanes with one command by telling an agent to execute pld watch <execution-name> --compact to get an immediate, compact view of what is ready, implementing, and the latest launch log.

Frequently Asked Questions about pld

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

FAQPage Schema
How do I coordinate parallel development across multiple worktrees without losing state?

Parallel development across multiple worktrees is coordinated using a single `/pld` entrypoint and SQLite as the only writable state authority. This ensures deterministic lane orchestration and prevents lost progress across independent worker and reviewer flows.

How does SQLite manage review-gated software development lifecycles?

SQLite manages review-gated software development lifecycles by storing all progress, recovery, and closeout state in a dedicated `.pld/executor.sqlite` file. This ensures correctness is driven by deterministic state rather than chat summaries or ad-hoc notes.

What is the best way to monitor parallel lane execution and audit status?

Monitoring parallel lane execution is handled through portable, token-efficient commands like `pld status`, `pld watch --compact`, and `pld audit`. These provide immediate views of what is ready, implementing, and the latest launch logs.

Can I recover blocked or failed lanes during multi-lane orchestration?

Blocked or failed lanes during multi-lane orchestration can be recovered using safe repair and recovery contracts. The system supports reviewer repair proposals and records recovery completion with evidence as deterministic lifecycle events.

Does parallel lane development support idempotent retries for role-specific contracts?

Parallel lane development supports idempotent retries and enforces role-specific contracts for claim, implement, report, and closeout actions. This ensures deterministic lane orchestration across multiple worktrees without duplicating execution.

When should I not use ad-hoc chat summaries for agent monitoring?

Ad-hoc chat summaries should not be used for agent monitoring when coordinating multi-lane, review-gated development. Deterministic state via SQLite is required to ensure progress, recovery, and closeout correctness across independent workers and coordinators.