Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

diamond-task

/diamond-task

Dzieli jedno duże zgłoszenie lub pull request na rozłączne zakresy zapisu, gdy jeden wykonawca nie wystarcza, i nie wprowadza zdalnych zmian.

Repozytorium
dalcom-skills ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

85/ 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ść20 / 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
2
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

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Dzieli jedno duże zgłoszenie lub pull request na rozłączne zakresy zapisu, gdy jeden wykonawca nie wystarcza, i nie wprowadza zdalnych zmian.

Oryginalny opis (EN)

Use when one issue or PR is too large for a worker and partitions into disjoint write sets. Not for independent parallel tasks: use parallel-launch. No remote or irreversible changes.

Jak działa

  1. What you need before starting
  2. Checkpointing the base
  3. Splitting the surface into worker nodes
  4. Running and vetting the workers
  5. Composing without authoring
  6. The fresh review and the landing
Sekcje z nagłówków SKILL.md, w oryginale · 41 linii, 916 słów
Podgląd SKILL.md
---
name: diamond-task
description: 'Use when one issue or PR is too large for a worker and partitions into disjoint write sets. Not for independent parallel tasks: use parallel-launch. No remote or irreversible changes.'
---

# Diamond task

One issue or pull request is too large or too entangled for a single worker, yet its whole writable surface splits cleanly into pieces no two workers need to touch at once. This skill turns that issue into a small production line: partition the work into disjoint write sets, run one isolated worker per set, union their diffs mechanically, and have a fresh reviewer approve the result. It is the sole generator of production task DAGs, and it works only on the local machine: named local run artifacts and declared target write sets, with the pre-run checkpoint as rollback. Nothing here reaches a remote or makes an irreversible change.

For genuinely independent parallel tasks that share no issue and no writable surface, use parallel-launch instead.

## What you need before starting

One issue or pull request with its acceptance criteria; the local target workspace, whose current bytes and metadata are the composition base; the checks each worker and the final composed result must satisfy; named local locations for the checkpoint, the isolated composition, and the run report; and any fixed ordering constraints between units of work (otherwise the partition itself decides which worker nodes are independent). The production task DAG comes from those units of work and their declared ordering constraints only. If required input, a checkpoint, isolation, or a required check is unavailable, return `blocked` without touching the target. When the acceptance criteria or the write-set partition were drafted by the agent rather than supplied by the user, confirm them with the user before dispatching any writer.

## Checkpointing the base

Capture the exact target base in the named checkpoint first. Then enumerate every target byte the task may create, replace, or delete: integration edits, formatting changes, and generated output the final result requires all count. An unenumerated byte is an uncovered byte later.

## Splitting the surface into worker nodes

Partition the complete writable surface into worker nodes with pairwise-disjoint write sets. Define each set by canonical target paths and, where a path is shared, by non-overlapping byte regions or insertion boundaries. Give every node its task, its allowed write set, the checks it must satisfy, the proof it must return, and only the inputs it needs. Every content byte the composer might otherwise have to author must belong to some worker node, because the composer authors nothing: it applies returned diffs by mechanical union inside the declared sets and changes nothing outside them.

Stop before running any worker if coverage is incomplete, any two sets overlap, or isolation cannot be provided. That stop is `split-falsified`: discard any isolated compositions, restore the target from the checkpoint if application began, keep the evidence, and emit no partial composition.

## Running and vetting the workers

Run every ready node in an isolated copy of the base, give each worker that copy's absolute path, and state in its brief that every read and write must resolve under it. Each worker may change only its declared write set and must return its exact diff, its check results, and its proof. No worker approves its own result, and no worker approves the composition. Any change to the target checkout that no approved composition declares stops the run as `split-falsified`.

Validate each returned diff against its node contract before composing anything. An overlap, an out-of-set byte, or a failing check falsifies the responsible node: re-run only that node in fresh isolation and validate again. When the failure spans write sets or exposes missing partition coverage, the split itself is falsified instead of any one node.

## Composing without authoring

Rebuild the isolated composition from the checkpoint and union the validated worker diffs mechanically: reproduce every diff byte-for-byte, change nothing outside the declared write sets, and write no reconciling, improving, formatting, or completing content of your own. Verify the composed bytes against every returned diff and run the declared composed-result checks.

Attribute any composition mismatch or failing check to exactly one worker node, re-run only that node, then rebuild from the checkpoint and repeat validation. A mismatch that spans write sets falsifies the split. If a node repeats an equivalent out-of-set change, check failure, composition mismatch, or review finding after its isolated re-run, that node is terminally falsified (`node-falsified`): stop with the target unchanged or restored, the responsible node named, the falsifying evidence retained, and no partial composition emitted.

## The fresh review and the landing

Hand the validated composition and all proofs to a fresh isolated reviewer who was neither a worker nor the composer; only that reviewer may approve. A review finding falsifies exactly one worker node (re-run it, rebuild from the checkpoint, repeat composition, checks, and fresh review), or the split when the finding spans write sets.

After approval, apply the reviewed mechanical union to the named target and verify its bytes equal the approved composition. Record everything in the run report: the node contracts, the diffs, the proofs, the composed check results, the reviewer identity and verdict, and the final byte comparison. Never report approval unless the composed checks, the byte comparison, and the fresh-review verdict all pass in the same replay.

On success return `approved` with the applied composed local result and that run report. On a clean stop return `blocked`, `split-falsified`, or `node-falsified` with the unchanged or restored target, no partial composition, the responsible node or split, and the falsifying evidence. Report either case in run order: checkpoint → partition → run → validate → compose → attribute → review → apply.
Pliki w paczce (2)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · gosuda/dalcom-skills85Apache-2.0
OutlineDriven/outline-driven-development90Apache-2.0

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

  • 90schedule-dependency-waves
    Układa jednostki pracy z zadeklarowanymi zależnościami w fale wykonania przed uruchomieniem i wykrywa cykle zależności.
  • 100code-swarm
    Dzieli zadanie na niezależne części, uruchamia równoległych wykonawców i zbiera wyniki w jeden raport z lukami.
  • 100prepare-repository-for-public-release
    Przygotowuje repozytorium do publicznego startu lub otwarcia kodu, bez zmian zdalnych, poświadczeń, publikacji, wdrożeń ani zmian nieodwracalnych.
  • 90schedule-dependency-waves
    Układa jednostki pracy z zadeklarowanymi zależnościami w fale wykonania przed uruchomieniem i wykrywa cykle zależności.
  • 100vibe-parallel-task-decomposition
    Analizuje duże zadanie pod kątem niezależnych podzadań i układa plan równoległego wykonania z kolejnością zależności.
  • 100implement-issue
    Zamienia jedno oznaczone zgłoszenie z GitHuba w jeden zrecenzowany pull request albo kończy pracę ze wskazaniem powodu, przy każdym uruchomieniu fabryki.

Uwagi i zgłoszenia

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