1. Shrnutí

Čas se neměří, odvozuje se. Nikdo neloguje hodiny. Nikdo nevyplňuje timesheets.

Člověk deklaruje kapacitu na období. Systém identifikuje work items, na nichž se prokazatelně podílel. Kapacita se ex post rozpadá poměrově mezi relevantní items podle Job Size a míry contribution.

Výsledkem je výkaz, který je vedlejším produktem dodávky, ne separátní administrativní aktivitou.

Model poskytuje dva komplementární pohledy na stejná data:

  • Per-person pohled: jak se kapacita člověka rozloží mezi jeho items → výkazy, timesheets
  • Per-item pohled: jak se práce na itemu rozloží mezi lidi → nákladová alokace, audit per deliverable

2. Terminologie

PojemDefiniceKonfigurace
IteraceDelivery cyklus. Stories se plánují, dodávají a uzavírají.1t (AI-native) / 2t (klasicky)
Planning IntervalPlánovací cyklus. Features se plánují, koordinují a vyhodnocují.5t (4+1 IP) / 10t (8+2 IP)
IP IteraceInnovation & Planning iterace na konci PI.Poslední iterace v PI
Job Size (JS)Relativní odhad velikosti work itemu. Modifikovaná Fibonacci podle WSJF (SAFe 6).1, 2, 3, 5, 8, 13, 20, 40, 100
WSJFPrioritizační skóre: (BV + TC + RR&OE) / JSPer úroveň nezávisle
CWContribution Weight — per-item normalizovaný podíl osoby na itemu (Σ napříč osobami = 1.0 na položce).0–1.0
Signal WeightVáha jednoho typu evidence signálu (commit_author, pr_reviewer, issue_comment), kterou agreguje detect_contributors.py. V configu pod klíčem signals.*.cw_heuristics.yaml
Contribution ScoreΣ vah fired signálů per (osoba, item). Vstup do per-item normalizace. V kódu jako contribution_score.Automaticky
Derived HoursOdvozené hodiny, výstup modelu.Po Iteration Close
Signal Weight → Contribution Score (Σ vah fired signálů) → CW (per-item normalizovaný podíl) → Derived Hours.

3. Architektura modelu

3.1 Tři oddělené vrstvy

VrstvaÚčelKde žije
Operational MetadataŽivá delivery dataGitHub Issues + Projects
Capacity RegistryKapacita lidi, role, FTEYAML / JSON v repo
Evidence & ReportingFrozen snapshoty, výkazy, podpisy/snapshots, /reports, /signed

3.2 Source of truth

GitHub JE source of truth pro: issue hierarchy, ownership, status, Job Size, WSJF inputs, review trail, delivery audit trail.

GitHub NENÍ source of truth pro: hodinovou kapacitu, FTE, derived hours, podpisové stavy. Tyto žijí v evidence vrstvě.

4. Hierarchie work items

Initiative (celý projekt, business case) └── Epic (strategický cíl, 6-9 měsíců) └── Feature (musí se vejít do Planning Intervalu) ├── Story (dodáváno v Iteraci) │ └── Task (technická práce, volitelné) └── Defect (oprava, na úrovni Story)
Initiative
Epic
Feature
Story
Defect
Task

Každá úroveň má vlastní nezávislý Job Size a WSJF. Feature WSJF se nepočítá ze Stories pod ní.

ÚroveňJob Size rozsahGitHub mapping
Initiative1–100 (mod. Fibonacci)Issue Type: Initiative
Epic1–100 (mod. Fibonacci)Issue Type: Epic
Feature1–100 (mod. Fibonacci)Issue Type: Feature
Story1–100 (mod. Fibonacci)Issue Type: Story
Defect1–100 (mod. Fibonacci)Issue Type: Defect
Task— (sub-Story checklist)Issue Type: Task
Modifikovaná Fibonacci škála (1, 2, 3, 5, 8, 13, 20, 40, 100) podle WSJF metodiky SAFe 6. Žádné fixní stropy per úroveň — granularita je odpovědnost týmu při refinementu. Při AI-asistované práci může být i Story s JS=20+ realisticky odpracovatelná v iteraci.
WSJF: (BV + TC + RR&OE) / JS BV = Business Value, TC = Time Criticality, RR&OE = Risk Reduction Počítá se per úroveň nezávisle.
BV — Business Value
TC — Time Criticality
RR&OE — Risk Reduction & Opportunity Enablement
JS — Job Size

