Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

loop-planner

/loop-planner

Tworzy szczegółowy plan wykonania nowej funkcji na podstawie spec.md i kontekstu projektu, z fazami, zadaniami, kryteriami akceptacji i zależnościami zapisanymi w plan.md.

Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
27.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
5
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (5). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Tworzy szczegółowy plan wykonania nowej funkcji na podstawie spec.md i kontekstu projektu, z fazami, zadaniami, kryteriami akceptacji i zależnościami zapisanymi w plan.md.

Wyzwalacze z opisu

plan featurecreate planstart track
Oryginalny opis (EN)

Evaluate-Loop Step 1: PLAN. Use this agent when starting a new track or feature to create a detailed execution plan. Reads spec.md, loads project context, and produces a phased plan.md with specific tasks, acceptance criteria, and dependencies. Triggered by: 'plan feature', 'create plan', 'start track', '/conductor implement' (planning phase).

Jak działa

  1. Inputs Required
  2. Workflow
  3. Metadata Checkpoint Updates
  4. Handoff
Sekcje z nagłówków SKILL.md, w oryginale · 334 linii, 1 135 słów
Podgląd SKILL.md
---
name: loop-planner
description: "Evaluate-Loop Step 1: PLAN. Use this agent when starting a new track or feature to create a detailed execution plan. Reads spec.md, loads project context, and produces a phased plan.md with specific tasks, acceptance criteria, and dependencies. Triggered by: 'plan feature', 'create plan', 'start track', '/conductor implement' (planning phase)."
---

# Loop Planner Agent — Step 1: PLAN

Creates detailed, scoped execution plans for tracks. This is Step 1 of the Evaluate-Loop.

## Inputs Required

1. Track `spec.md` — what needs to be built
2. `conductor/tracks.md` — what's already been done (to avoid overlap)
3. Track `plan.md` (if exists) — check for prior progress

## Workflow

### 1. Load Context

read_file in order:
1. `conductor/tracks.md` — completed tracks and their deliverables
2. Track's `spec.md` — requirements for this track
3. Track's `plan.md` (if exists) — check what's already `[x]` done
4. `conductor/product.md` — product scope reference
5. `conductor/tech-stack.md` — technical constraints

### 2. Identify Scope Boundaries

Before writing any plan:
- List what `spec.md` asks for (deliverables)
- List what's already done in other tracks (from `tracks.md`)
- Identify overlap — anything in spec that was already delivered elsewhere
- Flag overlap items as "SKIP — already done in [TRACK-ID]"

### 3. Create Phased Plan with DAG

write_file `plan.md` with this structure (now includes dependency DAG for parallel execution):

```markdown
# [Track Name] — Execution Plan

## Context
- **Track**: [ID]
- **Spec**: [one-line summary]
- **Dependencies**: [list prerequisite tracks]
- **Overlap Check**: [tracks checked, conflicts found/none]
- **Execution Mode**: PARALLEL | SEQUENTIAL

## Dependency Graph

<!-- YAML DAG for parallel execution -->
```yaml
dag:
  nodes:
    - id: "1.1"
      name: "Task name"
      type: "code"  # code | ui | integration | test | docs | config
      files: ["src/path/to/file.ts"]
      depends_on: []
      estimated_duration: "30m"
      phase: 1
    - id: "1.2"
      name: "Another task"
      type: "code"
      files: ["src/another/file.ts"]
      depends_on: []
      phase: 1
    - id: "1.3"
      name: "Depends on 1.1 and 1.2"
      type: "code"
      files: ["src/path/to/file.ts"]
      depends_on: ["1.1", "1.2"]
      phase: 1

  parallel_groups:
    - id: "pg-1"
      tasks: ["1.1", "1.2"]
      conflict_free: true
    - id: "pg-2"
      tasks: ["1.3", "1.4"]
      conflict_free: false
      shared_resources: ["src/path/to/file.ts"]
      coordination_strategy: "file_lock"
