| const VERSION_DATA = { |
| "v1-0": { |
| number: "V1.0", |
| title: "Ordnungs-Agent mit menschlichem Gate", |
| status: "gesicherter Snapshot", |
| oneLine: "V1.0 macht HAI erstmals wiederholbar: Projektlage, naechster Schritt und Ausfuehrung laufen durch ein menschliches Gate.", |
| skillstand: [ |
| "Projektlage, Idee, Codezustand, Briefing, Minimierung und Execution-Loop werden als Artefakt-Kette gebaut.", |
| "Der Executor arbeitet nur auf akzeptierten EXECUTION_STEPs; der Validator prueft danach read-only." |
| ], |
| skills: ["project-state", "idea-spec", "code-state", "briefing", "minimize", "execution-loop"], |
| stand: "Erster gespeicherter agentischer HAI-Workflow vom 2026-05-08; praktisch brauchbar, aber aus BahnAgent/Testfall entstanden.", |
| problem: "Unklar, ob der Workflow ausserhalb des Ursprungstests generalisiert. Die alte Ordnung war noch nicht als wiederholbarer Projektmanagement-Prozess bewiesen.", |
| proposal: "V1 sichern, Rollen trennen und danach mit fremden Projekten pruefen. Nicht die Basis umbauen, bevor Generalisierung messbar ist.", |
| implementation: "HAI-Agent erzeugt PROJECT_STATE, PROMPT, CODE_STATE, BRIEFING und NEXT_STEP; akzeptierte EXECUTION_STEPs laufen ueber Executer und Validator.", |
| test: "Nachfolgender V1.1-Dreierlauf auf WerBinIch, NasaCode und PromptBoost.", |
| validationText: "2 PASS, 1 PARTIAL; kein BahnAgent-Overfit sichtbar, aber Root-Bindung und Reporting bleiben offen.", |
| method: "Methodischer Kern: erst reproduzierbaren Baseline-Snapshot sichern, dann Generalisierung getrennt evaluieren.", |
| good: ["Klare Trennung: planen, ausfuehren, validieren.", "Samuel bleibt Gate vor jeder Ausfuehrung."], |
| weak: ["Noch stark aus BahnAgent/Testfall geboren.", "Root-Bindung und dauerhafte Reports fehlen."], |
| next: "V1.1 muss beweisen, dass HAI auch ausserhalb des Ursprungstests den kleinsten sinnvollen Schritt findet.", |
| background: "Der erste Fortschritt ist nicht Autonomie, sondern Wiederherstellbarkeit.", |
| proof: ["EXECUTION_STEP Gate", "read-only Validator", "2 PASS / 1 PARTIAL"], |
| sources: [ |
| { label: "V1 README", href: "../../V1/README.md" }, |
| { label: "V1 Manifest", href: "../../V1/MANIFEST.md" } |
| ], |
| matrix: ["Artefakt-Kette", "Briefing entsteht", "Validator", "kaum", "hartes Execution-Gate"], |
| asciiArt: String.raw` |
| V1.0 BASELINE / OWNER-GATE |
| |
| MENSCH / OWNER |
| Zustand + Absicht |
| | |
| v |
| +------------------+ +------------------+ |
| | PROJECT_STATE | ---> | BRIEFING | |
| +------------------+ +------------------+ |
| | | |
| v v |
| +------------------+ +------------------+ |
| | CODE_STATE | ---> | NEXT_STEP | |
| +------------------+ +---------+--------+ |
| | |
| HUMAN ACCEPT? |
| no | yes |
| v |
| +-------------------+ |
| | hai-executer | |
| +---------+---------+ |
| | |
| v |
| +-------------------+ |
| | hai-validator | |
| +---------+---------+ |
| | |
| v |
| EVIDENZ -> OWNER`, |
| website: { |
| storyTitle: "Vom Chaos zum ersten Owner-Gate", |
| storyLead: "V1.0 ist die erste HAI-Website ueber Wiederholbarkeit: nicht mehr Agent macht irgendwas, sondern Mensch akzeptiert einen konkreten Schritt.", |
| before: "Agentische Arbeit war moeglich, aber nicht stabil als Prozess greifbar.", |
| after: "PROJECT_STATE, BRIEFING, NEXT_STEP, Executer und Validator bilden eine kontrollierte Linie.", |
| ownerQuestion: "Hat Samuel nach dem Ruecklauf mehr Klarheit als vor dem Start?" |
| } |
| }, |
| "v1-1": { |
| number: "V1.1", |
| title: "Generalisierung statt Demo-Fit", |
| status: "PARTIAL, Richtung stimmt", |
| oneLine: "V1.1 loest HAI vom Demo-Fit: Projektabsicht wird breiter gelesen, PromptGarage bleibt read-only, Human Gate bleibt hart.", |
| skillstand: [ |
| "project-state -> user-wishlist -> idea-spec -> code-state -> briefing -> minimize -> execution-loop.", |
| "V1 bleibt stabil; Executor und Validator werden nicht umgebaut." |
| ], |
| skills: ["project-state", "user-wishlist", "idea-spec", "code-state", "briefing", "minimize"], |
| stand: "V1.1 ist der Generalization-Lernstand nach drei fremden Projekten: semantisch besser, aber noch PARTIAL.", |
| problem: "HAI hing zu stark an README/IDEA und schrieb bei PromptBoost Artefakte in den falschen Root-Kontext.", |
| proposal: "Intent-Quellen breiter lesen, PromptGarage nur read-only als historisches Quellenmaterial nutzen und Root-Bindung haerten.", |
| implementation: "Neuer Pre-Briefing-Schritt hai-user-wishlist; hai-idea-spec akzeptiert idea-aehnliche Dateien statt nur feste Dateinamen.", |
| test: "Manuelle Evaluation: WerBinIch PASS, NasaCode PASS, PromptBoost PARTIAL.", |
| validationText: "Generalisiert semantisch ueber drei Projekte; nicht clean PASS wegen Project-Root-Ambiguitaet und fehlendem durable Verification-Report.", |
| method: "Overfit-Test gegen neue Projektklassen statt Vertrauen in einen gelungenen Demo-Fall.", |
| good: ["HAI erkennt Projektabsicht breiter.", "PromptGarage wird nur read-only als Kontext genutzt."], |
| weak: ["Root-Bindung ist noch nicht sauber genug.", "Momentum und Verifikationsreport bleiben zu schwach."], |
| next: "V1.2 muss aus sicherem PARTIAL einen klareren PASS machen: Root bestaetigen, Verifikation dokumentieren, Nutzen zeigen.", |
| background: "Generalisierung heisst: Kontext nutzen, ohne ihn als Auftrag zu missverstehen.", |
| proof: ["2 PASS", "1 PARTIAL", "PromptGarage read-only"], |
| sources: [ |
| { label: "V1.1 README", href: "../../V1.1/README.md" }, |
| { label: "V1.1 Final Report", href: "../../docs/hai-architecture/v1_1_generalization_manual_eval_2026-05-08_1835/FINAL_GENERALIZATION_REPORT.md" } |
| ], |
| matrix: ["breiter Intent", "mehr Kontext", "manueller 3-Projekt-Test", "kaum", "Human Gate bleibt"], |
| asciiArt: String.raw` |
| V1.1 INTENT-DISCOVERY / WISHLIST |
| |
| MENSCH / OWNER |
| | |
| aktuelle Anweisung | bleibt hoechste Quelle |
| v |
| +-----------+ +---------------+ +-------------+ |
| | README | | idea-aehnlich | | Projektspur | |
| +-----+-----+ +-------+-------+ +------+------+ |
| \ | / |
| \ | / |
| v v v |
| +-------------------------------------+ |
| | hai-user-wishlist | |
| | PromptGarage nur READ-ONLY | |
| +------------------+------------------+ |
| | |
| v |
| +-------------------------------------+ |
| | idea-spec liest Intent breiter | |
| +------------------+------------------+ |
| | |
| v |
| BRIEFING -> NEXT_STEP |
| | |
| v |
| alte Spuren erklaeren, befehlen nicht`, |
| website: { |
| storyTitle: "Intent breiter lesen, ohne alte Prompts zu befehligen", |
| storyLead: "V1.1 zeigt HAI als Uebersetzer zwischen aktuellem Projekt und historischen Wunsch-Spuren.", |
| before: "HAI war zu abhaengig von README/IDEA und konnte fremde Projektformen misslesen.", |
| after: "Wishlist und breitere Intent-Discovery machen Kontext nuetzlich, aber PromptGarage bleibt read-only.", |
| ownerQuestion: "Bleibt die aktuelle menschliche Absicht hoeher priorisiert als alte Spuren?" |
| } |
| }, |
| "v1-2": { |
| number: "V1.2", |
| title: "Von Projekt-Verstehen zu stabiler Ausfuehrung", |
| status: "validierter Zwischenschritt", |
| oneLine: "V1.2 verbessert Intent; die Bruchstelle wird Umsetzung.", |
| skillstand: [ |
| "HAI erkennt mehr Quellen als IDEA/README und behandelt fehlende Standarddateien nur als Signal.", |
| "Gehaertet werden handoff, minimize, execution-loop, user-wishlist und idea-spec." |
| ], |
| skills: ["project-state", "wishlist", "idea", "code", "briefing", "minimize", "executor-handoff", "loop"], |
| stand: "V1.2 verbessert Projektwahrnehmung deutlich; die Hauptbruchstelle verschiebt sich zur Ausfuehrung.", |
| problem: "Sonnenuhr bekam einen zu grossen README-Step; schloss_PDF zeigte fragile Executor/Validator-Loop-Zustaende.", |
| proposal: "Atomization Gate haerten, NEXT_STEP fuer Menschen knapp lassen und daraus ein executor-klares Handoff erzeugen.", |
| implementation: "hai-minimize verlangt Step IDs und kleinere bounded surfaces; hai-executor-handoff erzeugt EXECUTOR_HANDOFF_NEXT_STEP; loop bekommt Timeout/No-Report-Zustaende.", |
| test: "Dreierlauf auf WG-Agent, Sonnenuhr und schloss_PDF; zusaetzlich meta-new-agent Review, doctor und Chat-Smoke.", |
| validationText: "Intent ca. 60 -> 85; PromptGarage 0 -> 80 brauchbar; Loop bleibt nur ca. 55-60 robust.", |
| method: "Methodisch: Fehlerklasse isolieren. Wenn Verstehen besser wird, wird die naechste Hypothese Ausfuehrungsrobustheit.", |
| good: ["Intent-Erkennung grob 60 -> 85.", "PromptGarage-Nutzung 0 -> 80, weiter immutable/read-only."], |
| weak: ["Loop nur 55-60 robust.", "Steps teils noch zu gross fuer saubere Ausfuehrung."], |
| next: "V1.3 muss pruefen, ob ein Schritt menschlich sinnvoll ist, nicht nur klein.", |
| background: "Projektverstehen generalisiert; jetzt muss HAI schlechte Arbeit aktiv verhindern.", |
| proof: ["Intent 60 -> 85", "PromptGarage 0 -> 80", "Loop 55-60", "3 Testprojekte"], |
| sources: [ |
| { label: "V1.2 Report", href: "../../V1.2/V1_2_GENERALIZATION_REPORT.md" }, |
| { label: "V1.2 Changelog", href: "../../V1.2/CHANGELOG.md" } |
| ], |
| matrix: ["85% grob", "Executor-Handoff", "doctor + meta PASS", "Loop-Gates", "weiter hart"], |
| asciiArt: String.raw` |
| V1.2 HANDOFF / ATOMIZATION ARCHITECTURE |
| |
| MENSCHLICH KNAPPER NEXT_STEP |
| | |
| v |
| +-------------------------------+ |
| | Step-ID + Allowed Changes | |
| | Atomizitaets-Gate | |
| +---------------+---------------+ |
| | |
| scope-identisch uebersetzen |
| v |
| +-------------------------------+ |
| | EXECUTOR_HANDOFF_NEXT_STEP | |
| +---------------+---------------+ |
| | |
| +--------------+--------------+ |
| | | |
| v v |
| +----------------+ +----------------+ |
| | hai-executer | | watchdog gates | |
| +-------+--------+ | timeout/no rpt | |
| | +----------------+ |
| v |
| +----------------+ |
| | hai-validator | |
| +-------+--------+ |
| | |
| v |
| ACCEPT / REJECT / BLOCKED mit Beweis`, |
| website: { |
| storyTitle: "Kleiner Schritt heisst noch nicht ausfuehrbarer Schritt", |
| storyLead: "V1.2 ist die Website ueber Handoff: aus menschlich knappem NEXT_STEP wird executor-klare Arbeit.", |
| before: "Verstehen wurde besser, aber die Ausfuehrung blieb fragil.", |
| after: "Step-ID, Handoff, Timeout und No-Report-Gates machen Failure sichtbar.", |
| ownerQuestion: "Kann Samuel erkennen, ob die Maschine wirklich im erlaubten Scope blieb?" |
| } |
| }, |
| "v1-3": { |
| number: "V1.3", |
| title: "Projekt-Sinn vor Agenten-Arbeit", |
| status: "eingefrorene akzeptierte Baseline", |
| oneLine: "V1.3 fragt nicht nur, ob ein Schritt klein ist, sondern ob er fuer Samuel ueberhaupt Sinn macht.", |
| skillstand: [ |
| "HAI unterscheidet Build, Verify, Goal reached, Archive/Maintain und menschliche Entscheidung.", |
| "Neu: explain-better, Lifecycle-Gates, executor handoff und canonical NEXT_STEP refresh." |
| ], |
| skills: ["project-state", "explain-better", "minimize", "executor-handoff", "execution-loop", "lifecycle-gates"], |
| stand: "V1.3 ist die akzeptierte Baseline nach V1.4-PASS; installiert, gesichert und eingefroren.", |
| problem: "V1.2 konnte kleine Schritte erzeugen, die technisch korrekt, aber menschlich schlecht, stale oder sinnlos waren.", |
| proposal: "Vor NEXT_STEP nicht nur Atomizitaet pruefen, sondern Lifecycle und Human-Payoff: already works, goal reached, event passed, archive/maintain.", |
| implementation: "hai-explain-better zwischen Briefing und Minimize; Lifecycle-Gates; canonical NEXT_STEP refresh/blocking nach Human Redirect.", |
| test: "V1.3-Eval auf TypoTuner, PseudoLogikPyhthonCPP und HeumandenParty; danach V1.4-Proof-Run als Regression.", |
| validationText: "V1.3-Eval PARTIAL mit zwei Patches; V1.4-Proof danach PASS und keine Pflicht-Patches.", |
| method: "Nicht nur Output-Qualitaet messen, sondern menschlichen Nutzen und Stop-Bedingungen als Erfolgskriterium.", |
| good: ["Weniger Busywork und klarere NEXT_STEPs.", "Bessere Gates vor Deploy, Commit, Push und externem Zugriff."], |
| weak: ["Kein Produkt-Autopilot.", "Bei Auth, Hosting oder Entscheidung blockt HAI statt zu raten."], |
| next: "V1.4 muss die Baseline an frischen Projekten pruefen, ohne schon wieder umzubauen.", |
| background: "HAI wird ein Sinn-Filter vor kontrollierter Agentenarbeit.", |
| proof: ["V1.4 PASS", "No mandatory patch", "Lifecycle Gates", "Human Gate"], |
| sources: [ |
| { label: "V1.3 Freeze", href: "../../V1.3/BASELINE_FREEZE.md" }, |
| { label: "V1.3 Eval", href: "../../docs/hai-architecture/v1_3_generalization_manual_eval_2026-05-08_1953/FINAL_GENERALIZATION_REPORT.md" } |
| ], |
| matrix: ["Sinn statt nur klein", "NEXT_STEP refresh", "V1.4 PASS", "Blocken korrekt", "stark"], |
| asciiArt: String.raw` |
| V1.3 LIFECYCLE-BREMSE / SINN-FILTER |
| |
| BRIEFING |
| | |
| v |
| +-----------------------------+ |
| | hai-explain-better | |
| | Warum hilft dieser Schritt? | |
| +--------------+--------------+ |
| | |
| v |
| +----------------+ |
| | Lifecycle Gate | |
| +--------+-------+ |
| | |
| +-------------------+-------------------+ |
| | | | |
| v v v |
| ALREADY_WORKS GOAL_REACHED EVENT_PASSED |
| | | | |
| +---------+----------+---------+---------+ |
| | | |
| v v |
| DECISION / STOP ARCHIVE_OR_MAINTAIN |
| | |
| v |
| nur wenn sinnvoll: NEXT_STEP -> Execution |
| |
| Erfolg = Arbeit verhindern, wenn Arbeit falsch ist`, |
| website: { |
| storyTitle: "Sinn-Bremse vor Busywork", |
| storyLead: "V1.3 macht HAI zur Scope-Maschine, die nicht nur Arbeit erzeugt, sondern schlechte Arbeit verhindert.", |
| before: "Ein kleiner technischer Schritt konnte trotzdem menschlich sinnlos sein.", |
| after: "Lifecycle-Gates erkennen ALREADY_WORKS, GOAL_REACHED und ARCHIVE_OR_MAINTAIN.", |
| ownerQuestion: "Wurde Samuel vor unnoetiger Agentenarbeit geschuetzt?" |
| } |
| }, |
| "v1-4": { |
| number: "V1.4", |
| title: "Proof-Run fuer V1.3", |
| status: "Proof-Run, nicht installierbare Version", |
| oneLine: "V1.4 ist der Generalization-Proof: drei neue Projekte, drei Zustandslagen, kein neuer Agentenbau.", |
| skillstand: [ |
| "Getestet wird die global installierte V1.3-Baseline, nicht eine neue installierbare Version.", |
| "Fokus: Lifecycle Gate, Explain-Better Gate, NEXT_STEP Refresh und Human Decision vor Deploy/Push." |
| ], |
| skills: ["v1.3-baseline", "lifecycle-test", "explain-better", "redirect-refresh", "regression-check"], |
| stand: "V1.4 ist Proof-Run, keine installierbare Version. Getestet wurde die global installierte V1.3-Baseline.", |
| problem: "Offen war, ob Lifecycle/Human-Payoff nur auf bekannten Faellen gut klingt oder in echten Projekten Busywork verhindert.", |
| proposal: "Drei neue Projektzustaende pruefen: unfertig aber low-payoff, deploy-gated Website, nahezu fertiges Portfolio.", |
| implementation: "Keine neue Runtime; Codex liest die von Samuel erzeugten Projek-Managment-Artefakte und Scorecards gegen definierte Fokusfragen.", |
| test: "BookmarkBrain, SandrasWritingWorld und PortfolioTimeline im manuellen V1.4-Eval vom 2026-05-10.", |
| validationText: "Gesamt PASS: BookmarkBrain PASS, SandrasWritingWorld BLOCKED_BUT_CORRECT, PortfolioTimeline PASS; keine Pflicht-Patches.", |
| method: "Methodisch: Proof-Run statt Feature-Run. Die Hypothese ist, ob HAI Arbeit stoppen kann, wenn Arbeit nicht mehr sinnvoll ist.", |
| good: ["HAI erkennt Build, Parken, Publizieren und menschliche Entscheidung besser.", "Der Run vermeidet stale oder low-payoff Busywork."], |
| weak: ["Kein Installationsstand.", "Proof ist manuell evaluiert und haengt an Projektartefakten."], |
| next: "V1.5 darf nur einen engen Repair-Pfad ergaenzen, ohne die akzeptierte Linie umzubauen.", |
| background: "Proof ist hier wichtiger als neue Features.", |
| proof: ["3 reale Projekte", "Gesamt PASS", "0 Pflicht-Patches", "Proof-only"], |
| sources: [ |
| { label: "V1.4 Final Report", href: "../../docs/hai-architecture/v1_4_generalization_manual_eval_2026-05-10_1747/FINAL_GENERALIZATION_REPORT.md" }, |
| { label: "V1.4 Run Notes", href: "../../docs/hai-architecture/v1_4_generalization_manual_eval_2026-05-10_1747/RUN_NOTES.md" } |
| ], |
| matrix: ["Proof statt Feature", "Baseline belegt", "3 reale Projekte", "indirekt", "entscheidet vor Deploy"], |
| asciiArt: String.raw` |
| V1.4 PROOF-RUN / BASELINE TEST |
| |
| V1.3 BASELINE (frozen) |
| | |
| v |
| +-----------------------------------+ |
| | Keine neue Runtime, nur Beweis | |
| +-----------------+-----------------+ |
| | |
| +---------------------+----------------------+ |
| | | | |
| v v v |
| +----------------+ +--------------------+ +----------------+ |
| | BookmarkBrain | | SandrasWritingWorld| | PortfolioLine | |
| | PASS | | BLOCKED_BUT_CORRECT| | PASS | |
| +-------+--------+ +---------+----------+ +--------+-------+ |
| \ | / |
| \ | / |
| v v v |
| +-----------------------------------+ |
| | Generalization Verdict: PASS | |
| | Pflichtpatches: 0 | |
| +-----------------------------------+ |
| |
| Version als Produktbeweis, nicht Feature-Hype`, |
| website: { |
| storyTitle: "Proof-Website statt Feature-Website", |
| storyLead: "V1.4 ist die Website des Beweises: keine neue Magie, sondern frische Faelle gegen V1.3.", |
| before: "Unklar war, ob die Sinn-Bremse nur auf bekannten Faellen gut klingt.", |
| after: "Drei Projekte zeigen PASS/BLOCKED_BUT_CORRECT/PASS ohne Pflichtpatch.", |
| ownerQuestion: "Wird korrektes Stoppen als Erfolg anerkannt?" |
| } |
| }, |
| "v1-5": { |
| number: "V1.5", |
| title: "Eskalieren, ohne Kontrolle abzugeben", |
| status: "zufriedenstellender aktueller Stand", |
| oneLine: "V1.5 bleibt eine testbare PM-Baseline: Gemini darf helfen, wenn ein Loop scheitert, aber nicht die Kontrolle uebernehmen.", |
| skillstand: [ |
| "Stabile V1.3/V1.4-Linie plus Gemini-MCP Escalation Review.", |
| "Trigger: BLOCKED, REJECT, UNCLEAR, Timeouts, Step-ID- und Finalization-Konflikte." |
| ], |
| skills: ["native-mcp", "gemini-escalation", "execution-loop", "human-gate", "no-fanout"], |
| stand: "V1.5 ist ein kleiner Patch auf der akzeptierten V1.3/V1.4-Linie und aktuell zufriedenstellender PM-Stand.", |
| problem: "Execution-Loop-Failures brauchen Repair-Analyse, aber ein zweiter autonomer Validator oder breiter Agenten-Fanout wuerde Kontrolle verschieben.", |
| proposal: "Gemini-MCP nur bei BLOCKED, REJECT, UNCLEAR, Timeout, No-Report, Step-ID- oder Finalization-Konflikt als Escalation Review nutzen.", |
| implementation: "hai-execution-loop bekommt GEMINI_ESCALATION_REVIEW_NEXT_STEP als Artefaktvertrag; Gemini darf Repair triggern, aber nicht Scope erweitern.", |
| test: "V1.5-Eval am 2026-05-25 auf FireTracker, miniZentrale und ShortcutCounter; Score 36/39.", |
| validationText: "PM-Baseline PASS_WITH_FINDING: 3/3 brauchbare PM-Pakete; Gemini-Pfad selbst NOT_MEASURED.", |
| method: "Wissenschaftlicher Caveat: Der Patch darf als nicht-regressiv gelten, aber die neue Gemini-Hypothese ist noch nicht kausal gemessen.", |
| good: ["3/3 Projekte erzeugten brauchbare PM-Pakete.", "Human Gate, NEXT_STEP und Executer-Validator-Kette bleiben erhalten."], |
| weak: ["Gemini-Pfad ist noch nicht gemessen.", "Der Repair-Pfad wurde noch nicht hart gegen Failure-Faelle getestet."], |
| next: "Kein breiter V1.6-Umbau; erst Report-to-NEXT_STEP-Canonicalization, dann gezielte Gemini-Failure-Eval.", |
| background: "Repair darf helfen, aber nicht die Besitzrechte am Prozess verschieben.", |
| proof: ["36/39", "92.3%", "3/3 PM-Pakete", "Gemini NOT_MEASURED"], |
| sources: [ |
| { label: "V1.5 Final Report", href: "../../docs/hai-architecture/v1_5_generalization_manual_eval_2026-05-25_1630/FINAL_GENERALIZATION_REPORT.md" }, |
| { label: "V1.5 README", href: "../../V1.5/README.md" } |
| ], |
| matrix: ["PM-Baseline stabil", "Repair-Eskalation", "36/39", "Gemini angelegt", "bleibt fuehrend"], |
| asciiArt: String.raw` |
| V1.5 FAILURE-REPAIR / GEMINI ESCALATION |
| |
| normaler Execution Loop |
| NEXT_STEP -> executer -> validator -> ACCEPT |
| | |
| nur bei Fehler/Unklarheit |
| v |
| +-----------------------------------------------+ |
| | BLOCKED | REJECT | UNCLEAR | TIMEOUT | NO RPT | |
| +----------------------+------------------------+ |
| | |
| v |
| +-----------------------------------------------+ |
| | GEMINI_ESCALATION_REVIEW_NEXT_STEP | |
| | analysiert Failure, erweitert Scope NICHT | |
| +----------------------+------------------------+ |
| | |
| +----------------+----------------+ |
| | | |
| v v |
| scope-identischer Repair zurueck zu Samuel |
| | |
| v |
| normaler Validator bleibt Wahrheitsinstanz |
| |
| Mehr Intelligenz, aber kein zweiter Owner`, |
| website: { |
| storyTitle: "Repair darf helfen, aber nicht uebernehmen", |
| storyLead: "V1.5 ist die Website fuer enge Eskalation: Gemini darf bei Failure analysieren, aber nicht Scope ausweiten.", |
| before: "Loop-Failures waren sichtbar, aber Repair-Analyse war nicht sauber kontrahiert.", |
| after: "Gemini-MCP ist nur Failure-/Unklarheits-Review, kein zweiter Autopilot.", |
| ownerQuestion: "Bleibt Samuel trotz zusaetzlicher Intelligenz der Kontrollpunkt?" |
| } |
| }, |
| "v1-6": { |
| number: "V1.6", |
| title: "Zwei Lanes, ein Owner", |
| status: "Pair-Modus Patchlinie", |
| oneLine: "V1.6 erlaubt maximal zwei unabhaengige EXECUTION_STEP-Lanes, aber nur wenn Scope, Worktrees und Join-Vertrag Samuels Ownership erhalten.", |
| skillstand: [ |
| "Stabile V1.5-Linie plus eng begrenzter Pair-Modus.", |
| "Zwei unabhaengige Lanes laufen isoliert in Git-Worktrees und werden erst nach Validator-ACCEPT zusammengefuehrt." |
| ], |
| skills: ["pair-plan", "pair-execution-loop", "worktrees", "validator-accept", "pair-join"], |
| stand: "V1.6 ist ein kleiner Patch auf V1.5: kein breiter Agenten-Fanout, sondern maximal zwei sichere unabhaengige Lanes.", |
| problem: "HAI soll fluessiger arbeiten, ohne bei paralleler Ausfuehrung Kontrolle, Scope oder menschliche Stop-Fragen zu verlieren.", |
| proposal: "Pair-Modus nur bei Pair Autonomy Verdict: AUTO_EXECUTION_ALLOWED. Gleiche Dateien, Lockfiles, Migrationen, globale Config, Produktfragen und externe Side Effects blocken Pair-Ausfuehrung.", |
| implementation: "Neuer hai-pair-plan erzeugt PAIR_PLAN.md; neuer hai-pair-execution-loop fuehrt Lane A/B in isolierten Worktrees aus und schreibt PAIR_STATUS.md sowie PAIR_JOIN_REPORT.md.", |
| test: "Noch zu messen: gezielter Pair-Modus-Canary mit zwei wirklich unabhaengigen atomaren Steps und einem Negativfall mit ueberlappendem Scope.", |
| validationText: "README beschreibt die Guardrails; kausale Pair-Evaluation steht noch aus.", |
| method: "Methodisch: Durchsatz nur dort erhoehen, wo Unabhaengigkeit beweisbar ist. Ownership-Fragen stoppen weiterhin beim Menschen.", |
| good: ["Maximal zwei Lanes statt beliebigem Batch-N-System.", "Join erst nach Validator-ACCEPT und Scope-Pruefung."], |
| weak: ["Pair-Modus braucht harte Negativtests.", "Mehr Parallelitaet erhoeht Merge- und Scope-Risiko, wenn Gates lax werden."], |
| next: "V1.6 braucht einen Pair-Canary: ein Positivfall mit zwei unabhaengigen Lanes und ein Negativfall, der korrekt auf Single-Step oder Samuel zurueckfaellt.", |
| background: "Mehr Durchsatz ist nur Fortschritt, wenn der Mensch danach mehr Owner ist, nicht weniger.", |
| proof: ["2-Lane-Limit", "Worktree-Isolation", "Validator-ACCEPT", "Pair-Join"], |
| sources: [ |
| { label: "V1.6 README", href: "../../V1.6/README.md" }, |
| { label: "V1.6 Changelog", href: "../../V1.6/CHANGELOG.md" } |
| ], |
| matrix: ["Pair-Autonomie", "Lane A/B Handoff", "Stop-Fragen bleiben", "Gemini bleibt Failure-Repair", "Owner vor Durchsatz"], |
| asciiArt: String.raw` |
| V1.6 PAIR-MODE / TWO-LANE JOIN |
| |
| NEXT_STEP Kandidaten |
| | |
| v |
| +------------------------------+ |
| | hai-pair-plan | |
| | Unabhaengigkeit beweisen | |
| +---------------+--------------+ |
| | |
| AUTO_EXECUTION_ALLOWED? |
| no | | yes |
| v v |
| Single Step +-------------+ |
| oder Samuel | 2-Lane Max | |
| +------+------+ |
| | |
| +------------------------+------------------------+ |
| | | |
| v v |
| +------------------+ +------------------+ |
| | Worktree A | | Worktree B | |
| | executer+val | | executer+val | |
| +--------+---------+ +--------+---------+ |
| | | |
| +------------------------+------------------------+ |
| | |
| beide Validator ACCEPT? |
| no | | yes |
| v v |
| STOP PAIR_JOIN_REPORT |
| | |
| v |
| mehr Evidenz -> Owner`, |
| website: { |
| storyTitle: "Zwei Lanes, kein Kontrollverlust", |
| storyLead: "V1.6 ist die Website fuer begrenzten Durchsatz: genau zwei unabhaengige Lanes, wenn Autonomie beweisbar ist.", |
| before: "Single-Step war sicher, aber manchmal langsamer als noetig.", |
| after: "Pair-Plan, Worktrees und Join nach Validator-ACCEPT erlauben parallele Arbeit ohne Fanout.", |
| ownerQuestion: "Hat Samuel nach zwei Lanes mehr Evidenz, ohne weniger Owner zu sein?" |
| } |
| } |
| }; |
|
|
| const ORDER = ["v1-0", "v1-1", "v1-2", "v1-3", "v1-4", "v1-5", "v1-6"]; |
| const MATRIX_ROWS = ["Verstehen", "Handoff", "Lifecycle-Stop", "Repair", "Human Gate"]; |
|
|
| const VISUAL_DATA = { |
| "v1-0": { |
| label: "Owner-Gate Baseline", |
| thesis: "V1.0 verwandelt unklare Projektlage in einen akzeptierten, validierten Schritt.", |
| layers: [ |
| { title: "Mensch", items: ["Zustand", "Absicht", "Risiko"] }, |
| { title: "HAI-Kette", items: ["Project State", "Briefing", "NEXT_STEP"] }, |
| { title: "Execution", items: ["Human Accept", "Executer", "Validator"] } |
| ], |
| deltas: ["erstes Gate", "Rollen getrennt", "Evidenz-Ruecklauf"], |
| warning: "Ohne ACCEPT keine Ausfuehrung." |
| }, |
| "v1-1": { |
| label: "Intent Source Discovery", |
| thesis: "V1.1 macht aus verstreuten Absichtsspuren einen kontrollierten Kontext, ohne alte Prompts zu befehligen.", |
| layers: [ |
| { title: "Quellen", items: ["README", "Idea-like Files", "Projektspuren"] }, |
| { title: "Read-only Kontext", items: ["PromptGarage", "Wishlist", "Priorisierung"] }, |
| { title: "Kanon", items: ["Idea Spec", "Briefing", "NEXT_STEP"] } |
| ], |
| deltas: ["Wishlist neu", "Intent breiter", "History != Auftrag"], |
| warning: "Aktuelle Samuel-Anweisung bleibt hoeher als alte Treffer." |
| }, |
| "v1-2": { |
| label: "Handoff Contract", |
| thesis: "V1.2 trennt menschliche Knappheit von maschineller Praezision: ein Step wird zum pruefbaren Vertrag.", |
| layers: [ |
| { title: "Kanonischer Step", items: ["Step-ID", "Allowed Changes", "Atomizitaet"] }, |
| { title: "Handoff", items: ["Executor Contract", "Scope Match", "Status Gates"] }, |
| { title: "Loop Watch", items: ["Timeout", "No Report", "Validator Verdict"] } |
| ], |
| deltas: ["Executor-Handoff", "Step-ID Lock", "Failure sichtbar"], |
| warning: "Wenn Handoff != NEXT_STEP, stoppt der Loop." |
| }, |
| "v1-3": { |
| label: "Lifecycle Brake", |
| thesis: "V1.3 fuegt vor Arbeit eine Sinn-Bremse ein: Nicht jeder kleine Schritt ist ein guter Schritt.", |
| layers: [ |
| { title: "Projektlage", items: ["Already works?", "Goal reached?", "Event passed?"] }, |
| { title: "Bremse", items: ["Explain Better", "Lifecycle Gate", "Human Payoff"] }, |
| { title: "Ausgang", items: ["Decision Step", "Archive/Maintain", "Execution Step"] } |
| ], |
| deltas: ["Sinn vor Arbeit", "Stale Step Block", "Stop ist Erfolg"], |
| warning: "HAI darf korrekt blocken, auch wenn Technik moeglich waere." |
| }, |
| "v1-4": { |
| label: "Proof, not Feature", |
| thesis: "V1.4 ist ein Beweis-Release: dieselbe Baseline wird gegen drei frische Projektlagen gehalten.", |
| layers: [ |
| { title: "Frozen Baseline", items: ["V1.3", "keine Runtime-Aenderung", "Hypothese"] }, |
| { title: "Eval Cases", items: ["BookmarkBrain", "WritingWorld", "Portfolio"] }, |
| { title: "Verdict", items: ["PASS", "BLOCKED_BUT_CORRECT", "0 Pflichtpatches"] } |
| ], |
| deltas: ["Proof-Run", "3 reale Faelle", "Baseline bestaetigt"], |
| warning: "Produktvalidierung ist hier wichtiger als neue Features." |
| }, |
| "v1-5": { |
| label: "Scoped Repair", |
| thesis: "V1.5 baut eine zweite Analyse-Brille ein, aber nicht einen zweiten Owner.", |
| layers: [ |
| { title: "Normal Loop", items: ["NEXT_STEP", "Executer", "Validator"] }, |
| { title: "Failure Trigger", items: ["BLOCKED", "REJECT", "UNCLEAR", "Timeout"] }, |
| { title: "Repair Review", items: ["Gemini MCP", "Scope bleibt", "Repair oder Samuel"] } |
| ], |
| deltas: ["Gemini nur Failure", "kein Fanout", "Repair-Vertrag"], |
| warning: "Gemini darf analysieren, aber keinen Scope erfinden." |
| }, |
| "v1-6": { |
| label: "Two-Lane Join", |
| thesis: "V1.6 erhoeht Durchsatz nur dort, wo Unabhaengigkeit beweisbar und der Join kontrolliert ist.", |
| layers: [ |
| { title: "Pair Plan", items: ["Lane A/B", "Unabhaengigkeitsbeweis", "AUTO_EXECUTION_ALLOWED"] }, |
| { title: "Isolation", items: ["Worktree A", "Worktree B", "Validator je Lane"] }, |
| { title: "Join Gate", items: ["beide ACCEPT", "PAIR_JOIN_REPORT", "sonst Stop"] } |
| ], |
| deltas: ["2-Lane Max", "Worktree-Isolation", "Join nach ACCEPT"], |
| warning: "Bei Scope-Ueberlappung zurueck zu Single-Step oder Samuel." |
| } |
| }; |
|
|
| const PROFILE_DATA = { |
| "v1-0": { |
| role: "Baseline-Agent / Owner-Gate", |
| positioning: "HAI V1.0 wird als erstes Produktprofil gezeigt: ein reproduzierbarer Agenten-Workflow, nicht nur ein loses Profil- und Skill-Buendel.", |
| inputs: ["Projektzustand", "IDEA/README-Signale", "Codezustand", "Samuels akzeptierter EXECUTION_STEP"], |
| process: "HAI baut eine Artefakt-Kette aus Project State, Idea Spec, Code State, Briefing und NEXT_STEP. Erst nach menschlicher Akzeptanz wird ausgefuehrt.", |
| outputs: ["PROJECT_STATE.md", "PROMPT.md", "CODE_STATE.md", "BRIEFING.md", "NEXT_STEP.md", "Validator-Ruecklauf"], |
| mentalModel: "Der Nutzer ist Owner, aber braucht eine Scope-Maschine, die aus unklarer Lage einen kleinsten verantwortbaren Schritt macht.", |
| changes: ["Erster gesicherter agentischer HAI-Snapshot", "Rollen getrennt: HAI-Agent, Executer, Validator", "Human Gate vor Ausfuehrung etabliert"], |
| functions: ["Artefakt-Kette", "EXECUTION_STEP Gate", "read-only Validator", "Change-Log/Commit-Regel nach ACCEPT"], |
| governance: "V1.0 darf ausfuehren, aber nicht ohne akzeptierten Step. Produktversprechen: Kontrolle vor Geschwindigkeit." |
| }, |
| "v1-1": { |
| role: "Intent-Reader / Wishlist-Agent", |
| positioning: "V1.1 positioniert HAI als Agentenprodukt, das Nutzerabsicht breiter erkennt und historische Wunsch-Spuren kontrolliert nutzt.", |
| inputs: ["Projektdateien", "idea-aehnliche Intent-Dateien", "PromptGarage read-only", "aktuelle Samuel-Anweisung"], |
| process: "Vor dem Briefing wird User-Wishlist-Kontext rekonstruiert. Alte Prompts werden Quellenmaterial, aber nicht neue aktuelle Entscheidung.", |
| outputs: ["WISHLIST.md", "breiteres PROMPT.md", "robusteres Briefing", "kanonischer NEXT_STEP"], |
| mentalModel: "Der Nutzer hat Absichten ueber Zeit verteilt. HAI darf diese Spuren lesen, muss aber aktuelle Ownership priorisieren.", |
| changes: ["hai-user-wishlist in die Pre-Briefing-Kette aufgenommen", "idea-spec liest mehr als nur IDEA/README", "fehlende Standarddateien werden Signal, kein Fehler"], |
| functions: ["PromptGarage read-only Rekonstruktion", "Intent Source Discovery", "Wishlist-Artefakt", "Prioritaetsregel: aktuelle Anweisung vor alten Treffern"], |
| governance: "V1.1 verhindert Prompt-Archaeologie als Autopilot: Historie erklaert, aber befiehlt nicht." |
| }, |
| "v1-2": { |
| role: "Handoff-Agent / Atomisierungsmaschine", |
| positioning: "V1.2 zeigt HAI als Produkt, das nicht nur versteht, sondern Uebergaben ausfuehrbar und pruefbar macht.", |
| inputs: ["NEXT_STEP.md", "Step-ID", "Allowed Changes", "Executor-/Validator-Reports", "Timeout/No-Report-Signale"], |
| process: "Der menschlich knappe Step wird in ein scope-identisches Executor-Handoff uebersetzt; der Loop bekommt explizite Status- und Konfliktzustaende.", |
| outputs: ["EXECUTOR_HANDOFF_NEXT_STEP.md", "Step-ID-Abgleich", "Timeout-/No-Report-Status", "archivierter NEXT_STEP-Verlauf"], |
| mentalModel: "Der Nutzer will nicht Mikromanagement betreiben; HAI muss beweisen, dass der Agent genau das erlaubte Ding macht.", |
| changes: ["Atomizitaets-Gate geschaerft", "Executor-Handoff Skill eingefuehrt", "Execution-Loop mit Status-Gates gehaertet"], |
| functions: ["Scope-identisches Handoff", "Step-ID-Konflikterkennung", "Timeout-Gates", "No-Report-Gates"], |
| governance: "V1.2 macht Failure sichtbar statt still weiterzulaufen. Unklare Uebergaben werden blockiert oder eskaliert." |
| }, |
| "v1-3": { |
| role: "Lifecycle-Bremse / Sinn-Filter", |
| positioning: "V1.3 ist die Produktversion, die HAI vom Task-Erzeuger zum Sinn-Filter weiterentwickelt.", |
| inputs: ["Briefing", "Projektlebenszyklus", "Human Redirects", "Goal-/Archive-Signale", "Deploy-/Side-Effect-Risiken"], |
| process: "Vor dem NEXT_STEP prueft HAI, ob Arbeit ueberhaupt sinnvoll ist: already works, goal reached, event passed, archive/maintain oder Entscheidung noetig.", |
| outputs: ["bessere NEXT_STEP-Begruendung", "Lifecycle-Verdict", "Human-Decision-Step", "stale NEXT_STEP Blocking/Refresh"], |
| mentalModel: "Der Nutzer ist nicht Auftraggeber fuer Busywork. HAI muss Arbeit stoppen, wenn Stoppen die bessere Produktentscheidung ist.", |
| changes: ["hai-explain-better hinzugefuegt", "Lifecycle-Gates eingefuehrt", "Canonical NEXT_STEP Refresh nach Human Redirect"], |
| functions: ["ALREADY_WORKS Gate", "GOAL_REACHED Gate", "EVENT_PASSED Gate", "ARCHIVE_OR_MAINTAIN Gate", "Explain-Better"], |
| governance: "V1.3 bewertet menschlichen Nutzen vor technischer Machbarkeit. Das Produkt darf korrekt blocken." |
| }, |
| "v1-4": { |
| role: "Proof-Run / Produktvalidierung", |
| positioning: "V1.4 ist keine neue Runtime, sondern eine Produktvorstellung des Beweises: HAI V1.3 funktioniert auf frischen Projektlagen.", |
| inputs: ["drei neue Projektartefakte", "V1.3-Baseline", "Scorecards", "Lifecycle-/Explain-Fokusfragen"], |
| process: "Die bestehende Baseline wird gegen neue Projekte evaluiert. Der Wert liegt im Nachweis, nicht im Feature-Ausbau.", |
| outputs: ["PASS/BLOCKED_BUT_CORRECT/PASS", "Final Report", "Regressionserkenntnis", "keine Pflichtpatches"], |
| mentalModel: "Der Nutzer braucht Vertrauen in die Produktlinie. Eine Version darf ein Beweis sein, nicht nur ein neues Feature.", |
| changes: ["Proof-Run als Versionsstufe dokumentiert", "drei reale Projekte evaluiert", "V1.3 als Baseline bestaetigt"], |
| functions: ["Generalization Proof", "Lifecycle-Regression", "Human-Payoff-Review", "Stop-Erfolg als Messpunkt"], |
| governance: "V1.4 trennt Produktvalidierung von Produktveraenderung. Keine Aenderung ohne Pflichtbefund." |
| }, |
| "v1-5": { |
| role: "Repair-Agent / Eskalationsreview", |
| positioning: "V1.5 stellt HAI als Produkt mit engem Repair-Kanal vor: mehr Intelligenz bei Failure, aber keine Kontrollabgabe.", |
| inputs: ["BLOCKED", "REJECT", "UNCLEAR", "Timeout", "No-Report", "Step-ID-/Finalization-Konflikte"], |
| process: "Gemini-MCP wird nur bei Loop-Problemen als Escalation Review genutzt. Gemini darf Repair ausloesen, aber Scope nicht erweitern.", |
| outputs: ["GEMINI_ESCALATION_REVIEW_NEXT_STEP", "Repair-Verdict", "dokumentierter Ausfall wenn MCP fehlt", "kanonischer NEXT_STEP bleibt fuehrend"], |
| mentalModel: "Der Nutzer akzeptiert Hilfe bei Sackgassen, aber nicht einen zweiten autonomen Entscheider neben sich.", |
| changes: ["Gemini-MCP in hai-execution-loop verdrahtet", "NEXT_STEP-Historie verlustfrei gehaertet", "SOUL/Registry auf Repair-Pfad aktualisiert"], |
| functions: ["Gemini Failure Review", "Scope-erhaltender Repair", "Archivierte NEXT_STEP-History", "MCP Availability Handling"], |
| governance: "V1.5 ist kein Fanout. Repair ist Assistenz im Fehlerfall, nicht ein neuer Autopilot." |
| }, |
| "v1-6": { |
| role: "Pair-Agent / Zwei-Lane-Orchestrator", |
| positioning: "V1.6 stellt HAI als begrenzt paralleles Agentenprodukt vor: Durchsatz steigt nur, wenn Ownership und Scope beweisbar stabil bleiben.", |
| inputs: ["PAIR_PLAN.md", "Lane A/B Kandidaten", "Unabhaengigkeitsbeweis", "Git-Worktree-Isolation", "Validator-ACCEPT pro Lane"], |
| process: "HAI darf genau zwei unabhaengige EXECUTION_STEP-Lanes vorbereiten und in isolierten Worktrees ausfuehren; Join erst nach beidseitiger Validierung.", |
| outputs: ["PAIR_PLAN.md", "PAIR_STATUS.md", "PAIR_JOIN_REPORT.md", "Lane Reports", "geparkte Restkandidaten"], |
| mentalModel: "Der Nutzer will mehr Fluss, aber nicht den Preis von Batch-Chaos. HAI muss beweisen, dass Parallelitaet sicher ist.", |
| changes: ["hai-pair-plan eingefuehrt", "hai-pair-execution-loop eingefuehrt", "2-Lane-Limit und Worktree-Grenzen definiert"], |
| functions: ["Pair Autonomy Verdict", "Lane A/B Worktrees", "Validator-ACCEPT pro Lane", "Pair Join", "Stop bei Scope-/Taste-/Risk-Fragen"], |
| governance: "V1.6 ist maximal zwei Lanes, kein N-Agenten-Fanout. Wenn Unabhaengigkeit nicht beweisbar ist, faellt HAI auf Single-Step oder Samuel zurueck." |
| } |
| }; |
|
|
|
|
| function esc(value) { |
| return String(value ?? "").replace(/[&<>"']/g, (char) => ({ |
| "&": "&", |
| "<": "<", |
| ">": ">", |
| '"': """, |
| "'": "'" |
| }[char])); |
| } |
|
|
| function list(items) { |
| return `<ul>${items.map((item) => `<li>${esc(item)}</li>`).join("")}</ul>`; |
| } |
|
|
| function chips(items, className = "skill-chip") { |
| return items.map((item) => `<span class="${className}">${esc(item)}</span>`).join(""); |
| } |
|
|
|
|
|
|
| function renderAdaptedVisual(visual, id) { |
| if (!visual) return ""; |
| const layers = (visual.layers ?? []).map((layer, index) => ` |
| <section class="adapted-lane" style="--lane-index:${index}"> |
| <div class="lane-head"> |
| <span>${esc(String(index + 1))}</span> |
| <h4>${esc(layer.title)}</h4> |
| </div> |
| <div class="adapted-card-stack"> |
| ${(layer.items ?? []).map((item) => `<article class="adapted-card"><p>${esc(item)}</p></article>`).join("")} |
| </div> |
| </section> |
| `).join(""); |
| const deltas = (visual.deltas ?? []).map((delta) => `<span>${esc(delta)}</span>`).join(""); |
| return `<div class="adapted-visual" data-version-visual="${esc(id)}"> |
| <div class="adapted-toolbar"> |
| <span>HAI Version Cockpit</span> |
| <strong>${esc(id.toUpperCase())}</strong> |
| </div> |
| <div class="adapted-title"> |
| <h3>${esc(visual.label)}</h3> |
| <p>${esc(visual.thesis)}</p> |
| </div> |
| <div class="adapted-board"> |
| ${layers} |
| <section class="adapted-lane owner-lane" style="--lane-index:3"> |
| <div class="lane-head"> |
| <span>4</span> |
| <h4>Owner Gate</h4> |
| </div> |
| <div class="adapted-card-stack"> |
| <article class="adapted-card adapted-card-lock"> |
| <p>${esc(visual.warning)}</p> |
| </article> |
| </div> |
| </section> |
| </div> |
| <div class="delta-row adapted-deltas" aria-label="Was neu ist">${deltas}</div> |
| </div>`; |
| } |
|
|
| function sourceLinks(items) { |
| return items.map((item) => `<span class="source-link" title="${esc(item.href)}">${esc(item.label)}</span>`).join(""); |
| } |
|
|
| function hrefFor(id) { |
| return `./versions/${id}/`; |
| } |
|
|
| function renderIndex() { |
| const evolution = document.querySelector("[data-evolution]"); |
| const matrix = document.querySelector("[data-matrix]"); |
| if (!evolution || !matrix) return; |
|
|
| evolution.innerHTML = ORDER.map((id, index) => { |
| const item = VERSION_DATA[id]; |
| return ` |
| <a class="process-node" href="${hrefFor(id)}"> |
| <span class="node-dot">${index + 1}</span> |
| <span class="node-number">${esc(item.number)}</span> |
| <h3>${esc(item.title)}</h3> |
| <p>${esc(item.oneLine)}</p> |
| <span class="node-status">${esc(item.status)}</span> |
| </a> |
| `; |
| }).join(""); |
|
|
| const header = `<tr><th scope="col">Faehigkeit</th>${ORDER.map((id) => `<th scope="col">${esc(VERSION_DATA[id].number)}</th>`).join("")}</tr>`; |
| const rows = MATRIX_ROWS.map((row, rowIndex) => ` |
| <tr> |
| <th scope="row">${esc(row)}</th> |
| ${ORDER.map((id) => `<td data-version="${esc(VERSION_DATA[id].number)}"><strong>${esc(VERSION_DATA[id].matrix[rowIndex])}</strong></td>`).join("")} |
| </tr> |
| `).join(""); |
| matrix.innerHTML = header + rows; |
| } |
|
|
| function renderVersion() { |
| const id = document.body.dataset.version; |
| if (!id) return; |
| const item = VERSION_DATA[id]; |
| if (!item) return; |
| const profile = PROFILE_DATA[id] ?? {}; |
|
|
| document.title = `${item.number} | HAI Version Dossier`; |
| document.querySelectorAll("[data-version-number]").forEach((node) => { node.textContent = item.number; }); |
| document.querySelectorAll("[data-version-title]").forEach((node) => { node.textContent = item.title; }); |
| document.querySelectorAll("[data-version-status]").forEach((node) => { node.textContent = item.status; }); |
| document.querySelectorAll("[data-version-one-line]").forEach((node) => { node.textContent = item.oneLine; }); |
|
|
| const targets = { |
| "[data-skillstand]": list(item.skillstand), |
| "[data-skill-chain]": chips(item.skills), |
| "[data-stand]": esc(item.stand), |
| "[data-problem]": esc(item.problem), |
| "[data-proposal]": esc(item.proposal), |
| "[data-implementation]": esc(item.implementation), |
| "[data-test]": esc(item.test), |
| "[data-validation-text]": esc(item.validationText), |
| "[data-method]": esc(item.method), |
| "[data-good]": list(item.good), |
| "[data-weak]": list(item.weak), |
| "[data-next]": esc(item.next), |
| "[data-background]": esc(item.background), |
| "[data-proof]": chips(item.proof, "proof-chip"), |
| "[data-sources]": sourceLinks(item.sources ?? []), |
| "[data-ascii-art]": esc(item.asciiArt ?? ""), |
| "[data-story-title]": esc(item.website?.storyTitle ?? ""), |
| "[data-story-lead]": esc(item.website?.storyLead ?? ""), |
| "[data-story-before]": esc(item.website?.before ?? ""), |
| "[data-story-after]": esc(item.website?.after ?? ""), |
| "[data-owner-question]": esc(item.website?.ownerQuestion ?? ""), |
| "[data-agent-role]": esc(profile.role ?? ""), |
| "[data-product-positioning]": esc(profile.positioning ?? ""), |
| "[data-system-inputs]": list(profile.inputs ?? []), |
| "[data-system-process]": esc(profile.process ?? ""), |
| "[data-system-outputs]": list(profile.outputs ?? []), |
| "[data-mental-model]": esc(profile.mentalModel ?? ""), |
| "[data-version-changes]": list(profile.changes ?? []), |
| "[data-version-functions]": list(profile.functions ?? []), |
| "[data-profile-governance]": esc(profile.governance ?? "") |
| }; |
|
|
| Object.entries(targets).forEach(([selector, html]) => { |
| const node = document.querySelector(selector); |
| if (node) node.innerHTML = html; |
| }); |
|
|
|
|
| const visualNode = document.querySelector("[data-adapted-visual]"); |
| if (visualNode) visualNode.innerHTML = renderAdaptedVisual(VISUAL_DATA[id], id); |
|
|
| const currentIndex = ORDER.indexOf(id); |
| const prev = document.querySelector("[data-prev]"); |
| const next = document.querySelector("[data-next-link]"); |
| if (prev && currentIndex > 0) prev.href = `../${ORDER[currentIndex - 1]}/`; |
| if (prev && currentIndex === 0) prev.hidden = true; |
| if (next && currentIndex < ORDER.length - 1) next.href = `../${ORDER[currentIndex + 1]}/`; |
| if (next && currentIndex === ORDER.length - 1) next.hidden = true; |
| } |
|
|
| renderIndex(); |
| renderVersion(); |
|
|