5. Model: Evidence-Driven Proportional Allocation

5.1 Protokol plánování iterace

Než EDPA odvodí hodiny (ex-post), tým musí naplánovat iteraci (ex-ante). Plánování vyžaduje potvrzenou kapacitu jako vstup.

  1. Potvrdit kapacitu — Každý člen týmu potvrdí dostupnost. Jde o závazek, ne odhad. Externí spolupracovníci vyjednávají alokaci explicitně. Výsledek: availability: confirmed v people.yaml.
  2. Upravit kapacitu na iteraci (volitelné) — Jednorázové odchylky od baseline (PTO, přesčas, nábor) se zapisují jako per-iterace override do people: bloku iteračního YAML — command /edpa:capacity <iterace> --add --person <id> --hours …. Baseline capacity_per_iteration zůstává; engine použije override a vykáže capacity_baseline + capacity_override. Nastav před uzávěrkou (Stage 1 v /edpa:close-iteration).
  3. Vypočítat Planning Capacity — Planning_Capacity = Σ Capacity[P, I] × planning_factor. planning_factor je vlastnost týmu (konfigurováno per tým v people.yaml pod teams:). Výchozí: 0.8.
  4. Vybrat práci — Vytáhni stories z prioritizovaného backlogu (WSJF pořadí) dokud Σ JobSize nedosáhne historické velocity × planning_factor. Neplánuj na 100%.
  5. Buffer — Zbylých ~20% absorbuje support, maintenance, incidenty a neplánovanou práci. Pokud buffer položky generují evidenci, EDPA je alokuje normálně.
  6. Edge case — Pokud žádná neplánovaná práce nenastane, veškerá kapacita jde na plánované položky. Garance Σ = Capacity platí vždy.
Proč 80%? Plánování na 100% vynucuje jeden ze tří failure modes: nedodané stories, přetížení, nebo scope creep. Heuristika 80% je konzistentní se SAFe load factor, Scrum velocity-based planning a Kanban WIP limits. Různé týmy si mohou zvolit různé faktory podle svého support loadu a zralosti.

5.2 Vstupy

VstupZdrojPříklad
Capacity[P, I]Potvrzeno při Iteration Planning40h
RelevantItems[P, I]Automaticky z GitHub evidence (Story Done + Feature/Epic/Initiative gates)6 items přes 4 úrovně
JobSize[item]Custom field na issueMod. Fibonacci 1–100
cw[P, item]detect_contributors.py — additivní agregace + per-item normalizace0–1.0 (Σ na itemu = 1.0)

5.3 Evidence detection

GitHub signalSignal weightDetekce
Commit author4.00Commit s S-/F-/E-/I-XXX v branchi/zprávě
PR reviewer2.17Schválený PR review (vyjma self)
Issue / PR comment1.46Komentář (boti vyloučeni)
/contribute @osoba weight:XexplicitManuální additivní signál — váha X z direktivy
state_transition0Status přechod (person/at/from→to) — analytics + delivery lead-time, nepřispívá do CW
  • Signály se sčítají additivně do contribution_score per (osoba, item) — žádný „highest wins"
  • Per-item normalizace dává cw share: cw = contribution_score / Σ_persons contribution_score
  • /contribute je rovnocenný signál — nepřepisuje auto-detekci, jen přidává váhu
  • Default váhy nahoře jsou kalibrované Monte Carlo simulací (1000 syntetických scénářů)