```

## Phase 1: [Phase Name]

### Tasks
- [ ] Task 1.1: [Specific action] <!-- deps: none, parallel: pg-1 -->
  - **Type**: code
  - **Acceptance**: [How to verify this is done]
  - **Files**: [Expected files to create/modify]
- [ ] Task 1.2: [Specific action] <!-- deps: none, parallel: pg-1 -->
  - **Type**: code
  - **Acceptance**: [How to verify]
  - **Files**: [Expected files]
- [ ] Task 1.3: [Depends on above] <!-- deps: 1.1, 1.2 -->
  - **Type**: code
  - **Acceptance**: [How to verify]
  - **Files**: [Expected files]

## Phase 2: [Phase Name]
...

## Discovered Work
<!-- Add items here during execution if scope expansion is needed -->
```

### 3.1 DAG Generation Algorithm

When creating the plan, build the dependency graph:

```python
def generate_dag(tasks: list) -> dict:
    """
    Generate DAG from task list.

    1. Create nodes for each task
    2. Analyze dependencies (explicit + file-based)
    3. Identify parallel groups (tasks at same level with no conflicts)
    4. Detect shared resources
    """

    nodes = []
    for task in tasks:
        nodes.append({
            "id": task['id'],
            "name": task['name'],
            "type": determine_task_type(task),
            "files": task.get('files', []),
            "depends_on": task.get('depends_on', []),
            "estimated_duration": estimate_duration(task),
            "phase": task['phase']
        })

    # Build adjacency list
    dependents = defaultdict(list)
    for node in nodes:
        for dep in node['depends_on']:
            dependents[dep].append(node['id'])

    # Compute topological levels
    levels = compute_topological_levels(nodes)

    # Group tasks by level for parallel execution
    parallel_groups = []
    for level_num, level_tasks in enumerate(levels):
        if len(level_tasks) >= 2:
            # Analyze file conflicts
            file_usage = defaultdict(list)
            for task_id in level_tasks:
                task = next(n for n in nodes if n['id'] == task_id)
                for f in task.get('files', []):
                    file_usage[f].append(task_id)

            # Find conflict-free groups
            shared_files = {f: tasks for f, tasks in file_usage.items() if len(tasks) > 1}

            if not shared_files:
                parallel_groups.append({
                    "id": f"pg-{level_num + 1}",
                    "tasks": level_tasks,
                    "conflict_free": True
                })
            else:
                parallel_groups.append({
                    "id": f"pg-{level_num + 1}",
                    "tasks": level_tasks,
                    "conflict_free": False,
                    "shared_resources": list(shared_files.keys()),
                    "coordination_strategy": "file_lock"
                })

    return {
        "nodes": nodes,
        "parallel_groups": parallel_groups
    }
```

### 3.2 Bite-Sized Task Format

Each task MUST follow the TDD bite-sized format. Every task is one focused action (2-5 minutes) with exact file paths and complete code:

````markdown
### Task 1.1: [Component Name]

**Files:**
- Create: `exact/path/to/file.ts`
- Modify: `exact/path/to/existing.ts:123-145`
- Test: `tests/exact/path/to/test.ts`

**Step 1: Write the failing test**

```typescript
test('specific behavior', () => {
    const result = function(input);
    expect(result).toBe(expected);
});
```

**Step 2: Run test to verify it fails**

Run: `npm test -- --grep "specific behavior"`
Expected: FAIL with "function not defined"

**Step 3: Write minimal implementation**

```typescript
export function specificFunction(input: string): string {
    return expected;
}
```

**Step 4: Run test to verify it passes**

Run: `npm test -- --grep "specific behavior"`
Expected: PASS

**Step 5: Commit**

```bash
git add tests/path/test.ts src/path/file.ts
git commit -m "feat: add specific feature"
```
````

**Key rules:**
- Exact file paths always — no "add to the appropriate file"
- Complete code in plan — not "add validation" or "implement logic"
- Exact commands with expected output
- DRY, YAGNI, TDD, frequent commits

### 3.3 Task Type Detection

Automatically detect task type from description and files:

