loop

Executes active goal contracts through parallel worktree waves with verification gates.

1|1|Updated Jun 21, 2026
One-click install
npx skills add https://github.com/Navdeepgambhir9023/nav --skill loop-navdeepgambhir9023
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: loop
Source: https://github.com/Navdeepgambhir9023/nav/tree/main/skills/loop
Command: npx skills add https://github.com/Navdeepgambhir9023/nav --skill loop-navdeepgambhir9023

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a declared goal into verified, completed work requires orchestrating many tasks without letting an agent prematurely claim success. This Skill drives an ACTIVE goal contract through waves of parallel execution, independent review, and mechanical verification, refusing to close the goal until the contract is provably satisfied. ## Core Features & Use Cases - Wave-Based Parallel Execution: Groups plan tasks into dependency-ordered waves using produces/consumes edges, depends_on overrides, and scope_paths disjointness, then dispatches each task to an isolated git worktree subagent. - Multi-Signal Verification Gates: Requires executor success, per-task reviewer PASS, mechanical verification commands, and a whole-contract /verify verdict before advancing or closing a goal. - Resumable State Machine: Persists state.json, an append-only journal.nav audit log, and checkpoints before irreversible transitions so a crash mid-wave can resume from the last persisted state. - Use Case: Migrating a 5-year-old React-JS codebase to Next.js and TypeScript: the engine groups hundreds of file tasks into 3 parallel waves instead of 6 serial stages, verifies each against the contract, and closes the goal only when independent verification agrees. ## Quick Start Ask the agent to run the loop skill to execute the currently active goal's plan through verified waves until the contract is satisfied.

Frequently Asked Questions about loop

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

FAQPage Schema
How do I execute a multi-task plan with parallel AI agents?

Activate a goal with a contract and plan, then invoke the loop skill. It groups remaining tasks into dependency-ordered waves, dispatches each task to an isolated git worktree subagent, and advances only after reviewer and verifier approval.

How does the loop skill decide which tasks run in parallel?

It uses three dependency signals: produces/consumes edges as the primary topological signal, explicit depends_on overrides, and scope_paths file-overlap detection as a safety net. Tasks with disjoint scope and satisfied dependencies run in the same wave.

Can I force serial execution instead of parallel waves?

Yes. Set execution.style to serial in contract.json to run tasks one at a time in the main checkout. Wave-based parallel execution remains the default because it suits large migrations with many independent file slices.

What happens if the loop crashes or is interrupted mid-wave?

The engine persists state.json, an append-only journal.nav, and checkpoints before irreversible transitions. On restart it reloads the last persisted state, re-runs drift checks, re-validates tracking commits against git log, and resumes from the wave cursor.

Why does the loop refuse to close a goal even when tests pass?

Passing mechanical verification commands is only one signal. The engine also requires a whole-contract /verify verdict of COMPLETE from an independent verifier subagent, and it blocks CLOSE if a KB_GAP surfaces owner-curated content the engine cannot write.

What are the limitations of the loop execution engine?

It cannot start without an ACTIVE goal and valid contract, cannot modify the contract or plan itself (changes require a RECONTRACT), halts on unresolvable dependency cycles, and escalates rather than auto-completing when token, loop, or retry budgets are exhausted.