grace-execute

Execute GRACE development plan steps sequentially with verification and commits.

233|51|Updated Feb 17, 2026
One-click install
npx skills add https://github.com/osovv/grace-marketplace --skill grace-execute
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: grace-execute
Source: https://github.com/osovv/grace-marketplace/tree/main/skills/grace/grace-execute
Command: npx skills add https://github.com/osovv/grace-marketplace --skill grace-execute

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Orchestrates end-to-end, sequential implementation of a GRACE development plan so modules are generated, verified, and committed in a controlled, dependency-safe order, preventing drift and broken builds caused by parallel or uncoordinated work.

Core Features & Use Cases

  • Controller-driven execution queue: parse development-plan.xml and knowledge-graph.xml once and build compact execution packets for each step.
  • Scoped generation and verification: generate code per-step, run step-level verification and scoped reviews, and escalate only when broader drift is detected.
  • Atomic commits and graph sync: commit module implementations immediately after verification and update the shared knowledge graph and plan artifacts centrally.
  • Use Case: Ideal for finishing a small set of high-dependency modules, performing risk-averse delivery waves, or maintaining strict knowledge-graph integrity in large repos.

Quick Start

Run the grace-execute skill to sequentially process the approved execution queue and commit each validated module implementation.

Frequently Asked Questions about grace-execute

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

FAQPage Schema
How do I execute a development plan sequentially to prevent dependency drift?

Sequential execution of a development plan involves processing ordered phases step-by-step, generating and verifying modules individually, and committing them immediately to prevent drift and broken builds caused by uncoordinated work.

When should I use sequential module execution instead of parallel waves?

Sequential module execution is necessary when dependency risk makes parallel waves unsafe, requiring strict knowledge-graph integrity and controlled, dependency-safe ordering to generate and commit modules without breaking builds.

How do code generation and git commits work with a knowledge graph?

Code generation applies step-level verification against a parsed knowledge graph, proposing graph deltas and committing module implementations immediately after validation to synchronize shared plan artifacts centrally.

What files are required to sequentially execute and commit development steps?

Sequential execution requires parsed docs/development-plan.xml and docs/knowledge-graph.xml files defining ordered phases and steps, along with controller-managed execution packets to process the approved queue.

What is the best way to maintain knowledge-graph integrity in large repositories?

Maintaining knowledge-graph integrity in large repositories requires scoped step-level verification, atomic commits immediately after validated generation, and centralized updates to shared graph and plan artifacts after each module.

Does scoped code generation limit verification to individual modules?

Scoped code generation runs step-level verification and scoped reviews per module, escalating only when broader dependency drift is detected across the sequentially executed development plan phases.