| Indicators | Type |
|------------|------|
| `src/components/`, `.tsx`, `ui`, `component` | `ui` |
| `api/`, `integration`, `supabase`, `stripe` | `integration` |
| `.test.ts`, `test`, `coverage` | `test` |
| `.md`, `docs`, `documentation` | `docs` |
| `config`, `.json`, `.env` | `config` |
| Default | `code` |

### 3.4 Parallel Group Identification

Tasks can run in parallel if:
1. No dependency relationship (neither depends on the other)
2. At the same topological level
3. Either:
   - No shared files (conflict_free: true)
   - Shared files with coordination strategy (conflict_free: false)

### 3.5 Plan Quality Checklist

Before finalizing, verify:

| Check | Question |
|-------|----------|
| Scoped | Does every task trace back to a `spec.md` requirement? |
| No Overlap | Does any task duplicate work from completed tracks? |
| Testable | Does every task have clear acceptance criteria? |
| Ordered | Are tasks sequenced by dependency? |
| Sized | Can each task be completed in a single session? |

### 4. Output

Save the plan to the track's `plan.md` and report:

```
## Plan Created

**Track**: [track-id]
**Phases**: [count]
**Tasks**: [total count]
**Dependencies**: [list]
**Ready for**: Step 2 (Evaluate Plan) → hand off to loop-plan-evaluator
```

## Metadata Checkpoint Updates

The planner MUST update the track's `metadata.json` at key points:

### On Start
```json
{
  "loop_state": {
    "current_step": "PLAN",
    "step_status": "IN_PROGRESS",
    "step_started_at": "[ISO timestamp]",
    "checkpoints": {
      "PLAN": {
        "status": "IN_PROGRESS",
        "started_at": "[ISO timestamp]",
        "agent": "loop-planner"
      }
    }
  }
}
```

### On Completion
```json
{
  "loop_state": {
    "current_step": "EVALUATE_PLAN",
    "step_status": "NOT_STARTED",
    "checkpoints": {
      "PLAN": {
        "status": "PASSED",
        "started_at": "[start timestamp]",
        "completed_at": "[ISO timestamp]",
        "agent": "loop-planner",
        "commit_sha": "[if plan was committed]",
        "plan_version": 1
      },
      "EVALUATE_PLAN": {
        "status": "NOT_STARTED"
      }
    }
  }
}
```

### Update Protocol
1. read_file current `metadata.json`
2. Update `loop_state.checkpoints.PLAN` fields
3. Advance `current_step` to `EVALUATE_PLAN`
4. write_file back to `metadata.json`

If `metadata.json` doesn't exist or is v1 format, create v2 structure with default values.

## Handoff

After creating the plan, the **Conductor** should dispatch the **loop-plan-evaluator** agent to verify the plan before execution begins.

Wersje

RepozytoriumWynikLicencja
Ta strona · ibrahim-3d/orchestrator-supaconductor100AGPL-3.0
trevormil/terminal90MIT

Migawka bazy z 13.11.2026 · wersja paczki 52f9fe31da9c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100planner
    Tworzy szczegółową specyfikację funkcji SpawnForge w katalogu specs, z kryteriami akceptacji gotowymi do implementacji.
  • 100loop-executor
    Realizuje zadania ze zweryfikowanego planu w kroku 3 pętli Evaluate-Loop: przechodzi po kolei przez plan.md, pisze kod, aktualizuje plan po każdym zadaniu i commituje w punktach kontrolnych, stosując TDD.
  • 100plan
    Tworzy szczegółowy plan implementacji funkcji lub zadania, gdy użytkownik chce planować przed kodowaniem.
  • 100plan
    Tworzy szczegółowy plan wdrożenia z zadaniami dla funkcji, która została wcześniej omówiona na burzy mózgów.
  • 100make-plan
    Tworzy szczegółowy fazowy plan wdrożenia z odkrywaniem dokumentacji, zwłaszcza przed wykonaniem poleceniem do, dla funkcji, zadania lub wieloetapowej implementacji.
  • 100plan-development
    Zamienia pomysł na projekt lub funkcję w etapowy plan rozwoju, z pierwszą fazą szkieletową i kryteriami wyjścia z każdej fazy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.