repo-task-proof-loop

Automate a repo-local proof loop with routing, frozen specs, and fresh verification.

1|Updated Apr 21, 2026
One-click install
npx skills add https://github.com/Lionheart-code/repo-task-proof-loop --skill repo-task-proof-loop-lionheart-code
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: repo-task-proof-loop
Source: https://github.com/Lionheart-code/repo-task-proof-loop/tree/main
Command: npx skills add https://github.com/Lionheart-code/repo-task-proof-loop --skill repo-task-proof-loop-lionheart-code

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires git, python3, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

It solves the problem of unreliable, hard-to-audit coding progress by turning a task into a durable, repo-local proof loop with routing, frozen specs, evidence capture, and fresh verification.

Core Features & Use Cases

  • Repo-local proof loop: creates and updates .agent/tasks/<TASK_ID>/ so work is resumable and auditable.
  • Frozen-spec + evidence + fresh verify: enforces a strict sequence from spec freeze through evidence packing and repeated fresh verification until every acceptance criterion passes.
  • Codex-first bounded subagents: uses installed helper roles for discovery and scoped implementation, with fallback to built-in helpers only when task-specific roles are unavailable.
  • Use case: when you need a substantial feature, refactor, migration, or bug fix that must leave behind concrete evidence and a verifiable PASS/FAIL trail.

Quick Start

Use repo-task-proof-loop to initialize the repo-local task state for TASK_ID demo-task and then automatically drive the proof loop until all acceptance criteria are verified as PASS.

Frequently Asked Questions about repo-task-proof-loop

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

FAQPage Schema
How do I automate an auditable proof loop for multi-file coding tasks in my repo?

An auditable repo-local proof loop is automated by initializing durable task artifacts that route through a strict freeze, build, evidence, verify, and fix sequence. This ensures every acceptance criterion passes with concrete evidence.

What is a frozen spec workflow and when do I need it for refactoring?

A frozen spec workflow locks requirements before implementation begins, routing them through fresh verification until acceptance criteria pass. You need it for refactors or migrations requiring auditable progress and explicit non-goals across multiple files.

How do I set up repo-local task state to make coding progress resumable?

To set up resumable coding progress, initialize a durable task state inside the .agent/tasks directory. This routes work through scoped subagents and stores workflow outputs locally so progress remains auditable across sessions.

Do I need git and python3 to run a repo-local proof loop?

Yes, you need git and python3 installed in your environment to run the repo-local proof loop. These dependencies initialize the durable task artifacts and execute the bounded subagent scripts required for fresh verification.

How does fresh verification work when fixing bugs with Codex subagents?

Fresh verification works by repeatedly testing built code against frozen specs within the loop, using Codex subagents for scoped implementation. If verification fails, a fixer role resolves issues until all acceptance criteria pass.

What is the best way to maintain a verifiable PASS/FAIL trail for feature work?

The best way to maintain a verifiable PASS/FAIL trail is enforcing a strict route, freeze, build, evidence, and verify sequence. This confines workflow outputs to a local task directory and captures concrete evidence for every acceptance criterion.