Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

loc-orchestrate

/loc-orchestrate

Wykonuje plan z katalogu inbox milestone po milestonie, z dowodem i przeglądem kodu po każdym etapie oraz końcowym.

Repozytorium
masterskills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.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
7
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wykonuje plan z katalogu inbox milestone po milestonie, z dowodem i przeglądem kodu po każdym etapie oraz końcowym.

Wyzwalacze z opisu

loc-orchestrate 018execute plan 018

Argumenty

/loc-orchestrate <plan number or file>
Oryginalny opis (EN)

Use when the user asks to execute a plan from loc/inbox/ (e.g. "loc-orchestrate 018", "execute plan 018"), or to resume one that has a state file in loc/state/. Builds it milestone by milestone with a proof and a code-review per milestone, then a final review.

Jak działa

  1. 1. Start
  2. 2. Each milestone
  3. 3. Deviations from the plan
  4. 4. When to stop
  5. 5. At the end
Sekcje z nagłówków SKILL.md, w oryginale · 64 linii, 1 307 słów
Podgląd SKILL.md
---
name: loc-orchestrate
description: Use when the user asks to execute a plan from loc/inbox/ (e.g. "loc-orchestrate 018", "execute plan 018"), or to resume one that has a state file in loc/state/. Builds it milestone by milestone with a proof and a code-review per milestone, then a final review.
argument-hint: "<plan number or file>"
---

# loc-orchestrate

Executes `loc/inbox/NNN-plan-<topic>.md` milestone by milestone. The plan is the contract: build it, prove it with its `Proof` lines, review each milestone, then the whole. Do not redesign it.

**Do not ask "shall I continue?" between milestones.**

Run each command on its own, exactly as written: no `cd`, variables, `;` or `&&`, so the plugin's permissions cover it.

## 1. Start

1. `$ARGUMENTS` is a plan number or file in `loc/inbox/`. No argument: if `loc/state/` holds a file whose `phase` is not `done`, resume it; otherwise the first plan in `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/plan_queue.py` not `blocked`; no open plan: say so.
2. If `loc/state/<NNN>.json` exists, **resume** from its `next_action` (`references/state.md`).
3. Read the plan, the project's `CLAUDE.md` (`Commands`, `Invariants`, `Limits`) and `loc/PATTERNS.md`.
4. Run `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/check_plan.py --ready <plan>`. If it exits non-zero, the plan's status says the gate failed, or `loc/inbox/` has an open `PRD:` `question`, **stop**: say why, point to `/masterskills:loc-planning`; no architect, no edits to the plan.
5. Choose the mode: **inline** for one or two small milestones; **subagent** otherwise. Create the state file (`references/state.md`).
6. Copy the tests: `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/test_baseline.py --plan <NNN>`.

## 2. Each milestone

Update the state file before and after every step.

A milestone with `**Kind:** search` runs the search loop of `references/search.md` instead of steps 2 and 3; a missed target is its accepted result, never stuck. A milestone that changes what the user sees, and the plan's end, follow `references/design.md` (the `designer` agent, `ui_check.py`, the `design-critic` gate).