Bez per-role korekcí. CW se počítá výhradně signálovou agregací a per-item normalizací (viz § 5.4 níže). Strategická-role bias se řeší kalibrací signálových vah proti ground truth — pokud BO/PM/Arch dostávají málo, kalibrátor zvedne issue_comment a pr_reviewer váhy. Detail v auto-calibration.md.

5.4 Výpočet — single source, sum-and-normalize

contribution_score[P, item] = Σ signal_weight × signal_fired(P, item) cw[P, item] = contribution_score[P, item] / Σpersons contribution_score[*, item] score[P, item] = JobSize[item] × cw[P, item] ratio[P, item] = score[P, item] / Σitems_of_P score DerivedHours[P, item] = ratio[P, item] × Capacity[P, I]
CW je per-item podíl (Σ napříč osobami = 1.0 na položce), ne absolutní role-coupled hodnota. Signály sčítají additivně, normalizují se per-item, engine konzumuje hotové cw.
Příklad: Kalkulátor. Plná specifikace: methodology.md § 5.4.

5.5 Matematické garance (dvě)

1. Per-item: Σpersons cw[*, item] = 1.0 2. Per-person: Σitems DerivedHours[P, *] = Capacity[P, I] Obě platí strukturálně — z konstrukce sum-and-normalize aggregation a ratio normalizace per osobu napříč iteračními položkami. Engine je při běhu validuje a snapshot odmítne zapsat při porušení.

5.6 Co engine kredituje per typ položky

EDPA pracuje se 6 typy issues (S-, F-, E-, I-, D-, T-). Ne všechny se ale zahrnují do výpočtu hodin stejně:

TypDetekce evidenceEngine kreditujeIteration filter
Story (S-)anoano, jen status==Doneexact match (PI-2026-1.1)
Feature (F-)anoano, Done + gate transitionsPI match (PI-2026-1.x)
Epic (E-)anoano, Done + gate transitionsalways (cross-PI)
Initiative (I-)anoano, Done + gate transitionsalways (cross-PI)
Defect (D-)anoano, jen status==Donealways (cross-PI) — záměrně
Task (T-)anone — engine tasks/ neprocházín/a
Defect cross-PI je záměrné. Defekt se nemusí stihnout opravit v iteraci, ve které byl založen — může přetéct i přes hranici PI. Engine ho proto kredituje vždy v iteraci, kdy přejde do Done, bez filtru na původ. To zachycuje skutečnou délku trvání defektu jako evidenci.
Task není deliverable v EDPA modelu. Tasks jsou míněny jako sub-Story breakdown (checklist na issue), ne samostatná položka pro výpočet hodin. Pokud tým commit referencuje T-XXX, evidence se sice detekuje, ale engine pro tu práci nezíská žádný score — práce by se měla připojit k parent Story.

6. Dual-view CW: dvě otázky, jeden dataset

CW = 0.25 pro reviewera může znamenat dvě věci. Jsou to dvě různé otázky — model řeší obě ze stejných dat:

Per-person normalizace

Otázka: Jak se kapacita člověka P rozloží mezi jeho items?

DerivedHours[P, item] = (Score[P, item] / Σ Score[P, *]) × Capacity[P, I] Garance: Σ DerivedHours[P, *] = Capacity

Výstup: výkaz per osoba pro OP TAK

Per-item normalizace

Otázka: Jak se práce na itemu X rozloží mezi lidi?

ItemShare[P, item] = DerivedHours[P, item] / Σ DerivedHours[*, item] Garance: Σ podilu na itemu = 100 %

Výstup: nákladová karta per deliverable

PohledOtázkaVýstupGarance
Per-personKolik hodin P strávil na čem?Výkaz, OP TAKΣ = kapacita
Per-itemKolik lidí a hodin stál item X?Nákladová alokaceΣ podilu = 100%

7. Konfigurace kadence

