docs: Archetyp-Vollspecs und Methodenkern vorlaeufig freigeben.
Deploy Development / deploy (push) Successful in 48s
Test Suite / pytest-backend (push) Failing after 3m23s
Test Suite / k6 /api/health Baseline (push) Has been skipped
Test Suite / playwright-smoke (push) Has been skipped
Test Suite / lint-backend (push) Successful in 3s
Test Suite / compose-smoke (push) Has been skipped

Decision-Lock, Spec-D-Methoden und C1-Massstab-Vollspecs als Zielbild; Steering-Registry/Compat und Horizon-Tests an die Normierung anbinden. Implementierungsausreichendheit bleibt bewusst offen.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-07-26 15:02:04 +02:00
1 parent 005b371ac0
commit 753f178b0c
48 files changed
+5113 -531

No files matched your search

@@ -1,11 +1,16 @@
# ADP — Archetyp- & Methoden-Katalog v0.2
**Status:** PO-freigegeben
**Status:** PO-freigegeben — **Inventar teilweise überholt** (2026-07-25)
**Stand:** 2026-07-10 (Archetypen-, Project- und Methoden-Schichten; Vier-Schichten-Modell)
**Aktuelles Inventar / Decision-Lock:** `docs/product/Kairo_Archetype_Decision_Lock_Interview_2026-07-25.md`
**Nächste Katalog-Konsolidierung:** v0.3 nach Methoden-Normierung (`Kairo_Steering_Method_Normalization_Program_v0.1.md`)
**Architektur-Voraussetzung:** `ADP_Archetype_Method_Plugin_Architecture_v0.1.md`, `ADP_AP2_4_Steering_Elements_and_Method_Contract_v0.1.md`
**Bezug:** `Kairo_MVP_Definition_v0.3.md`, `ADP_AP1_10_Initiative_Archetypes_and_Entity_Field_System_v0.1.md`, `Kairo_Method_Design_Principles_v0.1.md`, `Kairo_Canonical_Operating_Model_v0.2.md`
**Ersetzt:** `ADP_Archetype_and_Method_Catalog_v0.1.md` (Inhalt konsolidiert + B3 Agile Iteration)
**Auslöser:** Vorhaben jenseits von Software; heterogenes Portfolio; **Agile (Backlog, Sprint, Release)** vollständig im Katalog verankern
> **Hinweis 2026-07-25:** D1 als eigener Archetyp, B1-Label und fehlendes Care sind im Decision-Lock korrigiert. Bei Konflikt gilt das Decision-Lock; dieses v0.2 bleibt Referenz für Vier-Schichten und historische Begründung.
---
## 1. Problem
@@ -0,0 +1,117 @@
# Jinkendo Kairo
## Steuerungsmethoden — Fachlicher Kern & Contract v0.1 (M1 reframed)
**Status:** Entwurf — Phase M1 **umgebogen** (Kern zuerst, nicht Spec-Formular)
**Stand:** 2026-07-25
**Programm:** `Kairo_Steering_Method_Normalization_Program_v0.1.md`
**Nordstern:** `Kairo_Target_Architecture_Method_Driven_Adaptive_Steering_Core_v0.1.md`
**Prinzipien:** `Kairo_Method_Design_Principles_v0.1.md`
**Technik:** `ADP_AP2_4_Steering_Elements_and_Method_Contract_v0.1.md`
**Archetypen:** `Kairo_Archetype_Decision_Lock_Interview_2026-07-25.md`
---
## 0. Kurskorrektur
**Verworfen als Einstieg:** 10 Spec-Felder + Primitive-Stichliste (zu früh, MVP-verkürzt).
**Neuer M1-Pfad:**
```text
1) Methodenkern (invariant) — Steuerungszyklus, Lifecycle, Core vs Methode
2) Extension Points — Hooks, Strategies, Builder, Policies
3) Gemeinsame Primitive / Read Models
4) Methoden-Deltas (Besonderheiten)
5) Archetyp × Methode
6) Spec-Template (abgeleitet)
```
Spec-Tiefe = holistisch. Implementierungstiefe später MVP.
---
## 1. Methodenkern — Arbeitsstand
### 1.1 Leitfrage (unverändert)
> Welcher nächste Schritt bringt ein Vorhaben aktuell am wirkungsvollsten voran — und warum?
### 1.2 Steuerungszyklus (Kandidat — aus Target Architecture)
```text
intake → method_selection → structure_setup → planning → action_selection
→ assignment → waiting → result_intake → validation → review
→ adaptation → closure
```
| Schritt | Core (invariant) | Methode (Extension) |
|---------|------------------|---------------------|
| intake | SteeringContext, Ziel/Scope | zusätzliche Hooks |
| method_selection | Registry, Kompatibilität zu Archetyp | Domain-Filter, Default |
| structure_setup | Hook-Dispatch, Builder-Interface | welche Structure Builder |
| planning | Transition, Audit | DoD/Plan-Dichte-Policy |
| action_selection | Signal-/NextAction-Orchestrierung | Next-Action-Strategy |
| assignment | Actor-Validierung, Assignment-Service | Assignment-Strategy |
| waiting | Wartezustand (Runtime später) | Waiting/Reminder/Escalation |
| result_intake | Ergebnis entgegennehmen | Intake-Strategy |
| validation | Evidence/DoD-Checks anstoßen | Evidence-Policy |
| review | Review-Objekt | Review-Strategy |
| adaptation | Replan-Hooks | Structure-/Method-Adjustment |
| closure | Closure-Policy aufrufen | ob/wann Closure sinnvoll |
**Regel (Kandidat):** Methode darf Schritte **auslassen/spezialisieren**, nicht Tenant/Actor/Capability/OM-Kern umgehen.
**Analyse:** `M1_Lifecycle_Fit_Analysis_Archetypes_v0.1.md` — Lifecycle allein **nicht hinreichend**; siehe §5 dort (Kern-Anker A–G).
*(PO-Bestätigung: Interview M1.1 — reframed nach Analyse)*
### 1.3 Core vs. Methode vs. Archetyp (Kandidat)
| | Core | Methode | Archetyp |
|--|------|---------|----------|
| Rolle | Orchestrierung, Invarianten, Registries | Steuerungsverhalten | Natur/Horizont/UI-Hülle/OM-Fähigkeiten |
| Persistenz | OM + SteeringContext | nutzt OM, keine Parallelwelt | `archetype_key`, ui_profile, om_capabilities |
| UI Verhalten Work/Control | Element-Registry auflösen | `steering_elements`, `ui_features` | Nav/Routen/Outline |
| Next Action | Engine ruft Strategy | liefert Strategy | begrenzt über om_capabilities |
### 1.4 Extension Points (Kandidat — Pflicht vs. optional)
| Extension | Pflicht primary? | Bemerkung |
|-----------|------------------|-----------|
| `next_action_strategy` | **ja** | Kern der Leitfrage |
| `attention` / signal rules | **ja** (min. leer explizit) | Portfolio + Vorhaben |
| `compatible_archetype_keys` + `data_slices` | **ja** | AP2.4 |
| `steering_elements` | **ja** (min. `next_action_primary`) | AP2.4 |
| `lifecycle_steps` aktiv/skip | **ja** | welche Schritte gelten |
| Structure Builder | empfohlen | sonst manuelle Struktur |
| assignment / waiting / reminder / escalation | optional | Default-Core |
| evidence / review / closure policy | optional bis nötig | |
| Hook-Bindings über Standard-Slugs | empfohlen | stabil versioniert |
| `agile_iteration` als modifier | nur Komposition | kein primary Ersatz |
---
## 2. Primitive — später (nach Kern)
Arbeitsliste unverändert als Kandidaten; Definition **nach** M1.1–M1.3.
---
## 3. Spec-Formular (10 Punkte) — später
Wird **abgeleitet** aus Kern + Extensions — nicht Einstieg.
---
## 4. Interview-Log
| ID | Thema | Entscheidung |
|----|-------|--------------|
| — | Kurskorrektur Kern zuerst | ✓ A (2026-07-25) |
| — | Lifecycle allein hinreichend? | ✗ Analyse — Anker nötig |
| M1-Pfad | Hybrid A1 | ✓ (2026-07-25): Kandidat-Kern → Tiefe D → Freeze |
| Prozess | | `M1_Hybrid_Path_and_Depth_D_v0.1.md` |
---
*Living document.*
@@ -0,0 +1,215 @@
# Jinkendo Kairo
## Universeller Steuerungsmethoden-Kern v0.1
**Status:** PO-freigegeben (Freeze M1c) — 2026-07-25
**Zweck:** Fachlich universeller Kern für **alle** Steuerungsmethoden
**Nicht:** Archetyp-Katalog (→ Decision-Lock) · keine offene Workflow-Engine
**Voraussetzung Technik:** AP2.3/AP2.4 Plugin-Architektur
**Abgeleitet aus:** Spec-Tiefe D (`docs/architecture/methods/SPEC_D_*.md`), Fit-Analyse, Target Architecture Lifecycle
---
## 1. Was dieser Kern ist
Der **Steuerungsmethoden-Kern** ist die **eine gemeinsame Maschine**, mit der Kairo jedes Vorhaben steuert — unabhängig von der Methode.
Methoden sind **Steuerungspakete**: sie füllen feste Schlitze (Strategien, Policies, Skip-Regeln).
Sie bauen **keine** zweite Engine daneben.
```text
SteeringContext (Vorhaben + gebundene primary-Methode [+ Komposition])
│
▼
┌─────────────────────────────────────────────────────────┐
│ UNIVERSALER STEUERUNGSMETHODEN-KERN │
│ │
│ Auslöser: Plan-Zug und/oder Event-Schub │
│ Schlitze: Intake … Closure (unten) │
│ Querschnitt: Horizont · Attention · Audit · Nested │
└─────────────────────────────────────────────────────────┘
│
▼
Method Plugin (sequential_dependency, care_navigation, …)
```
**Leitfrage (unverändert):**
*Welcher nächste Schritt bringt das Vorhaben jetzt am wirkungsvollsten voran — und warum?*
---
## 2. Explizit nicht
| Nicht | Stattdessen |
|-------|-------------|
| Offene Workflow-/Plugin-Engine (beliebige Nodes) | Feste Schlitze + Method Registry |
| Eine Engine pro Vorhaben-Typ | Ein Kern, Methoden spezialisieren |
| Nur Plan-Pipeline ohne Events | Dualer Auslöser |
| Nur Action als „nächste Arbeit“ | Polymorphes Work Item |
| Programm überschreibt Child-NA | Nested: Impulse ≠ Child-NA |
PO ✓ 2026-07-25: Dual-Auslöser; **keine** offene Engine.
---
## 3. Duale Auslöser (PO ✓)
| Auslöser | Bedeutung | Typisch |
|----------|-----------|---------|
| **Plan-Zug** | Horizont/Plan fragt: was ist ready? | A2, B2a, B2b, Checklisten (dünn), Agile-Slice |
| **Event-Schub** | Etwas passiert → Reaktion/Arbeit öffnen oder ändern | C1, Care-Reaktionen, Cadence-Zeitpunkte (A3/A1) |
Beide münden in dieselben Schlitze (Next work, Result, DoD, Adaptation, Attention).
Jede Methode deklariert eine **Dominanz**:
| Dominanz | Bedeutung |
|----------|-----------|
| `plan` | Planung/Horizont führt |
| `event` | Ereignisse führen |
| `hybrid` | beides wesentlich (z. B. Care) |
---
## 4. Universelle Schlitze (Lifecycle als Schleife)
Der Kern orchestriert immer dieselbe Schrittliste.
Methode setzt pro Schritt: `active` | `skip` | `n/a` (+ Lieferant für den Schlitz).
| # | Schlitz | Kern tut immer | Methode liefert |
|---|---------|----------------|-----------------|
| 1 | **Intake** | Kontext/Ziel/Scope absichern | zusätzliche Aufnahme |
| 2 | **Method bind** | Methode binden, Kompatibilität zu Archetyp | Default/Wechselregeln |
| 3 | **Structure setup** | Builder/Struktur-Hooks aufrufen | welche Struktur |
| 4 | **Planning** | Planungsphase ermöglichen | *was* geplant wird — oder `n/a` |
| 5 | **Next work** | Strategie aufrufen, Kandidaten + Begründung | Ready-Logik, Ranking, Leading-Typ |
| 6 | **Assignment** | Actor-Zuweisung über Services | Assignment-Policy |
| 7 | **Waiting** | Wartezustand führen | Reminder/Eskalation |
| 8 | **Result / Event** | Rückmeldung **und** externe/situative Events annehmen | Interpretation |
| 9 | **DoD / Validation** | Prüfung gegen Kriterien/Evidence anstoßen | Criteria-/Evidence-Policy — oder `n/a` |
| 10 | **Review** | Review/Entscheidungspfad | wann Pflicht |
| 11 | **Adaptation** | Nachsteuern/Replan-Hooks | was sich ändert |
| 12 | **Closure** | Abschluss-Policy aufrufbar | ob Closure vorgesehen |
**Schleife:** Nach Adaptation (und oft nach Result) wieder Next work / Planning — kein Zwang zum Closure.
**Intake** kann erneut feuern (dauerhafter Eingang).
---
## 5. Querschnittsfähigkeiten (Anker — Teil des Kerns)
Damit Plan- und Event-Methoden dieselbe Maschine nutzen:
| # | Fähigkeit | Pflicht |
|---|-----------|---------|
| Q1 | **Horizont** auflösen („worauf schauen wir?“) | ja |
| Q2 | **Work-Item-Polymorphie** (Action, CadenceInstance, ChecklistItem, Decision, ProgramImpulse, …) | ja |
| Q3 | **Event-Eingang** gleichberechtigt zu Actor-Result | ja |
| Q4 | **Nested Contexts** (Parent-Impulse ≠ Child-Next-Work) | ja wenn Kinder existieren |
| Q5 | **Attention**-Orchestrierung | ja |
| Q6 | Formale Schritt-Status `active`/`skip`/`n/a` | ja |
| Q7 | **Kompositions-Methoden** (z. B. Agile): eigener Horizont-Slice, Primary bleibt Natur | ja |
---
## 6. Methodentypen (verbindlich)
Jede Methode hat genau eine **fachliche Rolle**. Technik-Feld AP2.4: `method_role`.
| Methodentyp | `method_role` | Bedeutung | Beispiele |
|-------------|---------------|-----------|-----------|
| **Primary (Ausführung)** | `primary` | Trägt Vorhaben-Natur: Horizon, Leading Work, Closure-Haltung, Ready/Ranking | `sequential_dependency`, `continuous_product`, `recurring_control`, `maturity_progression`, `checklist_flow`, `care_navigation`, `dispute_procedure`, `generic_operating` |
| **Primary (Meta)** | `primary` | Primary, aber **kein** Ausführungs-Leading der Kinder: Impulse, Nested, Lagebild | `program_delivery` (nur B2a) |
| **Komposition** | `modifier` | Horizont-/Takt-Slice; **braucht** Primary; ersetzt Natur nicht | `agile_iteration` |
**Regeln:**
1. Pro Vorhaben genau **eine** Primary-Methode (Ausführung oder Meta).
2. Komposition nur wenn Primary in `composes_with` der Kompositions-Methode steht.
3. Meta-Primary (`program_delivery`) komponiert **nicht** mit Agile am Dach; Agile nur an Kind-Primaries.
4. „Kompatible Methoden“ eines Archetyps = erlaubte Primary **plus** erlaubte Kompositionen — kein wilder Primary-Wechsel ohne Archetyp-Passung.
---
## 7. Method Plugin — was jede Methode am Kern anmeldet
Mindestens:
| Anmeldung | Inhalt |
|-----------|--------|
| Methodentyp / `method_role` | `primary` \| `modifier` (+ Meta nur fachlich bei `program_delivery`) |
| Dominanz | `plan` \| `event` \| `hybrid` |
| Lifecycle-Map | Status je Schlitz |
| Next-work-Strategie | Leading-Typ + Ready + Ranking + reason_codes |
| Attention-Regeln | Codes + Auslöser |
| Horizont-Definition | was Horizont ist |
| DoD-Policy | oder explizit `n/a` |
| `compatible_archetype_keys` + `data_slices` | AP2.4 |
| `steering_elements` | UI-Bausteine |
| Komposition | bei Primary: ob komponierbar; bei modifier: `composes_with` |
Details: jeweilige `SPEC_D_<method>.md`.
---
## 8. Komposition Agile (PO ✓)
`agile_iteration` = **Kompositions-/Horizont-Methode** mit eigener Sprint-Planungs- und Lifecycle-Logik.
Technisch `modifier`. Ersetzt Primary nicht. Genau ein aktiver Sprint. Ohne Sprint → nur Primary.
`composes_with`: `sequential_dependency`, `continuous_product`, `recurring_control` — **nicht** `program_delivery`.
---
## 9. Abbildung Dominanz (aus Spec-D)
| Methode | Dominanz |
|---------|----------|
| `sequential_dependency` | plan |
| `program_delivery` | plan (+ Signale aus Kindern) |
| `continuous_product` | plan (hybrid-light bei Incidents) |
| `checklist_flow` | plan (sehr dünn) |
| `maturity_progression` | hybrid (Cadence-Zeit + Stufe) |
| `recurring_control` | event (Cadence) |
| `care_navigation` | hybrid |
| `dispute_procedure` | event |
| `agile_iteration` | plan-Slice (Komposition; mit sequential, continuous_product, recurring_control) |
| `generic_operating` | plan (dünn) |
---
## 10. Beziehung zu Archetypen und Templates
| Schicht | Rolle |
|---------|--------|
| Archetyp | Natur, Horizont-Erwartung, OM-Fähigkeiten, UI-Hülle, Default-Methode |
| **Vorhaben-Template** | konkrete Vorlage **auf** einem Archetyp (Zusatzfelder, Darstellung, Sortierung/Filter, ggf. Profil) — **kein** neuer Archetyp (PO 2026-07-25) |
| **dieser Kern** | universelle Steuerungs-Maschine |
| Methode | Plugin in den Kern |
| Operating Context | Laufzeit-Auflösung (AP2.3/AP2.4) |
UI-Namen und Template-Darstellung sind nachrangig gegenüber Archetyp-Merkmalen + Methodensteuerung.
---
## 11. Freigabe-Log
| Datum | Entscheidung |
|-------|--------------|
| 2026-07-25 | Hybrid A1 Spec-D → Kern |
| 2026-07-25 | Dual-Auslöser; keine offene Workflow-Engine |
| 2026-07-25 | Schlitze 1–12 + Querschnitt Q1–Q7 = Methodenkern v0.1 Freeze |
| 2026-07-25 | Batch-Methoden Spec-D als Delta zum Kern akzeptiert (inhaltlich Decision-Lock; explizit mit Freeze) |
| 2026-07-25 | Methodentypen: Primary (Ausführung) / Primary (Meta) / Komposition; Agile + A3; nicht am Programm-Dach |
| 2026-07-26 | PO: Architektur beibehalten (schlank: Default-Primary + wenige Kompositionen); Vollspec-/Spec-D-Welle freigegeben |
---
## 12. Nächste Arbeit (nach Freeze)
1. Spec-D Dominanz-Feld + Schlitz-Maps gegen dieses Dokument normalisieren (redaktionell)
2. Ist-Code-Lücken (v. a. `program_delivery` Nested/Impulse) als Implementierungs-Schuld listen
3. Archetyp-Vollspecs / Catalog v0.3 auf diesem Kern aufsetzen
4. Kein neuer Methoden-Code außerhalb Open/Closed Registry
---
*Freeze-Dokument. Bei Änderung: Version v0.2 + PO-Entscheid.*
@@ -0,0 +1,147 @@
# Jinkendo Kairo
## Steuerungsmethoden-Normierungsprogramm v0.1
**Status:** aktiv — nächste fachliche Designphase nach Archetyp-Decision-Lock
**Stand:** 2026-07-25
**Voraussetzung (geliefert):** AP2.3 Plugin-Architektur, AP2.4 Method Contract & Steuerungselemente
**Decision-Lock Archetypen:** `docs/product/Kairo_Archetype_Decision_Lock_Interview_2026-07-25.md`
**Ersetzt nicht:** `ADP_AP2_4_Steering_Elements_and_Method_Contract_v0.1.md` (technischer Vertrag)
---
## 1. Ziel
Ein **kanonisches, normalisiertes Steuerungsmethoden-Modell**, auf dem:
1. alle Methoden denselben **Verhaltensvertrag** erfüllen (nicht nur Registry-Felder),
2. Archetypen **kompatible** Methoden binden können, ohne Steuerungslogik zu duplizieren,
3. neue Methoden (**`checklist_flow`**, **`care_navigation`**, …) und bestehende Stubs auf **gemeinsamen Primitiven** aufsetzen,
4. Archetyp-Vollspecs (Felder, Basiserfassung, GUI) erst danach stabil geschrieben werden.
**Leitfrage:** Welche Voraussetzungen muss jede Methode an OM + Core stellen — und welche Signale liefert sie verlässlich zurück?
---
## 2. Ausgangslage
| Schicht | Stand |
|---------|--------|
| Plugin-Auflösung / Operating Context | ✓ AP2.3 |
| `MethodDefinition` + `steering_elements` + Kompatibilität | ✓ AP2.4 technisch |
| Fachliche Primitive (einheitliche Semantik) | ○ Lücke |
| Strategien teils Stub / inkonsistente Voraussetzungen | ◐ |
| Decision-Lock Archetypen (8 Typen) | ✓ Inventar |
| Archetyp-Vollspecs | ⏸ warten auf Normierung |
**These (PO):** Die größte Hürde liegt in den Methoden. Archetypen werden ggf. an den Methodenkern **angepasst**, nicht umgekehrt Feature-Specs vorgezogen.
---
## 3. Normierungsgegenstand
### 3.1 Method Contract — fachliche Ebene (über AP2.4 hinaus)
Jede **primary**-Methode muss spezifizieren:
| # | Vertragspunkt | Inhalt |
|---|---------------|--------|
| 1 | **Horizon** | Was ist der Steuerungs-Horizont? (Stufe, Gate, Sprint, Cadence, Checklisten-Scope, Fall, Fürsorge-Fokus) |
| 2 | **Leading object** | Worauf zeigt Next Action primär? |
| 3 | **OM-Voraussetzungen** | Minimale Slices/Objekte, ohne die die Methode nicht starten darf |
| 4 | **Next Action** | Eingaben, Ranking, `reason_codes`, leerer Fall |
| 5 | **Attention** | wann / welche Codes |
| 6 | **steering_elements** | Keys aus Element-Registry |
| 7 | **ui_features / graph_profile** | Verhaltensflags |
| 8 | **Lifecycle-Bezug** | Closure erwartet? Adaptation? |
| 9 | **compatible_archetype_keys** | explizit, konsistent zu Decision-Lock |
| 10 | **modifier-Komposition** | z. B. mit `agile_iteration` |
### 3.2 Gemeinsame Primitive (kanonisch zu definieren)
Arbeitsliste — im Interview/Spec zu schärfen:
| Primitive | Nutzen |
|-----------|--------|
| `ReadyWorkItem` | einheitliche „kann jetzt gearbeitet werden“-Sicht |
| `HorizonMarker` | Gate / Stage / Sprint / Milestone / Care-Checkpoint |
| `CadenceInstance` | eine offene Rhythmus-Instanz (Anti-Duplikat) |
| `ChecklistItem` | abhakbares Listenitem (B1) |
| `CrossDependencySignal` | Programm-Roadblocker über Kinder (B2a) |
| `CareFocus` | Person im Fürsorgefokus + offener Bedarf |
| `AttentionSignal` | portfoliotaugliches Attention-Objekt |
Primitive sind **Read-Model-/Vertragsbegriffe** — keine neuen OM-Tabellen ohne ADP.
### 3.3 Methoden-Inventar (Ziel nach Decision-Lock)
| `method_key` | Rolle | Status fachlich |
|--------------|-------|-----------------|
| `maturity_progression` | primary | ◐ vorhanden, normieren |
| `sequential_dependency` | primary | ◐ |
| `recurring_control` | primary | ◐ Stub → Norm |
| `checklist_flow` | primary | ✗ neu (ersetzt Label `queue_pull`) |
| `program_delivery` | primary | ◐ |
| `continuous_product` | primary | ◐ |
| `dispute_procedure` | primary | ◐ Stub |
| `care_navigation` | primary | ✗ neu |
| `agile_iteration` | **modifier** | ◐ Komposition härten |
| `generic_operating` | primary Fallback | ✓ |
| `chapter_based_progression` | Profil/Strategie unter A2 | kein eigener Archetyp mehr |
| `product_milestone_driven` | Legacy | migrieren / kompatibel halten |
---
## 4. Arbeitsmodus
```text
Phase M0 Guardrails lesen (AP2.3/AP2.4 + dieses Programm) ✓
Phase M1 Hybrid A1 (PO 2026-07-25) ✓
M1a–b Spec-D Methoden
M1c Methodenkern Freeze ✓
→ Kairo_Steering_Method_Kernel_v0.1.md
Dual-Auslöser Plan|Event; keine offene Workflow-Engine
Phase M2 Kompatibilität + Code-Schuld ✓
→ M2_Method_Compatibility_and_Code_Debt_v0.1.md
Phase M3 Archetyp-Vollspecs (implementierbar)
→ docs/product/archetypes/VOLLSPEC_PROGRAM_v0.1.md
Phase M4 Catalog v0.3
Phase M5 Code-APs nur Open/Closed gegen Registry + Kernel-Schlitze
```
**Stop-Regel:** Keine parallele Steuerungsengine. Neue Methoden nur als Plugin in Kernel-Schlitze.
---
## 5. Abgrenzung
| Tun | Nicht tun |
|-----|-----------|
| Primitive und Voraussetzungen normalisieren | Tenant-Methoden-Designer |
| `queue_pull` → `checklist_flow` fachlich | Beliebige Workflow-Engine |
| Care-Methode spezifizieren | Mitai/Shinkan-Gesundheitsdomäne |
| Kompatibilität Decision-Lock ↔ Registry | Page-Ifs / parallele Heuristiken |
---
## 6. Phase M1 — Einstieg (reframed)
**Nicht:** Spec-Formular zuerst.
**Sondern:** Methodenkern aus Target Architecture + Method Design Principles verbindlich machen, AP2.4 als technische Abbildung.
Living Doc: `Kairo_Steering_Method_Contract_Fachlich_v0.1.md`
---
## 7. PO-Freigabe
- [x] Reihenfolge: Decision-Lock Archetypen → Methoden-Normierung → Archetyp-Vollspec
- [x] AP2.3/AP2.4 als Voraussetzung anerkannt
- [x] Phase M1 gestartet (2026-07-25)
- [x] Methodenkern v0.1 Freeze (2026-07-25)
- [x] M2 Kompatibilität + Code-Schuld (2026-07-25)
- [ ] Archetyp-Vollspecs (Welle A2 → …)
- [ ] Dominanz redaktionell in Spec-D-Dateien (P2)
---
*Erstellt 2026-07-25 im Anschluss an das Archetyp-Interview und die Plugin-/Guardrail-Arbeit.*
@@ -0,0 +1,117 @@
# M1 — Hybrid-Pfad & Spec-Tiefe D
**Status:** PO-Entscheidung A1 (2026-07-25)
**Bezug:** `M1_Lifecycle_Fit_Analysis_Archetypes_v0.1.md`, `Kairo_Steering_Method_Contract_Fachlich_v0.1.md`
---
## 1. Entscheidung
**Hybrid A1:**
```text
1) Kandidat-Kern (Lifecycle-Loop + Anker A–G) — Hypothese, nicht eingefroren
2) Alle primary-Methoden (+ Modifier agile_iteration) auf gleicher Spec-Tiefe D
3) Abgleich → Kern erweitern/streichen/schärfen
4) Kern einfrieren
5) Skip/n/a pro Methode formal finalisieren
```
Nicht: Kern jetzt final. Nicht: Methoden ohne gemeinsames Raster.
---
## 2. Kandidat-Kern (Hypothese)
```text
Methodenkern (Kandidat) =
1) Steerable Context (+ optional Child Contexts)
2) Standard-Lifecycle als Loop (Schritte mit Status active|skip|n/a)
3) Horizon (aktiver Ausschnitt)
4) Work-Item-Polymorphie (ReadyWorkItem-Union)
5) Signal-/Event-Eingang (Actor-Ergebnis + externe/situative Events)
6) Extension Points (Strategies, Policies, Builder, Hooks, steering_elements)
7) Orchestrierung: Attention + Next Action
(+ Program Impulse getrennt von Child Next Action)
```
Lifecycle-Schritte (Rückgrat):
```text
intake → method_selection → structure_setup → planning → action_selection
→ assignment → waiting → result_intake → validation → review
→ adaptation → closure
```
---
## 3. Spec-Tiefe D (verbindlich für Schritt 2)
### 3.0 Kurskorrektur Erhebungsstil (2026-07-25)
Meta-Abfrage von D1–D12 Abschnitt für Abschnitt **reproduziert nur die Fit-Analyse** und trägt nicht.
**Stattdessen:**
1. Pro Methode **eine substanzielle Spec** mit **konkreten Steuerungsregeln** (Ready, Ranking, Attention, Events, Graph-Semantik, Nested) — gespeist aus Decision-Lock, ADPs, Ist-Code.
2. PO-Interview nur zu **Spannungen / offenen Regeln** (D12), nicht zu Label-Feldern.
3. „Leichte“ Methoden (z. B. `sequential_dependency`) schnell verdichten; Härtetests (`program_delivery`, `care_navigation`, `checklist_flow`) gleich tief.
Jede Methode wird auf **genau dieser Tiefe** beschrieben — nicht tiefer (kein GUI/EFS), nicht flacher — aber **inhaltlich konkret**, nicht meta.
| # | Abschnitt | Inhalt |
|---|-----------|--------|
| D1 | Identität | `method_key`, Rolle primary/modifier, Label, 2–3 Sätze Zweck |
| D2 | Geltung | `compatible_archetype_keys` (Ziel), Default für welche Archetypen |
| D3 | Horizon | Was ist der aktive Horizont? (auch „keiner / Liste“) |
| D4 | Leading Work Item | Union-Mitglied: Action / Cadence / Checklist / Decision / ProgramImpulse / … |
| D5 | Lifecycle-Pfad | pro Schritt: `active` / `skip` / `n/a` + ein Satz warum |
| D6 | Next Action | Eingaben, Ranking-Idee, leerer Fall, reason_codes (Namen) |
| D7 | Attention | typische Auslöser + Codes (Namen) |
| D8 | Events | welche Ereignisse greifen ein (Actor-Result, extern, situativ, Kind-Status) |
| D9 | Nested | nur wenn relevant: Beziehung Parent/Child (B2a, Modifier) |
| D10 | OM-Voraussetzungen | minimale Slices/Objekte |
| D11 | Extension Points | welche Strategies/Policies/Elements (Namen, auch TBD) |
| D12 | Spannungen zum Kandidat-Kern | was der Kern noch nicht trägt / was gestrichen werden könnte |
**Explizit nicht in Tiefe D:** GUI-Layouts, EFS-Feldlisten, Starter-Kits, API-Routen, Implementierungsplan.
---
## 4. Methoden-Reihenfolge (Empfehlung)
Zuerst **Extreme** und **Kernfälle**, damit der Kandidat-Kern früh gestresst wird:
| Nr | Methode | Warum jetzt |
|----|---------|-------------|
| 1 | `sequential_dependency` | passt Lifecycle am besten — Referenz-Delta |
| 2 | `program_delivery` | Nested — härtester Anker-Test |
| 3 | `care_navigation` | Multi-Leading-Object |
| 4 | `checklist_flow` | degenerierter Pfad |
| 5 | `recurring_control` | Cadence / Anti-Duplikat |
| 6 | `continuous_product` | Loop / kein Closure |
| 7 | `maturity_progression` | Recurring + Stages |
| 8 | `dispute_procedure` | Event-Pfad |
| 9 | `agile_iteration` | Modifier auf A2/B2b |
| 10 | `generic_operating` | Fallback |
| — | Legacy `queue_pull` / `chapter_based_*` / `product_milestone_driven` | nachziehen / migrieren |
---
## 5. Arbeitsartefakte
| Artefakt | Rolle |
|----------|--------|
| `docs/architecture/methods/SPEC_D_<method_key>_v0.1.md` | eine Datei pro Methode auf Tiefe D |
| `docs/architecture/methods/_TEMPLATE_Method_Spec_Depth_D_v0.1.md` | Template |
| dieses Dokument | Prozess + Tiefe D |
| Fit-Analyse | Begründung Kandidat-Kern |
---
## 6. Freigabe-Log
| Datum | Entscheidung |
|-------|--------------|
| 2026-07-25 | Hybrid A1 gewählt |
| … | Kandidat-Kern eingefroren (nach Methoden-Durchgang) |
@@ -0,0 +1,195 @@
# M1 — Passungsprüfung Lifecycle-Kern × Archetypen/Methoden
**Status:** Analyse (keine Freigabe)
**Stand:** 2026-07-25
**Zweck:** Prüfen, ob der Standard-Lifecycle allein als Methodenkern trägt — gegen Decision-Lock (8 Typen)
Geprüfter Kandidat:
```text
intake → method_selection → structure_setup → planning → action_selection
→ assignment → waiting → result_intake → validation → review → adaptation → closure
```
Legende Passung: **✓** natürlich · **◐** nur mit Interpretation/Skip · **✗** Bruch / fehlender Anker
---
## 1. Urteil (kurz)
Der Lifecycle ist ein **taugliches Phasen-Rückgrat**, aber **nicht ausreichend** als alleiniger Methodenkern für unser Portfolio.
Er ist klar aus **Projekt-/Produktentwicklung** gedacht (A2, B2b). Für A3, B1, B2a, C1, Care und teilweise A1 braucht der Kern **zusätzliche invariante Anker**. Sonst werden „Skip“ und „Action“ zu Platzhaltern, die Unterschiede verdecken statt zu tragen.
---
## 2. Matrix pro Typ × Methode
### A2 · `sequential_dependency` (+ `agile_iteration`)
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| intake … structure_setup | ✓ | Ziel, Gates/Pfade |
| planning | ✓ | rollierend erlaubt |
| action_selection | ✓ | ready am Pfad |
| assignment … validation | ✓ | |
| review / adaptation | ✓ | |
| closure | ✓ | Ende/DoD |
| Agile-Modifier | ◐ | braucht **Horizon = work_cycle** als Kernkonzept, nicht nur Skip von planning |
**Fazit A2:** Lifecycle passt am besten. Ankerpunkt Horizon/Sprint fehlt im reinen Schrittnamen.
### B2b · `continuous_product` (+ Agile)
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| intake | ◐ | nicht nur einmalig — **Dauer-Eingang** |
| structure_setup | ✓ | Orientierungsgates |
| planning | ◐ | Triage/Backlog; mit Agile Sprint-Planung |
| action_selection | ✓ | |
| closure | ◐ | oft **dauerhaft inaktiv** — Zyklus ist Schleife, kein Pfad zum Ende |
| adaptation → action_selection | ✓ nötig | **Re-entrancy** muss Kern sein |
**Fazit B2b:** Lifecycle nur tragfähig, wenn er als **Loop mit optionalem Closure** gilt, nicht als einmalige Pipeline.
### A1 · `maturity_progression`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| structure_setup | ✓ | Stufen, Recurring |
| planning | ◐ | oft skip / schwach |
| action_selection | ◐ | Leading object oft **Recurring/Übung**, nicht Action |
| validation | ✓ | Stufenkriterien |
| adaptation | ✓ | Stufenwechsel, Routinen-Rotation |
| closure | ◐ | weich / selten |
**Fazit A1:** Bruch, wenn Core „Next Action = Action“ hardcodet. Kern braucht **polymorphes Work Item**.
### A3 · `recurring_control`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| planning | ◐ | typisch skip |
| action_selection | ◐ | fällige **CadenceInstance** |
| result_intake | ✓ | erledigt → nächster Zyklus, **kein Duplikat** |
| validation/review | ◐ | eher Gesundheits-/Abweichungssignal |
| closure | ◐ | meist nie |
**Fazit A3:** Lifecycle nur mit Cadence-Semantik im Kern; sonst wird A3 zu „Mini-A2 mit Skips“.
### B1 · `checklist_flow`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| intake | ✓ | Items fortlaufend |
| structure_setup | ◐ | Listen/Gruppen — dünn |
| planning | ◐ | oft dauerhaft skip |
| action_selection | ✓ | nächstes Item |
| assignment / waiting | ◐ | oft entbehrlich |
| validation / review / closure | ◐ | meist skip |
**Fazit B1:** Sehr viele Schritte dauerhaft NA. Kern muss **degenerierte, gültige Pfade** erlauben — sonst wirkt der Lifecycle wie aufgezwungene Projektmetaphorik. Das ist kein Ausschluss von B1, aber ein Warnsignal an den Kern.
### B2a · `program_delivery`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| structure_setup | ✓ | Programm-Horizont + Kinder |
| planning | ◐ | übergeordnete Priorisierung |
| action_selection | ✗/**kritisch** | PO: konkrete Next Action liegt bei **Kindern**; Programm liefert **Impulse** (Roadblocker, Kreuz-Deps) |
| assignment | ◐ | selten auf Programmebene |
| waiting | ✓ | auf Kinder/externe Lagen |
| closure | ✓ | Programm-Abschluss |
**Fazit B2a:** Größter struktureller Bruch. Ein Lifecycle auf **einem** SteeringContext erklärt nicht **verschachtelte Steuerung** (Parent-Impulse vs. Child-Next-Action). Das ist kein Methoden-Detail — das ist ein **Kern-Anker**.
### C1 · `dispute_procedure`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| planning | ◐ | schwach |
| waiting | ✓ | zentral |
| result_intake | ◐/**kritisch** | oft **externe Ereignisse**, nicht nur Actor-Ergebnis |
| action_selection | ✓ | nächste Frist/Entscheidung |
| review | ✓ | Decision |
| closure | ✓ | Fallende |
**Fazit C1:** Lifecycle braucht **Event-Injection** als erstklassigen Pfad (nicht nur result_intake von zugewiesener Arbeit).
### Care · `care_navigation`
| Schritt | Passung | Anmerkung |
|---------|---------|-----------|
| structure_setup | ✓ | Prinzipien, Meilensteine, Rituale |
| planning | ◐ | gemischt |
| action_selection | ◐/**kritisch** | Leading object wechselt: Ritual **oder** Reaktion **oder** Meilenstein-Schritt |
| waiting / result_intake | ✓ | inkl. situativer Ereignisse |
| closure | ◐ | weich |
**Fazit Care:** Ein Schritt `action_selection` reicht nur, wenn der Kern **mehrere parallele Bedenken** (Cadence + offene Reaktion + Horizon) tragen kann — nicht nur eine flache Action-Queue.
---
## 3. Was der Lifecycle allein nicht trägt
| Fehlender Kern-Anker | Warum nötig | Betroffen |
|----------------------|-------------|-----------|
| **A. Zyklus als Loop** | Closure optional; Wiedereintritt nach adaptation; Intake jederzeit | B2b, A3, B1, Care |
| **B. Horizon** | Aktiver Ausschnitt (Gate, Stage, Sprint, Care-Checkpoint, Programm-Meilenstein) | A2+Agile, B2b, A1, B2a, Care |
| **C. Polymorphes Work Item** | Next Action zeigt nicht immer auf `Action` | A1, A3, B1, C1, Care, B2a-Impulse |
| **D. Nested / Child Steering** | Parent-Impulse ≠ Child-Next-Action | **B2a** |
| **E. Event-Pfad** | Externe/situative Ereignisse mittendrin | C1, Care, teils B2b |
| **F. Step-Status pro Methode** | active / skip / N/A dauerhaft — formal | B1, A3, B2b closure |
| **G. Extension Points** | Strategies/Policies/Hooks an Schritten — sonst leerer Zyklus | alle |
Ohne A–G bleibt der Lifecycle eine **Erzählung**. Mit A–G wird er zum **Methodenkern**.
---
## 4. Was gut am Lifecycle bleibt
- Gemeinsame Sprache für „wo im Steuerungsgeschehen wir sind“
- Klare Orchestrierungsorte für Hooks/Strategies (Target Architecture §7)
- Passt stark zu A2 und brauchbar zu B2b (mit Loop)
- Verhindert freie Workflow-Engine
- Aligniert mit bereits beschlossenem Adaptive Steering Core
**Empfehlung:** Lifecycle **behalten als Rückgrat**, aber **nicht** als hinreichende Definition des Kerns freigeben.
---
## 5. Empfohlenes Kernmodell (Kandidat zur Entscheidung)
```text
Methodenkern =
1) Steerable Context (+ optional Child Contexts)
2) Standard-Lifecycle als Loop (Schritte mit Status active|skip|n/a)
3) Horizon (aktiver Ausschnitt)
4) Work-Item-Polymorphie (ReadyWorkItem-Union)
5) Signal-/Event-Eingang (Actor-Ergebnis + externe/situative Events)
6) Extension Points (Strategies, Policies, Builder, Hooks, steering_elements)
7) Orchestrierung: Attention + Next Action (+ Program Impulse getrennt von Child NA)
```
Abbildung B2a:
```text
Program Context --impulse/attention--> (kein Ersatz)
Child Context --next_action-------> konkrete Arbeit
```
---
## 6. Risiko bei „nur Lifecycle + Skip“
| Risiko | Folge |
|--------|--------|
| Alles wird Action | A3/B1/Care verbogen |
| Programm = großes Projekt | Hybrid-Entscheidung aus Interview unterlaufen |
| Closure implizit erwartet | Product/Rhythmus falsch modelliert |
| Events nur als Result | C1/Care zweitklassig |
| AP2.4-Felder ohne Semantik | Plugin-Technik ohne fachlichen Kern |
---
*Analyse für PO-Review. Keine Implementierungsentscheidung.*
@@ -0,0 +1,99 @@
# M2 — Methoden: Kompatibilität & Code-Schuld
**Status:** erledigt (Dokumentation) — 2026-07-25
**Voraussetzung:** `Kairo_Steering_Method_Kernel_v0.1.md`
**Spec-D:** `docs/architecture/methods/SPEC_D_*.md`
**Nächste Phase:** Archetyp-Vollspecs
---
## 1. Dominanz (Kernel §3 / §8)
| Methode | Dominanz | Rolle |
|---------|----------|-------|
| `sequential_dependency` | plan | primary |
| `program_delivery` | plan (+ Kind-Signale) | primary |
| `continuous_product` | plan (hybrid-light) | primary |
| `checklist_flow` | plan (dünn) | primary |
| `maturity_progression` | hybrid | primary |
| `recurring_control` | event (Cadence) | primary |
| `care_navigation` | hybrid | primary |
| `dispute_procedure` | event | primary |
| `agile_iteration` | plan-Slice | **Komposition** |
| `generic_operating` | plan (dünn) | primary Fallback |
| `queue_pull` | — | **Legacy** → ablösen durch `checklist_flow` |
| `chapter_based_progression` | — | **Legacy** → Content = A2 + Profil, keine eigene Methode nötig |
| `product_milestone_driven` | — | **Legacy** → migrieren zu program/product |
---
## 2. Kompatibilitätsmatrix Ziel (Archetyp × Methode)
| Archetyp | Default-Methode | Auch erlaubt | Komposition |
|----------|-----------------|--------------|-------------|
| `linear_project` (A2) | `sequential_dependency` | — | `agile_iteration` |
| `program` (B2a) | `program_delivery` | Kind-Methoden an Kindern | Agile nur an Kindern A2/B2b |
| `product` (B2b) | `continuous_product` | — | `agile_iteration` |
| `maturity_journey` (A1) | `maturity_progression` | — | — |
| `recurring_program` (A3) | `recurring_control` | — | `agile_iteration` |
| `checklists` (B1) | `checklist_flow` | — | — |
| `care` (NEU) | `care_navigation` | — | — |
| `dispute_case` (C1) | `dispute_procedure` | — | — |
| `generic` | `generic_operating` | Übergang zu konkreter Methode | — |
| `content_project` | **entfernt** als Archetyp | Content → A2 | — |
Kind unter B2a: jeder Kind-Archetyp mit seiner Default-Methode (Hybrid Decision-Lock).
---
## 3. Ist-Code vs. Ziel
| Methode | Ist `compatible_archetype_keys` | Ziel | Gap |
|---------|-------------------------------|------|-----|
| `sequential_dependency` | `*` | `linear_project` (+ Kind A2) | zu weit |
| `program_delivery` | `program` | `program` | Strategy ≠ Nested/Impulse |
| `continuous_product` | product-like | `product` | prüfen |
| `queue_pull` | `*` | ersetzen durch `checklist_flow` + Checklisten-Archetyp | Rename/neu |
| `agile_iteration` | `*`, composes_with product+**program** | composes_with **product + sequential + recurring** (nicht Programm-Meta) | composes_with unvollständig |
| `care_navigation` | fehlt | `care` | neu |
| `checklist_flow` | fehlt | checklists | neu |
| `chapter_based_*` | `content_project` | deprecated | entfernen/umwidmen |
| `maturity` / `recurring` / `dispute` | ok eng | ok | Strategie-Tiefe |
---
## 4. Code-Schuld (Implementierung später — priorisiert)
| Prio | Schuld | Bezug |
|------|--------|-------|
| P0 | `program_delivery`: Impulse + Nested; Child-NA getrennt | SPEC_D_program_delivery |
| P0 | Registry: `care_navigation` + Archetyp `initiative.care` | Decision-Lock |
| P0 | `checklist_flow` + Archetyp `initiative.checklists`; Nested Tiefe 3 + Roll-up; Multi-Listen | SPEC_B1_checklists / Spec-D |
| P1 | `sequential_dependency` compat auf A2 einschränken | Matrix §2 |
| P1 | `agile_iteration.composes_with` → `continuous_product`, `sequential_dependency`, `recurring_control` | Spec Agile |
| P1 | Dual-Auslöser Event-Pfad in Strategies (C1/Care) | Kernel §3 |
| P2 | Legacy `chapter_based_progression` / `content_project` Seed | Decision-Lock |
| P2 | Spec-D Dominanz-Feld redaktionell in alle Dateien | Kernel §8 |
| P3 | Stubs → volle Strategien (recurring, dispute, …) | Spec-D |
**Kein Code in M2** — nur Verbindlichkeit für spätere APs.
---
## 5. Implementierungsreife Methoden (ehrlich)
| Reife | Methoden |
|-------|----------|
| Fachlich bau-bar (Verhalten klar, Code teils da) | `sequential_dependency`, `continuous_product`, `agile_iteration` (Komposition), `maturity_progression` |
| Fachlich klar, Code weit weg | `program_delivery` (Umbau), `checklist_flow`, `care_navigation` |
| Spec-D gehärtet, Code teils Stub | `recurring_control`, `dispute_procedure`, `maturity_progression`, `continuous_product`, `generic_operating` |
Assignment-DoD für Code-APs: Kernel-Schlitze + Spec-D + diese Matrix — keine Page-Ifs.
---
## 6. Freigabe
- [x] Matrix Ziel §2
- [x] Code-Schuld §4
- [x] Weiter mit Archetyp-Vollspecs
+18
View File
@@ -0,0 +1,18 @@
# methods/ — Spec-Tiefe D Index
**Prozess:** `../M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Methodenkern (Freeze):** [`../Kairo_Steering_Method_Kernel_v0.1.md`](../Kairo_Steering_Method_Kernel_v0.1.md) — Methodentypen: Kernel §6
**PO 2026-07-26:** Architektur beibehalten; Spec-D-Batch **vorläufig freigegeben** (Implementierungsausreichendheit noch offen)
| Methode | Typ | Datei | Status |
|---------|-----|-------|--------|
| `sequential_dependency` | Primary (Ausführung) | SPEC_D_sequential_dependency_v0.1.md | vorläufig freigegeben|
| `continuous_product` | Primary (Ausführung) | SPEC_D_continuous_product_v0.1.md | vorläufig freigegeben|
| `recurring_control` | Primary (Ausführung) | SPEC_D_recurring_control_v0.1.md | vorläufig freigegeben|
| `maturity_progression` | Primary (Ausführung) | SPEC_D_maturity_progression_v0.1.md | vorläufig freigegeben|
| `checklist_flow` | Primary (Ausführung) | SPEC_D_checklist_flow_v0.1.md | vorläufig freigegeben|
| `care_navigation` | Primary (Ausführung) | SPEC_D_care_navigation_v0.1.md | vorläufig freigegeben|
| `dispute_procedure` | Primary (Ausführung) | SPEC_D_dispute_procedure_v0.1.md | vorläufig freigegeben|
| `generic_operating` | Primary (Ausführung, Fallback) | SPEC_D_generic_operating_v0.1.md | vorläufig freigegeben|
| `program_delivery` | Primary (**Meta**) | SPEC_D_program_delivery_v0.1.md | vorläufig freigegeben|
| `agile_iteration` | **Komposition** | SPEC_D_agile_iteration_v0.1.md | vorläufig freigegeben|
@@ -0,0 +1,100 @@
# SPEC-D — `agile_iteration`
## Steuerungsmethode — Spec-Tiefe D v0.1 (Kompositions-Methode)
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-25
**Rolle:** **Kompositions- / Horizont-Methode** (technisch AP2.4: `method_role=modifier`)
**Komponiert mit:** `continuous_product`, `sequential_dependency`, `recurring_control`
**Nicht:** eigene Vorhaben-Natur / kein Archetyp
---
## D1 Identität — PO ✓
| Feld | Wert |
|------|------|
| `method_key` | `agile_iteration` |
| Fachliche Rolle | **Komposition** (Kernel §6) mit eigener Plan-/Lifecycle-Logik für den Iterations-Horizont |
| Technische Rolle | `modifier` (ersetzt Primary nicht; nicht mit `program_delivery`) |
| Label (DE) | Agile Iteration / Sprint |
| Zweck | Taktet Arbeit in `work_cycle` (Sprint): Planung, Sprint-Backlog, Ausführung, Abschluss/Carryover. Ändert nicht, ob das Vorhaben Projekt (Ende) oder Product (Dauer) ist. |
**Klarstellung PO:** „Modifier“ ≠ schwache Logik. Agile hat volle Steuerungslogik für den Sprint — braucht aber eine **Primary** für Vorhaben-Natur (Closure, Gates-Rolle, Dauerbetrieb vs. Ende).
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Komponiert mit | B2b + `continuous_product`; A2 + `sequential_dependency`; A3 + `recurring_control` |
| Nicht allein | ohne Primary keine Aussage über Vorhaben-Natur |
| Nicht Archetyp | Decision-Lock |
---
## D3 Horizon
| Schicht | Owner |
|---------|--------|
| **Vorhaben- / Plan-Horizont** | Primary (Gate, Orientierung, …) |
| **Iterations-Horizont (Ist)** | diese Methode: aktiver `work_cycle` |
Beide gleichzeitig gültig; Ist-Default bei aktivem Sprint = Sprint-Backlog.
---
## D4 Leading Work Item
**Im Sprint-Slice:** **Action**, gefiltert auf `work_cycle_id` des aktiven Sprints (Primary-Ready ∩ Sprint).
**Mit Primary `recurring_control` (A3):** Sprint taktet Actions (Verbesserung/Sonderarbeit). **CadenceInstances** bleiben Leading der Primary und liegen **nicht** als Sprint-Backlog-Todos; Ranking: Cadence overdue/due vor Sprint-Actions (siehe Spec-D `recurring_control` D6).
---
## D5 Lifecycle — eigener Slice (nicht „Flag“)
| Sprint-Phase | Steuerung |
|--------------|-----------|
| Sprint anlegen / geplant | Plan-Container |
| Sprint-Planung | Items aus Eingang/Backlog in Sprint legen (Commit/`work_cycle_id`) |
| Sprint aktiv | action_selection nur Sprint-Scope; Work-Default Sprint |
| Sprint abschließen | Review/Carryover/Unplan; Status `reached`/`closed` |
| Reaktivierung | optional laut bestehendem Flow |
| Kein aktiver Sprint | Komposition wirkungslos → **nur Primary** (kein leerer Sprint-Sackgasse) |
Primary-Lifecycle (intake … closure des Vorhabens) bleibt; dieser Slice **hängt sich** in planning / action_selection / waiting / result_intake / adaptation ein.
---
## D6–D8
Next: ready Actions im aktiven Sprint (Primary-Ready-Regeln ∩ work_cycle).
Codes: `sprint_ready`, `sprint_empty`, `sprint_ending`.
Attention: leerer aktiver Sprint; Überhang vor Abschluss.
Events: activate, complete, carryover, reactivate, unplan.
---
## D9 Nested
Kann auf Kind unter B2a liegen, wenn Kind A2/B2b + Agile nutzt. Programm-Meta bleibt `program_delivery`.
---
## D10–D11
OM: `RoadmapItem(work_cycle)` + `actions.work_cycle_id`.
Elements: `work_cycle_scope`.
`composes_with`: `continuous_product`, `sequential_dependency`, `recurring_control`.
---
## D12
| Punkt | PO ✓ |
|-------|------|
| Eigene Steuerungslogik | ja — Planen + Sprint-Lifecycle |
| Primary nötig | ja — Vorhaben-Natur |
| Bezeichnung | fachlich Kompositions-/Horizont-Methode; technisch modifier |
| Ein aktiver Sprint | ja (Decision-Lock) |
@@ -0,0 +1,170 @@
# SPEC-D — `care_navigation`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock Care, `SPEC_Care_initiative_care_v0.1.md`, Fit-Analyse
**Ist-Code:** Methode existiert noch nicht (neu) — P0
**OM/UI:** Archetyp-Vollspec Care
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `care_navigation` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Fürsorge-Navigation |
| Zweck | Steuert das **Wohlergehen einer Person im Fürsorgefokus** (andere oder Self-Care). Vereinigt Prinzipien, Meilensteine, Rituale und reaktive Stränge unter **einer** Methode — ohne Archetyp-Mix A3+C1+A2. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default für | `initiative.care` |
| kompatibel | `initiative.care` |
| nicht Default für | A1 (Können), A3 (Cadence ohne Fürsorge-Kern), C1 (Verfahren/Fall), B1 (Checklisten) |
---
## D3 Horizon
| Schicht | Inhalt |
|---------|--------|
| **CareFocus** | welche Person (Selbst/Andere) ist der Fürsorgefokus |
| **Checkpoint** | optionaler Lebens-/Entwicklungs-Meilenstein („bis Schuleingang“, „Stabilität nach Krise“) |
| **Jetzt** | Schnitt aus: fälliges Ritual **oder** offene Reaktion **oder** nächster Checkpoint-Schritt |
Horizon ist **mehrschichtig** — nicht nur ein Gate.
---
## D4 Leading Work Item — polymorph (Kern)
Next Action zeigt auf **genau eines** der folgenden, je Ranking:
| Typ | Wann typisch |
|-----|----------------|
| `CadenceInstance` | fälliges/überfälliges Ritual (eine Instanz, kein Duplikat) |
| `CareReaction` | offener situativer Strang (Situation → Reaktion); oft Action oder Decision |
| `HorizonStep` | nächster Schritt am Care-Checkpoint (Action oder Kriterium) |
| `PrincipleReminder` | selten: Prinzip verletzt / Drift ohne konkrete Aufgabe — eher Attention als NA |
**Nicht Leading:** flache Todo-Wand; fremde Rechtsfall-Logik (C1); Skill-Übung ohne Fürsorge-Framing (A1).
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung Care |
|---------|--------|----------------|
| intake | active | Fokus-Person, Prinzipien, Ausgangslage |
| method_selection | active | Default `care_navigation` |
| structure_setup | active | Prinzipien (EFS/Config), optionale Checkpoints, Rituale, Reaktions-Eingang |
| planning | skip/light | keine Vollplanung; Checkpoints rollierend |
| action_selection | active | Ranking über Cadence / Reaction / HorizonStep |
| assignment | active | oft ein Primary Caregiver; Übernahme möglich (später) |
| waiting | active | auf Ritual-Erledigung, situatives Ereignis, Termin |
| result_intake | active | Ritual done, Reaktion abgeschlossen, Evidence |
| validation | optional | Checkpoint-Kriterien |
| review | optional | Lage der Fürsorge / Retrospektive |
| adaptation | active | Rituale/Prinzipien/Checkpoints anpassen |
| closure | skip/soft | Fürsorge oft dauerhaft; Closure nur wenn Fokus endet (z. B. Fall abgeschlossen) |
---
## D6 Next Action — Ranking (Ziel)
**Priorität (Vorschlag):**
1. **Offene kritische Reaktion** (akuter Bedarf, Frist, Sicherheit) → `care_reaction_urgent`
2. **Überfälliges Ritual** (verpasste Cadence, Eskalation) → `care_ritual_overdue`
3. **Heute fälliges Ritual** → `care_ritual_due`
4. **Checkpoint-Schritt ready** → `care_checkpoint_ready`
5. Sonst ruhige Lage → leerer NA-Kanal + Attention „stabil“ / Prinzip-Drift
**Anti-Patterns:**
- jedes verpasste Ritual erzeugt neuen Task-Duplikat (A3-Verbot gilt hier analog)
- alle Rituale + Reaktionen als gleichwertige Todo-Liste
- Self-Care als A1-Skill-Training umdeklarieren
**Leerer Fall:** erlaubt („gerade kein Schritt nötig“) — anders als A2, wo leerer Fall oft Planning Debt ist.
---
## D7 Attention
| Code | Wann |
|------|------|
| `care_reaction_open` | offene Reaktion ohne Fortschritt |
| `care_ritual_overdue` | Cadence verpasst |
| `care_checkpoint_at_risk` | Meilenstein gefährdet |
| `care_principle_drift` | wiederholte Abweichung von Prinzipien |
| `care_caregiver_overload` | zu viele offene Lasten auf einem Actor (später) |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Situatives Ereignis erfasst | öffnet/aktualisiert `CareReaction` |
| Ritual erledigt | CadenceInstance schließt; nächster Zyklus geplant (eine Instanz) |
| Checkpoint verify | Horizon wechselt |
| Prinzip geändert | Attention/Guidance, kein Auto-Commit von Arbeit |
| Externer Termin (Arzt, Schule) | kann Reaction oder Waiting speisen — **nicht** automatisch C1 |
---
## D9 Nested
`n/a` typisch. Care kann Kind unter B2a sein (selten); dann gilt Child-NA = diese Methode, Parent = Impulse.
---
## D10 OM-Voraussetzungen
| Minimal | Optional |
|---------|----------|
| Initiative `initiative.care` | Checkpoints als RoadmapItems |
| CareFocus (EFS oder gleichwertig) | Evidence |
| ≥1 Ritual (Recurring) **oder** Reaktions-Eingang | Decision bei schweren Abwägungen |
| Prinzipien (EFS/Text) | Mehrere Fokus-Personen — TBD |
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_action_strategy | `care_navigation` |
| steering_elements | `next_action_primary`, `recurring_rhythm`, neu `care_focus`, `care_reactions` |
| attention rules | siehe D7 |
| hooks | `on_next_action_requested`, `on_result_received`, `on_escalation_required`, `on_reassessment_required` |
| structure builder | optionales Minimal-Kit: Fokus + 1 Ritual + 1 Prinzip |
---
## D12 Spannungen zum Kandidat-Kern · offene PO-Punkte
| Anker | Bedarf |
|-------|--------|
| Work-Item-Polymorphie | **zwingend** (Cadence + Reaction + HorizonStep) |
| Event-Pfad | **zwingend** (Situation → Reaktion) |
| Loop / weiches Closure | **zwingend** |
| Horizon mehrschichtig | CareFocus + Checkpoint — Kern-Horizon muss mehr als „ein Gate“ können |
**PO ✓ (2026-07-25) — in Klartext:**
1. **Ein Vorhaben = eine Fokus-Person** (oder „ich“ bei Self-Care). Mehrere Personen → mehrere Vorhaben / später Programm.
2. **Reaktion = normales Arbeitspaket** (ggf. kurz über Eingang); kein neues OM-Objekt „CareReaction“ — nur Spec-/Read-Model-Begriff.
3. **Meilensteine/Checkpoints optional** — Care nur mit Ritualen + Reaktionen ist gültig.
## Nächste Methode
Degenerierter Pfad: **`checklist_flow`**.
@@ -0,0 +1,157 @@
# SPEC-D — `checklist_flow`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Archetyp:** `initiative.checklists`
**OM/UI:** `SPEC_B1_checklists_v0.1.md`
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock B1, Archetyp-Vollspec B1, Fit-Analyse
**Ist-Code:** nah an `queue_pull` — fachlich umbenennen/ablösen
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `checklist_flow` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Checklisten-Flow |
| Zweck | Items in Listen/Gruppen sammeln und abhaken bzw. als Nächstes ziehen. Leichte Steuerung — bewusst nah an klassischer Todo-Logik, als **ein** Vorhaben-Typ im Portfolio. Ersetzt fachlich das Label `queue_pull`. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default für | B1 Checklisten (`initiative.support_queue` → Zielrename `initiative.checklists`) |
| kompatibel | Checklisten-Archetyp |
| nicht | Product-Backlog von B2b (bleibt Eingang am Product); A2-Lieferprojekt; Care-Rituale |
---
## D3 Horizon
| Horizont | Bedeutung |
|----------|-----------|
| **Aktive Liste** | eine von mehreren parallelen Listen im Vorhaben |
| **Kein Gate-Pflicht-Horizont** | Meilensteine nicht steuerungsführend |
---
## D4 Leading Work Item
**ChecklistItem** — bevorzugt **offenes Blatt-ToDo** (Tiefe ≤ 3).
Struktur (PO ✓):
- Mehrere Listen parallel; Liste hat Beschreibung
- Punkte verschachtelt max. **Tiefe 3**; Punkt = ToDo (Blatt) oder Sammlung (Kinder)
- Parent erst schließbar, wenn alle Kinder geschlossen (Roll-up)
Abbildung: Items mit `parent_id`; Listen-Container siehe Archetyp-Vollspec.
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | active | Items erfassen (Paste, einzeln, später Capture) |
| method_selection | active | Default checklist_flow |
| structure_setup | light | Listen/Gruppen/Tags anlegen |
| planning | **n/a** | keine Projektplanung |
| action_selection | active | nächstes Item (Pull oder Priorität) |
| assignment | optional | oft entbehrlich (Selbst) |
| waiting | **n/a**/selten | |
| result_intake | active | abhaken / erledigt |
| validation | **n/a** | |
| review | **n/a** | |
| adaptation | light | Liste umsortieren, Gruppe wechseln |
| closure | optional | Liste leer / Archiv — nicht Pflicht |
**Kern-Konsequenz:** viele Schritte dauerhaft `n/a` — gültiger degenerierter Pfad, keine „kaputte“ Methode.
---
## D6 Next Action
**Ready:** offenes Item in aktivem Listen-Horizont, nicht erledigt.
**Ranking:**
1. manuell priorisiert / markiert (`!`, high)
2. mit Fälligkeit (früher zuerst)
3. Listen-Reihenfolge / sort_order
**reason_codes:** `checklist_next`, `checklist_due`, `checklist_priority`
**Leerer Fall:** Liste leer → „nichts offen“ (Erfolg), nicht Planning Debt.
**Anti-Pattern:** alle Items des Portfolios als eine Wand; Product-Issues hier statt in B2b.
---
## D7 Attention
| Code | Wann |
|------|------|
| `checklist_overdue` | Item überfällig |
| `checklist_overflow` | sehr viele offene Items (Schwellwert später) |
| `checklist_unscoped` | Item ohne Gruppe/Thema (wenn Gruppierung genutzt wird) |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Item angelegt | Ready-Menge |
| Item abgehakt | aus Next entfernt |
| Gruppe/Liste gewechselt | Horizon |
| Bulk-Capture freigegeben | viele Items intake |
---
## D9 Nested
`n/a`. Kann Kind unter B2a sein (selten).
---
## D10 OM-Voraussetzungen
| Minimal | Optional |
|---------|----------|
| Initiative Checklisten-Typ | Fälligkeiten |
| ≥1 Liste/Gruppe oder Default-Liste „Allgemein“ | Tags Ort/Thema |
| Items (BacklogItem oder äquivalent) | Convert zu Action |
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_action_strategy | `checklist_flow` (Nachfolger von queue_pull-Verhalten) |
| steering_elements | `next_action_primary`, `queue_inbox` → fachlich Checklisten-Panel |
| hooks | `on_next_action_requested`, `on_result_received` |
---
## D12 Spannungen · offene PO-Punkte
| Punkt | Detail |
|-------|--------|
| Degenerierter Lifecycle | Kern muss `n/a`-Schritte erlauben ohne Qualitätsmakel |
| Item vs Action | zu schweres Action-Modell zerstört Checklisten-Charakter |
| Rename | `queue_pull` → `checklist_flow`; Archetyp-Key später |
**PO ✓ (2026-07-25):**
1. Abhaken am Item = Normalfall; volles Arbeitspaket nur wenn nötig.
2. Bucket/Einkauf = Templates auf Archetyp Checklisten.
3. Nested Tiefe 3, Multi-Listen, Roll-up Parent←Kinder — vollständiges Modell (siehe Archetyp-Vollspec).
4. Listen-Container = Project (`project.checklists`); Punkte = BacklogItem + `parent_id`.
@@ -0,0 +1,170 @@
# SPEC-D — `continuous_product`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Default für:** B2b `initiative.product`
**Komposition:** `agile_iteration`
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock B2b, Archetyp-Vollspec B2b, Kernel Freeze
**OM/UI:** `SPEC_B2b_product_v0.1.md` (C1-Maßstab 2026-07-26)
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `continuous_product` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Kontinuierliches Produkt |
| Zweck | Dauerhaftes System steuern: Eingang triagieren → Actions committen → wirkungsvollsten Schritt wählen; optional Sprint-Takt. Closure ist **nicht** Kernziel. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default | B2b `initiative.product` |
| kompatibel als Primary | B2b / `project.product` (+ Kind unter B2a) |
| Komposition | `agile_iteration` |
| nicht | A2-Default (Ende/DoD); B1 (Product-Backlog ≠ Checklist-Vorhaben); A1 (Können); B2a-Meta |
| Dominanz | `plan` (hybrid-light bei kritischen Incidents/Bugs) |
---
## D3 Horizon
| Situation | Horizont |
|-----------|----------|
| **Ohne aktiven Sprint** | Orientierungs-Gate (falls genutzt) **oder** „wirkungsvollster Schritt“ über committete Ist-Arbeit + triagierter Eingang |
| **Mit `agile_iteration` + aktivem Sprint** | Ist-Default = aktiver `work_cycle`; Plan-Orientierung (Gate) bleibt Primary-Nebenblick |
| **Kein Sprint aktiv** | Komposition wirkungslos → nur Continuous (kein leerer Sprint-Screen) |
---
## D4 Leading Work Item
**Leading:** committete `Action` (ready).
**Eingang:** `BacklogItem` bis Commit — triage-/planungsrelevant, nicht Leading Next (außer expliziter „triage next“-Hinweis als Attention/Nebenkanal).
Sprint: Action ∩ `work_cycle_id` des aktiven Sprints (Primary-Ready ∩ Agile-Filter).
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | **active** | jederzeit neuer Eingang (Idee, Issue, Bug, Ops) |
| method_bind | active | Default `continuous_product` |
| structure_setup | active | Projects (z. B. Entwicklung/Betrieb), optional Orientierungs-Gates, Eingang |
| planning | active | Triage Backlog; Commit zu Action; mit Agile: Sprint-Planung |
| next_work | active | Continuous-Ranking oder Sprint-Ready (D6) |
| assignment | active | Actor an Action |
| waiting | active | auf Erledigung / Freigaben |
| result / event | active | done, Evidence, Blocker; Incident-Events |
| validation | light | Gate-Verify nur wo Orientierungs-Gates genutzt |
| review | optional | Sprint-Review / Product-Lage |
| adaptation | **active** | Re-Triage, Replan, Sprint Carryover → Loop zu next_work |
| closure | **n/a** / selten | kein Closure-Zwang; Archiv nur Ausnahmefall |
---
## D6 Next Action — konkrete Regeln
### Ready (Action)
1. Status ∈ offene Arbeitszustände
2. Deps/`requires` erfüllt (falls genutzt)
3. nicht blocked
4. **Mit aktivem Sprint:** `work_cycle_id` = aktiver Sprint
5. **Ohne Sprint:** im Continuous-Horizont (fokussiertes Gate-Segment und/oder priorisierte Ist-Menge — nicht „alle historischen APs“)
### Ranking
**Ohne Sprint:**
1. kritische Issues / Incidents (`product_issue_critical`)
2. ready am Orientierungs-Gate / fokussiertem Horizont
3. manuelle Prio / Impact / `sort_order`
4. reason: `product_next`
**Mit aktivem Sprint:**
1. ready im Sprint (Primary-Ready ∩ Sprint) → `sprint_ready`
2. leerer aktiver Sprint → Attention `sprint_empty`, **kein** Ausweichen auf außer-Sprint als Fake-Primary-Next (außer Incident-Override laut Ranking 1 ohne Sprint-Bruch nur wenn Policy es erlaubt — Default: Sprint-Scope hält, Incident = Attention + optional Unplan/Override-Decision)
**Leerer Fall ohne Sprint:** keine ready Action → Attention `planning_debt` / „Eingang triagieren oder committen“ — kein Closure-Druck.
**Anti:** Sprint-Backlog als BacklogItem-Liste; Product-Backlog als B1-Checklisten-Vorhaben; leere Sprint-Sackgasse ohne aktiven Sprint; Closure erzwingen.
---
## D7 Attention
| Code | Wann |
|------|------|
| `product_issue_critical` | kritischer Bug/Incident offen |
| `planning_debt` | Horizont ohne ready Actions / nur untriagierter Eingang |
| `sprint_empty` | aktiver Sprint ohne Items (Agile) |
| `sprint_ending` | Sprint-Ende nahe, Überhang |
| `product_backlog_overflow` | Eingang stark überladen (Schwellwert) |
| `gate_orient_stale` | Orientierungs-Gate ohne Fortschritt (wenn Gates genutzt) |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| BacklogItem angelegt | Intake; Triage |
| Commit Backlog → Action | Ready-Menge |
| Blocker gesetzt/gelöst | Ready/Attention |
| Incident/Bug kritisch | Ranking/Attention |
| Sprint activate / complete / carryover / unplan | Agile-Slice (Spec-D `agile_iteration`) |
| Gate verify (orientierend) | Validation light |
---
## D9 Nested
Kann Kind unter B2a sein — Parent-Impulse ≠ Child-Next. Product-Backlog bleibt am Kind.
---
## D10 OM-Voraussetzungen
| Minimal | Mit Agile / Gates |
|---------|-------------------|
| Initiative B2b + Methode | `work_cycles` |
| Eingang (Backlog) | Orientierungs-Gates |
| Commit-Pfad → Action | Evidence/Blocker |
| | Projects Entwicklung/Betrieb |
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_work_strategy | `continuous_product` |
| attention_rules | D7 |
| horizon_resolver | Gate und/oder Continuous; Sprint via Komposition |
| dod_policy | light / n/a (kein Closure-Kern); Gate optional |
| composes_with | `agile_iteration` |
| steering_elements | `next_action_primary`, `work_cycle_scope`, `gate_fulfillment` (orientierend) |
| compatible_archetype_keys | `initiative.product` |
| data_slices | backlog, actions, roadmap, projects, blockers, evidence, decisions, reviews, work_cycles, steering_methods |
---
## D12 Spannungen · PO
| Punkt | Lage |
|-------|------|
| Closure n/a | Kernel erlaubt; Produkt-Natur |
| Sprint optional | Komposition; ohne Sprint nur Primary |
| ≠ B1 | Product-Backlog = Eingang dieses Vorhabens |
| Incident hybrid-light | Event darf Ranking drücken, ersetzt Primary nicht |
@@ -0,0 +1,194 @@
# SPEC-D — `dispute_procedure`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Default für:** C1 `initiative.dispute_case`
**OM-Struktur:** `SPEC_C1_dispute_case_v0.1.md` §4
**Nicht:** Workflow-Engine-Runtime · künstliche Parallel-/Dep-Limits · keine Rechts-Fachlogik
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `dispute_procedure` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Verfahrenssteuerung |
| Zweck | Event→Reaktionsstrang steuern (reaktiv dominant): parallele/abhängige Schritte, Dritt-Actors, Fristen; optional **vorbereitete** Stränge aktivieren; Waiting ≠ Fall-Freeze. Closure am Fallende. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default | C1 `initiative.dispute_case` |
| kompatibel als Primary | nur C1 |
| Komposition | — |
| Dominanz | `event` |
| nicht | Care; A3-Cadence-Kern; offene Workflow-Engine |
---
## D3 Horizon
| Horizont | Bedeutung |
|----------|-----------|
| Aktive `procedure_phase` | Phasen-Fokus |
| Aktive Reaktionsstränge | steuerungsrelevante Arbeitscluster (`active`) |
| Vorbereitete Stränge | Plan-Nebenblick (`prepared`) — nicht Next |
| Nächste Frist(en) | Schritt-, Strang- oder Phasen-Deadline |
---
## D4 Leading Work Item
Polymorph:
| Typ | Wann |
|-----|------|
| `Action` (ready) | Deps erfüllt, nicht im Waiting, nicht blocked |
| `Decision` | offene Entscheidungspflicht |
| Strang-/Schritt-Frist | fällige/überfällige Deadline-Arbeit |
Primary-Next = Top-Rank eines ready Items. **Weitere parallele Ready-Items** sind Nebenkandidaten (sichtbar), kein Singleton-Zwang der Ready-Menge.
Waiting-Schritt ist **nicht** Leading, erzeugt Attention; parallele Ready-Geschwister bleiben Leading-fähig.
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | active | Fall, Parteien/Actors (inkl. Dritte) |
| method_bind | active | `dispute_procedure` |
| structure_setup | active | Phasen; Event-Eingang; Strang-Editor (prepared/active) |
| planning | light | vorbereiten & nachziehen — **kein** Vollplanungszwang; Dominanz bleibt event/reaktiv |
| next_work | active | Ready nur aus `active`-Strängen (D6) |
| assignment | active | Actor je Schritt (Selbst, Anwalt, …) |
| waiting | **central** | am Schritt/Strang — Fall bleibt steuerbar |
| result / event | **central** | Actor-Done + externe Events |
| validation | active | Phasen-/Strang-Kriterien |
| review | active | Decisions |
| adaptation | active | Strang erweitern, Deps/Fristen ändern nach Event |
| closure | **active** | Fallende |
---
## D6 Next Action — konkrete Regeln
### Ready
Action/Decision ist ready wenn:
1. Strang-Status = **`active`** (nicht `prepared`), und
2. Status offen, und
3. alle `requires`-Vorgänger erfüllt, und
4. **nicht** im Waiting-Zustand, und
5. nicht durch Blocker gesperrt
Parallel: fehlende Dep ⇒ gleichzeitig ready — **ohne Obergrenze** für parallele Schritte oder parallele `active`-Stränge.
Deps: gerichteter azyklischer Graph, **ohne** Maximaltiefe/-kanten-Cap; Zyklen = Validierungsfehler.
`prepared`: nicht ready. Strang-übergreifende `requires` erlaubt.
### Ranking
1. überfällige Schritt-/Strang-/Phasen-Frist
2. heute fällige Frist / Fenster-Druck
3. offene Pflicht-Decision
4. ready Schritte (Owner Selbst vor optionaler Anzeige Dritter — oder nach `due`/`sort_order`)
5. reine Waiting-Hinweise → Attention, nicht Fake-Next
**reason_codes:**
`dispute_deadline_overdue`, `dispute_deadline`, `dispute_decision_open`, `dispute_phase_step`, `dispute_parallel_ready`, `dispute_waiting_event`
**Leerer Fall:** nur Waiting, keine parallele Ready-Arbeit → Next leer + Attention `dispute_waiting` (kein A2-Planning-Debt).
**Anti:** Waiting friert Fall; `prepared` als Ready; Todo-Wand; Engine-Runtime; Pflicht-Vollplanung; künstliche Caps auf Parallelität/Deps.
### Event / Result → Strang (Steuerregel)
1. **Neu reaktiv:** Event/manuell → Strang `active` mit 1..n Schritten.
2. **Aktivierung:** Event, Actor-Result, Decision-Outcome oder manuell → passenden Strang `prepared` → `active` (Aktivierungsregel am Strang oder Auswahl-UI).
3. **Erweitern:** Adaptation fügt Schritte an `active`-Strang an; kein Duplikat-Chaos.
4. **Weiche:** ein Outcome aktiviert genau einen (oder bewusst mehrere) vorbereitete Stränge — deklarativ, keine offene Engine.
---
## D7 Attention
| Code | Wann |
|------|------|
| `dispute_deadline_overdue` | Frist überschritten |
| `dispute_deadline_soon` | Frist/Fenster nahe |
| `dispute_decision_stale` | Decision ohne Fortschritt |
| `dispute_waiting` | Strang/Schritt wartet (extern) |
| `dispute_third_party_stale` | zugewiesener Dritt-Actor ohne Rückmeldung über Schwellwert |
| `dispute_phase_stalled` | Phase ohne Ready und ohne begründetes Waiting |
| `dispute_unscoped_event` | Event ohne Strang/Phase-Zuordnung und ohne aktivierbaren prepared-Strang |
| `dispute_dep_blocked` | kritische Dep blockiert fristrelevanten Schritt |
| `dispute_prepared_pending` | Outcome/Event legt Aktivierung nahe, passender prepared-Strang noch nicht aktiviert |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Brief / Dokument | Evidence; `active`-Strang öffnen/erweitern **oder** `prepared` aktivieren |
| Termin gesetzt | Schritt/Frist; ggf. Waiting |
| Gegenseite / Behörde | Ready/Decision; Waiting lösen; ggf. prepared aktivieren |
| Fristablauf | Attention + Pflicht-Schritt/Decision |
| Actor-Result (inkl. Dritte) | Schritt done; Deps freigeben; **kann** prepared-Strang aktivieren |
| Decision-Outcome | Pfad fortsetzen, Closure, **oder** vorbereiteten Strang aktivieren |
| Phasen-Kriterien | nächste Phase |
| Fallabschluss | Closure |
---
## D9 Nested
Kann Kind unter B2a sein. Parent-Impulse ≠ Child-Next.
---
## D10 OM-Voraussetzungen
| Minimal | Vollmodell |
|---------|------------|
| C1 + Methode | mehrere Phasen |
| Event-Eingang | Reaktionsstränge mit strand_id |
| Actions + `requires` | parallele Ready-Mengen |
| Assignment (Actors) | Dritt-Actors |
| Fristen an Action | Strang-/Phasen-Fenster |
| Waiting an Action/Strang | Evidence, Decision, Closure |
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_work_strategy | `dispute_procedure` (Parallel-Ready + Ranking) |
| attention_rules | D7 |
| horizon_resolver | Phase + Stränge + Fristen |
| event_hooks | Event→Strang öffnen/erweitern |
| assignment_policy | inkl. Dritt-Actors |
| steering_elements | `next_action_primary`, `dispute_timeline` |
| compatible_archetype_keys | `initiative.dispute_case` |
| data_slices | actions, roadmap, evidence, decisions, blockers, reviews, steering_methods |
---
## D12 Spannungen · PO
| Punkt | Lage |
|-------|------|
| Komplexität | beliebig viele Stränge/Deps/Parallelen — **keine** Produktlimits |
| Optik | Graph/Timeline als Hilfe, nicht als Engine |
| prepared → active | verbindlich; reaktiv dominant |
| Waiting ≠ Freeze | verbindlich |
| Dritte | Actors + Assignment |
@@ -0,0 +1,105 @@
# SPEC-D — `generic_operating`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Rolle:** Primary (**Ausführung**, dünn) — Fallback / Übergang
**Default für:** `initiative.generic`
**Nicht:** empfohlen für neue Vorhaben
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `generic_operating` |
| Rolle | primary (**Ausführung**, absichtlich dünn — Kernel §6) |
| Label (DE) | Generischer Betrieb |
| Zweck | Minimale Steuerung ohne Vorhaben-Natur: offene Actions grob priorisieren; Attention „Struktur/Methode fehlt“; Übergang zu konkreter Primary. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default | `initiative.generic` |
| kompatibel | nur generic (Übergang: Methode wechseln → anderer Archetyp empfohlen) |
| Komposition | — |
| Dominanz | `plan` (sehr dünn) |
| nicht | als Dauer-Default für neue Vorhaben |
---
## D3 Horizon
Schwach / keiner — kein Gate-, Cadence- oder Phasen-Horizont als Pflicht.
---
## D4 Leading Work Item
Offene `Action`, grob priorisiert (`sort_order` / Fälligkeit falls vorhanden).
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | active | Vorhaben existiert |
| method_bind | active | Fallback; Wechsel zu konkreter Methode empfohlen |
| structure_setup | light | optional |
| planning | light / n/a | |
| next_work | active | nächste offene Action |
| assignment | active | |
| waiting | light | |
| result / event | active | |
| validation | n/a | |
| review | n/a | |
| adaptation | light | Archetyp/Methode wechseln |
| closure | optional | |
---
## D6 Next Action
**Ready:** offene Action.
**Ranking:** manuelle Prio / due / sort_order.
**reason_codes:** `generic_next_action`, `generic_unstructured`.
**Leerer Fall:** keine Action → Attention `generic_needs_archetype` (nicht „Erfolg wie A3 im Takt“).
---
## D7 Attention
| Code | Wann |
|------|------|
| `generic_needs_archetype` | Vorhaben noch generic / ohne spezifische Struktur |
| `generic_method_drift` | Daten legen anderen Archetyp nahe (optional Heuristik) |
---
## D8 Events
Standard Actor-Result. Keine Fall-/Cadence-Spezialevents.
---
## D9 Nested
Kann Kind unter B2a sein — unerwünscht dauerhaft; Migration zu konkretem Kind-Archetyp.
---
## D10–D11
OM: actions minimal. Elements: `next_action_primary`.
`compatible_archetype_keys`: `initiative.generic`.
---
## D12
PO: Create-UI zeigt primär konkrete Archetypen; `generic` nur Altbestand / expliziter Notfall.
@@ -0,0 +1,196 @@
# SPEC-D — `maturity_progression`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Default für:** A1 `initiative.maturity_journey`
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock A1, Archetyp-Vollspec A1, Kernel Freeze, AP2.0e
**OM-Struktur (Stage Activity Set, Felder):** verbindlich in `SPEC_A1_maturity_journey_v0.1.md` §4 / §10
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `maturity_progression` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Reifegrad-Progression |
| Zweck | Fähigkeit über Stufen steuern: Active Stage als Horizont; Next = fällige/alternierende Übung oder Stage-Action; bei Stage `reached` Activity Set wechseln. Weiches Vorhaben-Ende. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default | A1 `initiative.maturity_journey` |
| kompatibel | nur A1 (Project-Spiegel `project.maturity_journey`) |
| nicht | Care (Wohlergehen); A3 (Rhythmus ohne Stufen); A2 (Liefer-DoD) |
| Dominanz | `hybrid` — Cadence-Zeit (Event) + Stufen-Plan (Plan) |
---
## D3 Horizon
| Horizont | Bedeutung |
|----------|-----------|
| **Aktive `maturity_stage`** | fokussierte Stufe; nur deren Stage Activity Set liefert Next |
| Plan-Nebenblick | nächste Stufe / Graph-Voraussetzungen — nicht Leading für Next |
| Ist | CadenceInstances + Stage-Actions der aktiven Stufe |
Keine Next-Kandidaten aus inaktiven Stufen.
---
## D4 Leading Work Item
**Primär:** `CadenceInstance` (Übung/Ritual am RecurringElement der aktiven Stufe).
**Sekundär:** `Action` (Stage-gebunden: Prüfung, Workshop, Nachweis).
**Hinweis-Objekt (kein Leading Work):** offenes Stufen-Kriterium / Verify-Fortschritt — erscheint in Next/Attention als Steuerhinweis.
Pro Recurring: genau **eine** offene Instanz (kein Duplikat bei Verpassen).
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | active | Fähigkeit/Fokus, Vorhaben anlegen |
| method_bind | active | Default `maturity_progression` |
| structure_setup | active | Stufen, Graph, Stage Activity Sets (Recurrings + Stage-Actions), Alternanz-Gruppen |
| planning | light | Fokus/Frequenz; keine Vollprojekt-Planungspflicht |
| next_work / action_selection | active | Ready-Menge + Ranking (D6) |
| assignment | active | Owner-Actor an Ritual/Action (oft Selbst) |
| waiting | active | auf Cadence-Zeitpunkt / Erfüllung |
| result / event | active | practice done; externe/situative Events möglich |
| dod / validation | active | Stufenkriterien + Evidence vor `reached` |
| review | optional | bei Stufenwechsel / Nachweis — nicht jede Übung |
| adaptation | active | Set-Wechsel bei `reached`; manuelle Set-/Cadence-/Alternanz-Änderung |
| closure | soft / skip | Vorhaben-Ende nicht erzwungen |
Kernel-Schlitznamen: Abbildung auf §4 Kernel (Intake … Closure).
---
## D6 Next Action — konkrete Regeln
### Ready-Menge (aktive Stufe)
Ein Work Item ist ready, wenn:
1. gebunden an die **aktive** `maturity_stage` und Aktivität **aktiv**, und
2. eines von:
- **Cadence ohne Alternanz:** Instanz fällig oder überfällig (heute laut Cadence / overdue), oder
- **Cadence in Alternanz-Gruppe:** Instanz ist das **aktuelle** Gruppenmitglied **und** fällig/überfällig (bzw. „dran“ laut Gruppenpolicy, wenn Cadence der Gruppe geteilt ist), oder
- **Stage-Action:** Status offen und Deps/Blocker erlauben Arbeit
**Nicht ready:** Mitglieder einer Alternanz-Gruppe, die nicht aktuell sind — auch wenn ihre Kalender-Cadence „heute“ wäre.
### Ranking
1. überfällige CadenceInstances (inkl. Alternanz-aktuell overdue)
2. heutige fällige Cadences (ohne Alternanz)
3. Alternanz-aktuell (fällig / dran)
4. offene Stage-Actions (sort_order / Fälligkeit)
5. Steuerhinweis offenes Stufen-Kriterium (wenn Verify offen und keine höher priorisierte Arbeit)
**reason_codes:**
| Code | Bedeutung |
|------|-----------|
| `maturity_practice_overdue` | Übung überfällig |
| `maturity_today_practice` | Übung heute fällig |
| `maturity_alternation_current` | aktuelles Alternanz-Mitglied |
| `maturity_stage_action` | Stage-Action |
| `maturity_stage_criteria` | Kriterien/Verify-Hinweis |
**Leerer Fall:** aktive Stufe, nichts fällig → „nächste geplante Übung am …“ / Fokus auf Kriterien — **keine** Fake-Action, **keine** Todo-Wand aus allen Stufen.
### Alternanz (Steuerregeln)
1. Pro `alternation_group_id` genau ein aktuelles Mitglied (State am Group- oder Recurring-Kontext).
2. Nach erfolgreicher Erfüllung des aktuellen Mitglieds: Rotation zum nächsten `alternation_order` (zyklisch).
3. Attention bei overdue nur auf aktuelles Mitglied.
4. Bei Stage-Wechsel: Gruppen der alten Stufe inaktiv; neue Stufe eigene Gruppen.
### Zeitversatz
Unabhängige Cadences am gleichen Stage → mehrere ready am selben Tag möglich; Ranking wie oben. Kein Zwang zur Alternanz.
---
## D7 Attention
| Code | Wann |
|------|------|
| `maturity_practice_overdue` | fällige/überfällige Übung (inkl. Alternanz-aktuell) |
| `maturity_alternation_blocked` | aktuelles Mitglied dauerhaft nicht erfüllbar / ohne Owner |
| `maturity_stage_stagnant` | aktive Stufe ohne Fortschritt (keine fulfilled practice / kein Kriterien-Fortschritt über Schwellwert) |
| `maturity_criteria_open` | Verify/Kriterien offen bei sonst leerer Ready-Menge oder Stage „bereit“ |
| `maturity_inactive_set` | aktive Stufe ohne aktives Activity Set (Strukturfehler) |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| practice done / Cadence erfüllt | Instanz schließen; nächste Instanz laut Cadence; bei Alternanz Rotation |
| Stage-Action done | aus Ready; ggf. Kriterien-Fortschritt |
| Evidence / Kriterium erfüllt | Validation-Fortschritt |
| stage `reached` (Verify ok) | altes Activity Set deaktivieren; nächste Stufe aktiv; neues Set aktiv (AP2.0e erweitert) |
| manuelle Adaptation (Set/Cadence/Alternanz) | Ready-Menge neu; auditiert |
| Cadence-Zeitpunkt erreicht | Event-Schub → Ready neu bewerten |
---
## D9 Nested
`n/a` als Parent-Methode. Kann Kind unter B2a sein — dann Parent-Impulse ≠ Child-Next (Kernel Q4).
Multi-Fähigkeit = mehrere Projects im selben Vorhaben, **kein** Nested-Parent/Child im Methoden-Sinn.
---
## D10 OM-Voraussetzungen
| Minimal | Optional / Template |
|---------|---------------------|
| Initiative A1 + Methode gebunden | Graph-Voraussetzungen |
| ≥1 `maturity_stage`, eine aktiv | mehrere Fähigkeits-Projects |
| Stage Activity Set der aktiven Stufe (≥1 Recurring oder Stage-Action) | Alternanz-Gruppen |
| Recurring: Stage-Bindung, Cadence, aktiv/inaktiv | EFS Fokus/Frequenz |
| Evidence/Kriterien-Pfad für Verify | |
Felder `alternation_group_id`, `alternation_order`: Archetyp-Vollspec A1 §10.
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_work_strategy | `maturity_progression` |
| attention_rules | Codes D7 |
| horizon_resolver | aktive `maturity_stage` |
| dod_policy | Stage-Kriterien / Verify |
| adaptation_hooks | `on_stage_reached` → Set-Wechsel; manuelle Set-Änderung |
| steering_elements | `next_action_primary`, `maturity_stage`, `recurring_rhythm` |
| compatible_archetype_keys | `initiative.maturity_journey` |
| data_slices | recurring, roadmap, actions, evidence, decisions, reviews, projects, steering_methods |
---
## D12 Spannungen · PO
| Punkt | Lage |
|-------|------|
| Hybrid Dominanz | Cadence-Event + Stage-Plan — Kernel trägt Dual-Auslöser |
| Leading polymorph | Cadence + Action — Kernel Q2 |
| Alternanz-State | Persistenz am Group-/Recurring-Kontext — Implementierungsdetail, fachlich hier verbindlich |
| Multi-Fähigkeit | mehrere Projects ok; kein Abnahme-Zwang für Kern-Kit |
**PO-Empfehlung:** A1-Vollspec §4 OM + diese Spec-D = Steuervertrag; UI nur in Archetyp-Vollspec.
@@ -0,0 +1,188 @@
# SPEC-D — `program_delivery`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock B2a, `SPEC_B2a_program_v0.1.md`, Fit-Analyse, Ist-Code `ProgramDeliveryStrategy` (⚠ Gap)
**OM/UI:** Archetyp-Vollspec B2a
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `program_delivery` |
| Rolle | primary (**Meta** — Kernel §6; kein Ausführungs-Leading der Kinder) |
| Label (DE) | Programm-Lieferung / Programm-Controlling |
| Zweck | Steuert den **Schirm** über Kind-Kontexte: Lagebild, Kreuz-Abhängigkeiten, Roadblocker, Priorisierungsimpulse, Programm-Horizont/Closure. **Ersetzt nicht** die Next Action der Kinder. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default für | B2a `initiative.program` |
| kompatibel | `initiative.program` |
| nicht | als Default für A2-Einzelprojekt (dort `sequential_dependency`); nicht für dauerhaftes Product ohne Abschluss-Natur |
---
## D3 Horizon
| Ebene | Horizont |
|-------|----------|
| **Programm-Plan** | übergreifende Zielzustände / Phasen-Meilensteine des Programms |
| **Programm-Steuerung** | Menge der Kind-Kontexte + deren Blockade-/Fortschrittslage |
| **Nicht** | Sprint der Kinder als Programm-Horizon (Kinder behalten eigene Modifier) |
---
## D4 Leading Work Item
**Zielbild (Decision-Lock):** Leading Object auf Programmebene = **`ProgramImpulse`** (Priorisierungs-/Roadblocker-Empfehlung), **nicht** die konkrete Child-Action.
| Objekt | Ebene |
|--------|-------|
| `ProgramImpulse` | Parent — „Kind X zuerst entblocken / Priorität verschieben“ |
| Child Next Action (`Action` / …) | Kind-Methode — unverändert |
**Ist-Code (Abweichung):** Strategy liefert heute ready **Actions am Programm-Initiative** + Gate-Reviews — als wäre das Programm ein flaches A2/B2. Das unterläuft Nested-Entscheidung.
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung Programm |
|---------|--------|-------------------|
| intake | active | Programmziel, Scope, Abschlussabsicht |
| method_selection | active | Default `program_delivery` |
| structure_setup | active | Programm-Meilensteine + **Kind-Kontexte** anbinden (Initiativen/Projects mit eigenem Archetyp/Methode) |
| planning | active | übergeordnete Priorisierung / Reihenfolge der Kinder-Horizonte — nicht AP-Feinplanung der Kinder |
| action_selection | **umgedeutet** | wählt **Impulse**, nicht Child-AP als „die“ Next Action des Programms |
| assignment | skip/optional | selten auf Meta-Ebene; Arbeit liegt in Kindern |
| waiting | active | auf Kind-Fortschritt / externe Programm-Lage |
| result_intake | active | Kind-Statusänderungen, Programm-Meilenstein-Evidence |
| validation | active | Programm-Gate/Meilenstein-Kriterien |
| review | active | Programm-Reviews, Go/No-Go zwischen Phasen |
| adaptation | active | Kinder umpriorisieren, Scope des Programms anpassen |
| closure | active | **erwartet** — Programm hat Ende (≠ Product) |
---
## D6 Next Action / Impulse — konkrete Regeln (Zielbild)
**Auf dem Programm-Kontext zeigt die Steuerung zwei getrennte Kanäle:**
| Kanal | Inhalt | UI/API-Semantik |
|-------|--------|-----------------|
| **A — Child Next Actions** | unverändert von Kind-Methode | Scope = Kind; Programm listet/aggregiert höchstens |
| **B — Program Impulse** | Empfehlung mit reason_code | Scope = Programm; **kein** Ersatz für A |
**Impulse-Ranking (Ziel):**
1. Kreuz-Abhängigkeit / Roadblocker, der ≥2 Kinder oder Programm-Meilenstein blockiert
2. Kind auf kritischem Programm-Pfad ohne Fortschritt
3. Priorisierungsempfehlung (Portfolio-/Programm-Rang zwischen Kindern)
4. Programm-Meilenstein mit offenen Kriterien ohne zurechenbares Kind
**reason_codes (Ziel):** `program_roadblocker`, `program_cross_dependency`, `program_child_stalled`, `program_priority_shift`, `program_milestone_risk`
**Leerer Fall:** keine Impulse und Kinder ohne Attention → Programm-Lage „stabil“; trotzdem Child-NAs in Kindern sichtbar — Programm zeigt nicht „nichts zu tun“ indem es Child-APs als eigene NA ausgibt.
**Verboten (Zielbild):**
- Programm-`action_selection` gibt Child-Action als *die* Next Action des Programms aus und suggeriert, das Programm steuere die AP-Reihenfolge restriktiv wie A2
---
## D7 Attention
| Code (Ziel) | Wann |
|-------------|------|
| `program_roadblocker` | Blocker/Dep über Kinder hinweg |
| `program_milestone_at_risk` | Programm-Gate gefährdet |
| `program_child_stalled` | Kind ohne Fortschritt am kritischen Programm-Pfad |
| `program_orphan_work` | Arbeit ohne Zuordnung zu Kind/Meilenstein |
| `program_closure_ready` | alle Kinder/Meilensteine closure-fähig |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Kind Next Action / Statusänderung | Programm-Lage + Impulse neu |
| Kreuz-Dep angelegt/gelöst | Impulse + Attention |
| Programm-Meilenstein verify | Horizont |
| Kind Archetyp/Methode gewechselt | Hybrid bleibt erlaubt; Impulse neu bewerten |
| Kind closure | Programm-Closure-Prüfung |
---
## D9 Nested — Kernanker (Härtetest)
```text
Program Context (method = program_delivery)
├── Impulse / Attention / Programm-Horizont / Closure
└── Child Context 1 (eigene Methode, z. B. sequential_dependency)
└── Child Context 2 (eigene Methode, z. B. continuous_product oder A2 Content)
└── deren Next Action unverändert
```
**PO ✓ Decision-Lock:** konkrete Next Action auf Projektebene; Programm = übergeordnete Impulse.
**Kern-Konsequenz:** Kandidat-Anker **D Nested Steering** und **polymorphes Work Item (`ProgramImpulse`)** sind für diese Methode **nicht optional**.
---
## D10 OM-Voraussetzungen
| Minimal | Optional |
|---------|----------|
| Programm-Initiative + `program_delivery` | Programm-Backlog (Eingang) |
| ≥1 Programm-Meilenstein/Phase | work_cycle nur wenn Modifier auf Kind oder explizit am Programm gewünscht |
| ≥1 Kind-Kontext (Initiative oder Project mit eigenem Steering) | Kreuz-Deps als Graph-Kanten zwischen Kind-Horizonten / Programm-Items |
| Lagebild-Read-Model über Kinder | |
**Offen modellseitig:** Sind Kinder **eigene Initiativen** unter einem Programm-Portfolio-Link, oder **Projects** mit eigenem `method_key`-Override unter einer Programm-Initiative? Decision-Lock erlaubt hybrid inhaltlich — **Datenmodell muss in D12 entschieden werden**.
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_action_strategy | `program_delivery` → Impulse-Kanal; Aggregation Child-NA getrennt |
| steering_elements | `next_action_primary` (Impulse), `gate_fulfillment` (Programm), neu z. B. `program_child_lage` / `cross_dependency` |
| graph_profile | Programm-Meilensteine; Kreuz-Deps |
| ui_features | Programm-Lage vs. Child-Drilldown getrennt |
| hooks | `on_next_action_requested` (Impulse), `on_replan_required`, `on_closure_requested`, Kind-Status-Hooks |
---
## D12 Spannungen — Ist vs. Ziel · offene PO-Punkte
| Spannung | Detail |
|----------|--------|
| **Ist-Code ≠ Decision-Lock** | `ProgramDeliveryStrategy` ≈ Gate-ready Actions auf derselben Initiative — **kein** Nested/Impulse-Modell |
| **Katalog v0.2 veraltet** | „Next Action: nächstes Gate/AP am Programm-Horizont“ widerspricht Interview |
| **Kern** | Ohne Nested + ProgramImpulse bricht diese Methode den Kandidat-Kern |
**PO ✓ (2026-07-25):**
1. **Kind-Modell:** beides erlaubt; Logik adressiert Child SteeringContext; Primärbild Projects + `method_key`-Override, verlinkte Initiativen optional später.
2. **Programm-Widget:** Impulse primär; Child-NAs als klar getrennter zweiter Block.
3. **Programm-Büro-Actions:** erlaubt, sekundär — dürfen Impulse-NA nicht ersetzen/tarnen.
---
## Bezug sequential_dependency
Als Kind-Methode unverändert (`SPEC_D_sequential_dependency`). Programm darf Kind-NA nicht überschreiben.
## Nächste Methode
Härtetest Multi-Leading-Object: **`care_navigation`**.
@@ -0,0 +1,171 @@
# SPEC-D — `recurring_control`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**Default für:** A3 `initiative.recurring_program`
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Quellen:** Decision-Lock A3, Archetyp-Vollspec A3, Kernel Freeze
**OM-Struktur:** verbindlich in `SPEC_A3_recurring_program_v0.1.md`
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | `recurring_control` |
| Rolle | primary |
| Label (DE) | Rhythmus-Steuerung |
| Zweck | Systemgesundheit über wiederkehrende Rituale steuern: Next = fällige/überfällige CadenceInstance; eine offene Instanz pro Rhythmus; Abweichung/Score sichtbar — kein Todo-Duplikat bei Verpassen. |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default | A3 `initiative.recurring_program` |
| kompatibel als Primary | nur A3 / `project.recurring_program` |
| Komposition | `agile_iteration` (Sprint-Slice für Actions; Cadence bleibt Leading der Primary) |
| nicht | Care; A1; B1 als Primary-Ersatz |
| Dominanz | `event` — Cadence führt; bei Agile zusätzlich plan-Slice auf Actions |
---
## D3 Horizon
| Horizont | Bedeutung |
|----------|-----------|
| **Zeitfenster „heute / fällig / überfällig“** | über alle aktiven Rituale (optional gefiltert nach Domain-Project) |
| Domain-Filter | aktiver Domain-Ausschnitt (Project) — optional, nicht Pflicht für Next |
| Gates | nicht steuerungsführend (`n/a` / light) |
---
## D4 Leading Work Item
**`CadenceInstance`** am `RecurringElement`.
- Pro Ritual genau **eine** offene Instanz.
- Verpassen → Instanz bleibt / eskaliert (Attention, Score) — **kein** zweites offenes Duplikat.
- `Action` nur für Ausnahme/Eskalation (Reparatur, Sonderarbeit), nicht Leading für Normalzyklus.
---
## D5 Lifecycle-Pfad
| Schritt | Status | Bedeutung |
|---------|--------|-----------|
| intake | active | System/Domains/Rhythmen erfassen |
| method_bind | active | Default `recurring_control` |
| structure_setup | active | Domain-Projects, RecurringElements, Owner-Actors, Cadences |
| planning | n/a | keine Gate-/Lieferplanung als Kern |
| next_work / action_selection | active | fällige/überfällige Instanzen (D6) |
| assignment | active | Owner; optionale freiwillige Übernahme |
| waiting | active | auf Cadence-Zeitpunkt |
| result / event | active | erledigt → genau eine nächste Instanz planen |
| dod / validation | light | optional Qualitätscheck am Ritual — nicht Gate-DoD |
| review | light | periodischer System-Health-Blick |
| adaptation | active | Cadence/Owner/Score-Parameter anpassen |
| closure | skip | Dauerprogramm — Closure nicht erwartet |
---
## D6 Next Action — konkrete Regeln
### Ready
CadenceInstance ist ready, wenn:
1. Ritual aktiv, und
2. Instanz offen, und
3. Fälligkeit ≤ jetzt (fällig/heute) **oder** überfällig, und
4. nicht durch Blocker gesperrt (sonst Attention)
### Ranking
1. überfällig (älter zuerst / höherer Abweichungs-Score zuerst)
2. heute fällig
3. als Nächstes geplant (nur Anzeige/Hinweis, nicht als Fake-Druck-Next)
**reason_codes:** `recurring_overdue`, `recurring_due`, `recurring_next_scheduled`
**Leerer Fall:** nichts fällig → „System im Takt“ / nächste Fälligkeit — Erfolg, nicht Planning Debt.
**Anti:** alle historischen Verfehlungen als Task-Wand; Gates als Leading Horizon.
### Komposition `agile_iteration`
Bei aktivem Sprint (siehe Spec-D Agile):
1. CadenceInstance overdue/due bleibt Ready und rankt **vor** Sprint-Actions.
2. Sprint filtert **Actions** (Verbesserung/Sonderarbeit), nicht Ritual-Instanzen.
3. reason_codes Primary unverändert; zusätzlich Agile-Codes für Sprint-Actions.
4. Ohne aktiven Sprint: nur diese Primary.
---
## D7 Attention
| Code | Wann |
|------|------|
| `recurring_overdue` | Instanz überfällig |
| `recurring_deviation` | Abweichungs-Score über Schwellwert (verpasste Zyklen, Verspätung) |
| `recurring_unowned` | Ritual ohne Owner-Actor |
| `recurring_stale_definition` | Ritual lange ohne erfolgreichen Zyklus trotz aktiv |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Cadence-Zeitpunkt | Event-Schub → Ready |
| Instanz erledigt | schließen; genau eine nächste Instanz; Score aktualisieren |
| Verpasst / überfällig | Score/Attention; **keine** zweite Instanz |
| Owner-Wechsel / Übernahme | Assignment; Audit |
| Cadence geändert | Adaptation; nächste Fälligkeit neu |
---
## D9 Nested
`n/a` primary. Kann Kind unter B2a sein — Parent-Impulse ≠ Child-Next.
---
## D10 OM-Voraussetzungen
| Minimal | Vollmodell |
|---------|------------|
| Initiative A3 + Methode | Domain-Projects |
| ≥1 RecurringElement mit Cadence + Owner | Multi-Actor / Übernahme |
| eine offene Instanz-Semantik | Abweichungs-Score je Ritual/Domain |
| | optionale Eskalations-Action |
---
## D11 Extension Points
| Art | Ziel |
|-----|------|
| next_work_strategy | `recurring_control` |
| attention_rules | Codes D7 |
| horizon_resolver | Zeitfenster + optional Domain |
| dod_policy | light / n/a |
| adaptation_hooks | Cadence, Score, Owner |
| steering_elements | `next_action_primary`, `recurring_rhythm` (+ `work_cycle_scope` bei Agile) |
| compatible_archetype_keys | `initiative.recurring_program` |
| composes_with | `agile_iteration` |
| data_slices | recurring, projects, actions, blockers, steering_methods (+ work_cycles bei Agile) |
---
## D12 Spannungen · PO
| Punkt | Lage |
|-------|------|
| Event-Dominanz | Kernel Dual-Auslöser — Plan-Zug dünn ok |
| Score | Teil des vollständigen Steuerungsmodells; Implementierungs-Schnitt in APs |
| ≠ Care / ≠ A1 | Gegenstand = Systemrhythmus, nicht Wohlergehen oder Können-Stufen |
@@ -0,0 +1,170 @@
# SPEC-D — `sequential_dependency`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** vorläufig freigegeben (PO 2026-07-26) — mit zugehöriger Archetyp-Vollspec; Implementierungsausreichendheit noch offen
**Stand:** 2026-07-26
**OM/UI:** `SPEC_A2_linear_project_v0.1.md`
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md` (+ Kurskorrektur: konkrete Steuerungsregeln)
**Quellen:** Decision-Lock A2, ADP Execution Plan / AP1.16, Fit-Analyse, Code `execution_ready` / graph-state
---
## D1 Identität — PO ✓
| Feld | Wert |
|------|------|
| `method_key` | `sequential_dependency` |
| Rolle | primary (**Ausführung** — Kernel §6) |
| Label (DE) | Sequenzielle Abhängigkeit / kritischer Pfad |
| Zweck | Begrenztes Vorhaben über Gates/Abhängigkeiten; Next Action = nächster **ready**-Schritt am relevanten Pfad (typisch kritischer Pfad). |
---
## D2 Geltung — PO ✓
| Feld | Wert |
|------|------|
| Default | A2 `initiative.linear_project` |
| kompatibel | A2; projektartige Kind-Projekte unter B2a |
| nicht Meta für | B2a-Programm (`program_delivery`); B2b Default (`continuous_product`) |
---
## D3 Horizon — PO ✓ (AA)
| Horizont | Bedeutung |
|----------|-----------|
| **Plan** | aktives / fokussiertes Gate (Zielzustand) + erreichbarer Teilgraph |
| **Ist (ohne Agile)** | Actions am Gate-/Pfad-Ausschnitt |
| **Ist (mit `agile_iteration`)** | zusätzlich aktiver `work_cycle` als Ausführungs-Takt; Gate bleibt Plan-Horizont |
---
## D4 Leading Work Item — PO ✓ (AA)
**Action** (Arbeitspaket). Ready über Abhängigkeiten. Task = unter Action, nicht Leading Object.
---
## D5 Lifecycle-Pfad (konkret)
| Schritt | Status | Konkrete Bedeutung in dieser Methode |
|---------|--------|--------------------------------------|
| intake | active | Ziel, Scope, Vorhaben anlegen |
| method_selection | active | Default A2; Wechsel auditiert |
| structure_setup | active | Projects/Stränge, Gates, Gate-Deps (`requires`), optional Action-Deps |
| planning | active | rollierend: nächster Gate-Horizont + APs; nicht „alles vorab“ Pflicht |
| action_selection | active | `ready_actions` ∩ Ranking kritischer Pfad |
| assignment | active | Actor an Action |
| waiting | active | auf Erledigung / Freigabe Deps |
| result_intake | active | Status done / Evidence / Blocker |
| validation | active | Gate-Kriterien / Verify vor `reached` |
| review | skip/optional | bei Meilenstein-Review; nicht jeder AP |
| adaptation | active | Replan Graph/APs bei Blocker oder Planänderung |
| closure | active | Vorhaben-/Gate-Abschluss möglich und erwartet |
---
## D6 Next Action — konkrete Regeln
**Ready (Action):**
1. Status ∈ offene Arbeitszustände (`open` / `ready` / `in_progress` … je OM)
2. Alle `requires`-Vorgänger (Action-Deps und ggf. Gate-Bindung laut Graph-Profil) erfüllt (`done` oder waived per Decision)
3. Nicht durch Blocker gesperrt (sonst Attention, nicht Next)
4. Im aktiven Horizont (Gate und/oder Sprint, wenn Modifier aktiv) — **PO ✓:** kritischer Pfad nur **innerhalb** des Horizonts; keine Next Action außerhalb des Gate-/Sprint-Filters nur weil „auf globalem critical path“
**Ranking:**
1. Actions auf dem **critical_path** vor anderen ready
2. dann `sort_order` / Titel
3. reason_codes: `execution_critical_path`, `execution_ready`
**Leerer Fall:**
- keine ready Action → Attention: blockiert / Planning Debt / „nächstes Gate ohne APs“ — **keine** Fake-Next-Action
**Nicht Next Action:**
- blockierte Nachfolger als ready verkaufen
- Programm-Impulse (das ist `program_delivery`)
- Recurring/Checklist als Leading Object
---
## D7 Attention — konkrete Auslöser
| Signal (Ziel-Code) | Wann |
|--------------------|------|
| `path_blocked` | kritische Action/Gate durch Blocker oder offene requires |
| `gate_at_risk` | `target_date` / Kriterien gefährdet |
| `planning_debt` | aktiver Horizont ohne planbare/ready APs (AP1.16d-Semantik) |
| `overdue_action` | Action überfällig |
---
## D8 Events
| Event | Wirkung |
|-------|---------|
| Action → `done` | Deps neu auswerten → neue ready-Menge |
| Blocker create/clear | Attention + ready neu |
| Gate verify / reopen | Horizont + Erfüllung |
| Plan-Graph-Änderung | critical_path / ready neu |
| (mit Agile) Sprint aktiv/complete | Ist-Horizont wechselt |
Externe Gerichts-/Fürsorge-Events: **nicht** Kern dieser Methode.
---
## D9 Nested
`n/a` als Programm-Meta.
Als **Kind** unter B2a: diese Methode steuert nur den Kind-Kontext; Parent nutzt `program_delivery` für Impulse.
---
## D10 OM-Voraussetzungen
| Minimal | Optional |
|---------|----------|
| Initiative + SteeringContext | Tasks unter Action |
| ≥1 Gate/Milestone oder äquivalenter Zielzustand | Gate-Kriterien |
| Actions | `work_cycle` nur mit Agile-Modifier |
| Abhängigkeiten: Gate- und/oder Action-Deps (sonst degeneriert zu flacher Liste — Attention `planning_debt` / Hinweis) | Evidence, Blocker |
---
## D11 Extension Points
| Art | Key / Verhalten |
|-----|-----------------|
| next_action_strategy | `sequential_dependency` → nutzt `ready_actions` + `critical_path` |
| steering_elements | `next_action_primary`, `critical_path`, `gate_fulfillment` |
| graph_profile | Gate-Blocking / Fulfillment betont (`enforce_gate_blocking` typisch true) |
| ui_features | `criticalPathControl` |
| modifier | `agile_iteration` komponierbar (Horizon Ist = Sprint) |
| hooks (Ziel) | `on_next_action_requested`, `on_structure_required`, `on_dependency_analysis_required`, `on_evidence_required`, `on_replan_required` |
---
## D12 Spannungen zum Kandidat-Kern / offene Punkte
| Punkt | Bewertung |
|-------|-----------|
| Lifecycle-Loop | passt; Closure expected |
| Horizon-Anker | **nötig** — ohne ihn Agile-Komposition unklar |
| Work-Item-Polymorphie | hier nur Action — stützt Anker, nutzt Union minimal |
| Nested | nur als Kind — stützt Trennung zu `program_delivery` |
| Zwei Graphen (Gate vs Action-Deps) | **Besonderheit:** beide erlaubt; Next Action primär Ist-Graph (Actions), Plan-Graph begrenzt Horizont — muss im Kern als „Horizon + ReadyWorkItem“ klar bleiben, nicht vermischt werden |
**PO ✓ (2026-07-25):**
1. Next Action **nicht** außerhalb des aktiven Horizonts, auch wenn global auf critical path.
2. Gate-Graph allein reicht als **Minimalstart**; Action-Deps schärfen Ready/Critical Path. Ohne jegliche Deps → flache Liste + Attention `planning_debt`, Methode bleibt gültig.
---
## Nächste Methode
Härtetest Nested: **`program_delivery`**.
@@ -0,0 +1,104 @@
# SPEC-D — `{method_key}`
## Steuerungsmethode — Spec-Tiefe D v0.1
**Status:** Entwurf
**Stand:** YYYY-MM-DD
**Prozess:** `M1_Hybrid_Path_and_Depth_D_v0.1.md`
**Kandidat-Kern:** Hypothese (Lifecycle-Loop + Anker A–G)
---
## D1 Identität
| Feld | Wert |
|------|------|
| `method_key` | |
| Rolle | primary / modifier |
| Label (DE) | |
| Zweck (2–3 Sätze) | |
---
## D2 Geltung
| Feld | Wert |
|------|------|
| Default für Archetypen | |
| `compatible_archetype_keys` (Ziel) | |
| Nicht kompatibel mit | |
---
## D3 Horizon
Was begrenzt „jetzt relevant“?
---
## D4 Leading Work Item
Welches Union-Mitglied zeigt Next Action primär?
---
## D5 Lifecycle-Pfad
| Schritt | Status (`active`/`skip`/`n/a`) | Warum |
|---------|--------------------------------|-------|
| intake | | |
| method_selection | | |
| structure_setup | | |
| planning | | |
| action_selection | | |
| assignment | | |
| waiting | | |
| result_intake | | |
| validation | | |
| review | | |
| adaptation | | |
| closure | | |
---
## D6 Next Action
- Eingaben:
- Ranking:
- Leerer Fall:
- reason_codes:
---
## D7 Attention
---
## D8 Events
---
## D9 Nested
`n/a` oder Beschreibung Parent/Child.
---
## D10 OM-Voraussetzungen
---
## D11 Extension Points
| Art | Keys / TBD |
|-----|------------|
| next_action_strategy | |
| attention / signals | |
| steering_elements | |
| policies / builder | |
| hooks (Namen) | |
---
## D12 Spannungen zum Kandidat-Kern
1. …