1. **Snapshot** `--point start`.
2. **Implement** exactly this milestone, code and its tests together. With `**Criteria:**`: tests first, red gate `M<n>/red`, then the code (`references/tests.md`). Before writing code, climb the ladder and stop at the first rung that works: is it needed at all, already in the project, in the standard library, a platform feature (the browser's date picker), an installed dependency, one line; only then the minimum that works. Never cut validation, error handling, security or accessibility.
   - *inline*: do it yourself.
   - *subagent*: a fresh general-purpose sub-agent per milestone with the plan path, the milestone's heading and text, `Code context`, and the rules: only this milestone, the ladder, follow the project's `CLAUDE.md`, scratch files only in `loc/tmp/` and delete only files you created there, never the directory, report the files changed and the proof output.
3. **Proof gate** (`M<n>/proof`). Increase `rounds`, run each `Proof` line exactly as written, one at a time, and compare each with its expected result. Pass → next step. Fail → fix the cause (not the proof) and start the next round. After the third failed round: **stuck** (below).
4. **Snapshot** `--point end`. It prints the changed files.
5. **Code-review gate** (`M<n>/code-review`). Increase `rounds`, then `Skill(skill: "code-review", args: "<changed files> medium — also flag new code the project, its standard library, platform or dependencies already provide")`: always explicit files and level, **never `ultra`** (it leaves the machine). It runs once per round. A lost agent report is asked for again (core rule 6a), never a relaunch. Give each finding a verdict (`references/gates.md`), then the `judge` agent weighs the Blocking and Non-blocking ones; fix those it marks `fix`. Suggestions, Unrealistic findings and its `enough` verdicts are not fixed: one line each in the plan's `## Review notes`. Rounds 2 and 3 review only the fixes (`references/gates.md`). Rerun the proof after the fixes and take a new `end` snapshot. Passed when the judge leaves nothing to fix. After the third failed round: **stuck**.
6. **Manual check**, only for a `user` performer, after the proof and the review passed: put the milestone's `**Manual check:**` on the checks sheet, `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/checks.py --add --plan <NNN> --milestone M<n> --title "<what>" --step "<what to open or click>" --look "<what to look at>"` (`--image "<png> | <caption>"` per screenshot; `--blocking` for `user (blocking)`). Blocking: give the user the sheet path and wait; deferrable: go on. Record the user's answer by number: `checks.py --rate --ok <n> --fix <n> "<what>"`. A fix first becomes a test that fails on it, then the fix, the proof and the review again, then a new point with `--again <n>`. The answer with the date goes under the milestone in the plan.
7. Mark the milestone `done`, move to the next one.

**Stuck gate.** No fourth round or code change: record the gate in the plan's `## Stuck gates` (`references/stuck.md`), set its `stuck` to `"plan"` and the milestone to `stuck`, and go on with the next milestone.

## 3. Deviations from the plan

- **Rules 1–3** (a bug, a missing critical piece like validation, a blocker like a missing dependency): fix it, record a deviation, carry on.
- **A blocker only the user can remove** (a file outside the project is gone): a `question` file at once, never only in chat; the milestone `stuck`, then the next one.
- A step of this skill you skipped (the red gate, the `test-author` agent, a review) is not a deviation: go back and do it; if it cannot be done, the gate is **stuck**.
- **Rule 4** (architecture: a new component, a changed interface or data model, a different library): call the `architect` agent in Decide mode with options, costs and your recommendation; record the deviation with its ruling, or, when it escalates, with a `question` file of its options (`next_number.py --type question --title "<choice>" --by "architect (Decide)"`), and continue on the recommendation.

## 4. When to stop

Only in these cases:

- **before the start**: step 1.4, or the file is not a plan;
- **expensive to undo**: data loss, a migration, anything outside the project, a rule 4 choice that cannot be reverted cheaply;
- **permissions**: a tool or access you do not have;
- **the end**.

A failed gate ends in `stuck`, not in a stop.

## 5. At the end

1. **QA gate** (`qa`), only when the plan has `**Criteria:**` (else report `**No tests:**`): `phase: qa`, `Skill(skill: "masterskills:loc-qa", args: "plan <NNN>")`. NOT APPROVED: fix the code behind each FAIL, never tests; next round. Third failure: **stuck**.
2. `phase: final-review`. `Skill(skill: "masterskills:loc-review", args: "plan <NNN>")` (orchestrated mode, gate `final-review`).
3. **Close what the plan resolved**, then **triage** (`references/stuck.md`): mark the fixed points of `## Stuck gates`; a stuck final review or a point still open goes to the architect, whose `triage` decides between more rounds, a `deferred` file and a question.
4. **Close the plan.** Under `## Resolution`: `done <date>`, one line per milestone (`M1 ✅`, or `M2 ⚠️ → loc/inbox/NNN-deferred-…`), deviations and new `question` files. `**Status:**` → `done <date>` and move it to `loc/inbox/done/` with `mv`; with a stuck `qa` gate → `open — QA failed`, not moved. Update `plan` in the state file, set `phase: journal`.
5. **Journal.** First, add to `loc/PATTERNS.md` what failed during the plan and worked another way (rule 10). Then one command, your text (English, at most 3 sentences: what was done, what did not work out): `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/memory_index.py --type Plan --title "<title>" --text "<sentences> Details: <plan path>"`. Then `Skill(skill: "masterskills:loc-diagram", args: "overview")`.
6. **Commit** the plan's files, never push: `sh "${CLAUDE_PLUGIN_ROOT}/scripts/py.sh" scripts/commit_plan.py --state loc/state/<NNN>.json --message "<type(scope): summary>"`, or `--skip "<reason>"` when the project's `CLAUDE.md` says the user commits. A new directory git tracks nothing in stops it: run again with `--add <dir>` for the plan's own work or `--leave <dir>` for files it did not make (e.g. manual-check data), then a `question` file asks whether `<dir>` goes into `.gitignore`. Rejected: report it, never bypass. Then `phase: done`, validate.
7. **Report** in the user's language, briefly: the commit, milestones with proof results, gates that went stuck, files closed in step 3, deviations, new inbox files, the checks sheet with its open points, QA verdict, final review result. Then **"Judge: enough"**: every `enough` line, numbered in plan order, grouped by its PRD point; "fix 2" goes to `loc-planning`. In a `loc-director` course the director goes on: never ask to continue.
Pliki w paczce (7)
  • SKILL.md 9 KB
  • references/design.md 5 KB
  • references/gates.md 5 KB
  • references/search.md 5 KB
  • references/state.md 5 KB
  • references/stuck.md 5 KB
  • references/tests.md 4 KB

Wersje

W bazie nie ma innych skilli o nazwie loc-orchestrate.

Migawka bazy z 13.11.2026 · wersja paczki fe52d9d3e75b (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

  • 100loc-review
    Przegląda zmiany, łącząc krytyka i przegląd kodu, sprawdza niezmienniki projektu i po planie poprawia znalezione błędy.
  • 100loc-qa
    Wydaje werdykt QA dla planu lub zmiany: uruchamia pełny zestaw testów, dopisuje brakujące testy i kończy zatwierdzeniem lub odrzuceniem.
  • 90executing-plans
    Prowadzi pisemny plan wdrożenia w odrębnej sesji, z przeglądem po każdym etapie.
  • 90executing
    Wykonuje spisany plan zadanie po zadaniu, z kontrolami i końcowym przeglądem, gdy plan istnieje i użytkownik prosi o jego wdrożenie.
  • 100scout-loc
    Liczy linie kodu w wielu językach narzędziem cloc, także w czasie z historii git, np. kod aplikacji względem testów.
  • 100agilab-code-statistics
    Generuje szybkie, powtarzalne statystyki kodu AGILAB: LOC, liczby plików, podział na języki, proporcje testów, dokumentacji i źródeł oraz podsumowania churnu, bez uruchamiania buildów.

Uwagi i zgłoszenia

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