Varianta A: Klasická (2/10)
CyklusDélka1.0 FTE0.50.25
Iterace2 týdny80h40h20h
PI10 týdnů400h200h100h
Varianta B: AI-Native (1/5)
CyklusDélka1.0 FTE0.50.25
Iterace1 týden40h20h10h
PI5 týdnů200h100h50h
Doporučení: začít na A. Po prvním PI vyhodnotit přechod na B na základě velocity a lead time dat.

8. Učící smyčka

Velocity tracking
Story_Velocity = Σ JS uzavřených Stories / iterace Feature_Velocity = Σ JS uzavřených Features / PI Accuracy = Actual / Planned × 100 %
Kalibrace
  • CW: Po 2–3 iteracích vyhodnotit heuristiku. Rekalibrace signálových vah optimizérem /edpa:calibrate (Monte Carlo + coordinate descent, syntetický korpus).
  • Job Size: Referenční Story “3” ≠ Feature “3”. Per úroveň nezávisle.
  • AI: Vykazuješ čas na dodání, ne minuty kódu. AI → velocity, ne výkaz.

9. Implementace v GitHub

9.1 Native Issue Types & custom fields

EDPA je local-first: engine čte lokální git evidence a backlog YAML, GitHub vrstva je volitelná. Pokud tým GitHub používá, Issue Types jsou nativní funkce GitHubu na úrovni organizace (ne labels, ne custom fields). Spravují se přes issue_types.py setup --org <org>. Filtrování: type:Epic, type:Story atd.

Issue TypePopis
InitiativeBusiness case, investiční záměr
EpicStrategický cíl, 6-9 měsíců
FeatureMusí se vejít do Planning Intervalu
StoryDodáváno v iteraci
DefectDefekt v existující funkcionalitě
TaskTechnická práce
Enabler je label klasifikace (Business vs Enabler), ne Issue Type. Epic může mít label „Enabler“ pro označení Enabler Epicu (SAFe).
Custom fieldTypHodnoty
Job SizeNumberMod. Fibonacci 1–100
BV / TC / RR&OENumberMod. Fibonacci 1–100
WSJF ScoreNumberAuto (Action)
Planning IntervalIteration5 nebo 10 týdnů
IterationIteration1 nebo 2 týdny
TeamSingle selectTýmové hodnoty
Primary OwnerAssigneeAccountable owner
Co nedržet jako GitHub field: Capacity, Derived Hours, FTE, podpisový stav → patří do evidence vrstvy.

9.2 Engine běží lokálně, GitHub vrstva je volitelná

V2 nemá pipeline GitHub Actions. Engine, výpočet WSJF, iteration/PI close i velocity běží lokálně přes /edpa:close-iteration a MCP nástroje. Atribuci řeší post-commit hook (local_evidence.py) — pro každý commit s referencí na EDPA item emituje commit_author, funguje i offline a na GitLab/Forgejo. Hooky se registrují do .git/hooks/, nebo — pokud projekt používá lefthook — přes jediný řádek extends:, který EDPA do lefthook.yml zapíše sama.

VrstvaKde běžíFunkce
Engine + výpočetLokálně (/edpa:close-iteration)Score, DerivedHours, snapshot + výkazy (MD/JSON/XLSX) + per-item
AtribuceLokální post-commit hookcommit_author z git historie pro každý item-referencující commit
VelocityLokálně (MCP edpa_flow_metrics)Velocity a flow metriky z lokálních dat
Contribution sync (volitelné)GitHub Action — --with-ciedpa-contribution-sync.yml: po merge PR dopíše pr_reviewer + issue_comment z PR vlákna do evidence[]
Kdy nasadit --with-ci: jen když máte signály, které nežijí v git historii (PR reviews, komentáře) a chcete je započítat. Single-dev / review-light / off-GitHub týmy workflow přeskočí — local evidence stačí.

9.3 Timestamp pole

Každý backlog item nese tři timestamp pole (zapisuje engine při přechodech stavů; pokud tým používá GitHub, naplní se z issue):

PoleZdrojVyužití
created_atVznik položkyCycle time start, item age
updated_atPoslední změna položkyFreshness, řazení
closed_atPřechod do DoneCycle time end, throughput
Tato pole jsou vstupem pro flow metriky (§ 9.4). Žádný obousměrný sync ani řešení konfliktů — jediný zdroj pravdy je lokální YAML v repu.

9.4 Flow Metrics MCP tool

MCP tool edpa_flow_metrics poskytuje analytiku toku práce na základě timestamp polí:

MetrikaVýpočetVyužití
Cycle Timeclosed_at - created_atJak dlouho trvá dodání položky
ThroughputPočet uzavřených položek / iteracePrediktabilita, kapacitní plánování
Item Agenow - created_at (otevřené)Detekce stagnujících položek

9.5 Branch naming & DoR

feature/S-200-omop-parser defect/D-215-upload-validation feature/F-102-anon-engine

CI check blokuje PR bez reference na issue (S-XXX, F-XXX, E-XXX). DoR: Issue Type, Parent, Job Size, BV+TC+RR&OE, Owner.

9b. ID kolize a renumbering (multi-developer setup)

Týmy: rezervace ID na sdíleném git remote (od 2.23.0). Projekt může přidělování čísel svěřit git remote, na který tým stejně pushuje. Rezervace je push jednoho servisního commitu do refu refs/edpa/ids, který server přijme jen tehdy, když se ref mezitím nezměnil — vyhraje právě jeden, ostatní zkusí další číslo. ID je tak unikátní napříč worktree, větvemi i vývojáři v okamžiku přidělení (~2 s), bez GitHub API a bez gh. Tiket už nemusí přes PR jen proto, aby si „zabral" číslo; hooky pustí jen tiket s rezervací.

python3 .edpa/engine/scripts/id_counter.py init-remote --write-config   # jednou na repozitář
git add .edpa/config/edpa.yaml && git commit -m "chore(no-ticket): reserve ticket IDs in the shared ledger"
python3 .edpa/engine/scripts/id_counter.py status                       # kdo tady přiděluje ID a proč

Postup přechodu na jednu stránku: id-ledger-prechod.md.

Bez sdíleného ledgeru (výchozí, lokální režim) čerpají worktree jednoho klonu z jedné řady, ale dva klony ne — pokud dva vývojáři současně vytvoří backlog item ze stejného počátečního stavu mainu, oba dostanou stejné ID (např. oba S-5). Kolizi zachytí pre-push hook, nejpozději merge druhého PR.

4 vrstvy obrany detekují kolizi co nejdřív + poloautomatický recovery tool:

VrstvaKdyToolCo dělá
5 local git commit validate_ids.py --staged (pre-commit hook) Blokuje commit pokud staged backlog má ID nekonzistence (filename ≢ id, missing fields, duplicity)
6 local git push validate_ids.py --pre-push (pre-push hook) Fetch origin, porovná lokálně přidané ID proti origin/main. Pokud ID už existuje na mainu → push BLOKOVÁN
7 PR open/sync (server-side) .github/workflows/edpa-collision-check.yml Spustí renumber_collisions.py --check. Při kolizi: comment na PR s instrukcemi + fail check (PR's merge button disabled)
Recovery po conflictu renumber_collisions.py --apply Přejmenuje lokální file (S-5.md → S-6.md), přepíše id:, updatuje parent: reference v dependent items, bumpne counter

Standardní recovery flow

git fetch origin python3 .edpa/engine/scripts/renumber_collisions.py --apply # Detected 1 collision: S-5 → S-6 git add . && git commit -m "renumber(S-5→S-6): collision with main" git merge origin/main # resolve id_counters.yaml conflict (vezmi MAX hodnotu) git push

Setup pro nový projekt (jednou):

python3 .edpa/engine/scripts/project_setup.py --with-hooks cp .edpa/engine/templates/github-workflows/edpa-collision-check.yml \ .github/workflows/

Plný guide s rozhodovacím stromem a běžnými typy kolizí (single / multi / parent-chain / cascading): docs/dev-collisions.md.

9c. Jak funguje rezervace ID — ledger na git refu

Čísla jsou unikátní, když je vydává jedno místo. Dříve měl každý pracovní strom vlastní čítač a o ostatních nevěděl, takže dva worktree, dva klony nebo dva lidé dostali stejné S-285. Ledger dělá tím jedním místem git remote, na který tým stejně pushuje — jako automat na pořadové lístky. Žádné API forge, žádné gh: jen git fetch a git push, takže funguje na jakémkoli git serveru.

Na čem to v gitu stojí

Git má dvě vrstvy: objekty (commity, stromy, obsah souborů — pojmenované hashem a neměnné) a refy (pojmenované ukazatele na commit; ref je jméno a jeden hash). Větev je ref refs/heads/main, tag refs/tags/v2.23.0, GitHub si pro PR vede refs/pull/94/head. refs/edpa/ids je ukazatel stejného druhu, jen mimo refs/heads/. Důsledky:

  • git clone a git pull ho samy nestahují (berou větve a tagy),
  • nezobrazí se mezi větvemi v UI forge,
  • nevztahují se na něj pravidla větví ani spouštěče CI.

Stejně ukládá data sám git (refs/notes/), Gerrit nebo git-bug.

Co ref obsahuje

Ref ukazuje na poslední commit řetězu. Každý commit má rodiče (předchozí rezervaci), strom s jediným souborem counters.yaml a zprávu, která je auditním záznamem rezervace. Je to obyčejná git historie, jen bez vašeho kódu.

schema: 1
counters:        # nejvyšší vydané číslo per typ
  Defect: 93
  Story: 290
floors:          # nejvyšší číslo, které smí existovat BEZ záznamu o rezervaci
  Defect: 92
  Story: 289
alloc S-290: Website (CZ/EN): describe the remote ID authority

EDPA-Id: S-290
EDPA-Type: Story
EDPA-Parent: F-129
EDPA-Branch: main
EDPA-Created-At: 2026-10-08T07:52:11Z
EDPA-Nonce: 5f0c…
git fetch origin refs/edpa/ids
git log FETCH_HEAD --format='%s  [%an, %ar]'
git show FETCH_HEAD:counters.yaml

Jedna rezervace krok za krokem

  1. Přečte stav. Stáhne špičku refs/edpa/ids do dočasného refu a přečte Story: 290.
  2. Připraví nový stav. Nízkoúrovňovými příkazy složí commit se Story: 291 — bez pracovního stromu a indexu, váš checkout se nedotkne.
  3. Pošle ho s podmínkou „přijmi jen tehdy, pokud ref stále míří na commit z kroku 1“.
  4. Server rozhodne. Přijato → S-291 je vaše. Odmítnuto, protože se ref posunul → někdo byl rychlejší; zpět na krok 1 a další číslo.
  5. Teprve teď se zapíše soubor tiketu a commitne do vaší větve.
git hash-object -w --stdin          # counters.yaml → blob
git mktree                          # strom s tím jedním souborem
git commit-tree <tree> -p <tip>     # commit, zpráva = auditní záznam

git push --no-verify --porcelain \
  --force-with-lease=refs/edpa/ids:<tip> \
  origin <new commit>:refs/edpa/ids

Kde vzniká atomičnost

V protokolu git push. Klient pro každý ref posílá trojici:

<old hash>  <new hash>  refs/edpa/ids

Server ref zamkne, ověří, že na něm právě je starý hash, a teprve pak zapíše nový — compare-and-swap. Stejný mechanismus způsobí, že obyčejný git push do main selže, když někdo pushnul před vámi. --force-with-lease=<ref>:<hash> očekávanou hodnotu zadává výslovně; s prázdnou hodnotou znamená „jen pokud ref ještě neexistuje“ — tak se ledger zakládá.

  • Výsledek se nikdy nečte z textu chyby. Po každém pushi, který není čistý úspěch, klient znovu přečte remote: ref obsahuje můj commit → rezervováno (i když se potvrzení ztratilo v timeoutu); ref se posunul bez něj → prohraný závod, opakovat; ref se nepohnul → server toto prostředí nepustí.
  • Nonce. Dva worktree jednoho člověka mohou složit bajtově shodný commit; git by druhý push ohlásil jako „up to date“ a číslo by měli oba. Každá zpráva proto nese náhodné EDPA-Nonce a „up to date“ se nikdy nebere jako úspěch.
  • --no-verify jen u tohoto pushe: projekty pouštějí v pre-push testy a tento push nese jediný servisní commit, nikdy kód.

Proč neprojde ručně napsaný tiket

Hooky (validate_ids.py) u každého nového tiketu ověří rezervaci. Číslo na úrovni floor nebo pod ní nic nepotřebuje — tiket je starší než ledger. Nad floor musí existovat záznam pro dané ID a jeho EDPA-Created-At se musí shodovat s created_at v tiketu. Pravidlo „číslo ≤ nejvyšší vydané“ by nestačilo: ID vyražené zastaralým pluginem by prošlo, kdykoli někdo drží nesloučenou rezervaci nad ním. pre-commit pracuje s lokální kopií (offline jen varuje), pre-push a CI ověřují online — to zachytí i commity s --no-verify.

Větve, worktree, klony, agenti

  • Větve: číslo se rezervuje na remote, ne ve větvi. Soubor tiketu se commitne tam, kde stojíte; dvě větve nemohou dostat stejné ID.
  • Worktree jednoho klonu: sdílejí kopii ledgeru, zámek i režim (vše leží ve společném .git). Přepnou se najednou, i ty vzniklé před opt-in commitem.
  • Jiné klony a lidé: koordinuje server.
  • Agentní session: jako člověk, pokud smí pushovat do repa. Sandbox omezený na vlastní větev ID nezíská a ohlásí to.
  • Co zůstává: obsah tiketu vidí ostatní větve až po sloučení.
KdeCo
refs/edpa/cache/idsnejnovější známý stav ledgeru; posouvá se jen dopředu
git config edpa.idLedgerRemote / edpa.idLedgerRefkde tento klon ledger naposledy našel
<git common dir>/edpa/zámek, high-water mark, zásoba čísel rezervovaných předem

Chování při selhání

SituaceChování
Nejde síťžádné ID, nic se nezapíše. Číslo se nikdy neodhaduje — tak vznikají dvě řady ID. Pro práci offline si vezměte čísla předem: id_counter.py reserve --type Story --count 5
Ref na serveru smazán nebo vrácen zpětkaždý klon má řetěz v kopii a čítače jsou maxima, takže příští rezervace z klonu, který si pamatuje víc, ho obnoví
Ref přepsán nesouvisející historiíobě historie se sloučí, per typ maximum
Proces spadne mezi rezervací a zápisem souboručíslo propadne; díra v řadě ničemu nevadí
Zatoulaný soubor typu S-9999.mdodmítnuto (zvedl by řadu všem); vědomě převzít lze přes id_counter.py doctor --raise
Prohraný závodautomatické opakování, asi 2 s na pokus

Proč jeden ref, a ne ref pro každý typ

Ref per typ by ušetřil jedno opakování, když ve stejné vteřině vzniká Story a Defect. Zisk je malý (opakování stojí asi 2 s; v zátěži 16 souběžných procesů vyšlo průměrně 1,6 pokusu na rezervaci) a úzké hrdlo je síťové kolo, ne typ. Cena by byla sedm čtení místo jednoho, neatomické založení, sedm auditních řad a složitější samooprava. Soubor nese schema: 1, takže případné pozdější rozdělení čísla tiketů nezmění.

Změřeno: GitHub přijal push do refs/edpa/*, asi 2,4 s na rezervaci; 2×128 souběžných rezervací ze 3 klonů a 8 worktree bez duplicity. Neověřeno: jiné forge než GitHub, Windows. Plná technická reference: id-ledger.md · přechod projektu: id-ledger-prechod.md · rozhodnutí: ADR-014.

10. Výkazy a audit

10.1 Pipeline

/.edpa/snapshots/ iteration-PI-2026-1.3.json ← frozen snapshot /.edpa/reports/ iteration-PI-2026-1.3/ vykaz-urbanek.md ← čitelný výkaz vykaz-urbanek.json ← strojová data summary.xlsx ← souhrnný Excel item-costs.xlsx ← per-item pohled /signed/ PI-2026-1.3-urbanek.pdf ← BankID podepsaný

10.2 Freeze rule

Po Iteration Close: snapshot je frozen. Evidence se nepřepisuje in-place. Každá oprava je nová revize. Zásadní pro auditní obhajobu.

10.3 Auditni princip

Průkaznost stojí na 5 pilírich:

  1. Lokální git delivery evidence (commit_author, yaml_edit, gate_events, story_activity)
  2. Capacity registry (YAML)
  3. Frozen snapshot (reprodukovatelný vstup)
  4. Reprodukovatelný výpočet (Score = JS × CW; CW = additivní agregace + per-item normalizace)
  5. Podepsaný výstup (BankID, zákon 21/2020 Sb.)

11. Předpoklady a rizika

Předpoklady
  • Všechny items se uzavírají (nedodané se přesouvají)
  • Kapacita potvrzena při Iteration Planning
  • Branch naming dodržen (CI check)
  • Job Size konzistentní per úroveň
  • CW se kalibruje po prvních iteracích
Rizika
RizikoMitigace
Auditor neuznáMetodika + snapshoty + BankID
CW neodpovidaOverride + kalibrace
Commit bez S-/F-/E-XXXCI check blokuje PR
PM/Arch bez commituComments + /contribute
0 items pro osobuProcesní eskalace

12. Srovnání s alternativami

Fixed Split

Předem definované koše (např. 60% Dev, 20% Arch, 20% QA). Hodiny se rozdělují fixně podle role, nezávisle na skutečném příspěvku. Jednoduché, ale nepřesné.

EDPA v2.25.1

Evidence-Driven Proportional Allocation. Hodiny se odvozují automaticky z lokální git evidence (commity, yaml edits, status přechody, in-flight Story aktivita); GitHub Projects + Actions jsou volitelný doplněk. Matematická garance: Σ = Capacity.

Ruční timesheets

Každý člen týmu ručně vyplňuje hodiny. Subjektivní, administrativně náročné, nemá per-item pohled, neauditovatelné bez doplňkové evidence.

VlastnostFixed SplitEDPA v2.25.1Ruční timesheets
Fixované košeAnoNeNe
Prázdné úrovněProblémNeexistujíN/A
Per-person pohledAnoAno (primární)Ano
Per-item pohledNeAno (dual-view)Ne
Cross-funkčníOmezenáPlnáPlná
AutomatizaceStředníVysokáŽádná
Mat. garanceSložitějšíNativněNe

13. Implementační plán

FázeČasObsah
Den 11h/edpa:setup — vendoring enginu do .edpa/engine/, config (edpa.yaml, people.yaml), seed backlogu
Den 1 (volitelné)30 min--with-hooks (git hooky), --with-ci (contribution-sync workflow), --with-rules
Iterace 11–2tPilotní provoz, první výkazy z /edpa:close-iteration
Kalibrace10 min/edpa:calibrate — rekalibrace signálových vah po prvních iteracích
Retro PI 11 denKadence, CW accuracy, velocity, dual-view validace