======================================================================== AVH DEV MASTER BUNDLE ======================================================================== Generated: 2026-06-07 13:18:25 UTC Bundle file: avh_dev_bundle_2026-06-07_13-18.txt Purpose: Load PRQ plans and current GTPX standard for structured analysis. ======================================================================== BUNDLE SOURCES ------------------------------------------------------------------------ PRQ: /opt/dev/prq Files: 15 GTPX_STANDARD: /opt/dev/public_html/gtpx Files: 37 ======================================================================== READ ORDER ======================================================================== 1. PRQ documents 2. GTPX standard documents 3. Bundle load confirmation ======================================================================== SOURCE: PRQ ======================================================================== ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: AVH-DEV-ARCHITECTURE.md MODIFIED: 2026-04-25 16:02:58 UTC SIZE_BYTES: 2306 ------------------------------------------------------------------------ # AVH DEV ARCHITECTURE ## STATUS draft --- ## 1. SVRHA Definira strukturu i odnose između: - DEV Managera - GTPX standarda - AVHS obrazaca - Synarch platforme - projekata --- ## 2. GLAVNI ENTITETI - DEV Manager - GTPX - AVHS - Synarch - Projects --- ## 3. OSNOVNA LOGIKA DEV Manager upravlja razvojem svih entiteta. GTPX definira standard. AVHS definira obrasce. Synarch koristi GTPX i AVHS za izvršenje. Projects koriste Synarch u produkciji. --- ## 4. RELACIJE DEV Manager → upravlja → GTPX → AVHS → Synarch → Projects GTPX → definira pravila za → AVHS → Synarch AVHS → koristi GTPX → definira obrasce za Synarch Synarch → koristi GTPX → koristi AVHS → izvršava workflow-e Projects → koriste Synarch → koriste AVHS obrasce --- ## 5. OKRUŽENJA Svaki entitet ima: 1. DEV okruženje (interno) → pod kontrolom DEV Managera 2. PUBLIC okruženje (javno) → dostupno preko weba --- DEV Manager → postoji samo interno GTPX → dev: /opt/dev/public_html/gtpx → public: gtpx.avhcode.com AVHS → dev: /opt/dev/public_html/avhs → public: avhs.avhcode.com Synarch → dev: /opt/dev/public_html/synarch → public: verzionirani pristup (npr. synarch1.0.0) Projects → koriste produkcijske verzije Synarcha --- ## 6. WORKFLOW Svi entiteti koriste isti razvojni workflow: 1. PLAN 2. ANALYZE 3. DRY RUN 4. PATCH PROPOSAL 5. PATCH APPLY 6. COMMIT 7. VERSION 8. AUDIT --- ## 7. PRAVILA 1. Nema direktnog uređivanja fajlova → sve ide kroz DEV Manager 2. Svaka promjena mora imati: → razlog → analiza → patch 3. GTPX je jedini izvor istine za komunikaciju s AI 4. AVHS ne sadrži logiku → samo obrasce 5. Synarch je jedini izvršni sloj 6. Projekti ne koriste dev verzije → samo verzionirani Synarch 7. Sve mora biti auditirano --- ## 8. TRENUTNO STANJE GTPX → dokumenti postoje (importirani iz legacy) → zahtijeva analizu i doradu AVHS → nije definiran Synarch → postoji runtime (gtpx-runtime) → nije strukturiran kao platforma DEV Manager → ne postoji (u planiranju) Projects → postoje u legacy, nisu strukturirani ------------------------------------------------------------------------ FILE_END PATH: AVH-DEV-ARCHITECTURE.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVH-BUNDLE-MODEL.md MODIFIED: 2026-04-26 14:05:25 UTC SIZE_BYTES: 0 ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVH-BUNDLE-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVH-INTERACTION-MODEL.md MODIFIED: 2026-04-26 14:02:30 UTC SIZE_BYTES: 4241 ------------------------------------------------------------------------ # PRQ-AVH-INTERACTION-MODEL.md ## META id: PRQ-AVH-INTERACTION-MODEL version: 0.1.0 status: draft owner: DEV Manager depends_on: - GTPX-ENUMS - GTPX-RESPONSE-MODEL - GTPX-RUNTIME-MODEL - PRQ-AVH-PATCH-MANAGER.md --- ## 1. SVRHA Ovaj dokument definira standardizirani model interakcije između korisnika i AI sustava (ChatGPT) unutar AVH Development Platforme. Cilj: - eliminirati slobodni (neorganizirani) output - osigurati deterministički i strukturirani odgovor - omogućiti kontrolirani workflow - osigurati potvrdu svakog koraka - spriječiti lutanje i gubitak konteksta --- ## 2. OSNOVNI PRINCIPI Svaki odgovor mora biti: - strukturiran - potpun - deterministički - čitljiv čovjeku - strojno parsabilan - bez slobodnog narativnog odstupanja --- ## 3. OBAVEZNA STRUKTURA ODGOVORA Svaki odgovor mora sadržavati sljedeće blokove: ### 3.1 STATUS STATUS: - bundle_loaded: true/false - completeness: <0-100%> - missing_sections: [] - errors: [] ### 3.2 REPORT REPORT: - type: - scope: <što je analizirano> - findings: - ... - ... ### 3.3 NEXT_ACTIONS NEXT_ACTIONS: A - Full structural analysis B - Conflict analysis C - GTPX compliance D - Implementation planning E - Patch proposal F - Refresh bundle INPUT: A/B/C/D/E/F ### 3.4 CONFIRMATION CONFIRMATION_REQUIRED: true/false --- ## 4. GLOBALNA PRAVILA Obavezno: - svaki odgovor mora završiti s NEXT_ACTIONS blokom - svaki korak mora imati jasno stanje - svaki korak mora imati mogućnost nastavka Zabranjeno: - slobodni tekst bez strukture - djelomičan odgovor - nedostajući blokovi - implicitni prijelaz na sljedeći korak - višestruki paralelni prijedlozi bez izbora --- ## 5. MENU MODE menu_mode: enabled: true strict: true U strict modu: - korisnik mora odabrati jednu opciju - AI ne smije nastaviti bez inputa - svaka opcija mora biti deterministička --- ## 6. TIPOVI ODGOVORA Dozvoljeni tipovi: - analysis - report - menu - patch - validation --- ## 7. PATCH RESPONSE MODEL Kada se generira patch: ### 7.1 STEP STEP: - step_id: - description: - status: proposed ### 7.2 PATCH PATCH: { canonical_patch_object } ### 7.3 VALIDATION VALIDATION: - expected_result: ... - risk_level: low/medium/high - critical_checks: - ... --- ## 8. POST-COMMIT RESPONSE Nakon uspješnog commita: ### 8.1 RESULT RESULT: - status: success - affected_files: - ... ### 8.2 CHANGELOG PATCH CHANGELOG_PATCH: { patch za changelog dokument } --- ## 9. BUNDLE LOAD POTVRDA Nakon učitavanja bundle-a: BUNDLE_STATUS: - loaded: true - sections_loaded: - ... - sections_missing: - ... Ako bundle nije kompletan: execution_status: blocked reason: INCOMPLETE_BUNDLE --- ## 10. ERROR HANDLING Svaka greška mora imati: ERROR: - code: ... - description: ... - impact: ... - next_step: ... --- ## 11. ZABRANE Zabranjeno: - generirati patch bez odobrenja koraka - preskakati confirmation - davati višestruke neorganizirane opcije - raditi pretpostavke bez bundle podataka - koristiti nepotvrđene informacije - ignorirati response structure --- ## 12. DETERMINIZAM Sustav mora garantirati: isti input → isti response format → isti menu → isti izbori --- ## 13. VEZA S PATCH MANAGEROM Ovaj model direktno utječe na: - generiranje patcha - validaciju prije dry-run-a - interpretaciju rezultata - generiranje changelog patcha Patch Manager mora odbiti: - patch bez strukturiranog outputa - patch bez confirmation flowa - patch bez canonical formata --- ## 14. IMPLEMENTACIJSKA NAPOMENA Ovaj dokument je obavezan dio bundle-a: interaction_contract: source: /opt/dev/prq/PRQ-AVH-INTERACTION-MODEL.md --- ## 15. STATUS Ovaj model je: - obavezan za sve analize - obavezan za sve patch prijedloge - obavezan za sve workflow korake ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVH-INTERACTION-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVH-PATCH-MANAGER.md MODIFIED: 2026-04-26 12:29:29 UTC SIZE_BYTES: 10783 ------------------------------------------------------------------------ # PRQ-AVH-PATCH-MANAGER.md ## META id: PRQ-AVH-PATCH-MANAGER version: 0.3.0 status: draft owner: DEV Manager depends_on: - PRQ-DEV-MANAGER.md - PRQ-SYNARCH.md - PRQ-RELATIONSHIP-MODEL.md - GTPX-ENUMS - 09_runtime/GTPX-PATCH-MODEL.gtpx - 09_runtime/GTPX-DRY-RUN-MODEL.gtpx - 09_runtime/GTPX-AUDIT-MODEL.gtpx - 07_validation/GTPX-HASH-NORMALIZATION.gtpx --- ## 1. SVRHA AVH Patch Manager je izvršni alat za provođenje kontroliranih izmjena nad filesystemom AVH Development Platforme. Alat: - NE definira plan - NE mijenja PRQ logiku - NE uvodi novi workflow - NE definira vlastiti patch model Alat isključivo: - izvršava canonical patch objekt definiran u GTPX-PATCH-MODEL - validira izmjene prije primjene - provodi dry-run - provodi commit samo nakon uspješnog dry-runa - izrađuje backup prije svake stvarne izmjene - osigurava deterministički rezultat - generira audit trag --- ## 2. GRANICE SUSTAVA Patch Manager: - radi nad filesystemom /opt/dev/ - koristi postojeće PRQ definicije - koristi bundle kao input kontekst - koristi canonical patch objekt iz 09_runtime/GTPX-PATCH-MODEL.gtpx Patch Manager NE: - donosi odluke - ne generira promjene autonomno - ne mijenja plan bez definiranog patcha - ne proširuje GTPX standard lokalnim pravilima - ne izvršava commit bez validnog dry-runa --- ## 3. ODNOS PREMA PLANU - Plan je jedini source of truth - Patch Manager izvršava promjene nad filesystem reprezentacijom plana i dokumenata - Svaka potvrđena promjena mora rezultirati novom verzijom plana kada promjena utječe na plan - Ako plan i filesystem nisu usklađeni → plan ima prioritet - Patch Manager ne odlučuje o sadržaju plana, nego izvršava već odobren patch --- ## 4. WORKFLOW (OBAVEZAN) change request → analysis → dry-run → patch → commit → audit Patch Manager implementira samo izvršne faze: - dry-run - patch execution - commit - audit Patch Manager ne zamjenjuje DEV Manager, Synarch ni GTPX workflow. --- ## 5. INPUTI ### 5.1 CANONICAL PATCH OBJECT Patch Manager koristi isključivo canonical patch objekt definiran u: 09_runtime/GTPX-PATCH-MODEL.gtpx Minimalni izvršni slojevi koje Patch Manager mora čitati: - meta - context - target - operation - match - change - validation - dry_run - commit - audit Patch Manager NE definira vlastiti PATCH SPEC. Lokalna polja poput: - target_path - operation - search_pattern - replace_content - position - reason smiju postojati samo kao mapiranje prema canonical patch objektu, ali nisu autoritativni model. --- ### 5.2 BUNDLE Bundle mora sadržavati: - file_tree - file_index - file_hash - file_content - session_entry - patch_instructions Bundle služi kao kontekst za analizu i pripremu patcha, ali ne zamjenjuje canonical patch objekt. Bundle se ne smatra autoritativnim izvorom stanja filesystema. --- ## 6. OPERACIJE Dozvoljene filesystem operacije: - replace - insert_before - insert_after - append - prepend - create_file - delete_file - rename_file Patch Manager ne smije izvršiti operaciju koja nije definirana u canonical patch objektu. --- ## 7. FILE MATCH ENGINE Podržani match tipovi: - exact_string - regex - line_number - file_exists --- ### 7.1 MATCH PRAVILA Default: expected_match_count == 1 allow_multiple_matches == false Rezultati: 0 → FAIL 1 → PASS >1 → FAIL Višestruki match dozvoljen samo ako: allow_multiple_matches == true --- ### 7.2 DETERMINIZAM MATCHA isti target file + isti search_pattern + isti match_type → isti match rezultat --- ## 8. DRY-RUN PRAVILA Dry-run: - ne smije mijenjati filesystem - mora validirati patch - mora validirati target - mora validirati match - mora simulirati rezultat - mora generirati diff - mora vratiti deterministički izvještaj Validacije: - target postoji - encoding validan - search_pattern postoji - match count - operacija validna - after_state moguće generirati - hash prije - očekivani hash poslije --- ### 8.1 UVJETI PROLAZA target_valid == true operation_valid == true match_count_valid == true encoding_valid == true dry_run_simulation_valid == true Ako nije: dry_run_status = invalid Ako nedostaju podaci: dry_run_status = blocked Dozvoljene vrijednosti: - valid - invalid - blocked --- ## 9. DRY-RUN IZVJEŠTAJ - patch_id - status - target_file - operation - match_type - match_count - before_preview - after_preview - diff - risk_level - errors[] - warnings[] - before_hash - expected_after_hash --- ## 10. DIFF ENGINE - before_state - after_state - unified_diff - line_level_diff Mora biti: - deterministički - čitljiv - auditabilan --- ## 11. COMMIT PRAVILA Uvjeti: dry_run_status == valid commit.requires_passed_dry_run == true backup_required == true Koraci: - reload file - provjera before_hash - backup - izvršenje patcha - zapis after_hash - commit report - audit log Ako se stanje promijenilo: commit_status = failed --- ## 12. COMMIT IZVJEŠTAJ - patch_id - timestamp - target_file - operation - before_hash - after_hash - status - backup_path - executor - errors[] - warnings[] --- ## 13. AUDIT LOG - audit_id - patch_id - change_request_id - plan_version_before - plan_version_after - timestamp - executor - target_file - operation - before_hash - after_hash - backup_path - result Audit mora biti: - append-only - traceable - reconstructible - machine-readable --- ## 14. BACKUP PRAVILA backup_must_exist = true backup_path_required = true --- ## 15. STORAGE MODEL - dry_run_reports - commit_reports - audit_logs - backups Struktura: /opt/dev/audit/ /opt/dev/backups/ /opt/dev/patch-reports/dry-run/ /opt/dev/patch-reports/commit/ --- ## 16. REFRESH FUNKCIJA - scan filesystem - update file_tree - regenerate file_index - recalc hash - regenerate bundle --- ## 17. SIGURNOSNA PRAVILA Zabranjeno: - commit bez dry-run-a - commit ako dry_run_status nije valid - višestruki match bez dopuštenja - rad nad nepostojećim fajlom - izmjena bez backupa - implicitno kreiranje datoteka - silent fail - partial write - lokalno proširivanje GTPX enum vrijednosti --- ## 18. DETERMINIZAM isti canonical patch objekt + isti bundle + isto filesystem stanje → isti dry-run rezultat --- ## 19. RESPONSE DELIVERY GUARD Patch Manager mora osigurati da je svaki patch objekt korišten za commit cjelovit, deterministički i verificiran. ### 19.1 PRIMJENA Response Delivery Guard se primjenjuje kada je izvor patch objekta: - AI generirani output - bundle derivacija - eksterni sustav koji koristi GTPX komunikaciju Ne primjenjuje se na ručno verificirane CLI inpute u kontroliranom okruženju. --- ### 19.2 COMMIT GUARD UVJETI Commit je dozvoljen samo ako su zadovoljeni svi uvjeti: response_mode == atomic response_delivery_status == complete complete == true response_hash present dry_run_status == valid Ako bilo koji uvjet nije zadovoljen: commit_status = blocked execution_status = blocked reason = INVALID_RESPONSE_DELIVERY --- ### 19.3 ZABRANE Zabranjeno: - commit nad parcijalnim outputom - commit nad streaming responseom - korištenje incomplete response kao patch inputa - audit označiti kao uspješan bez validnog responsea --- ### 19.4 POVEZANOST SA GTPX MODELOM Koristi se isključivo: - GTPX-ENUMS - GTPX-RESPONSE-MODEL - GTPX-ACK-HASH - GTPX-RUNTIME-MODEL Lokalna redefinicija nije dozvoljena. --- ## 20. PATH SECURITY Patch Manager mora osigurati da sve operacije ostaju unutar definiranog root prostora. ### 20.1 ROOT OGRANIČENJE root_path = /opt/dev/ Svaki target_path mora biti: - canonical resolved - unutar root_path --- ### 20.2 ZABRANE Zabranjeno: - path traversal (../) - absolute path izvan roota - symbolic link escape Primjeri: ../../etc/passwd /var/log/syslog /opt/dev/../outside --- ### 20.3 VALIDACIJA resolved_path.startswith(root_path) == true Ako nije: execution_status = blocked reason = INVALID_TARGET_PATH --- ## 21. ATOMIC WRITE / ROLLBACK Patch Manager mora garantirati da nijedna izmjena ne rezultira parcijalnim zapisom. --- ### 21.1 ATOMIC WRITE Za sve write operacije: 1. zapis u temporary file 2. validacija sadržaja 3. atomic rename → target file --- ### 21.2 ROLLBACK Ako bilo koji korak ne uspije: - original file ostaje netaknut - commit_status = failed - rollback izvršen --- ### 21.3 ZABRANE Zabranjeno: - direktno pisanje u target file - partial write - overwrite bez backupa --- ## 22. ENCODING I LINE ENDINGS Radi determinističkog ponašanja definiraju se standardi zapisa. --- ### 22.1 ENCODING encoding = UTF-8 Ako nije: dry_run_status = invalid reason = INVALID_ENCODING --- ### 22.2 LINE ENDINGS line_endings = LF (\n) Patch Manager mora: - normalizirati prije matcha - održati konzistentnost nakon patcha --- ### 22.3 BINARY FILES U v0.1: binary_files = not_supported Ako se detektira binary sadržaj: execution_status = blocked reason = BINARY_FILE_NOT_SUPPORTED --- ## 23. V0.1 IMPLEMENTATION SCOPE Radi stabilnosti i determinističkog ponašanja, v0.1 ima ograničen opseg. --- ### 23.1 PODRŽANO - exact_string match_type - operacije nad tekstualnim datotekama - dry-run simulacija - commit uz backup - audit zapis - hash validacija - diff (line-level) --- ### 23.2 OGRANIČENO - regex = planned - line_number = planned - advanced diff = planned - bundle validation = partial - plan sync = external responsibility --- ### 23.3 NIJE PODRŽANO - binary patching - multi-file transactional patch - paralelni commit - automatski plan update - runtime integracija sa Synarch --- ### 23.4 CILJ V0.1 stabilan deterministički auditabilan predvidiv file-level patch executor ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVH-PATCH-MANAGER.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-CLASSIFICATION-MODEL.md MODIFIED: 2026-04-26 15:10:37 UTC SIZE_BYTES: 3775 ------------------------------------------------------------------------ # PRQ - AVHS CLASSIFICATION MODEL ## META id: PRQ-AVHS-CLASSIFICATION-MODEL version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - GTPX-CORE --- ## 1. SVRHA Ovaj dokument definira klasifikacijski model AVHS sustava. Cilj: - omogućiti jasnu organizaciju dokumenata - omogućiti jednostavno indeksiranje i navigaciju - omogućiti determinističku klasifikaciju svakog dokumenta - spriječiti miješanje različitih tipova sadržaja --- ## 2. OSNOVNI PRINCIP Svaki AVHS artefakt mora biti klasificiran kroz 4 razine: - domain - module - document_type - artifact_type Bez potpune klasifikacije dokument se smatra: `invalid` --- ## 3. RAZINE KLASIFIKACIJE --- ### 3.1 DOMAIN Najviša razina. Odgovara na pitanje: U kojem području se dokument koristi? --- ### 3.2 MODULE Funkcionalna podcjelina unutar domene. Odgovara na pitanje: Koji dio sustava dokument pokriva? --- ### 3.3 DOCUMENT TYPE Definira logičku vrstu dokumenta. Odgovara na pitanje: Što dokument predstavlja? --- ### 3.4 ARTIFACT TYPE Definira konkretnu primjenu dokumenta. Odgovara na pitanje: Kako se dokument koristi? --- ## 4. DOMAIN MODEL Definirane domene: - planning - reference_data - communication - projects - time_tracking - resources_inventory - human_resources - finance - operations - it_devops - events_procedures - programs - audit_analytics - knowledge_base - compliance_governance Svaki dokument mora pripadati točno jednoj domeni. --- ## 5. MODULE MODEL Moduli su definirani unutar domene. Primjer: domain: operations moduli: - task_management - execution_tracking - issue_resolution - quality_control - handover Pravila: - modul mora pripadati jednoj domeni - modul ne smije biti generički (npr. "general") - modul mora biti funkcionalno definiran --- ## 6. DOCUMENT TYPE MODEL Definirani tipovi: - prq - plan - template - pipeline - procedure - checklist - report - audit_record - changelog - reference - policy - schema - status - decision_record - implementation_plan - patch_proposal Svaki dokument mora imati točno jedan document_type. --- ## 7. ARTIFACT TYPE MODEL Artifact type definira konkretnu primjenu. Primjeri: - template_prq - template_analysis - pipeline_procedural - pipeline_diagnostic - procedure_execution - report_analysis - report_status - audit_log - changelog_entry Artifact type mora biti u skladu s document_type. --- ## 8. KLASIFIKACIJSKA PRAVILA Obavezno: - svaki dokument mora imati sve 4 razine - svaka razina mora biti validna - vrijednosti moraju dolaziti iz definiranog modela Zabranjeno: - izostavljanje razine - višestruke vrijednosti iste razine - slobodni unos izvan definiranog modela --- ## 9. IDENTIFIKACIJA Svaki dokument mora imati klasifikacijski identifikator: format: `domain.module.document_type.artifact_type` primjer: `operations.task_management.pipeline.procedural` --- ## 10. INDEXIRANJE Klasifikacija se koristi za: - navigaciju kroz AVHS - filtriranje dokumenata - automatsko učitavanje bundle-a - validaciju kompatibilnosti --- ## 11. VALIDACIJA Dokument je validan ako: - ima sve 4 razine - sve vrijednosti su definirane - postoji konzistentnost između razina Ako nije: `classification_status: invalid` --- ## 12. STATUS Klasifikacijski model je temelj za: - domenski model - tipove dokumenata - pipeline modele - bundle strukturu ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-CLASSIFICATION-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-DOCUMENT-TYPES.md MODIFIED: 2026-04-26 15:12:37 UTC SIZE_BYTES: 3572 ------------------------------------------------------------------------ # PRQ - AVHS DOCUMENT TYPES MODEL ## META id: PRQ-AVHS-DOCUMENT-TYPES version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - PRQ-AVHS-CLASSIFICATION-MODEL - PRQ-AVHS-DOMAINS-MODEL --- ## 1. SVRHA Ovaj dokument definira tipove dokumenata u AVHS sustavu. Cilj: - jasno razlikovati vrste dokumenata - spriječiti miješanje struktura - omogućiti pravilnu primjenu obrazaca - omogućiti determinističku klasifikaciju --- ## 2. OSNOVNI PRINCIP Svaki dokument mora imati točno jedan document_type. Document_type definira: - logičku svrhu dokumenta - očekivanu strukturu - način korištenja --- ## 3. DEFINICIJA DOCUMENT TYPE Document type predstavlja: - tip sadržaja - funkciju dokumenta - način upotrebe Document type ne predstavlja: - domenu - modul - alat - implementaciju --- ## 4. POPIS DOCUMENT TYPES --- ### 4.1 prq Opis: Formalni zahtjev za sustav ili komponentu. Obuhvaća: - svrhu - opseg - pravila - ograničenja --- ### 4.2 plan Opis: Strukturirani plan aktivnosti. Obuhvaća: - korake - redoslijed - ciljeve --- ### 4.3 template Opis: Standardizirani obrazac za izradu dokumenta. Obuhvaća: - strukturu - obavezna polja --- ### 4.4 pipeline Opis: Proceduralni GTPX obrazac koji definira niz koraka u vremenu. Obuhvaća: - korake - uvjete - redoslijed - očekivani rezultat --- ### 4.5 procedure Opis: Operativni koraci za izvršenje zadatka. Razlika od pipeline-a: - manje formalan - može biti pojednostavljen --- ### 4.6 checklist Opis: Popis kontrolnih koraka. Obuhvaća: - provjere - potvrde --- ### 4.7 report Opis: Strukturirani izvještaj. Obuhvaća: - rezultate - nalaze - zaključke --- ### 4.8 audit_record Opis: Zapis o izvršenoj promjeni. Obuhvaća: - što se dogodilo - kada - tko - rezultat --- ### 4.9 changelog Opis: Kronološki zapis promjena. --- ### 4.10 reference Opis: Referentni dokument bez operativne logike. --- ### 4.11 policy Opis: Pravila i ograničenja. --- ### 4.12 schema Opis: Struktura podataka ili model. --- ### 4.13 status Opis: Trenutno stanje sustava ili dokumenta. --- ### 4.14 decision_record Opis: Zapis donesene odluke. Obuhvaća: - odluku - razlog - posljedice --- ### 4.15 implementation_plan Opis: Plan implementacije promjena. --- ### 4.16 patch_proposal Opis: Prijedlog izmjene u canonical patch formatu. --- ## 5. PRAVILA KORIŠTENJA Obavezno: - svaki dokument mora imati jedan document_type - document_type mora odgovarati sadržaju Zabranjeno: - kombiniranje više tipova u jednom dokumentu - korištenje pogrešnog tipa za sadržaj --- ## 6. ODNOS PREMA KLASIFIKACIJI Document type je treća razina: `domain → module → document_type → artifact_type` Document type određuje: - strukturu dokumenta - način interpretacije - način korištenja --- ## 7. VALIDACIJA Dokument je validan ako: - document_type postoji u ovom modelu - document_type odgovara sadržaju - struktura dokumenta odgovara tipu Ako nije: `document_type_status: invalid` --- ## 8. STATUS Model tipova dokumenata je temelj za: - template sustav - pipeline modele - bundle strukturu ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-DOCUMENT-TYPES.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-DOMAINS-MODEL.md MODIFIED: 2026-04-26 15:11:36 UTC SIZE_BYTES: 4420 ------------------------------------------------------------------------ # PRQ - AVHS DOMAINS MODEL ## META id: PRQ-AVHS-DOMAINS-MODEL version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - PRQ-AVHS-CLASSIFICATION-MODEL --- ## 1. SVRHA Ovaj dokument definira domenski model AVHS sustava. Cilj: - jasno razdvojiti područja uporabe dokumentacije - spriječiti preklapanje odgovornosti između dokumenata - omogućiti logičnu organizaciju AVHS sustava - omogućiti determinističku klasifikaciju prema domeni --- ## 2. OSNOVNI PRINCIP Svaki AVHS dokument mora pripadati točno jednoj domeni. Ako dokument pripada više domena: → mora se razdvojiti u više dokumenata --- ## 3. DEFINICIJA DOMENE Domain predstavlja: - područje uporabe - funkcionalni kontekst - poslovnu ili operativnu cjelinu Domain ne predstavlja: - tip dokumenta - način izvršenja - alat --- ## 4. POPIS DOMENA --- ### 4.1 planning Opis: Planiranje aktivnosti, strukture i razvoja. Obuhvaća: - planove - strategije - roadmap - razvojne smjernice --- ### 4.2 reference_data Opis: Referentni izvori podataka i statičke informacije. Obuhvaća: - standarde - tehničke specifikacije - baze znanja - normativne podatke --- ### 4.3 communication Opis: Komunikacijski materijali i interakcijski sadržaji. Obuhvaća: - upute - komunikacijske modele - interakcijske protokole - korisničke poruke --- ### 4.4 projects Opis: Struktura i organizacija projekata. Obuhvaća: - projektne definicije - projektne strukture - projektne planove --- ### 4.5 time_tracking Opis: Praćenje vremena i aktivnosti. Obuhvaća: - evidenciju rada - rasporede - praćenje trajanja aktivnosti --- ### 4.6 resources_inventory Opis: Upravljanje resursima i inventarom. Obuhvaća: - alate - materijale - opremu - dostupnost resursa --- ### 4.7 human_resources Opis: Upravljanje kadrovima i evidencijom ljudi. Obuhvaća: - zaposlenike - uloge - kompetencije - evidenciju rada --- ### 4.8 finance Opis: Financijsko praćenje i upravljanje. Obuhvaća: - troškove - prihode - budžete - financijske analize --- ### 4.9 operations Opis: Operativna realizacija i izvršenje aktivnosti. Obuhvaća: - zadatke - izvršenje - praćenje rada - kontrolu kvalitete --- ### 4.10 it_devops Opis: IT komunikacija, razvoj i skriptiranje. Obuhvaća: - konfiguracije - skripte - deployment - sustavnu komunikaciju --- ### 4.11 events_procedures Opis: Event management i proceduralni procesi. Obuhvaća: - događaje - operativne procedure - organizaciju aktivnosti --- ### 4.12 programs Opis: Strukturirani programi znanja i proizvodnje. Obuhvaća: - edukativne programe - proizvodne programe - operativne programe --- ### 4.13 audit_analytics Opis: Praćenje stanja, analiza i izvještavanje. Obuhvaća: - audit zapise - analitičke izvještaje - KPI - evaluacije --- ### 4.14 knowledge_base Opis: Sustavno pohranjeno znanje. Obuhvaća: - dokumentaciju - priručnike - tehničke zapise - iskustva --- ### 4.15 compliance_governance Opis: Pravila, regulativa i kontrola usklađenosti. Obuhvaća: - politike - pravila - regulatorne zahtjeve - kontrolne mehanizme --- ## 5. PRAVILA KORIŠTENJA Obavezno: - svaki dokument mora imati točno jednu domenu - domena mora odgovarati stvarnoj upotrebi dokumenta Zabranjeno: - korištenje više domena - generičke domene (npr. "misc") - neodređene domene --- ## 6. ODNOS PREMA KLASIFIKACIJI Domain je prva razina klasifikacije: `domain → module → document_type → artifact_type` Domain određuje: - kontekst dokumenta - dozvoljene module - logičku organizaciju --- ## 7. VALIDACIJA Dokument je validan ako: - domena postoji u ovom modelu - domena je ispravno dodijeljena - domena je konzistentna s modulom i sadržajem Ako nije: `domain_status: invalid` --- ## 8. STATUS Domenski model je temelj za: - module model - tipove dokumenata - pipeline modele - bundle strukturu ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-DOMAINS-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-NAMING-INDEXING-RULES.md MODIFIED: 2026-04-26 15:13:43 UTC SIZE_BYTES: 3085 ------------------------------------------------------------------------ # PRQ - AVHS NAMING & INDEXING RULES ## META id: PRQ-AVHS-NAMING-INDEXING-RULES version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - PRQ-AVHS-CLASSIFICATION-MODEL - PRQ-AVHS-DOMAINS-MODEL - PRQ-AVHS-DOCUMENT-TYPES --- ## 1. SVRHA Ovaj dokument definira pravila imenovanja i indeksiranja AVHS dokumenata. Cilj: - omogućiti konzistentno imenovanje - omogućiti jednostavno pretraživanje - omogućiti determinističko indeksiranje - spriječiti kaos u strukturi --- ## 2. OSNOVNI PRINCIPI Svi dokumenti moraju biti: - jednoznačno imenovani - deterministički klasificirani - lako pretraživi - konzistentno organizirani --- ## 3. NAZIV DATOTEKE Format: `....gtpx` Primjer: `operations.task_management.pipeline.procedural.gtpx` --- ## 4. IDENTIFIER (ID) Svaki dokument mora imati ID u META sekciji. Format: `---` Primjeri: `PRQ-AVHS-CLASSIFICATION-MODEL` `PIPELINE-OPERATIONS-TASK-MANAGEMENT-EXECUTION` --- ## 5. FOLDER STRUKTURA Lokacija: `/opt/dev/public_html/avhs/` Organizacija: - po document_type - po funkcionalnoj logici - bez duplikata Primjer: - templates - pipelines - procedures - reports - audit - bundles --- ## 6. INDEX MODEL Svaki AVHS sustav mora imati: - globalni INDEX - REGISTRY - STATUS dokument --- ### 6.1 INDEX Sadrži: - listu svih dokumenata - hijerarhiju - navigaciju --- ### 6.2 REGISTRY Sadrži: - popis svih ID-eva - mapiranje na lokacije - tipove dokumenata --- ### 6.3 STATUS Sadrži: - stanje sustava - verzije - aktivne dokumente --- ## 7. NAMING PRAVILA Obavezno: - koristiti lowercase - koristiti underscore za razmake - koristiti točke za razdvajanje razina - koristiti konzistentne nazive Zabranjeno: - korištenje razmaka - miješanje velikih i malih slova - nejasni nazivi - duplikati --- ## 8. VERSIONING Svaki dokument mora imati verziju. Format: `major.minor.patch` Primjeri: - 0.1.0 - 1.0.0 - 1.2.3 --- ## 9. STATUS DOKUMENTA Svaki dokument mora imati status: - draft - review - stable - deprecated --- ## 10. READ ORDER Dokumenti moraju imati definiran redoslijed čitanja. Prioritet: 1. META 2. SVRHA 3. STRUKTURA 4. PRAVILA --- ## 11. INDEXIRANJE Index mora omogućiti: - pretragu po domeni - pretragu po modulu - pretragu po document_type - pretragu po artifact_type --- ## 12. VALIDACIJA Dokument je validan ako: - naziv datoteke odgovara klasifikaciji - ID odgovara naming pravilima - lokacija odgovara document_type-u - postoji u registry-u Ako nije: `index_status: invalid` --- ## 13. STATUS Naming i indexing model je temelj za: - navigaciju - bundle generiranje - validaciju - povezivanje dokumenata ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-NAMING-INDEXING-RULES.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-RELATIONSHIP-MODEL.md MODIFIED: 2026-04-26 15:14:51 UTC SIZE_BYTES: 3478 ------------------------------------------------------------------------ # PRQ - AVHS RELATIONSHIP MODEL ## META id: PRQ-AVHS-RELATIONSHIP-MODEL version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - PRQ-AVHS-CLASSIFICATION-MODEL - PRQ-AVHS-DOMAINS-MODEL - PRQ-AVHS-DOCUMENT-TYPES - PRQ-AVHS-NAMING-INDEXING-RULES --- ## 1. SVRHA Ovaj dokument definira odnose između entiteta u AVHS sustavu. Cilj: - spriječiti miješanje entiteta - omogućiti jasno povezivanje dokumenata - omogućiti validaciju odnosa - omogućiti determinističku strukturu sustava --- ## 2. OSNOVNI PRINCIP Svaki entitet u AVHS sustavu mora imati: - jasno definirane odnose - ograničen skup povezanih entiteta - determinističku strukturu povezivanja --- ## 3. GLAVNI ENTITETI AVHS koristi sljedeće entitete: - domain - module - document_type - artifact_type - template - pipeline - procedure - workflow - bundle - resource - audit_record - changelog --- ## 4. HIJERARHIJA Osnovna struktura: `domain → module → document_type → artifact_type` Ova hijerarhija je obavezna i ne smije se preskakati. --- ## 5. ODNOSI IZMEĐU ENTITETA --- ### 5.1 domain → module - jedan domain ima više module-a - module pripada točno jednom domain-u --- ### 5.2 module → document_type - module može imati više document_type-ova - document_type nije ograničen na jedan module --- ### 5.3 document_type → artifact_type - document_type definira dozvoljene artifact_type-ove - artifact_type mora pripadati jednom document_type-u --- ### 5.4 template → document_type - template definira strukturu za određeni document_type - jedan document_type može imati više template-ova --- ### 5.5 pipeline → procedure - pipeline može sadržavati više procedura - procedure su granularni koraci pipeline-a --- ### 5.6 pipeline → workflow - pipeline je sastavni dio workflow-a - workflow može sadržavati više pipeline-ova --- ### 5.7 workflow → bundle - workflow definira što bundle sadrži - bundle koristi workflow kao kontekst --- ### 5.8 bundle → document - bundle sadrži više dokumenata - dokument može biti dio više bundle-ova --- ### 5.9 pipeline → resource - pipeline može koristiti resurse - resursi su definirani unutar resource modela --- ### 5.10 audit_record → changelog - audit_record generira zapis - changelog grupira zapise kronološki --- ## 6. OGRANIČENJA Zabranjeno: - preskakanje hijerarhije - direktno povezivanje nepovezanih entiteta - višestruka pripadnost domain-u - implicitni odnosi --- ## 7. RELACIJSKA PRAVILA Obavezno: - svaki odnos mora biti definiran - svaki odnos mora biti validiran - svaki odnos mora biti konzistentan --- ## 8. VALIDACIJA Sustav mora provjeriti: - pripadnost domain-u - pripadnost module-u - kompatibilnost document_type-a - valjanost artifact_type-a - ispravnost povezanosti Ako nije: `relationship_status: invalid` --- ## 9. KORIŠTENJE Relationship model se koristi za: - validaciju dokumentacije - generiranje bundle-a - povezivanje pipeline-ova - navigaciju kroz sustav - audit i analizu --- ## 10. STATUS Relationship model je temelj za: - pipeline modele - bundle modele - execution modele ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-RELATIONSHIP-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS-VALIDATION-MODEL.md MODIFIED: 2026-04-26 15:16:10 UTC SIZE_BYTES: 3356 ------------------------------------------------------------------------ # PRQ - AVHS VALIDATION MODEL ## META id: PRQ-AVHS-VALIDATION-MODEL version: 0.1.0 status: draft owner: DEV Manager depends_on: - PRQ-AVHS - PRQ-AVHS-CLASSIFICATION-MODEL - PRQ-AVHS-DOMAINS-MODEL - PRQ-AVHS-DOCUMENT-TYPES - PRQ-AVHS-NAMING-INDEXING-RULES - PRQ-AVHS-RELATIONSHIP-MODEL --- ## 1. SVRHA Ovaj dokument definira pravila validacije AVHS sustava. Cilj: - osigurati konzistentnost dokumenata - osigurati ispravnu klasifikaciju - osigurati ispravne odnose - spriječiti neispravne ili nedovršene dokumente --- ## 2. OSNOVNI PRINCIP Svaki AVHS dokument mora proći validaciju prije korištenja. Ako dokument ne prođe validaciju: → ne smije se koristiti → mora se označiti kao invalid --- ## 3. VRSTE VALIDACIJE --- ### 3.1 STRUCTURE VALIDATION Provjerava: - postojanje obaveznih sekcija - strukturu dokumenta - format zapisa --- ### 3.2 CLASSIFICATION VALIDATION Provjerava: - domain - module - document_type - artifact_type Svi elementi moraju: - postojati u modelu - biti međusobno kompatibilni --- ### 3.3 NAMING VALIDATION Provjerava: - naziv datoteke - ID u META sekciji - usklađenost s pravilima imenovanja --- ### 3.4 RELATIONSHIP VALIDATION Provjerava: - odnose između entiteta - pripadnost domain-u i module-u - kompatibilnost između tipova --- ### 3.5 CONTENT VALIDATION Provjerava: - logičku konzistentnost sadržaja - usklađenost s document_type-om - prisutnost obaveznih informacija --- ### 3.6 DEPENDENCY VALIDATION Provjerava: - depends_on reference - postojanje referenciranih dokumenata - kompatibilnost verzija --- ## 4. VALIDATION STATUS Dozvoljene vrijednosti: - valid - invalid - incomplete - blocked --- ## 5. OBAVEZNA POLJA Svaki dokument mora imati: - META sekciju - id - version - status - depends_on Ako bilo koje nedostaje: `validation_status: invalid` --- ## 6. VALIDATION PROCESS Redoslijed: 1. structure validation 2. classification validation 3. naming validation 4. relationship validation 5. content validation 6. dependency validation Ako bilo koji korak ne prođe: → validacija se prekida --- ## 7. VALIDACIJSKA PRAVILA Obavezno: - svi modeli moraju biti konzistentni - svi odnosi moraju biti definirani - svi identifikatori moraju biti jedinstveni Zabranjeno: - korištenje nepotpunih dokumenata - ignoriranje validacijskih grešaka - implicitne pretpostavke --- ## 8. GREŠKE Svaka greška mora imati: - code - opis - uzrok - posljedicu Primjer: `ERROR: MISSING_DOMAIN` `ERROR: INVALID_DOCUMENT_TYPE` `ERROR: RELATIONSHIP_CONFLICT` --- ## 9. VALIDATION OUTPUT Rezultat validacije mora sadržavati: - validation_status - errors[] - warnings[] --- ## 10. KORIŠTENJE Validation model se koristi za: - provjeru AVHS dokumenata - provjeru bundle-a - provjeru pipeline-a - provjeru patch-a --- ## 11. STATUS Validation model zatvara osnovni AVHS sustav i omogućuje: - sigurnu primjenu obrazaca - kontroliranu izgradnju sustava - sprječavanje grešaka u strukturi ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS-VALIDATION-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-AVHS.md MODIFIED: 2026-04-26 15:07:01 UTC SIZE_BYTES: 4084 ------------------------------------------------------------------------ # PRQ - AVHS ## META id: PRQ-AVHS version: 0.2.0 status: draft owner: DEV Manager depends_on: - GTPX-CORE - GTPX-ENUMS - GTPX-MODELS --- ## 1. SVRHA AVHS (AVH Standard) je sustav standardizacije GTPX obrazaca i obveznog sadržaja za različite namjene. Cilj AVHS-a je: - omogućiti dosljednu strukturu dokumenata - omogućiti ponovljivu primjenu procedura - omogućiti standardizirano zapisivanje znanja - smanjiti varijabilnost u radu - omogućiti jednostavno indeksiranje i navigaciju --- ## 2. OPSEG AVHS obuhvaća standardizaciju: - PRQ obrazaca - analysis obrazaca - patch obrazaca - workflow obrazaca - pipeline obrazaca - proceduralnih obrazaca - komunikacijskih obrazaca - bundle obrazaca - izvještajnih obrazaca - audit i changelog zapisa --- ## 3. ULOGA AVHS služi kao: - sloj između GTPX standarda i konkretne primjene GTPX definira: - komunikacijski standard - strukturu podataka - validaciju - canonical modele AVHS definira: - kako se GTPX koristi u praksi - kako izgledaju obrasci - koji sadržaj je obavezan - kako se dokumenti organiziraju --- ## 4. ŠTO AVHS DEFINIRA AVHS definira: - strukturu PRQ dokumenata - strukturu analysis izvještaja - strukturu patch prijedloga - strukturu workflow-a - strukturu pipeline-a - strukturu procedura - strukturu komunikacijskih obrazaca - strukturu bundle-a kao komunikacijskog paketa - strukturu audit i changelog zapisa - klasifikaciju dokumenata prema načinu upotrebe --- ## 5. ŠTO AVHS NE DEFINIRA AVHS ne definira: - komunikacijski standard (to je GTPX) - izvršnu logiku (to je Synarch) - implementaciju sustava - UI ili alat - runtime ponašanje sustava - način izvršenja pipeline-a --- ## 6. KORIŠTENJE AVHS koriste: - DEV Manager - Synarch - Bundle Tool - ChatGPT (kroz definirane obrasce) Projects ne koriste AVHS direktno, nego kroz Synarch platformu. AVHS omogućuje: - ponovljivu strukturu rada - standardizirane dokumente - kontrolirani workflow - lakše održavanje sustava --- ## 7. STRUKTURA AVHS-A AVHS je organiziran kao biblioteka standardiziranih obrazaca. Lokacija: `/opt/dev/public_html/avhs/` Osnovna struktura: - meta (index, registry, status) - templates (osnovni obrasci) - pipelines (proceduralni obrasci) - workflows (povezani procesi) - bundles (komunikacijski paketi) - interaction modeli - audit i izvještaji Svi AVHS dokumenti koriste GTPX format: `.gtpx` --- ## 8. AVHS KAO OPERATIVNI SLOJ AVHS predstavlja operativni sloj primjene GTPX standarda. AVHS omogućuje: - zapisivanje procedura kao pipeline-a - zapisivanje procesa kao workflow-a - zapisivanje stanja kao bundle-a - zapisivanje promjena kroz patch i audit modele AVHS ne izvršava procese, nego definira kako oni moraju biti zapisani. --- ## 9. KLJUČNI ENTITETI AVHS razlikuje sljedeće entitete: - domain (područje primjene) - module (funkcionalna cjelina) - document_type (tip dokumenta) - template (obrazac) - pipeline (proceduralni obrazac) - workflow (kronološki niz funkcionalnosti) - bundle (komunikacijski paket) - procedure (operativni koraci) - resource (entitet koji se koristi u procesu) - audit_record (zapis promjene) - changelog (kronološki zapis izmjena) --- ## 10. OPEN SOURCE AVHS može biti javno dostupan kao zbirka obrazaca. Mora imati: - verzioniranje - changelog - jasnu strukturu - kompatibilnost s GTPX standardom - dokumentiranu klasifikaciju AVHS ovisi o GTPX standardu i ne može postojati bez njega. --- ## 11. STATUS AVHS je u fazi definiranja klasifikacijskog modela i strukture. Daljnji razvoj uključuje: - definiranje klasifikacijskog modela - definiranje domenskog modela - definiranje tipova dokumenata - definiranje pravila imenovanja i indeksiranja ------------------------------------------------------------------------ FILE_END PATH: PRQ-AVHS.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-DEV-MANAGER.md MODIFIED: 2026-04-26 11:09:03 UTC SIZE_BYTES: 8816 ------------------------------------------------------------------------ # PRQ - DEV MANAGER ## STATUS draft --- ## 1. SVRHA DEV Manager je centralni interni sustav za upravljanje razvojem svih AVH entiteta. --- ## 2. OPSEG DEV Manager upravlja razvojem sljedećih cjelina: - GTPX - AVHS - Synarch - Projects - Modules - Services - Business --- ## 3. GLAVNI CILJ Omogućiti kontrolirano: - planiranje - analizu - dry-run - patchanje - verzioniranje - audit --- ## 4. ENTITETI DEV Manager upravlja sljedećim tipovima entiteta: - Standards - GTPX - AVHS - Platforms - Synarch - Projects - Modules - Services - external - internal - Business --- ## 5. FUNKCIJE DEV Manager mora omogućiti: 1. pregled entiteta 2. upravljanje planovima (PRQ) 3. generiranje bundle-a za ChatGPT 4. generiranje analysis upita 5. generiranje dry-run upita 6. generiranje patch prijedloga 7. pregled i primjenu patcha 8. verzioniranje 9. audit log --- ## 6. WORKFLOW Svaka promjena prolazi kroz: 1. CHANGE REQUEST 2. ANALYSIS 3. DRY RUN 4. PATCH PROPOSAL 5. PATCH REVIEW 6. PATCH APPLY 7. COMMIT 8. AUDIT --- ## 7. NAČIN RADA 1. Korisnik ne uređuje fajlove direktno. 2. Sve promjene se definiraju kao CHANGE REQUEST. 3. DEV Manager određuje zahvaćene entitete. 4. Generira se analiza. 5. Generira se patch. 6. Korisnik potvrđuje primjenu. 7. Promjena se zapisuje u audit. --- ## 8. STATUS MODEL DEV Manager ne definira vlastiti lokalni status model. Svi statusi, enum vrijednosti i lifecycle vrijednosti moraju se preuzimati iz: `/opt/dev/public_html/gtpx/03_language/GTPX-ENUMS.gtpx` DEV Manager smije koristiti samo enum vrijednosti koje su definirane u GTPX-ENUMS. Ako potrebna vrijednost ne postoji u GTPX-ENUMS, promjena se mora prvo predložiti kao patch GTPX standarda. --- ## 9. DATA MODEL DEV Manager upravlja sljedećim osnovnim entitetima: - Entity - Plan - Plan Version - Change Request - Analysis - Dry Run - Patch - Commit - Audit - User - Role / Permission --- ### 9.1 ENTITY Entity predstavlja osnovni objekt u sustavu. Entity može biti: - Standard - Platform - Project - Module - Service - Business --- #### POLJA - id - type - name - description - status - version - created_at - updated_at - owner_id --- #### STATUS Polje `status` mora koristiti vrijednosti iz odgovarajućeg enum seta u GTPX-ENUMS. --- ### 9.2 PLAN Plan predstavlja strukturirani opis stanja, ciljeva i pravila entiteta. Plan nije običan tekstualni dokument, nego strukturirani canonical model koji se u kasnijoj fazi mora precizno definirati. Plan je source of truth na konceptualnoj razini. Tehnički canonical storage plana definira se u zasebnoj fazi stabilizacije kroz PLAN MODEL. --- #### POLJA - id - entity_id - name - description - current_version_id - status - created_at - updated_at --- #### STATUS Polje `status` mora koristiti `plan_status` iz GTPX-ENUMS. --- ### 9.3 PLAN VERSION Plan Version predstavlja snapshot plana u određenom trenutku. Svaka potvrđena promjena mora stvoriti novu verziju plana. --- #### POLJA - id - plan_id - version - payload - hash - status - created_at - created_by --- #### STATUS Polje `status` mora koristiti odgovarajući enum iz GTPX-ENUMS. Ako trenutni enum set nije dovoljan, status se ne dodaje lokalno, nego kroz patch GTPX-ENUMS. --- ### 9.4 CHANGE REQUEST Change Request predstavlja zahtjev za promjenu plana ili sustava. --- #### POLJA - id - entity_id - plan_id - title - description - requested_by - status - created_at - updated_at --- #### STATUS Polje `status` mora koristiti `change_request_status` iz GTPX-ENUMS. --- ### 9.5 ANALYSIS Analysis predstavlja analizu stanja ili change requesta. Može biti generirana od strane AI-a ili korisnika. ChatGPT i drugi AI alati nisu source of truth, nego pomoćni analitički alati. --- #### POLJA - id - change_request_id - input_data - output_data - summary - risks - recommendations - status - created_at - created_by --- #### STATUS Polje `status` mora koristiti `analysis_status` iz GTPX-ENUMS. --- ### 9.6 DRY RUN Dry Run predstavlja simulaciju promjene bez stvarne primjene. Koristi se za provjeru posljedica patcha. --- #### POLJA - id - change_request_id - plan_version_before_id - plan_version_after_id - result - diff - warnings - created_at --- #### RESULT Polje `result` mora koristiti `validation_outcomes` iz GTPX-ENUMS dok se ne definira zaseban `dry_run_result` enum. --- ### 9.7 PATCH Patch predstavlja konkretan skup promjena nad planom ili sustavom. --- #### POLJA - id - change_request_id - plan_version_before_id - plan_version_after_id - patch_data - status - created_at - applied_at --- #### STATUS Polje `status` mora koristiti `patch_status` iz GTPX-ENUMS. --- ### 9.8 COMMIT Commit predstavlja potvrđenu i primijenjenu promjenu u sustavu. Commit stvara novu verziju plana. --- #### POLJA - id - patch_id - plan_version_id - commit_message - status - created_at - created_by --- #### STATUS Polje `status` mora koristiti `commit_status` iz GTPX-ENUMS. --- ### 9.9 AUDIT Audit predstavlja zapis svih događaja u sustavu. Svaka promjena mora biti auditirana. --- #### POLJA - id - entity_id - action - reference_id - user_id - data_snapshot - created_at --- #### ACTION Polje `action` mora koristiti zaseban audit/action enum kada bude definiran. Do tada se lokalne action vrijednosti ne smatraju autoritativnim enum modelom. --- ### 9.10 USER User predstavlja korisnika sustava. --- #### POLJA - id - name - email - status - created_at --- #### STATUS Polje `status` mora koristiti odgovarajući korisnički status enum kada bude definiran. Do tada je korisnički status otvorena stavka stabilizacije. --- ### 9.11 ROLE / PERMISSION Definira ovlasti korisnika u sustavu. --- #### POLJA - id - name - permissions --- ## 10. OTVORENE STAVKE Prije implementacije potrebno je dodatno stabilizirati: 1. canonical PLAN MODEL 2. user status enum 3. audit action enum 4. dry_run result enum 5. permission model 6. role model 7. odnos DEV Managera i Synarcha 8. granicu između plana kao konceptualnog source of truth i tehničkog storagea plana --- ## 11. PRAVILA 1. DEV Manager ne smije uvoditi lokalne enum vrijednosti mimo GTPX-ENUMS. 2. DEV Manager ne smije direktno mijenjati autoritativne fajlove bez change requesta, analize, patcha i audita. 3. DEV Manager koristi GTPX kao komunikacijski i zapisni standard. 4. DEV Manager koristi AVHS obrasce kada budu definirani. 5. DEV Manager ne izvršava produkcijske procese krajnjih projekata. 6. DEV Manager upravlja razvojem, ali Synarch je izvršni sloj za plan-driven runtime. --- ## 12. STATUS DOKUMENTA Ovaj PRQ je u stanju `draft`. Dokument je usklađen s odlukom da je `GTPX-ENUMS.gtpx` jedini autoritativni izvor enum vrijednosti. --- ## 13. RESPONSE DELIVERY ENFORCEMENT DEV Manager mora osigurati da su svi sistemski odgovori deterministički, cjeloviti i validirani prije nego što se koriste u bilo kojoj fazi workflowa. --- ### 13.1 OBAVEZNA PRAVILA Za sve operacije: - analysis - dry_run - patch - commit - audit vrijedi: response_mode: atomic response_delivery_status: complete complete: true response_hash: required --- ### 13.2 VALIDACIJA Ako bilo koji od uvjeta nije zadovoljen: validation_result: blocked reason: INVALID_RESPONSE_DELIVERY DEV Manager mora: - odbaciti parcijalni output - zabraniti nastavak workflowa - zabraniti prijelaz u commit fazu - zahtijevati ponavljanje operacije u atomic modu --- ### 13.3 ZABRANE streaming_response_forbidden_for: - analysis - dry_run - patch - commit - audit --- ### 13.4 POVEZANOST SA GTPX SUSTAVOM DEV Manager mora biti usklađen s: - GTPX-RESPONSE-MODEL - GTPX-ACK-HASH - GTPX-RUNTIME-MODEL Sve vrijednosti moraju koristiti isključivo enum setove iz: /opt/dev/public_html/gtpx/03_language/GTPX-ENUMS.gtpx --- ### 13.5 GREŠKE Ako se detektira: response_delivery_status != complete ili: response_mode != atomic status mora biti: execution_status: blocked --- ### 13.6 HARD ENFORCEMENT Ovo pravilo nije opcionalno. DEV Manager ne smije: - prihvatiti parcijalni output - koristiti streaming output za sistemske operacije - generirati commit bez validnog atomic response-a ------------------------------------------------------------------------ FILE_END PATH: PRQ-DEV-MANAGER.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-GTPX-STANDARD.md MODIFIED: 2026-04-25 16:13:59 UTC SIZE_BYTES: 2368 ------------------------------------------------------------------------ # PRQ - GTPX STANDARD ## STATUS draft --- ## 1. SVRHA GTPX je deklarativni standard za determinističku komunikaciju između čovjeka i AI sustava. --- ## 2. OPSEG Obuhvaća: - strukturu komunikacije - ugovor (CONTRACT) - upit (REQUEST) - odgovor (RESPONSE) - validaciju - izvore podataka - workflow (analysis, dry-run, patch, audit) --- ## 3. ŠTO GTPX DEFINIRA GTPX definira: - format komunikacije - obavezne sekcije - dozvoljene pojmove (dictionary) - sintaksu i semantiku - pravila validacije - način potvrde (ACK) - način rada (workflow) --- ## 4. ŠTO GTPX NE DEFINIRA GTPX ne definira: - poslovnu logiku aplikacija - implementaciju runtime-a - UI/UX - način pohrane podataka - konkretne algoritme --- ## 5. KORIŠTENJE GTPX koriste: - DEV Manager (za komunikaciju s AI) - AVHS (kao temelj za obrasce) - Synarch (za izvršavanje workflow-a) GTPX je jedini standard komunikacije s AI sustavima. --- ## 6. STATUS I RAZVOJ GTPX se razvija kroz: - analizu postojećeg stanja - prijedloge izmjena (patch) - dry-run provjeru - prihvaćanje promjena - verzioniranje - audit Sve promjene se upravljaju kroz DEV Manager. --- ## 7. OPEN SOURCE MODEL GTPX je javni open source standard. Standard mora imati: - javno dostupnu specifikaciju - verzioniranje - changelog - javni repozitorij - definirani proces izmjena --- ## 8. UPRAVLJANJE STANDARDOM GTPX se razvija kroz: 1. prijedlog izmjene (patch) 2. analiza utjecaja 3. dry-run provjera 4. review 5. prihvaćanje ili odbijanje 6. verzioniranje 7. objava --- ## 9. VERZIONIRANJE GTPX koristi: - major (breaking change) - minor (proširenje) - patch (ispravke) Svaka verzija mora imati: - changelog - audit zapis - jasno definirane promjene --- ## 10. JAVNA DOSTUPNOST GTPX mora biti dostupan na: - gtpx.avhcode.com Javni sloj mora omogućiti: - pregled dokumentacije - pregled verzija - pristup primjerima - pristup promjenama --- ## 11. KOMPATIBILNOST GTPX mora biti: - neovisan o platformi - neovisan o implementaciji - primjenjiv na različite AI sustave --- ## 12. CILJ GTPX treba omogućiti: - determinističku komunikaciju - uklanjanje pretpostavki - ponovljivost rezultata - auditabilnost komunikacije ------------------------------------------------------------------------ FILE_END PATH: PRQ-GTPX-STANDARD.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-RELATIONSHIP-MODEL.md MODIFIED: 2026-04-25 18:52:32 UTC SIZE_BYTES: 1612 ------------------------------------------------------------------------ # PRQ - RELATIONSHIP MODEL ## STATUS draft --- ## 1. SVRHA Definira odnose između: - DEV Managera - GTPX standarda - AVHS obrazaca - Synarch platforme (uključuje projekte kao instance planova) --- ## 2. RELACIJE DEV Manager → upravlja razvojem → GTPX → AVHS → Synarch --- GTPX → definira komunikacijski i zapisni standard za → AVHS → Synarch --- AVHS → koristi GTPX → definira obrasce za → Synarch --- Synarch → koristi GTPX → koristi AVHS → implementira engine → upravlja planovima → upravlja projektima (kao instancama planova) → upravlja modulima i pipeline-ima --- ## 3. TOK PODATAKA 1. DEV Manager definira ili mijenja plan 2. Plan se strukturira kroz GTPX standard 3. AVHS definira obrasce za rad s planom 4. Synarch: - učitava plan - validira plan - izvršava operacije nad planom - generira patch - zapisuje promjene u bazu - zapisuje audit 5. Korisnici koriste Synarch kroz module i sučelja 6. Sve promjene se vraćaju u plan kao izvor istine --- ## 4. PRAVILA 1. GTPX je jedini komunikacijski i zapisni standard 2. AVHS je sloj standardiziranih obrazaca temeljenih na GTPX-u 3. Synarch je izvršni sustav koji implementira plan-driven engine 4. DEV Manager upravlja razvojem i strukturnim promjenama sustava 5. Plan je jedini source of truth za stanje sustava 6. Sve promjene stanja moraju biti definirane kroz patch 7. Svaki patch mora biti validiran prije primjene 8. Svaka promjena mora biti auditirana i zapisiva ------------------------------------------------------------------------ FILE_END PATH: PRQ-RELATIONSHIP-MODEL.md ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: PRQ PATH: PRQ-SYNARCH.md MODIFIED: 2026-04-25 20:08:07 UTC SIZE_BYTES: 4938 ------------------------------------------------------------------------ # PRQ - SYNARCH ## STATUS draft --- ## 1. SVRHA Synarch je plan-driven platforma za upravljanje i izvršavanje strukturiranih sustava temeljenih na GTPX standardu. Synarch nije samo alat, nego izvršni sloj koji omogućuje: - interpretaciju planova - upravljanje promjenama - validaciju - simulaciju (dry-run) - primjenu promjena (patch) - audit --- ## 2. OPSEG Synarch pokriva: - upravljanje planovima - izvršavanje GTPX workflow-a - koordinaciju agenata - validaciju i kontrolu konzistentnosti - audit sustava Synarch ne definira: - komunikacijski standard (to je GTPX) - obrasce (to je AVHS) - razvojni proces sustava i standarda (to je DEV Manager) Synarch djeluje isključivo kao runtime sustav koji izvršava planove i upravlja promjenama nad već definiranim strukturama. --- ## 3. GLAVNI PRINCIPI 1. Plan-driven sustav 2. determinističko ponašanje 3. bez implicitnih pretpostavki 4. sve promjene su kontrolirane 5. audit je obavezan --- ## 4. ODNOS S DRUGIM SUSTAVIMA ### GTPX - definira jezik i pravila komunikacije - Synarch ga mora striktno koristiti ### AVHS - definira obrasce (template-e) - Synarch ih koristi kao input/output strukture ### DEV Manager - upravlja razvojem sustava - Synarch izvršava planove u runtime-u --- ## 5. PLAN MODEL (KONCEPTUALNO) Plan je centralni element sustava. Plan definira: - stanje - pravila - ciljeve - ograničenja Plan je konceptualni source of truth. --- ### ⚠️ OTVORENO PITANJE Tehnička implementacija plana (canonical storage): - baza podataka - datoteke - verzionirani JSON NIJE još definirana i mora se stabilizirati prije implementacije. --- ## 6. PLAN LIFECYCLE Plan prolazi kroz životni ciklus. Status mora koristiti `plan_status` iz GTPX-ENUMS. --- ## 7. WORKFLOW Synarch koristi standardni workflow: 1. CHANGE REQUEST 2. ANALYSIS 3. DRY RUN 4. PATCH PROPOSAL 5. PATCH REVIEW 6. PATCH APPLY 7. COMMIT 8. AUDIT --- ## 8. CHANGE MANAGEMENT Sve promjene moraju: - imati change request - biti analizirane - proći dry-run - biti patchirane - biti auditirane Direktne promjene nisu dozvoljene. --- ## 9. AGENT MODEL Synarch koristi više agenata. Agent: - ima definiranu ulogu - ima ograničenja - koristi GTPX --- ### VRSTE AGENATA (KONCEPTUALNO) - interpreter - planner - analyst - validator - patch generator - auditor --- ### ⚠️ OTVORENO PITANJE - granularnost agenata - komunikacija između agenata - memorijski model --- ## 10. VALIDACIJA Synarch mora validirati: - strukturu - semantiku - ugovor (contract) - izvore - potpunost --- ### REZULTAT VALIDACIJE Mora koristiti `validation_outcomes` iz GTPX-ENUMS. --- ## 11. DRY RUN Dry-run predstavlja simulaciju promjene bez primjene. Koristi se za: - procjenu utjecaja - otkrivanje grešaka - sigurnost sustava --- ### ⚠️ OTVORENO PITANJE - format dry-run rezultata - razina detalja diff-a --- ## 12. PATCH MODEL Patch predstavlja kontroliranu promjenu sustava. Patch mora: - biti deterministički - biti validiran - biti auditiran --- ### ⚠️ OTVORENO PITANJE - format patch-a (JSON patch ili drugi model) - granularnost promjena --- ## 13. COMMIT Commit predstavlja potvrđenu promjenu. Commit mora: - stvoriti novu verziju plana - biti auditiran --- ## 14. AUDIT Svaka akcija mora biti auditirana. Audit mora sadržavati: - što se dogodilo - kada - tko - zašto - rezultat --- ### ⚠️ OTVORENO PITANJE - standard audit modela - razina detalja --- ## 15. IZVRŠNI MODEL Synarch definira ponašanje sustava, ali ne definira: - konkretan runtime engine - bazu podataka - API implementaciju To se definira kasnije. --- ## 16. STATUS MODEL Synarch ne definira vlastite enum vrijednosti. Svi statusi moraju koristiti: `/opt/dev/public_html/gtpx/03_language/GTPX-ENUMS.gtpx` --- ## 17. OGRANIČENJA Synarch mora: - raditi deterministički - koristiti GTPX - ne uvoditi implicitna pravila Synarch ne smije: - imati skrivene statuse - imati nedokumentirane procese - zaobilaziti workflow --- ## 18. OTVORENE STAVKE 1. canonical PLAN MODEL 2. agent komunikacijski model 3. agent memory model 4. patch format 5. audit model 6. dry-run model 7. execution engine --- ## 19. PRAVILA 1. sve mora biti eksplicitno 2. ništa se ne pretpostavlja 3. svi procesi su auditirani 4. nema direktnih promjena 5. sve ide kroz workflow --- ## 20. STATUS DOKUMENTA Ovaj PRQ je u stanju `draft`. Dokument je usklađen s: - GTPX-ENUMS kao jedinim izvorom enum vrijednosti - DEV Manager PRQ dokumentom - trenutnom stabilizacijskom fazom sustava ------------------------------------------------------------------------ FILE_END PATH: PRQ-SYNARCH.md ------------------------------------------------------------------------ ======================================================================== SOURCE: GTPX_STANDARD ======================================================================== ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 00_meta/GTPX-LOCK.gtpx MODIFIED: 2026-04-25 19:56:32 UTC SIZE_BYTES: 1757 ------------------------------------------------------------------------ === META === { "id": "GTPX-LOCK", "title": "GTPX Standard Lock", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "00_meta/GTPX-LOCK.gtpx", "type": "meta_lock", "project": "GTPX", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx", "99_reports/STATUS.gtpx", "99_reports/TEST-REPORT-001.gtpx" ] } === DATA === { "purpose": "Defines current non-locked state of the GTPX Standard during stabilization phase.", "lock_policy": { "standard_is_locked": false, "all_core_documents_are_final": false, "modifications_require_new_version": false, "implicit_changes_are_forbidden": true }, "current_version": "0.1.0", "lock_scope": [ "meta_layer", "foundation_layer", "prq_layer", "language_layer", "contract_layer", "sources_layer", "protocol_layer", "validation_layer", "agents_layer", "runtime_layer", "examples_layer" ], "stabilization_state": { "phase": "pre_stable", "requires_full_review": true, "conflicts_present": true, "open_questions_present": true }, "guarantees": [ "no_implicit_assumptions", "explicit_structure_enforced", "validation_required_before_execution" ] } === RULES === { "standard_must_not_be_marked_stable": true, "no_version_1_0_0_until_full_stabilization": true, "all_documents_must_be_reviewed_before_lock": true, "implicit_behavior_is_forbidden": true } === STATUS === { "state": "draft", "open_questions": [ "Resolve all registry/index mismatches", "Unify status and enum models", "Define canonical plan model", "Define AVHS templates" ], "next_step": "Proceed to structural synchronization (INDEX vs REGISTRY)." } ------------------------------------------------------------------------ FILE_END PATH: 00_meta/GTPX-LOCK.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 00_meta/INDEX.gtpx MODIFIED: 2026-04-26 09:32:29 UTC SIZE_BYTES: 4154 ------------------------------------------------------------------------ === META === { "id": "GTPX-INDEX", "title": "GTPX Standard Index", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "00_meta/INDEX.gtpx", "type": "meta_index", "project": "GTPX", "canonical_root": "/opt/dev/public_html/gtpx/", "depends_on": [] } === DATA === { "purpose": "Defines the canonical entry point, read order, document groups, and navigation model for the GTPX Standard during stabilization phase.", "entry_point": { "document": "00_meta/INDEX.gtpx", "description": "This document is the first document that must be read when loading the GTPX Standard." }, "canonical_read_order": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx", "00_meta/GTPX-LOCK.gtpx", "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx", "01_foundation/GTPX-ACTORS.gtpx", "01_foundation/GTPX-SCOPE.gtpx", "02_prq/GTPX-PRQ-CORE.gtpx", "03_language/GTPX-DICTIONARY.gtpx", "03_language/GTPX-ENUMS.gtpx", "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-MODEL.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "04_contract/GTPX-PLAN-MODEL.gtpx", "05_sources/GTPX-SOURCE-MODEL.gtpx", "05_sources/GTPX-SOURCE-RELEVANCE.gtpx", "05_sources/GTPX-SOURCE-VERIFICATION.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "06_protocol/GTPX-ACK-HASH.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "07_validation/GTPX-HASH-NORMALIZATION.gtpx", "07_validation/GTPX-ERROR-MODEL.gtpx", "07_validation/GTPX-COMPLETENESS.gtpx", "08_agents/GTPX-AGENT-MODEL.gtpx", "08_agents/AGENT-PAM.gtpx", "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "09_runtime/GTPX-DRY-RUN-MODEL.gtpx", "09_runtime/GTPX-PATCH-MODEL.gtpx", "09_runtime/GTPX-AUDIT-MODEL.gtpx", "10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx", "11_workflow/GTPX-WORKFLOW-MODEL.gtpx", "11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx", "99_reports/STATUS.gtpx", "99_reports/TEST-REPORT-001.gtpx" ], "document_groups": { "00_meta": { "purpose": "Controls index, registry, lock state, versioning and document discovery." }, "01_foundation": { "purpose": "Defines what GTPX is, why it exists, who participates, and what it covers." }, "02_prq": { "purpose": "Defines the project requirement for the GTPX Standard." }, "03_language": { "purpose": "Defines dictionary, enums, syntax and semantics." }, "04_contract": { "purpose": "Defines the communication contract model." }, "05_sources": { "purpose": "Defines source types, relevance and verification." }, "06_protocol": { "purpose": "Defines request, response and ACK/hash models." }, "07_validation": { "purpose": "Defines validation, error handling and completeness rules." }, "08_agents": { "purpose": "Defines agents and their allowed responsibilities." }, "09_runtime": { "purpose": "Defines runtime, dry-run, patch and audit behavior as a standard model, not a concrete implementation." }, "10_examples": { "purpose": "Contains controlled examples proving standard usability." }, "11_workflow": { "purpose": "Defines standard maintenance workflow, analysis reports and patch governance." }, "99_reports": { "purpose": "Contains status reports, review outputs and audit summaries." } } } === RULES === { "read_order_is_authoritative": true, "registry_must_match_index": true, "unregistered_documents_are_invalid": true, "missing_documents_are_invalid": true, "document_paths_are_relative_to_canonical_root": true, "changes_to_read_order_require_registry_update": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm final file naming convention before stable release.", "Confirm whether all future documents must use the same META/DATA/RULES/STATUS block structure." ], "next_step": "Update 00_meta/REGISTRY.gtpx to match this index exactly." } ------------------------------------------------------------------------ FILE_END PATH: 00_meta/INDEX.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 00_meta/REGISTRY.gtpx MODIFIED: 2026-04-26 09:36:20 UTC SIZE_BYTES: 15087 ------------------------------------------------------------------------ === META === { "id": "GTPX-REGISTRY", "title": "GTPX Standard Registry", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "00_meta/REGISTRY.gtpx", "type": "meta_registry", "project": "GTPX", "canonical_root": "/opt/dev/public_html/gtpx/", "depends_on": [ "00_meta/INDEX.gtpx" ] } === DATA === { "purpose": "Defines the canonical registry of all documents that belong to the GTPX Standard during stabilization phase.", "registry_rules": { "all_standard_documents_must_be_registered": true, "all_registered_documents_must_exist": true, "registry_must_follow_index_read_order": true, "unregistered_documents_are_not_authoritative": true, "duplicate_ids_are_invalid": true, "duplicate_paths_are_invalid": true }, "documents": [ { "id": "GTPX-INDEX", "path": "00_meta/INDEX.gtpx", "title": "GTPX Standard Index", "status": "draft", "version": "0.1.0", "authority": "00_meta/INDEX.gtpx", "depends_on": [] }, { "id": "GTPX-REGISTRY", "path": "00_meta/REGISTRY.gtpx", "title": "GTPX Standard Registry", "status": "draft", "version": "0.1.0", "authority": "00_meta/REGISTRY.gtpx", "depends_on": [ "00_meta/INDEX.gtpx" ] }, { "id": "GTPX-LOCK", "path": "00_meta/GTPX-LOCK.gtpx", "title": "GTPX Standard Lock", "status": "draft", "version": "0.1.0", "authority": "00_meta/GTPX-LOCK.gtpx", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx", "99_reports/STATUS.gtpx", "99_reports/TEST-REPORT-001.gtpx" ] }, { "id": "GTPX-DEFINITION", "path": "01_foundation/GTPX-DEFINITION.gtpx", "title": "GTPX Definition", "status": "draft", "version": "0.1.0", "authority": "01_foundation/GTPX-DEFINITION.gtpx", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx" ] }, { "id": "GTPX-PURPOSE", "path": "01_foundation/GTPX-PURPOSE.gtpx", "title": "GTPX Purpose", "status": "draft", "version": "0.1.0", "authority": "01_foundation/GTPX-PURPOSE.gtpx", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx" ] }, { "id": "GTPX-ACTORS", "path": "01_foundation/GTPX-ACTORS.gtpx", "title": "GTPX Actors", "status": "draft", "version": "0.1.0", "authority": "01_foundation/GTPX-ACTORS.gtpx", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx" ] }, { "id": "GTPX-SCOPE", "path": "01_foundation/GTPX-SCOPE.gtpx", "title": "GTPX Scope", "status": "draft", "version": "0.1.0", "authority": "01_foundation/GTPX-SCOPE.gtpx", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx", "01_foundation/GTPX-ACTORS.gtpx" ] }, { "id": "GTPX-PRQ-CORE", "path": "02_prq/GTPX-PRQ-CORE.gtpx", "title": "GTPX Core Project Requirement", "status": "draft", "version": "0.1.0", "authority": "02_prq/GTPX-PRQ-CORE.gtpx", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx", "01_foundation/GTPX-ACTORS.gtpx", "01_foundation/GTPX-SCOPE.gtpx" ] }, { "id": "GTPX-DICTIONARY", "path": "03_language/GTPX-DICTIONARY.gtpx", "title": "GTPX Dictionary", "status": "draft", "version": "0.1.0", "authority": "03_language/GTPX-DICTIONARY.gtpx", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "02_prq/GTPX-PRQ-CORE.gtpx" ] }, { "id": "GTPX-ENUMS", "path": "03_language/GTPX-ENUMS.gtpx", "title": "GTPX Enums", "status": "draft", "version": "0.1.0", "authority": "03_language/GTPX-ENUMS.gtpx", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx" ] }, { "id": "GTPX-SYNTAX", "path": "03_language/GTPX-SYNTAX.gtpx", "title": "GTPX Syntax", "status": "draft", "version": "0.1.0", "authority": "03_language/GTPX-SYNTAX.gtpx", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx" ] }, { "id": "GTPX-SEMANTICS", "path": "03_language/GTPX-SEMANTICS.gtpx", "title": "GTPX Semantics", "status": "draft", "version": "0.1.0", "authority": "03_language/GTPX-SEMANTICS.gtpx", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "03_language/GTPX-SYNTAX.gtpx" ] }, { "id": "GTPX-CONTRACT-MODEL", "path": "04_contract/GTPX-CONTRACT-MODEL.gtpx", "title": "GTPX Contract Model", "status": "draft", "version": "0.1.0", "authority": "04_contract/GTPX-CONTRACT-MODEL.gtpx", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx" ] }, { "id": "GTPX-CONTRACT-CORE", "path": "04_contract/GTPX-CONTRACT-CORE.gtpx", "title": "GTPX Contract Core", "status": "draft", "version": "0.1.0", "authority": "04_contract/GTPX-CONTRACT-CORE.gtpx", "depends_on": [ "04_contract/GTPX-CONTRACT-MODEL.gtpx" ] }, { "id": "GTPX-PLAN-MODEL", "path": "04_contract/GTPX-PLAN-MODEL.gtpx", "title": "GTPX Plan Model", "status": "draft", "version": "0.1.0", "authority": "04_contract/GTPX-PLAN-MODEL.gtpx", "depends_on": [ "03_language/GTPX-ENUMS.gtpx", "04_contract/GTPX-CONTRACT-MODEL.gtpx", "09_runtime/GTPX-AUDIT-MODEL.gtpx" ] }, { "id": "GTPX-SOURCE-MODEL", "path": "05_sources/GTPX-SOURCE-MODEL.gtpx", "title": "GTPX Source Model", "status": "draft", "version": "0.1.0", "authority": "05_sources/GTPX-SOURCE-MODEL.gtpx", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "04_contract/GTPX-CONTRACT-MODEL.gtpx" ] }, { "id": "GTPX-SOURCE-RELEVANCE", "path": "05_sources/GTPX-SOURCE-RELEVANCE.gtpx", "title": "GTPX Source Relevance", "status": "draft", "version": "0.1.0", "authority": "05_sources/GTPX-SOURCE-RELEVANCE.gtpx", "depends_on": [ "05_sources/GTPX-SOURCE-MODEL.gtpx" ] }, { "id": "GTPX-SOURCE-VERIFICATION", "path": "05_sources/GTPX-SOURCE-VERIFICATION.gtpx", "title": "GTPX Source Verification", "status": "draft", "version": "0.1.0", "authority": "05_sources/GTPX-SOURCE-VERIFICATION.gtpx", "depends_on": [ "05_sources/GTPX-SOURCE-MODEL.gtpx", "05_sources/GTPX-SOURCE-RELEVANCE.gtpx" ] }, { "id": "GTPX-REQUEST-MODEL", "path": "06_protocol/GTPX-REQUEST-MODEL.gtpx", "title": "GTPX Request Model", "status": "draft", "version": "0.1.0", "authority": "06_protocol/GTPX-REQUEST-MODEL.gtpx", "depends_on": [ "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "05_sources/GTPX-SOURCE-MODEL.gtpx" ] }, { "id": "GTPX-RESPONSE-MODEL", "path": "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "title": "GTPX Response Model", "status": "draft", "version": "0.1.0", "authority": "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx" ] }, { "id": "GTPX-ACK-HASH", "path": "06_protocol/GTPX-ACK-HASH.gtpx", "title": "GTPX ACK and Hash Model", "status": "draft", "version": "0.1.0", "authority": "06_protocol/GTPX-ACK-HASH.gtpx", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] }, { "id": "GTPX-VALIDATION-MODEL", "path": "07_validation/GTPX-VALIDATION-MODEL.gtpx", "title": "GTPX Validation Model", "status": "draft", "version": "0.1.0", "authority": "07_validation/GTPX-VALIDATION-MODEL.gtpx", "depends_on": [ "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] }, { "id": "GTPX-HASH-NORMALIZATION", "path": "07_validation/GTPX-HASH-NORMALIZATION.gtpx", "title": "GTPX Hash Normalization", "status": "draft", "version": "0.1.0", "authority": "07_validation/GTPX-HASH-NORMALIZATION.gtpx", "depends_on": [ "04_contract/GTPX-PLAN-MODEL.gtpx", "06_protocol/GTPX-ACK-HASH.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] }, { "id": "GTPX-ERROR-MODEL", "path": "07_validation/GTPX-ERROR-MODEL.gtpx", "title": "GTPX Error Model", "status": "draft", "version": "0.1.0", "authority": "07_validation/GTPX-ERROR-MODEL.gtpx", "depends_on": [ "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] }, { "id": "GTPX-COMPLETENESS", "path": "07_validation/GTPX-COMPLETENESS.gtpx", "title": "GTPX Completeness Model", "status": "draft", "version": "0.1.0", "authority": "07_validation/GTPX-COMPLETENESS.gtpx", "depends_on": [ "07_validation/GTPX-VALIDATION-MODEL.gtpx", "07_validation/GTPX-ERROR-MODEL.gtpx" ] }, { "id": "GTPX-AGENT-MODEL", "path": "08_agents/GTPX-AGENT-MODEL.gtpx", "title": "GTPX Agent Model", "status": "draft", "version": "0.1.0", "authority": "08_agents/GTPX-AGENT-MODEL.gtpx", "depends_on": [ "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] }, { "id": "AGENT-PAM", "path": "08_agents/AGENT-PAM.gtpx", "title": "GTPX Reference Agent PAM", "status": "draft", "version": "0.1.0", "authority": "08_agents/AGENT-PAM.gtpx", "depends_on": [ "08_agents/GTPX-AGENT-MODEL.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] }, { "id": "GTPX-RUNTIME-MODEL", "path": "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "title": "GTPX Runtime Model", "status": "draft", "version": "0.1.0", "authority": "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "depends_on": [ "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "08_agents/GTPX-AGENT-MODEL.gtpx" ] }, { "id": "GTPX-DRY-RUN-MODEL", "path": "09_runtime/GTPX-DRY-RUN-MODEL.gtpx", "title": "GTPX Dry Run Model", "status": "draft", "version": "0.1.0", "authority": "09_runtime/GTPX-DRY-RUN-MODEL.gtpx", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "08_agents/GTPX-AGENT-MODEL.gtpx" ] }, { "id": "GTPX-PATCH-MODEL", "path": "09_runtime/GTPX-PATCH-MODEL.gtpx", "title": "GTPX Patch Model", "status": "draft", "version": "0.1.0", "authority": "09_runtime/GTPX-PATCH-MODEL.gtpx", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "09_runtime/GTPX-DRY-RUN-MODEL.gtpx" ] }, { "id": "GTPX-AUDIT-MODEL", "path": "09_runtime/GTPX-AUDIT-MODEL.gtpx", "title": "GTPX Audit Model", "status": "draft", "version": "0.1.0", "authority": "09_runtime/GTPX-AUDIT-MODEL.gtpx", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "09_runtime/GTPX-PATCH-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] }, { "id": "EXAMPLE-WMS-PARCEL-NUMBER", "path": "10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx", "title": "Example - Parcel Number Validation", "status": "draft", "version": "0.1.0", "authority": "10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "09_runtime/GTPX-RUNTIME-MODEL.gtpx" ] }, { "id": "GTPX-WORKFLOW-MODEL", "path": "11_workflow/GTPX-WORKFLOW-MODEL.gtpx", "title": "GTPX Workflow Model", "status": "draft", "version": "0.1.0", "authority": "11_workflow/GTPX-WORKFLOW-MODEL.gtpx", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx", "09_runtime/GTPX-PATCH-MODEL.gtpx", "09_runtime/GTPX-AUDIT-MODEL.gtpx" ] }, { "id": "GTPX-ANALYSIS-REPORT-MODEL", "path": "11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx", "title": "GTPX Analysis Report Model", "status": "draft", "version": "0.1.0", "authority": "11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx", "depends_on": [ "11_workflow/GTPX-WORKFLOW-MODEL.gtpx" ] }, { "id": "GTPX-STATUS", "path": "99_reports/STATUS.gtpx", "title": "GTPX Standard Status Report", "status": "draft", "version": "0.1.0", "authority": "99_reports/STATUS.gtpx", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx" ] }, { "id": "GTPX-TEST-REPORT-001", "path": "99_reports/TEST-REPORT-001.gtpx", "title": "GTPX Test Report 001", "status": "draft", "version": "0.1.0", "authority": "99_reports/TEST-REPORT-001.gtpx", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "09_runtime/GTPX-RUNTIME-MODEL.gtpx" ] } ] } === RULES === { "registry_is_authoritative": true, "document_id_must_be_unique": true, "document_path_must_be_unique": true, "registered_document_without_file_is_invalid": true, "file_without_registry_entry_is_non_authoritative": true, "registry_must_match_index": true, "version_format": "MAJOR.MINOR.PATCH" } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether status_values_allowed should be moved fully to GTPX-ENUMS as the only authoritative enum source.", "Confirm whether registry should contain only document lifecycle statuses, not execution statuses." ], "next_step": "Validate INDEX and REGISTRY alignment, then proceed to enum/status unification." } ------------------------------------------------------------------------ FILE_END PATH: 00_meta/REGISTRY.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 01_foundation/GTPX-ACTORS.gtpx MODIFIED: 2026-04-24 23:08:50 UTC SIZE_BYTES: 2365 ------------------------------------------------------------------------ === META === { "id": "GTPX-ACTORS", "title": "GTPX Actors", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "01_foundation/GTPX-ACTORS.gtpx", "type": "foundation_actors", "project": "GTPX", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx" ] } === DATA === { "purpose": "Defines the initial actor groups that participate in the creation, implementation, maintenance, use, and education of the GTPX Standard.", "actor_policy": { "actor_set_is_closed_for_this_phase": true, "new_actor_groups_must_not_be_added_without_explicit_decision": true, "this_document_defines_actor_groups_only": true, "detailed_responsibilities_are_defined_later": true }, "actor_groups": [ { "id": "ACTOR-GROUP-001", "name": "Developers / Implementers / System Integrators", "description": "Persons or organizations that build, implement, integrate, adapt, or operate systems based on the GTPX Standard." }, { "id": "ACTOR-GROUP-002", "name": "AI Model", "description": "The artificial intelligence model or machine that receives, interprets, processes, or generates outputs according to GTPX-defined structures and constraints." }, { "id": "ACTOR-GROUP-003", "name": "Maintainers / Community", "description": "Persons, organizations, or open-source community members responsible for maintaining, reviewing, improving, versioning, and governing the GTPX Standard." }, { "id": "ACTOR-GROUP-004", "name": "Educators / Advisors / Licensors", "description": "Persons or organizations that teach, document, advise on, certify, license, review, or professionally support adoption and correct use of the GTPX Standard." } ] } === RULES === { "only_listed_actor_groups_are_valid_in_this_phase": true, "actor_group_names_must_not_be_changed_without_explicit_decision": true, "actor_groups_must_not_be_split_without_explicit_decision": true, "actor_groups_must_not_be_extended_without_explicit_decision": true, "this_document_must_not_define_runtime_components": true, "this_document_must_not_define_agent_architecture": true } === STATUS === { "state": "draft", "open_questions": [], "next_step": "Create and populate 01_foundation/GTPX-SCOPE.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 01_foundation/GTPX-ACTORS.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 01_foundation/GTPX-DEFINITION.gtpx MODIFIED: 2026-04-24 23:02:05 UTC SIZE_BYTES: 1965 ------------------------------------------------------------------------ === META === { "id": "GTPX-DEFINITION", "title": "GTPX Definition", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "01_foundation/GTPX-DEFINITION.gtpx", "type": "foundation_definition", "project": "GTPX", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx" ] } === DATA === { "purpose": "Provides a single, precise, and non-ambiguous definition of the GTPX Standard.", "definition": "GTPX is a deterministic communication standard that defines a structured contract between a human, an AI agent, and a runtime system, ensuring that all inputs, outputs, validations, and state transitions are explicit, verifiable, and free from implicit interpretation.", "core_properties": [ "deterministic", "contract-driven", "explicit_structure", "verifiable", "auditable", "fail_closed" ], "determinism_definition": "Given the same input, contract, source set, and runtime state, the system must produce the same validated output without variation.", "non_goals": [ "GTPX does not define business logic of specific applications.", "GTPX does not replace legal interpretation or jurisdiction-specific rules.", "GTPX does not define implementation details of runtime systems.", "GTPX does not allow implicit assumptions or inferred behavior." ] } === RULES === { "definition_must_be_unique": true, "definition_must_not_contain_synonyms": true, "definition_must_be_machine_readable": true, "definition_must_be_human_understandable": true, "implicit_interpretation_is_forbidden": true, "non_goals_are_mandatory": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether 'runtime system' should be strictly defined as Synarch or remain generic.", "Confirm if 'fail_closed' must be enforced globally or configurable via contract." ], "next_step": "Create and populate 01_foundation/GTPX-PURPOSE.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 01_foundation/GTPX-DEFINITION.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 01_foundation/GTPX-PURPOSE.gtpx MODIFIED: 2026-04-24 23:02:48 UTC SIZE_BYTES: 3046 ------------------------------------------------------------------------ === META === { "id": "GTPX-PURPOSE", "title": "GTPX Purpose", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "01_foundation/GTPX-PURPOSE.gtpx", "type": "foundation_purpose", "project": "GTPX", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx" ] } === DATA === { "purpose": "Defines the problems that GTPX solves and the reasons for its existence.", "primary_objective": "To eliminate ambiguity, implicit assumptions, and non-deterministic behavior in communication between humans and AI systems.", "problems": [ { "id": "P1", "name": "implicit_assumptions", "description": "AI systems infer missing data and silently fill gaps, leading to unpredictable outputs." }, { "id": "P2", "name": "unstructured_requests", "description": "Human inputs are often incomplete, inconsistent, or not machine-readable." }, { "id": "P3", "name": "non_deterministic_outputs", "description": "The same input can produce different outputs due to lack of strict constraints." }, { "id": "P4", "name": "lack_of_validation", "description": "There is no enforced mechanism to verify completeness and correctness before execution." }, { "id": "P5", "name": "missing_auditability", "description": "Outputs cannot be reliably traced back to inputs, sources, and decisions." } ], "objectives": [ { "id": "O1", "name": "eliminate_assumptions", "description": "All required data must be explicitly defined before execution." }, { "id": "O2", "name": "structure_requests", "description": "All inputs must follow a predefined, machine-readable format." }, { "id": "O3", "name": "ensure_determinism", "description": "Same input and state must always produce the same output." }, { "id": "O4", "name": "enforce_validation", "description": "Inputs must be validated for completeness and correctness before processing." }, { "id": "O5", "name": "enable_audit", "description": "All actions and outputs must be traceable and explainable." } ], "expected_outcomes": [ "Predictable AI behavior", "No silent failures or hidden assumptions", "Full traceability of decisions", "Clear separation of responsibilities between human, agent, and runtime", "Machine-verifiable communication" ] } === RULES === { "problems_must_be_explicit": true, "objectives_must_map_to_problems": true, "each_problem_must_have_id": true, "each_objective_must_have_id": true, "descriptions_must_be_non_ambiguous": true, "implicit_behavior_is_forbidden": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if objectives must have measurable KPIs in later versions.", "Confirm if expected outcomes should be validated via examples." ], "next_step": "Create and populate 01_foundation/GTPX-ACTORS.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 01_foundation/GTPX-PURPOSE.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 01_foundation/GTPX-SCOPE.gtpx MODIFIED: 2026-04-24 23:09:34 UTC SIZE_BYTES: 1850 ------------------------------------------------------------------------ === META === { "id": "GTPX-SCOPE", "title": "GTPX Scope", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "01_foundation/GTPX-SCOPE.gtpx", "type": "foundation_scope", "project": "GTPX", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx", "01_foundation/GTPX-ACTORS.gtpx" ] } === DATA === { "purpose": "Defines what the GTPX Standard covers and what it explicitly does not cover.", "in_scope": [ "communication_standard", "contract_model", "request_model", "response_model", "validation_model", "source_model", "source_relevance", "source_verification", "acknowledgement_model", "hash_model", "dry_run_model", "patch_model", "audit_model" ], "out_of_scope": [ "business_logic_of_specific_applications", "legal_interpretation_by_itself", "implementation_of_a_specific_runtime", "automatic_execution_without_handler", "uncontrolled_agent_autonomy", "undocumented_source_usage", "implicit_assumptions", "silent_data_transformation" ], "scope_statement": "GTPX defines a deterministic communication and validation standard for structured interaction between humans, AI models, and systems. It does not define the internal business logic of a specific application, nor does it replace professional legal, technical, or domain-specific judgment." } === RULES === { "scope_must_be_explicit": true, "in_scope_items_are_authoritative": true, "out_of_scope_items_are_authoritative": true, "undefined_scope_is_invalid": true, "scope_expansion_requires_explicit_patch": true, "implicit_scope_expansion_is_forbidden": true } === STATUS === { "state": "draft", "open_questions": [], "next_step": "Create and populate 02_prq/GTPX-PRQ-CORE.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 01_foundation/GTPX-SCOPE.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 02_prq/GTPX-PRQ-CORE.gtpx MODIFIED: 2026-04-24 23:10:26 UTC SIZE_BYTES: 3417 ------------------------------------------------------------------------ === META === { "id": "GTPX-PRQ-CORE", "title": "GTPX Core Project Requirement", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "02_prq/GTPX-PRQ-CORE.gtpx", "type": "prq_core", "project": "GTPX", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "01_foundation/GTPX-PURPOSE.gtpx", "01_foundation/GTPX-ACTORS.gtpx", "01_foundation/GTPX-SCOPE.gtpx" ] } === DATA === { "purpose": "Defines the core project requirement for the GTPX Standard.", "problem": "Current human-AI communication is non-deterministic, relies on implicit assumptions, lacks structured validation, and is not fully auditable.", "goal": "To create a deterministic communication standard that enforces explicit structure, validation, traceability, and reproducibility in interactions between humans, AI models, and systems.", "scope": [ "definition_of_standard", "definition_of_contract", "definition_of_request_and_response", "definition_of_validation", "definition_of_sources", "definition_of_ack_and_hash", "definition_of_runtime_models", "definition_of_audit_models" ], "functional_requirements": [ "must_define_structured_request_format", "must_define_structured_response_format", "must_define_contract_constraints", "must_define_validation_rules", "must_define_source_handling", "must_define_acknowledgement_and_hash", "must_define_dry_run_behavior", "must_define_patch_behavior", "must_define_audit_behavior" ], "non_functional_requirements": [ "determinism", "traceability", "auditability", "explicitness", "fail_closed_behavior", "machine_readability" ], "actors": [ "Developers / Implementers / System Integrators", "AI Model", "Maintainers / Community", "Educators / Advisors / Licensors" ], "risks": [ "overcomplexity_of_standard", "incomplete_definition_of_language", "incorrect_scope_expansion", "misinterpretation_by_implementers", "lack_of_adoption" ], "constraints": [ "no_implicit_behavior", "no_undefined_fields", "no_unverified_sources", "no_execution_without_validation" ], "acceptance_criteria": [ "all_documents_defined_in_registry_exist", "all_documents_have_clear_purpose", "request_model_is_fully_defined", "response_model_is_fully_defined", "validation_model_can_detect_errors", "ack_model_can_confirm_complete_read", "audit_model_can_trace_execution", "dry_run_model_can_simulate_without_commit" ], "definition_of_done": [ "all_core_documents_status_stable", "no_open_questions_in_core_documents", "all_dependencies_resolved", "full_request_response_flow_tested", "no_implicit_behavior_present" ] } === RULES === { "prq_must_be_complete": true, "all_sections_are_mandatory": true, "requirements_must_be_testable": true, "constraints_must_be_enforceable": true, "acceptance_criteria_must_be_verifiable": true, "definition_of_done_must_be_measurable": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether non-functional requirements should be quantified in later phases.", "Confirm whether risks require mitigation strategies in this document or separate one." ], "next_step": "Review all foundation and PRQ documents before proceeding to 03_language." } ------------------------------------------------------------------------ FILE_END PATH: 02_prq/GTPX-PRQ-CORE.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 03_language/GTPX-DICTIONARY.gtpx MODIFIED: 2026-04-24 23:18:19 UTC SIZE_BYTES: 3655 ------------------------------------------------------------------------ === META === { "id": "GTPX-DICTIONARY", "title": "GTPX Dictionary", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "03_language/GTPX-DICTIONARY.gtpx", "type": "language_dictionary", "project": "GTPX", "depends_on": [ "01_foundation/GTPX-DEFINITION.gtpx", "02_prq/GTPX-PRQ-CORE.gtpx" ] } === DATA === { "purpose": "Defines the controlled vocabulary used in the GTPX Standard. Only terms defined here are allowed for formal communication.", "term_policy": { "only_defined_terms_are_allowed": true, "synonyms_are_forbidden": true, "implicit_terms_are_forbidden": true, "all_terms_must_be_explicitly_defined": true }, "terms": [ { "term": "contract", "definition": "A formal set of rules that defines allowed behavior, constraints, and boundaries for a GTPX interaction." }, { "term": "request", "definition": "A structured input sent to an AI model or system, following GTPX-defined format." }, { "term": "response", "definition": "A structured output generated by an AI model or system, following GTPX-defined format." }, { "term": "agent", "definition": "An entity that processes a request and produces a response under defined constraints." }, { "term": "runtime", "definition": "The execution environment that manages flow, validation, and contract enforcement." }, { "term": "validator", "definition": "A component that verifies structure, completeness, and compliance with rules." }, { "term": "source", "definition": "Any data origin used to support or justify a response." }, { "term": "evidence", "definition": "Verified data derived from a source used to support a claim." }, { "term": "dry_run", "definition": "A simulation of execution without committing changes." }, { "term": "patch", "definition": "An explicit modification applied to an existing state or document." }, { "term": "commit", "definition": "A confirmed and applied change after validation." }, { "term": "audit", "definition": "A traceable record of actions, decisions, inputs, and outputs." }, { "term": "complete", "definition": "A state where all required fields and data are present and validated." }, { "term": "valid", "definition": "A state where data satisfies all defined structural and rule constraints." }, { "term": "blocked", "definition": "A state where execution cannot proceed due to missing or invalid data." }, { "term": "fail_closed", "definition": "A rule where the system rejects execution if requirements are not fully satisfied." }, { "term": "ack", "definition": "A confirmation that a message has been fully received and processed." }, { "term": "hash", "definition": "A deterministic value representing the integrity of a payload." } ] } === RULES === { "terms_must_be_unique": true, "definitions_must_be_non_ambiguous": true, "terms_must_not_overlap_in_meaning": true, "undefined_terms_are_forbidden": true, "synonyms_are_forbidden": true, "all_future_documents_must_use_only_these_terms": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if additional system states (e.g. rejected, partial) are required.", "Confirm if term 'agent' should later be split into multiple agent types." ], "next_step": "Create and populate 03_language/GTPX-SYNTAX.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 03_language/GTPX-DICTIONARY.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 03_language/GTPX-ENUMS.gtpx MODIFIED: 2026-04-26 10:58:06 UTC SIZE_BYTES: 3060 ------------------------------------------------------------------------ === META === { "id": "GTPX-ENUMS", "title": "GTPX Enums", "version": "0.1.1", "status": "draft", "updated": "2026-04-26", "authority": "03_language/GTPX-ENUMS.gtpx", "type": "language_enums", "project": "GTPX", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx" ] } === DATA === { "purpose": "Defines all allowed enumerated values across the entire GTPX ecosystem. This is the single authoritative source for all enums.", "enum_policy": { "single_source_of_truth": true, "all_enums_must_be_defined_here": true, "external_enum_definitions_forbidden": true, "implicit_values_forbidden": true }, "document_status": [ "planned", "draft", "review", "accepted", "stable", "deprecated", "rejected" ], "plan_status": [ "draft", "active", "archived" ], "change_request_status": [ "open", "in_analysis", "approved", "rejected", "implemented" ], "analysis_status": [ "created", "completed" ], "patch_status": [ "proposed", "validated", "approved", "applied", "failed" ], "commit_status": [ "created", "finalized" ], "validation_outcomes": [ "valid", "invalid", "blocked" ], "completeness_outcomes": [ "complete", "incomplete", "conditionally_complete" ], "response_mode": [ "atomic", "streaming" ], "incomplete_response_policy": [ "reject", "retry_atomic", "allow_preview_only" ], "response_delivery_status": [ "complete", "incomplete", "interrupted", "invalid", "blocked" ], "execution_modes": [ "analysis_mode", "dry_run_mode", "proposal_mode" ], "ack_values": [ "READ_COMPLETE", "READ_REJECTED", "HASH_MISMATCH" ], "error_types": [ "structure_error", "contract_error", "completeness_error", "source_error", "hash_error" ], "error_severity": [ "critical", "non_critical" ], "source_types": [ "PUBLIC", "INTERNAL", "SPECIALIZED_API", "USER_PROVIDED", "RUNTIME_PROVIDED" ], "authority_levels": [ "low", "medium", "high", "authoritative" ], "allowed_usage": [ "read_only", "validation_only", "analysis", "decision_support" ], "change_types": [ "add", "modify", "remove" ], "fail_policies": [ "fail_closed", "fail_open" ] } === RULES === { "only_values_from_this_document_are_allowed": true, "enum_names_must_not_be_changed_without_patch": true, "enum_values_must_not_be_extended_without_patch": true, "all_documents_must_reference_this_enum_set": true, "duplicate_enum_values_are_forbidden": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether numeric scoring is needed for authority_levels", "Confirm whether fail_open should be allowed in production", "Confirm if plan_status needs more lifecycle states" ], "next_step": "Align GTPX response delivery rules with this enum set." } ------------------------------------------------------------------------ FILE_END PATH: 03_language/GTPX-ENUMS.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 03_language/GTPX-SEMANTICS.gtpx MODIFIED: 2026-04-26 09:37:47 UTC SIZE_BYTES: 3385 ------------------------------------------------------------------------ === META === { "id": "GTPX-SEMANTICS", "title": "GTPX Semantics", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "03_language/GTPX-SEMANTICS.gtpx", "type": "language_semantics", "project": "GTPX", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "03_language/GTPX-SYNTAX.gtpx" ] } === DATA === { "purpose": "Defines the meaning of GTPX structural elements, states, and execution terms.", "semantic_policy": { "meaning_must_be_explicit": true, "same_term_must_have_same_meaning_everywhere": true, "contextual_redefinition_is_forbidden": true, "implicit_meaning_is_forbidden": true }, "states": { "planned": "Defined as intended future work, not yet active.", "draft": "Written but not yet accepted as stable.", "review": "Under analysis for correctness, completeness, and conflicts.", "accepted": "Approved for use but not yet locked as stable.", "stable": "Accepted, validated, and treated as authoritative.", "deprecated": "No longer recommended but retained for compatibility.", "rejected": "Invalid and not allowed for use." }, "execution_terms": { "complete": "All required data is present.", "valid": "All required data satisfies structure and rules.", "blocked": "Execution cannot continue.", "fail_closed": "Execution must stop when required data or validation is missing." }, "request_semantics": { "CONTRACT": "Defines rules, constraints, permissions, source requirements, and output limits for the request.", "AGENT": "Defines the AI model or processing entity allowed to handle the request.", "PURPOSE": "Defines why the request exists.", "CONTEXT": "Defines the information background needed to interpret the request.", "SOURCE_SET": "Defines the sources allowed or required for processing.", "FILE_SET": "Defines files attached, referenced, or required for processing.", "REQUEST": "Defines the concrete task to be performed.", "EXPECTED_OUTPUT": "Defines the required response form, structure, and level of detail.", "PAYLOAD_HASH": "Defines the integrity hash of the payload.", "END_OF_MESSAGE": "Marks the explicit end of the request." }, "response_semantics": { "ACK": "Confirms whether the request was received, read, and structurally recognized.", "STATUS": "Defines current processing state.", "SUMMARY": "Provides a concise summary of understood input.", "MISSING_CONTEXT": "Lists missing data required for valid execution.", "ANALYSIS": "Provides structured reasoning output allowed by the contract.", "RISKS": "Lists identified risks, conflicts, or uncertainties.", "PROPOSED_ACTIONS": "Lists possible next actions without committing changes.", "PATCH": "Defines explicit proposed modifications.", "DRY_RUN": "Simulates expected result without applying changes.", "NEXT_STEP": "Defines the next valid action." } } === RULES === { "semantic_meaning_is_authoritative": true, "terms_must_not_be_redefined": true, "states_must_match_registry_allowed_status_values": true, "request_sections_must_match_syntax": true, "response_sections_must_match_syntax": true, "undefined_meaning_is_invalid": true } === STATUS === { "state": "draft", "open_questions": [], "next_step": "Proceed to 04_contract/GTPX-CONTRACT-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 03_language/GTPX-SEMANTICS.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 03_language/GTPX-SYNTAX.gtpx MODIFIED: 2026-04-24 23:19:02 UTC SIZE_BYTES: 2284 ------------------------------------------------------------------------ === META === { "id": "GTPX-SYNTAX", "title": "GTPX Syntax", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "03_language/GTPX-SYNTAX.gtpx", "type": "language_syntax", "project": "GTPX", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx" ] } === DATA === { "purpose": "Defines the allowed structural format of GTPX documents and messages.", "syntax_policy": { "structure_is_mandatory": true, "section_order_is_fixed": true, "undefined_sections_are_forbidden": true, "free_text_outside_structure_is_forbidden": true }, "document_structure": [ "META", "DATA", "RULES", "STATUS" ], "section_format": { "META": "JSON object", "DATA": "JSON object", "RULES": "JSON object", "STATUS": "JSON object" }, "section_rules": { "META": { "required_fields": [ "id", "title", "version", "status", "updated", "authority" ] }, "DATA": { "required": true }, "RULES": { "required": true }, "STATUS": { "required": true } }, "request_structure": [ "CONTRACT", "AGENT", "PURPOSE", "CONTEXT", "SOURCE_SET", "FILE_SET", "REQUEST", "EXPECTED_OUTPUT", "PAYLOAD_HASH", "END_OF_MESSAGE" ], "response_structure": [ "ACK", "STATUS", "SUMMARY", "MISSING_CONTEXT", "ANALYSIS", "RISKS", "PROPOSED_ACTIONS", "PATCH", "DRY_RUN", "NEXT_STEP" ], "forbidden_patterns": [ "missing_required_sections", "incorrect_section_order", "undefined_sections", "mixed_structure_and_free_text", "partial_messages_without_status" ] } === RULES === { "section_order_must_be_respected": true, "all_sections_must_exist": true, "json_must_be_valid": true, "no_extra_fields_allowed_without_definition": true, "no_implicit_structure_allowed": true, "request_and_response_structures_are_authoritative": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if FILE_SET is mandatory or optional.", "Confirm if PATCH and DRY_RUN sections must always exist or only when used." ], "next_step": "Create and populate 03_language/GTPX-SEMANTICS.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 03_language/GTPX-SYNTAX.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 04_contract/GTPX-CONTRACT-CORE.gtpx MODIFIED: 2026-04-26 11:00:57 UTC SIZE_BYTES: 3490 ------------------------------------------------------------------------ === META === { "id": "GTPX-CONTRACT-CORE", "title": "GTPX Contract Core", "version": "0.1.1", "status": "draft", "updated": "2026-04-26", "authority": "04_contract/GTPX-CONTRACT-CORE.gtpx", "type": "contract_core", "project": "GTPX", "depends_on": [ "04_contract/GTPX-CONTRACT-MODEL.gtpx", "03_language/GTPX-ENUMS.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines the minimal mandatory field set for a valid GTPX contract, including response delivery requirements.", "contract_policy": { "contract_is_mandatory": true, "all_fields_must_be_present": true, "missing_field_results_in_blocked": true, "implicit_values_are_forbidden": true }, "minimal_contract_fields": [ "meta_ugovora", "obavezni_sadrzaj", "dodatni_sadrzaj", "ogranicenja_komunikacije" ], "meta_ugovora": { "description": "Defines identity and purpose of the contract.", "fields": [ "contract_id", "contract_version", "contract_purpose" ] }, "obavezni_sadrzaj": { "description": "Defines required elements that must always exist.", "fields": [ "allowed_actors", "allowed_sources", "required_structure", "required_validation", "required_output_format", "response_delivery" ] }, "response_delivery": { "description": "Defines mandatory response delivery behavior required by the contract.", "fields": [ "response_mode", "require_complete_response", "require_response_hash", "incomplete_response_policy" ], "field_requirements": { "response_mode": "Must use response_mode from GTPX-ENUMS.", "require_complete_response": "Must be boolean and must be true for system outputs.", "require_response_hash": "Must be boolean and must be true for atomic system outputs.", "incomplete_response_policy": "Must use incomplete_response_policy from GTPX-ENUMS." } }, "dodatni_sadrzaj": { "description": "Defines optional extensions allowed within the contract.", "fields": [ "extended_rules", "custom_constraints", "domain_specific_requirements" ] }, "ogranicenja_komunikacije": { "description": "Defines strict limitations of allowed behavior.", "fields": [ "forbidden_actions", "fail_policy", "max_scope", "allowed_operations" ] } } === RULES === { "all_minimal_fields_are_required": true, "field_names_must_not_be_changed": true, "contract_without_any_field_is_invalid": true, "contract_must_define_allowed_and_forbidden_behavior": true, "contract_must_define_fail_policy": true, "contract_must_define_structure_requirements": true, "contract_must_define_response_delivery": true, "response_mode_must_use_gtpx_enums": true, "incomplete_response_policy_must_use_gtpx_enums": true, "system_output_contracts_must_require_atomic_response": true, "system_output_contracts_must_reject_incomplete_response": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm exact field naming standard (snake_case vs strict GTPX naming).", "Confirm if additional mandatory fields will be added after first implementation.", "Confirm whether response_delivery belongs permanently under obavezni_sadrzaj or should later become a dedicated top-level contract section." ], "next_step": "Integrate response delivery validation into GTPX runtime model." } ------------------------------------------------------------------------ FILE_END PATH: 04_contract/GTPX-CONTRACT-CORE.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 04_contract/GTPX-CONTRACT-MODEL.gtpx MODIFIED: 2026-04-24 23:20:48 UTC SIZE_BYTES: 2465 ------------------------------------------------------------------------ === META === { "id": "GTPX-CONTRACT-MODEL", "title": "GTPX Contract Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "04_contract/GTPX-CONTRACT-MODEL.gtpx", "type": "contract_model", "project": "GTPX", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx" ] } === DATA === { "purpose": "Defines what a contract is in GTPX and which dimensions it must control.", "contract_definition": "A contract is a formal, explicit, and machine-readable set of rules that defines allowed behavior, constraints, boundaries, and expectations for a GTPX request and response.", "contract_scope": [ "allowed_behavior", "forbidden_behavior", "input_requirements", "output_requirements", "validation_requirements", "source_requirements", "execution_constraints", "error_handling_policy" ], "contract_dimensions": { "behavior_control": "Defines what the AI model is allowed and not allowed to do.", "input_control": "Defines required structure and completeness of input.", "output_control": "Defines required structure and limits of output.", "source_control": "Defines which sources are allowed, required, or forbidden.", "validation_control": "Defines validation rules before execution.", "execution_control": "Defines execution conditions such as dry_run, commit, or blocked states.", "error_control": "Defines how errors must be handled (fail_closed, blocked, etc.)." }, "contract_requirements": [ "contract_must_be_explicit", "contract_must_be_machine_readable", "contract_must_define_constraints", "contract_must_define_allowed_actions", "contract_must_define_failure_behavior" ], "contract_effect": "No request may be processed and no response may be generated outside the rules defined in the contract." } === RULES === { "contract_is_mandatory_for_execution": true, "execution_without_contract_is_forbidden": true, "contract_overrides_default_behavior": true, "contract_must_not_be_implicit": true, "contract_must_be_validated_before_use": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether contract inheritance is allowed in later versions.", "Confirm whether multiple contracts per request are allowed." ], "next_step": "Create and populate 04_contract/GTPX-CONTRACT-CORE.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 04_contract/GTPX-CONTRACT-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 04_contract/GTPX-PLAN-MODEL.gtpx MODIFIED: 2026-04-25 20:13:37 UTC SIZE_BYTES: 4236 ------------------------------------------------------------------------ === META === { "id": "GTPX-PLAN-MODEL", "title": "GTPX Plan Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "04_contract/GTPX-PLAN-MODEL.gtpx", "type": "contract_plan_model", "project": "GTPX", "depends_on": [ "03_language/GTPX-ENUMS.gtpx", "04_contract/GTPX-CONTRACT-MODEL.gtpx", "09_runtime/GTPX-AUDIT-MODEL.gtpx" ] } === DATA === { "purpose": "Defines the canonical technical model for how a plan exists, is versioned, validated, hashed, and changed inside the AVH Development Platform.", "definition": "A plan is a structured, versioned, hashable and auditable canonical JSON payload that defines the state, rules, objectives and constraints of an entity.", "scope": { "applies_to": [ "GTPX", "AVHS", "Synarch", "Projects", "Modules", "Services", "Business" ], "does_not_define": [ "business_logic", "runtime_implementation", "database_schema", "api_routes", "ui_behavior" ] }, "canonical_storage_policy": { "canonical_plan_form": "JSON payload", "canonical_storage": "database", "files_are_authoritative": false, "files_allowed_for": [ "import", "export", "debugging", "human_review", "bundle_generation" ] }, "plan_identity": { "required_fields": [ "id", "entity_id", "version", "status", "payload", "hash", "created_at", "created_by", "parent_version_id" ] }, "field_definitions": { "id": "Unique identifier of the plan version.", "entity_id": "Identifier of the entity this plan belongs to.", "version": "Version of the plan.", "status": "Lifecycle status of the plan, using plan_status from GTPX-ENUMS.", "payload": "Canonical JSON content of the plan.", "hash": "Deterministic hash of the canonical payload.", "created_at": "Timestamp when the plan version was created.", "created_by": "Identifier of the user or process that created the plan version.", "parent_version_id": "Reference to the previous plan version, or null for the first version." }, "payload_minimum_structure": { "required_sections": [ "structure", "rules", "constraints", "objectives" ], "section_definitions": { "structure": "Defines the internal structure of the planned entity.", "rules": "Defines allowed and forbidden behavior.", "constraints": "Defines technical, operational, legal or process limitations.", "objectives": "Defines goals and intended outcomes." } }, "versioning_policy": { "overwrite_existing_versions": false, "new_change_creates_new_version": true, "parent_version_required_after_first_version": true, "version_chain_must_be_reconstructible": true }, "hash_policy": { "hash_required": true, "hash_algorithm": "SHA-256", "hash_target": "canonical_payload", "hash_mismatch_blocks_commit": true }, "change_policy": { "direct_edit_forbidden": true, "change_request_required": true, "analysis_required": true, "dry_run_required": true, "patch_required": true, "commit_required": true, "audit_required": true } } === RULES === { "plan_model_is_global": true, "synarch_uses_plan_model_but_does_not_define_it": true, "dev_manager_uses_plan_model_for_development_control": true, "all_plan_changes_must_follow_change_policy": true, "payload_must_be_valid_json": true, "payload_must_include_minimum_structure": true, "plan_status_must_use_gtpx_enums": true, "hash_must_match_payload": true, "old_versions_must_not_be_overwritten": true } === STATUS === { "state": "draft", "open_questions": [ "Define exact canonical JSON normalization rules before hashing", "Define exact payload schema per entity type", "Define whether version uses semver or monotonic internal versioning", "Define plan import/export format" ], "next_step": "Register GTPX-PLAN-MODEL in INDEX and REGISTRY." } ------------------------------------------------------------------------ FILE_END PATH: 04_contract/GTPX-PLAN-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 05_sources/GTPX-SOURCE-MODEL.gtpx MODIFIED: 2026-04-24 23:21:52 UTC SIZE_BYTES: 1949 ------------------------------------------------------------------------ === META === { "id": "GTPX-SOURCE-MODEL", "title": "GTPX Source Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "05_sources/GTPX-SOURCE-MODEL.gtpx", "type": "source_model", "project": "GTPX", "depends_on": [ "03_language/GTPX-DICTIONARY.gtpx", "04_contract/GTPX-CONTRACT-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how sources are declared and referenced in GTPX.", "source_types": [ "PUBLIC", "INTERNAL", "SPECIALIZED_API", "USER_PROVIDED", "RUNTIME_PROVIDED" ], "source_policy": { "all_sources_must_be_declared": true, "undeclared_sources_are_forbidden": true, "each_source_must_have_id": true, "source_usage_must_follow_contract": true }, "source_structure": { "required_fields": [ "source_id", "source_type", "authority_level", "freshness_required", "citation_required", "allowed_usage" ] }, "field_definitions": { "source_id": "Unique identifier of the source.", "source_type": "Type of the source (PUBLIC, INTERNAL, etc.).", "authority_level": "Defines trust level of the source.", "freshness_required": "Defines whether up-to-date data is required.", "citation_required": "Defines whether the source must be explicitly cited.", "allowed_usage": "Defines how the source may be used." } } === RULES === { "source_id_must_be_unique": true, "source_type_must_be_from_defined_set": true, "authority_level_must_be_defined": true, "freshness_required_must_be_boolean": true, "citation_required_must_be_boolean": true, "allowed_usage_must_be_explicit": true, "using_undeclared_source_is_invalid": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm authority level scale definition.", "Confirm allowed_usage value set." ], "next_step": "Create and populate 05_sources/GTPX-SOURCE-RELEVANCE.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 05_sources/GTPX-SOURCE-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 05_sources/GTPX-SOURCE-RELEVANCE.gtpx MODIFIED: 2026-04-24 23:24:42 UTC SIZE_BYTES: 1859 ------------------------------------------------------------------------ === META === { "id": "GTPX-SOURCE-RELEVANCE", "title": "GTPX Source Relevance", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "05_sources/GTPX-SOURCE-RELEVANCE.gtpx", "type": "source_relevance", "project": "GTPX", "depends_on": [ "05_sources/GTPX-SOURCE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how the relevance and priority of sources are determined in GTPX.", "relevance_policy": { "relevance_must_be_explicit": true, "relevance_must_be_deterministic": true, "conflicting_sources_must_be_resolved": true, "implicit_priority_is_forbidden": true }, "relevance_dimensions": [ "authority_level", "freshness", "context_match", "contract_requirement" ], "dimension_definitions": { "authority_level": "Priority based on trust and credibility of the source.", "freshness": "Priority based on how up-to-date the data is.", "context_match": "Priority based on how well the source matches the request context.", "contract_requirement": "Priority enforced by contract rules." }, "resolution_rules": [ "contract_requirement_overrides_all", "higher_authority_level_has_priority", "more_recent_source_has_priority_if_freshness_required", "better_context_match_has_priority", "if_conflict_remains_mark_as_risk" ] } === RULES === { "relevance_must_be_computed_using_defined_dimensions": true, "undefined_relevance_rules_are_forbidden": true, "conflicting_sources_must_not_be_silently_merged": true, "source_priority_must_be_traceable": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm authority_level scale definition.", "Confirm whether numeric scoring is required or rule-based only." ], "next_step": "Create and populate 05_sources/GTPX-SOURCE-VERIFICATION.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 05_sources/GTPX-SOURCE-RELEVANCE.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 05_sources/GTPX-SOURCE-VERIFICATION.gtpx MODIFIED: 2026-04-24 23:25:11 UTC SIZE_BYTES: 2173 ------------------------------------------------------------------------ === META === { "id": "GTPX-SOURCE-VERIFICATION", "title": "GTPX Source Verification", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "05_sources/GTPX-SOURCE-VERIFICATION.gtpx", "type": "source_verification", "project": "GTPX", "depends_on": [ "05_sources/GTPX-SOURCE-MODEL.gtpx", "05_sources/GTPX-SOURCE-RELEVANCE.gtpx" ] } === DATA === { "purpose": "Defines how sources are verified before being used in GTPX execution.", "verification_policy": { "all_sources_must_be_verified": true, "unverified_sources_must_not_be_used": true, "verification_must_be_traceable": true, "implicit_trust_is_forbidden": true }, "verification_methods": [ "direct_validation", "cross_source_validation", "authority_validation", "contract_enforced_validation" ], "method_definitions": { "direct_validation": "Source is verified directly against known trusted data.", "cross_source_validation": "Source is verified by comparing with other sources.", "authority_validation": "Source is accepted based on defined authority level.", "contract_enforced_validation": "Source must satisfy contract-defined validation rules." }, "verification_outcomes": [ "verified", "partially_verified", "unverified", "conflict_detected" ], "outcome_definitions": { "verified": "Source is confirmed valid.", "partially_verified": "Source is partially confirmed but not complete.", "unverified": "Source could not be verified.", "conflict_detected": "Source conflicts with other verified sources." } } === RULES === { "verification_method_must_be_declared": true, "verification_outcome_must_be_declared": true, "unverified_sources_must_be_flagged": true, "conflicting_sources_must_be_reported": true, "verification_process_must_be_auditable": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether partially_verified is acceptable under certain contracts.", "Confirm whether automatic rejection is required for conflict_detected." ], "next_step": "Proceed to 06_protocol/GTPX-REQUEST-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 05_sources/GTPX-SOURCE-VERIFICATION.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 06_protocol/GTPX-ACK-HASH.gtpx MODIFIED: 2026-04-26 11:00:07 UTC SIZE_BYTES: 2868 ------------------------------------------------------------------------ === META === { "id": "GTPX-ACK-HASH", "title": "GTPX Acknowledgment and Hash Integrity Model", "version": "0.1.1", "status": "draft", "updated": "2026-04-26", "authority": "06_protocol/GTPX-ACK-HASH.gtpx", "type": "protocol_integrity", "project": "GTPX", "depends_on": [ "03_language/GTPX-ENUMS.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how responses are acknowledged and how integrity is validated through hashing. Integrates response delivery constraints to ensure deterministic and auditable outputs.", "ack_policy": { "ack_is_mandatory": true, "ack_values_must_use_gtpx_enums": true, "ack_is_required_for_all_responses": true }, "hash_policy": { "hash_algorithm": "sha256", "hash_is_required_for_atomic_responses": true, "hash_must_be_deterministic": true, "hash_input_must_be_normalized": true, "hash_verification_is_mandatory": true }, "response_integrity_policy": { "ack_requires_complete_response": true, "atomic_response_hash_required": true, "streaming_response_cannot_be_acknowledged_as_complete": true, "incomplete_response_cannot_be_acknowledged": true, "interrupted_stream_results_in": "READ_REJECTED", "response_delivery_status_must_be_complete_for_valid_ack": true }, "hash_input_rules": { "must_include": [ "response_sections", "ordered_structure", "normalized_whitespace" ], "must_exclude": [ "transport_metadata", "stream_chunks", "non_deterministic_tokens" ] }, "ack_behavior": { "READ_COMPLETE": { "conditions": [ "response_delivery_status == complete", "complete == true", "response_mode == atomic", "hash_verified == true" ] }, "READ_REJECTED": { "conditions": [ "response_delivery_status != complete", "complete != true", "response_mode != atomic", "hash_mismatch == true", "response_interrupted == true" ] }, "HASH_MISMATCH": { "conditions": [ "hash_verification_failed == true" ] } } } === RULES === { "ack_must_reflect_delivery_integrity": true, "hash_must_be_computed_before_ack": true, "atomic_response_without_hash_is_invalid": true, "incomplete_response_is_invalid": true, "interrupted_stream_is_invalid": true, "ack_cannot_be_read_complete_for_streaming": true, "ack_cannot_be_read_complete_for_partial_response": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm canonical normalization rules for hashing (line endings, spacing, encoding).", "Confirm whether response_meta is part of hash input.", "Define handling for large responses and chunked processing." ], "next_step": "Integrate delivery enforcement into contract layer." } ------------------------------------------------------------------------ FILE_END PATH: 06_protocol/GTPX-ACK-HASH.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 06_protocol/GTPX-REQUEST-MODEL.gtpx MODIFIED: 2026-04-24 23:25:45 UTC SIZE_BYTES: 2131 ------------------------------------------------------------------------ === META === { "id": "GTPX-REQUEST-MODEL", "title": "GTPX Request Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "06_protocol/GTPX-REQUEST-MODEL.gtpx", "type": "protocol_request", "project": "GTPX", "depends_on": [ "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "05_sources/GTPX-SOURCE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines the canonical structure of a GTPX request.", "request_policy": { "structure_is_mandatory": true, "all_sections_must_exist": true, "missing_section_results_in_blocked": true, "implicit_fields_are_forbidden": true }, "sections": [ "CONTRACT", "AGENT", "PURPOSE", "CONTEXT", "SOURCE_SET", "FILE_SET", "REQUEST", "EXPECTED_OUTPUT", "PAYLOAD_HASH", "END_OF_MESSAGE" ], "section_definitions": { "CONTRACT": "Contains the full GTPX contract controlling behavior.", "AGENT": "Defines which AI model or processing entity is used.", "PURPOSE": "Defines why the request is made.", "CONTEXT": "Provides all necessary background information.", "SOURCE_SET": "Defines allowed and required sources.", "FILE_SET": "Defines attached or referenced files.", "REQUEST": "Defines the exact task to be executed.", "EXPECTED_OUTPUT": "Defines required structure and format of the response.", "PAYLOAD_HASH": "Defines integrity hash of the full request.", "END_OF_MESSAGE": "Marks explicit end of request." } } === RULES === { "section_order_must_follow_syntax": true, "all_sections_are_required": true, "payload_hash_must_match_content": true, "end_of_message_is_mandatory": true, "request_without_contract_is_invalid": true, "request_without_hash_is_invalid": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm whether FILE_SET can be empty or must always exist.", "Confirm whether AGENT must be strictly defined or inferred from contract." ], "next_step": "Create and populate 06_protocol/GTPX-RESPONSE-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 06_protocol/GTPX-REQUEST-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 06_protocol/GTPX-RESPONSE-MODEL.gtpx MODIFIED: 2026-04-26 10:59:20 UTC SIZE_BYTES: 3979 ------------------------------------------------------------------------ === META === { "id": "GTPX-RESPONSE-MODEL", "title": "GTPX Response Model", "version": "0.1.1", "status": "draft", "updated": "2026-04-26", "authority": "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "type": "protocol_response", "project": "GTPX", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "03_language/GTPX-ENUMS.gtpx" ] } === DATA === { "purpose": "Defines the canonical structure of a GTPX response, including response delivery requirements for deterministic and auditable outputs.", "response_policy": { "structure_is_mandatory": true, "all_sections_must_exist": true, "missing_section_results_in_invalid": true, "implicit_output_is_forbidden": true }, "response_delivery_policy": { "default_response_mode": "atomic", "response_mode_must_use_gtpx_enums": true, "response_delivery_status_must_use_gtpx_enums": true, "streaming_allowed_for_system_outputs": false, "atomic_required_for": [ "analysis", "dry_run", "patch", "commit", "audit" ], "partial_response_is_invalid": true, "interrupted_response_must_be_rejected": true, "incomplete_response_policy": "reject" }, "response_delivery_fields": { "required_fields": [ "response_mode", "response_delivery_status", "complete", "response_hash" ], "field_definitions": { "response_mode": "Defines whether the response is delivered as atomic or streaming output.", "response_delivery_status": "Defines whether the delivered response is complete, incomplete, interrupted, invalid, or blocked.", "complete": "Boolean confirmation that the response is fully generated and ready for validation.", "response_hash": "SHA-256 hash of the complete atomic response payload, computed according to GTPX hash normalization rules." } }, "sections": [ "ACK", "STATUS", "SUMMARY", "MISSING_CONTEXT", "ANALYSIS", "RISKS", "PROPOSED_ACTIONS", "PATCH", "DRY_RUN", "NEXT_STEP" ], "section_definitions": { "ACK": "Confirms whether the request has been fully received and read.", "STATUS": "Defines the current processing state (valid, blocked, etc.).", "SUMMARY": "Provides a concise understanding of the request.", "MISSING_CONTEXT": "Lists missing data required for execution.", "ANALYSIS": "Provides structured reasoning output allowed by the contract.", "RISKS": "Lists risks, conflicts, or uncertainties.", "PROPOSED_ACTIONS": "Lists possible actions without committing changes.", "PATCH": "Defines explicit proposed changes.", "DRY_RUN": "Simulates output without committing.", "NEXT_STEP": "Defines the next valid action." } } === RULES === { "section_order_must_follow_syntax": true, "all_sections_are_required": true, "ack_must_be_first": true, "status_must_be_declared": true, "response_must_not_skip_sections": true, "blocked_status_requires_missing_context": true, "invalid_status_requires_error_explanation": true, "response_mode_must_be_declared": true, "response_mode_must_use_gtpx_enums": true, "response_delivery_status_must_be_declared": true, "response_delivery_status_must_use_gtpx_enums": true, "system_outputs_must_use_atomic_response_mode": true, "streaming_response_is_forbidden_for_system_outputs": true, "incomplete_or_interrupted_response_is_invalid": true, "atomic_response_requires_complete_true": true, "atomic_response_requires_response_hash": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if ANALYSIS is always allowed or contract-dependent.", "Confirm if PATCH and DRY_RUN must always be present or conditionally used.", "Define exact response hash target and whether response metadata is included." ], "next_step": "Align GTPX-ACK-HASH with response delivery requirements." } ------------------------------------------------------------------------ FILE_END PATH: 06_protocol/GTPX-RESPONSE-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 07_validation/GTPX-COMPLETENESS.gtpx MODIFIED: 2026-04-24 23:28:43 UTC SIZE_BYTES: 2099 ------------------------------------------------------------------------ === META === { "id": "GTPX-COMPLETENESS", "title": "GTPX Completeness Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "07_validation/GTPX-COMPLETENESS.gtpx", "type": "validation_completeness", "project": "GTPX", "depends_on": [ "07_validation/GTPX-VALIDATION-MODEL.gtpx", "07_validation/GTPX-ERROR-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how completeness is determined for GTPX requests and responses.", "completeness_policy": { "completeness_is_mandatory": true, "incomplete_data_blocks_execution": true, "implicit_completion_is_forbidden": true, "missing_fields_must_be_reported": true }, "completeness_dimensions": [ "structure_completeness", "contract_completeness", "context_completeness", "source_completeness" ], "dimension_definitions": { "structure_completeness": "All required sections and fields are present.", "contract_completeness": "All contract-defined requirements are satisfied.", "context_completeness": "All required contextual information is provided.", "source_completeness": "All required sources are declared and verified." }, "completeness_outcomes": [ "complete", "incomplete", "conditionally_complete" ], "outcome_definitions": { "complete": "All required completeness dimensions satisfied.", "incomplete": "One or more required dimensions missing.", "conditionally_complete": "Execution possible but limited by constraints." } } === RULES === { "all_completeness_dimensions_must_be_checked": true, "incomplete_must_be_reported": true, "incomplete_must_block_if_required_by_contract": true, "conditional_completeness_must_be_explicit": true, "completeness_status_must_be_included_in_response": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if conditionally_complete is allowed under all contracts or restricted.", "Confirm if completeness must always map to validation outcome." ], "next_step": "Proceed to 08_agents/GTPX-AGENT-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 07_validation/GTPX-COMPLETENESS.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 07_validation/GTPX-ERROR-MODEL.gtpx MODIFIED: 2026-04-24 23:28:13 UTC SIZE_BYTES: 2033 ------------------------------------------------------------------------ === META === { "id": "GTPX-ERROR-MODEL", "title": "GTPX Error Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "07_validation/GTPX-ERROR-MODEL.gtpx", "type": "validation_error_model", "project": "GTPX", "depends_on": [ "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] } === DATA === { "purpose": "Defines error types, classification, and handling in GTPX.", "error_policy": { "all_errors_must_be_explicit": true, "silent_errors_are_forbidden": true, "error_must_be_classified": true, "error_must_block_execution_if_critical": true }, "error_types": [ "structure_error", "contract_error", "completeness_error", "source_error", "hash_error" ], "error_definitions": { "structure_error": "Message does not follow required syntax or structure.", "contract_error": "Request violates contract constraints.", "completeness_error": "Required data is missing.", "source_error": "Source is missing, invalid, or unverified.", "hash_error": "Payload hash is invalid or mismatched." }, "error_severity_levels": [ "critical", "non_critical" ], "severity_definitions": { "critical": "Execution must stop immediately.", "non_critical": "Execution may continue but must report the issue." }, "error_handling_rules": [ "critical_errors_must_block_execution", "non_critical_errors_must_be_reported", "errors_must_be_traceable", "errors_must_be_returned_in_response" ] } === RULES === { "error_type_must_be_from_defined_set": true, "error_severity_must_be_defined": true, "error_without_type_is_invalid": true, "error_without_severity_is_invalid": true, "all_errors_must_be_included_in_response": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if additional error types are required.", "Confirm if severity must be numeric or remain categorical." ], "next_step": "Create and populate 07_validation/GTPX-COMPLETENESS.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 07_validation/GTPX-ERROR-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 07_validation/GTPX-HASH-NORMALIZATION.gtpx MODIFIED: 2026-04-25 20:24:07 UTC SIZE_BYTES: 3013 ------------------------------------------------------------------------ === META === { "id": "GTPX-HASH-NORMALIZATION", "title": "GTPX Hash Normalization", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "07_validation/GTPX-HASH-NORMALIZATION.gtpx", "type": "validation_hash_normalization", "project": "GTPX", "depends_on": [ "04_contract/GTPX-PLAN-MODEL.gtpx", "06_protocol/GTPX-ACK-HASH.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] } === DATA === { "purpose": "Defines deterministic normalization rules for hashing GTPX payloads, plans, requests and other canonical JSON structures.", "hash_algorithm": "SHA-256", "normalization_target": [ "canonical_json_payload", "plan_payload", "request_payload", "patch_payload" ], "canonical_json_rules": { "encoding": "UTF-8", "object_keys_sorted": true, "whitespace_ignored": true, "line_endings_normalized": "LF", "trailing_spaces_removed": true, "null_values_preserved": true, "empty_arrays_preserved": true, "empty_objects_preserved": true, "number_format_must_be_canonical": true, "string_values_must_not_be_modified": true }, "hash_input_policy": { "hash_is_computed_after_normalization": true, "hash_target_must_be_explicit": true, "hash_must_not_include_hash_field_itself": true, "metadata_inclusion_must_be_explicit": true, "implicit_payload_transformation_forbidden": true }, "plan_hash_policy": { "plan_hash_target": "payload", "plan_hash_excludes_fields": [ "hash", "created_at", "created_by" ], "plan_hash_includes_parent_version_id": false }, "request_hash_policy": { "request_hash_target": "full_request_without_payload_hash", "payload_hash_field_excluded": true, "end_of_message_included": true }, "patch_hash_policy": { "patch_hash_target": "patch_data", "patch_hash_excludes_fields": [ "hash", "created_at", "applied_at" ] }, "hash_failure_policy": { "hash_mismatch_result": "invalid", "missing_hash_result": "blocked", "unsupported_hash_algorithm_result": "invalid", "non_canonical_payload_result": "invalid" } } === RULES === { "sha256_is_required": true, "canonicalization_must_precede_hashing": true, "hash_field_must_not_hash_itself": true, "same_canonical_payload_must_produce_same_hash": true, "different_canonical_payload_must_produce_different_hash": true, "hash_mismatch_blocks_commit": true, "hash_mismatch_blocks_execution": true, "normalization_rules_must_not_be_implicit": true } === STATUS === { "state": "draft", "open_questions": [ "Define exact canonical number representation", "Define whether Unicode normalization form must be NFC", "Define whether metadata hash profile is needed for document-level hashing" ], "next_step": "Register GTPX-HASH-NORMALIZATION in INDEX and REGISTRY." } ------------------------------------------------------------------------ FILE_END PATH: 07_validation/GTPX-HASH-NORMALIZATION.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 07_validation/GTPX-VALIDATION-MODEL.gtpx MODIFIED: 2026-04-24 23:27:22 UTC SIZE_BYTES: 2166 ------------------------------------------------------------------------ === META === { "id": "GTPX-VALIDATION-MODEL", "title": "GTPX Validation Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "07_validation/GTPX-VALIDATION-MODEL.gtpx", "type": "validation_model", "project": "GTPX", "depends_on": [ "03_language/GTPX-SYNTAX.gtpx", "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how GTPX validates requests and responses before execution and acceptance.", "validation_policy": { "validation_is_mandatory": true, "validation_precedes_execution": true, "failed_validation_blocks_execution": true, "partial_validation_is_forbidden": true }, "validation_layers": [ "structure_validation", "contract_validation", "completeness_validation", "source_validation", "hash_validation" ], "layer_definitions": { "structure_validation": "Checks if the message follows defined syntax and structure.", "contract_validation": "Checks if the request respects the contract constraints.", "completeness_validation": "Checks if all required data is present.", "source_validation": "Checks if sources are declared and verified.", "hash_validation": "Checks if payload integrity is valid." }, "validation_outcomes": [ "valid", "invalid", "blocked" ], "outcome_definitions": { "valid": "All validation layers passed.", "invalid": "At least one validation layer failed.", "blocked": "Validation cannot proceed due to missing data." } } === RULES === { "all_validation_layers_must_be_executed": true, "validation_result_must_be_explicit": true, "invalid_or_blocked_must_stop_execution": true, "validation_must_be_traceable": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if validation order must be strictly enforced or parallelizable.", "Confirm if validation results must include detailed error mapping." ], "next_step": "Create and populate 07_validation/GTPX-ERROR-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 07_validation/GTPX-VALIDATION-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 08_agents/AGENT-PAM.gtpx MODIFIED: 2026-04-24 23:30:11 UTC SIZE_BYTES: 2130 ------------------------------------------------------------------------ === META === { "id": "AGENT-PAM", "title": "GTPX Reference Agent PAM", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "08_agents/AGENT-PAM.gtpx", "type": "agent_reference", "project": "GTPX", "depends_on": [ "08_agents/GTPX-AGENT-MODEL.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx" ] } === DATA === { "purpose": "Defines a reference agent (PAM) that demonstrates correct GTPX-compliant behavior.", "agent_identity": { "name": "PAM", "role": "Planning Application Manager", "description": "A reference agent designed to analyze, structure, validate, and propose actions for project planning tasks." }, "supported_modes": [ "analysis_mode", "dry_run_mode", "proposal_mode" ], "capabilities": [ "analyze_request", "detect_missing_context", "identify_risks", "propose_actions", "simulate_outcome" ], "constraints": [ "must_follow_contract", "must_not_infer_missing_data", "must_not_skip_validation", "must_not_execute_real_changes", "must_only_propose_or_simulate" ], "expected_behavior": { "on_valid_request": "Produces structured response according to response model.", "on_incomplete_request": "Sets STATUS to blocked and fills MISSING_CONTEXT.", "on_invalid_request": "Sets STATUS to invalid and reports errors.", "on_dry_run": "Produces DRY_RUN section without committing.", "on_conflict": "Reports RISKS and does not resolve silently." } } === RULES === { "agent_must_follow_global_agent_model": true, "agent_must_not_override_contract": true, "agent_must_not_modify_input": true, "agent_output_must_follow_response_model": true, "agent_must_respect_validation_and_completeness": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if PAM should be allowed to chain actions across multiple steps.", "Confirm if PAM should support memory in future versions." ], "next_step": "Proceed to 09_runtime/GTPX-RUNTIME-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 08_agents/AGENT-PAM.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 08_agents/GTPX-AGENT-MODEL.gtpx MODIFIED: 2026-04-24 23:29:26 UTC SIZE_BYTES: 2067 ------------------------------------------------------------------------ === META === { "id": "GTPX-AGENT-MODEL", "title": "GTPX Agent Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "08_agents/GTPX-AGENT-MODEL.gtpx", "type": "agent_model", "project": "GTPX", "depends_on": [ "03_language/GTPX-SEMANTICS.gtpx", "04_contract/GTPX-CONTRACT-CORE.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how agents operate, their constraints, and allowed behavior within GTPX.", "agent_policy": { "agents_must_follow_contract": true, "agents_must_not_act_outside_defined_scope": true, "agents_must_not_infer_missing_data": true, "agents_must_respect_validation_outcomes": true }, "agent_definition": "An agent is any processing entity that executes a GTPX request under a defined contract.", "agent_capabilities": [ "read_request", "validate_input", "process_request", "generate_response", "propose_patch", "simulate_dry_run" ], "agent_constraints": [ "must_not_modify_contract", "must_not_generate_undefined_fields", "must_not_use_undeclared_sources", "must_not_continue_if_blocked", "must_not_override_validation" ], "agent_execution_modes": [ "analysis_mode", "dry_run_mode", "proposal_mode" ], "mode_definitions": { "analysis_mode": "Agent analyzes input and produces structured response.", "dry_run_mode": "Agent simulates output without committing changes.", "proposal_mode": "Agent proposes changes without executing them." } } === RULES === { "agent_must_follow_contract": true, "agent_must_follow_validation": true, "agent_must_respect_completeness": true, "agent_actions_must_be_traceable": true, "agent_must_not_have_hidden_behavior": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if execution modes must be explicitly declared in request.", "Confirm if multi-agent workflows are allowed in v1.0." ], "next_step": "Create and populate 08_agents/AGENT-PAM.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 08_agents/GTPX-AGENT-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 09_runtime/GTPX-AUDIT-MODEL.gtpx MODIFIED: 2026-04-24 23:32:40 UTC SIZE_BYTES: 2367 ------------------------------------------------------------------------ === META === { "id": "GTPX-AUDIT-MODEL", "title": "GTPX Audit Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "09_runtime/GTPX-AUDIT-MODEL.gtpx", "type": "runtime_audit", "project": "GTPX", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "09_runtime/GTPX-PATCH-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how all actions, decisions, inputs, and outputs are recorded and traceable in GTPX.", "audit_definition": "Audit is a complete, deterministic, and reconstructible record of the entire execution flow, including input, validation, decisions, processing steps, and output.", "audit_policy": { "audit_is_mandatory": true, "all_steps_must_be_recorded": true, "audit_must_be_reconstructible": true, "audit_must_be_immutable_after_commit": true }, "audit_scope": [ "request_payload", "contract", "validation_results", "selected_agent", "execution_steps", "generated_response", "ack_status", "hash_verification", "patch_operations", "final_state" ], "audit_structure": { "required_fields": [ "audit_id", "timestamp", "request_reference", "validation_summary", "execution_trace", "response_reference", "status", "hash_status" ] }, "field_definitions": { "audit_id": "Unique identifier of the audit record.", "timestamp": "Time of execution.", "request_reference": "Reference to original request.", "validation_summary": "Summary of validation results.", "execution_trace": "Step-by-step execution log.", "response_reference": "Reference to generated response.", "status": "Final execution status.", "hash_status": "Result of hash verification." } } === RULES === { "audit_id_must_be_unique": true, "audit_must_cover_full_execution": true, "audit_must_be_traceable": true, "audit_must_be_readable_and_machine_parsable": true, "audit_must_not_be_modified_after_commit": true, "missing_audit_is_invalid": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm audit storage format (log vs structured DB).", "Confirm retention policy requirements." ], "next_step": "Create and populate 10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 09_runtime/GTPX-AUDIT-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 09_runtime/GTPX-DRY-RUN-MODEL.gtpx MODIFIED: 2026-04-24 23:31:33 UTC SIZE_BYTES: 1839 ------------------------------------------------------------------------ === META === { "id": "GTPX-DRY-RUN-MODEL", "title": "GTPX Dry Run Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "09_runtime/GTPX-DRY-RUN-MODEL.gtpx", "type": "runtime_dry_run", "project": "GTPX", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "08_agents/GTPX-AGENT-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how execution can be simulated without committing changes.", "dry_run_definition": "Dry run is a controlled execution mode where the system simulates processing and produces an output without applying any changes.", "dry_run_policy": { "dry_run_must_not_commit": true, "dry_run_must_follow_full_validation": true, "dry_run_must_produce_full_response": true, "dry_run_must_be_explicitly_declared": true }, "dry_run_behavior": [ "execute_full_flow_without_commit", "simulate_agent_processing", "generate_expected_output", "report_potential_changes", "report_risks" ], "dry_run_outputs": [ "simulated_result", "identified_risks", "proposed_actions", "impact_estimation" ], "dry_run_constraints": [ "must_not_modify_state", "must_not_write_data", "must_not_trigger_external_actions", "must_be_indistinguishable_from_real_execution_except_commit" ] } === RULES === { "dry_run_mode_must_be_declared": true, "dry_run_must_follow_runtime_flow": true, "dry_run_must_not_bypass_validation": true, "dry_run_output_must_follow_response_model": true, "dry_run_must_be_traceable": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm how dry_run is activated (contract vs request flag).", "Confirm if dry_run must always include impact estimation." ], "next_step": "Create and populate 09_runtime/GTPX-PATCH-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 09_runtime/GTPX-DRY-RUN-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 09_runtime/GTPX-PATCH-CANONICAL-MODEL.gtpx MODIFIED: 2026-04-26 10:34:50 UTC SIZE_BYTES: 1428 ------------------------------------------------------------------------ { "meta": { "patch_id": "", "patch_version": "", "change_request_id": "", "created_at": "", "created_by": "", "status": "proposed" }, "context": { "plan_id": "", "plan_version_before": "", "plan_version_after": null, "source_bundle_hash": "" }, "target": { "target_type": "file", "target_path": "", "target_encoding": "UTF-8" }, "operation": { "operation": "replace" }, "match": { "match_type": "exact_string", "search_pattern": "", "expected_match_count": 1, "allow_multiple_matches": false }, "change": { "before_state": "", "after_state": "", "replace_content": "", "position": null }, "validation": { "required_checks": [ "target_exists", "encoding_valid", "match_count_valid", "operation_valid", "result_hash_valid" ], "fail_policy": "fail_closed" }, "dry_run": { "dry_run_required": true, "dry_run_status": null, "diff_required": true, "risk_level": null }, "commit": { "commit_allowed": false, "requires_passed_dry_run": true, "backup_required": true, "before_hash": null, "after_hash": null, "backup_path": null }, "audit": { "audit_required": true, "audit_id": null, "audit_path": null, "executor": null, "result": null } } ------------------------------------------------------------------------ FILE_END PATH: 09_runtime/GTPX-PATCH-CANONICAL-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 09_runtime/GTPX-PATCH-MODEL.gtpx MODIFIED: 2026-04-26 10:37:22 UTC SIZE_BYTES: 5231 ------------------------------------------------------------------------ === META === { "id": "GTPX-PATCH-MODEL", "title": "GTPX Patch Model", "version": "0.2.0", "status": "draft", "updated": "2026-04-26", "authority": "09_runtime/GTPX-PATCH-MODEL.gtpx", "type": "runtime_patch", "project": "GTPX", "depends_on": [ "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "09_runtime/GTPX-DRY-RUN-MODEL.gtpx", "07_validation/GTPX-HASH-NORMALIZATION.gtpx" ] } === DATA === { "purpose": "Defines how changes are proposed, validated, and applied in GTPX, including a canonical executable patch structure.", "patch_definition": "A patch is an explicit, structured, deterministic, and validated modification to an existing state, document, or execution context.", "patch_policy": { "patch_must_be_explicit": true, "patch_must_be_structured": true, "patch_must_be_deterministic": true, "patch_must_be_validated_before_commit": true, "implicit_changes_are_forbidden": true }, "patch_lifecycle": [ "propose_patch", "validate_patch", "dry_run_patch", "approve_patch", "commit_patch" ], "lifecycle_definitions": { "propose_patch": "Defines a structured change proposal.", "validate_patch": "Ensures patch follows contract and validation rules.", "dry_run_patch": "Simulates the effect of the patch.", "approve_patch": "Confirms patch is accepted for application.", "commit_patch": "Applies the patch as a real change." }, "patch_structure": { "required_fields": [ "patch_id", "target", "change_type", "before_state", "after_state", "justification" ] }, "field_definitions": { "patch_id": "Unique identifier of the patch.", "target": "Defines what is being changed.", "change_type": "Defines type of change (add, modify, remove).", "before_state": "Defines current state.", "after_state": "Defines new state.", "justification": "Explains why the change is needed." }, "canonical_patch_object": { "description": "Defines the executable canonical patch format used by runtime systems such as Synarch and Patch Manager.", "structure": { "meta": { "patch_id": "string", "patch_version": "string", "change_request_id": "string", "created_at": "timestamp", "created_by": "string", "status": "patch_status" }, "context": { "plan_id": "string", "plan_version_before": "string", "plan_version_after": "string|null", "source_bundle_hash": "string" }, "target": { "target_type": "string", "target_path": "string", "target_encoding": "UTF-8" }, "operation": { "operation": "replace|insert_before|insert_after|append|prepend|create_file|delete_file|rename_file" }, "match": { "match_type": "exact_string|regex|line_number|file_exists", "search_pattern": "string", "expected_match_count": "number", "allow_multiple_matches": "boolean" }, "change": { "before_state": "string", "after_state": "string", "replace_content": "string", "position": "number|null" }, "validation": { "required_checks": [ "target_exists", "encoding_valid", "match_count_valid", "operation_valid", "result_hash_valid" ], "fail_policy": "fail_closed" }, "dry_run": { "dry_run_required": "boolean", "dry_run_status": "validation_outcomes|null", "diff_required": "boolean", "risk_level": "low|medium|high|null" }, "commit": { "commit_allowed": "boolean", "requires_passed_dry_run": "boolean", "backup_required": "boolean", "before_hash": "string|null", "after_hash": "string|null", "backup_path": "string|null" }, "audit": { "audit_required": "boolean", "audit_id": "string|null", "audit_path": "string|null", "executor": "string|null", "result": "string|null" } } }, "execution_requirements": [ "patch_execution_must_be_deterministic", "same_input_must_produce_same_output", "match_result_must_be_unique_unless_explicitly_allowed", "dry_run_must_precede_commit", "commit_requires_backup", "all_changes_must_be_audited" ] } === RULES === { "patch_id_must_be_unique": true, "patch_must_define_before_and_after": true, "patch_must_be_validated": true, "patch_must_support_dry_run": true, "patch_without_justification_is_invalid": true, "patch_must_be_traceable": true, "canonical_patch_object_is_authoritative_for_execution": true, "legacy_patch_structure_is_allowed_for_compatibility": true, "execution_must_follow_canonical_patch_object": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if patch approval must be human-only or can be automated.", "Confirm if batch patches are allowed.", "Define risk_level enum in GTPX-ENUMS", "Define execution error mapping" ], "next_step": "Align Patch Manager PRQ with canonical_patch_object and remove local patch spec duplication." } ------------------------------------------------------------------------ FILE_END PATH: 09_runtime/GTPX-PATCH-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 09_runtime/GTPX-RUNTIME-MODEL.gtpx MODIFIED: 2026-04-26 11:01:53 UTC SIZE_BYTES: 3696 ------------------------------------------------------------------------ === META === { "id": "GTPX-RUNTIME-MODEL", "title": "GTPX Runtime Model", "version": "0.1.1", "status": "draft", "updated": "2026-04-26", "authority": "09_runtime/GTPX-RUNTIME-MODEL.gtpx", "type": "runtime_model", "project": "GTPX", "depends_on": [ "04_contract/GTPX-CONTRACT-CORE.gtpx", "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "06_protocol/GTPX-ACK-HASH.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "08_agents/GTPX-AGENT-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how GTPX execution is orchestrated from request to response, including response delivery validation before final output.", "runtime_definition": "Runtime is the execution layer that enforces contract, validation, agent processing, response generation, response delivery validation, and deterministic finalization.", "execution_flow": [ "receive_request", "verify_ack_and_hash", "validate_structure", "validate_contract", "validate_completeness", "validate_sources", "select_agent", "execute_agent", "generate_response", "validate_response_delivery", "attach_ack", "finalize_output" ], "step_definitions": { "receive_request": "Runtime receives structured request.", "verify_ack_and_hash": "Checks payload integrity and completeness.", "validate_structure": "Ensures syntax is correct.", "validate_contract": "Ensures contract constraints are respected.", "validate_completeness": "Ensures all required data exists.", "validate_sources": "Ensures sources are declared and verified.", "select_agent": "Chooses appropriate agent based on contract.", "execute_agent": "Agent processes request within constraints.", "generate_response": "Agent produces structured output.", "validate_response_delivery": "Ensures generated response uses allowed response_mode, has complete delivery status, and contains required response hash before ACK and finalization.", "attach_ack": "Adds ACK confirmation and validation result.", "finalize_output": "Returns final deterministic response." }, "response_delivery_runtime_policy": { "validation_step_required": true, "validation_step_position": "after_generate_response_before_attach_ack", "default_response_mode": "atomic", "system_outputs_require_atomic": true, "complete_status_required": true, "response_hash_required": true, "streaming_system_output_must_be_blocked": true, "interrupted_or_incomplete_response_must_be_invalid": true }, "runtime_constraints": [ "must_follow_execution_order", "must_not_skip_validation_steps", "must_not_modify_request_payload", "must_not_allow_execution_if_blocked", "must_be_deterministic", "must_validate_response_delivery_before_ack", "must_not_finalize_incomplete_response" ] } === RULES === { "execution_flow_is_mandatory": true, "step_order_must_not_change": true, "validation_must_precede_execution": true, "response_delivery_validation_must_precede_ack": true, "runtime_must_be_traceable": true, "runtime_must_not_have_hidden_steps": true, "atomic_response_is_required_for_system_outputs": true, "incomplete_response_must_not_be_finalized": true, "streaming_response_must_not_be_finalized_for_system_outputs": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if execution flow can be parallelized in future versions.", "Confirm if multiple agents per request are allowed.", "Define exact response delivery validation result structure." ], "next_step": "Align DEV Manager PRQ with response delivery enforcement." } ------------------------------------------------------------------------ FILE_END PATH: 09_runtime/GTPX-RUNTIME-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx MODIFIED: 2026-04-24 23:33:12 UTC SIZE_BYTES: 2719 ------------------------------------------------------------------------ === META === { "id": "EXAMPLE-WMS-PARCEL-NUMBER", "title": "Example - Parcel Number Validation", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx", "type": "example", "project": "GTPX", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "09_runtime/GTPX-RUNTIME-MODEL.gtpx" ] } === DATA === { "purpose": "Demonstrates a full GTPX request-response cycle for validating a parcel number.", "request_example": { "CONTRACT": { "meta_ugovora": { "contract_id": "C-001", "contract_version": "1.0.0", "contract_purpose": "Validate parcel number format" }, "obavezni_sadrzaj": { "allowed_actors": ["AI Model"], "allowed_sources": ["USER_PROVIDED"], "required_structure": "GTPX request model", "required_validation": "full", "required_output_format": "GTPX response model" }, "dodatni_sadrzaj": {}, "ogranicenja_komunikacije": { "forbidden_actions": ["data_inference"], "fail_policy": "fail_closed", "max_scope": "single_validation", "allowed_operations": ["validate"] } }, "AGENT": "PAM", "PURPOSE": "Validate parcel number", "CONTEXT": { "country": "HR" }, "SOURCE_SET": [ { "source_id": "S1", "source_type": "USER_PROVIDED", "authority_level": "low", "freshness_required": false, "citation_required": false, "allowed_usage": "validation_only" } ], "FILE_SET": [], "REQUEST": { "parcel_number": "123-ABC-456" }, "EXPECTED_OUTPUT": "validation_result", "PAYLOAD_HASH": "abc123", "END_OF_MESSAGE": true }, "response_example": { "ACK": "READ_COMPLETE", "STATUS": "valid", "SUMMARY": "Parcel number format validated.", "MISSING_CONTEXT": [], "ANALYSIS": { "format_check": "passed", "structure_check": "passed" }, "RISKS": [], "PROPOSED_ACTIONS": [ "accept_parcel_number" ], "PATCH": null, "DRY_RUN": null, "NEXT_STEP": "store_parcel_number" } } === RULES === { "example_must_follow_full_standard": true, "example_must_be_traceable": true, "example_must_be_validatable": true, "example_must_not_skip_sections": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if hash value must be realistic in examples.", "Confirm if multiple examples are required for v1.0." ], "next_step": "Create and populate 99_reports/STATUS.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 10_examples/EXAMPLE-WMS-PARCEL-NUMBER.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx MODIFIED: 2026-04-25 09:18:11 UTC SIZE_BYTES: 2407 ------------------------------------------------------------------------ === META === { "id": "GTPX-ANALYSIS-REPORT-MODEL", "title": "GTPX Analysis Report Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx", "type": "analysis_model", "project": "GTPX", "depends_on": [ "11_workflow/GTPX-WORKFLOW-MODEL.gtpx" ] } === DATA === { "purpose": "Defines a structured format for analyzing GTPX standard, modules, or runtime components.", "analysis_scope": [ "standard", "module", "runtime", "document", "input", "output" ], "analysis_structure": { "required_fields": [ "analysis_id", "target", "timestamp", "summary", "findings", "errors", "warnings", "risks", "recommendations", "next_step" ] }, "field_definitions": { "analysis_id": "Unique identifier of the analysis.", "target": "What is being analyzed (file, module, runtime, request, etc.).", "timestamp": "Time of analysis.", "summary": "Short description of current state.", "findings": "Neutral observations about the system.", "errors": "Critical problems that break expected behavior.", "warnings": "Non-critical issues or missing elements.", "risks": "Potential future problems or uncertainties.", "recommendations": "Suggested improvements or fixes.", "next_step": "Immediate next action to take." }, "error_types": [ "missing_data", "invalid_structure", "invalid_logic", "conflict", "undefined_behavior" ], "risk_types": [ "incomplete_definition", "future_incompatibility", "runtime_failure", "user_misinterpretation" ], "analysis_rules": [ "analysis_must_not_modify_target", "analysis_must_be_explicit", "analysis_must_separate_facts_from_opinions", "analysis_must_not_infer_missing_data", "analysis_must_be_reproducible" ] } === RULES === { "all_required_fields_must_be_present": true, "errors_must_be_explicit": true, "warnings_must_not_be_confused_with_errors": true, "recommendations_must_be_actionable": true, "analysis_must_be_traceable": true } === STATUS === { "state": "draft", "open_questions": [ "Define severity scoring system.", "Define machine-readable output format (JSON export)." ], "next_step": "Create first real analysis report for offgrid module." } ------------------------------------------------------------------------ FILE_END PATH: 11_workflow/GTPX-ANALYSIS-REPORT-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 11_workflow/GTPX-WORKFLOW-MODEL.gtpx MODIFIED: 2026-04-25 09:16:08 UTC SIZE_BYTES: 5054 ------------------------------------------------------------------------ === META === { "id": "GTPX-WORKFLOW-MODEL", "title": "GTPX Workflow Model", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "11_workflow/GTPX-WORKFLOW-MODEL.gtpx", "type": "workflow_model", "project": "GTPX", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx", "09_runtime/GTPX-PATCH-MODEL.gtpx", "09_runtime/GTPX-AUDIT-MODEL.gtpx" ] } === DATA === { "purpose": "Defines how the GTPX Standard is analyzed, reviewed, improved, versioned, published, and communicated to AI systems.", "workflow_scope": [ "standard_analysis", "improvement_proposal", "patch_review", "patch_dry_run", "patch_acceptance", "version_release", "open_source_publication", "ai_contract_communication" ], "core_workflow": [ "READ", "ANALYZE", "REPORT", "PROPOSE_PATCH", "REVIEW_PATCH", "DRY_RUN_PATCH", "ACCEPT_OR_REJECT", "COMMIT_VERSION", "PUBLISH", "AUDIT" ], "step_definitions": { "READ": "Load all registered GTPX documents according to INDEX and REGISTRY.", "ANALYZE": "Check structure, dependencies, consistency, terms, enums, conflicts, and missing definitions.", "REPORT": "Produce a structured analysis report with findings, risks, and recommended actions.", "PROPOSE_PATCH": "Create an explicit patch proposal with before, after, target, reason, and impact.", "REVIEW_PATCH": "Review whether the patch is valid, necessary, compatible, and non-conflicting.", "DRY_RUN_PATCH": "Simulate the effect of the patch without modifying the authoritative standard.", "ACCEPT_OR_REJECT": "Maintainer or authorized process approves or rejects the patch.", "COMMIT_VERSION": "Apply accepted patch and increment version according to versioning rules.", "PUBLISH": "Publish the updated standard in the public repository or canonical location.", "AUDIT": "Record the full change process, decision, version, and affected documents." }, "analysis_requirements": { "must_check_registered_documents_exist": true, "must_check_unregistered_documents": true, "must_check_meta_blocks": true, "must_check_required_sections": true, "must_check_dependency_chain": true, "must_check_dictionary_terms": true, "must_check_enum_values": true, "must_check_conflicting_rules": true, "must_report_open_questions": true }, "patch_requirements": { "patch_must_have_id": true, "patch_must_have_target": true, "patch_must_have_reason": true, "patch_must_have_before_state": true, "patch_must_have_after_state": true, "patch_must_have_impact_analysis": true, "patch_must_have_acceptance_criteria": true }, "versioning_policy": { "major": "Breaking change to syntax, contract, validation, or execution behavior.", "minor": "Backward-compatible functional extension.", "patch": "Clarification, typo correction, documentation improvement, or non-breaking fix." }, "open_source_policy": { "repository_structure": [ "spec/", "examples/", "tools/", "modules/", "runtime/", "docs/" ], "change_request_model": "Each proposed change must be submitted as a patch or pull request.", "review_model": "Each change must pass analysis, review, dry-run, and maintainer acceptance before merge.", "release_model": "Each accepted release must have a version tag, changelog, and audit record." }, "ai_contract_communication": { "manual_mode": { "description": "Human sends CONTRACT, REQUEST, EXPECTED_OUTPUT, and constraints directly to ChatGPT or another AI model.", "risk": "AI may not enforce GTPX unless instructed and checked by the human." }, "runtime_mode": { "description": "Human sends request to Synarch or another GTPX runtime, which validates, enforces contract, calls AI, checks response, and returns structured output.", "preferred": true } }, "minimum_ai_prompt_contract": { "required_blocks": [ "CONTRACT", "TASK", "CONTEXT", "SOURCES", "RULES", "EXPECTED_OUTPUT", "FAIL_POLICY" ], "fail_policy": "If required information is missing, respond with BLOCKED and list missing information." } } === RULES === { "standard_must_not_be_changed_without_patch": true, "patch_must_not_be_committed_without_review": true, "patch_must_not_be_committed_without_dry_run": true, "accepted_patch_requires_version_update": true, "published_release_requires_audit_record": true, "ai_contract_must_be_explicit": true, "runtime_mode_is_preferred_for_enforcement": true } === STATUS === { "state": "draft", "open_questions": [ "Define exact analyzer output format.", "Define exact patch document format.", "Define maintainer approval policy.", "Define public repository license.", "Define minimum ChatGPT-compatible prompt template." ], "next_step": "Create GTPX-ANALYSIS-REPORT-MODEL.gtpx and GTPX-PATCH-PROPOSAL-MODEL.gtpx." } ------------------------------------------------------------------------ FILE_END PATH: 11_workflow/GTPX-WORKFLOW-MODEL.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 99_reports/STATUS.gtpx MODIFIED: 2026-04-25 19:57:05 UTC SIZE_BYTES: 2031 ------------------------------------------------------------------------ === META === { "id": "GTPX-STATUS", "title": "GTPX Standard Status Report", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "99_reports/STATUS.gtpx", "type": "status_report", "project": "GTPX", "depends_on": [ "00_meta/INDEX.gtpx", "00_meta/REGISTRY.gtpx" ] } === DATA === { "purpose": "Defines the current real state of the GTPX Standard during stabilization phase.", "standard_version": "0.1.0", "global_state": "draft", "completion_status": { "meta_layer": "defined", "foundation_layer": "defined", "prq_layer": "defined", "language_layer": "defined", "contract_layer": "defined", "sources_layer": "defined", "protocol_layer": "defined", "validation_layer": "defined", "agents_layer": "defined", "runtime_layer": "defined", "examples_layer": "defined" }, "stability_assessment": { "structural_consistency": "partial", "document_alignment": "incomplete", "enum_consistency": "inconsistent", "runtime_readiness": "not_ready", "production_readiness": "blocked" }, "known_conflicts": [ "GTPX-LOCK version mismatch", "INDEX and REGISTRY mismatch", "multiple status models", "plan vs database source-of-truth ambiguity" ], "known_gaps": [ "no canonical plan model", "no AVHS template set", "no unified enum model", "no defined hash algorithm", "no source scoring model" ], "next_steps": [ "fix_registry_alignment", "unify_status_and_enums", "define_plan_model", "define_avhs_templates", "define_patch_format" ] } === RULES === { "status_must_reflect_real_state": true, "no_false_stability_allowed": true, "all_conflicts_must_be_listed": true, "all_gaps_must_be_explicit": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm stabilization checklist completeness", "Define criteria for transition to review phase" ], "next_step": "Proceed to INDEX ↔ REGISTRY synchronization." } ------------------------------------------------------------------------ FILE_END PATH: 99_reports/STATUS.gtpx ------------------------------------------------------------------------ ------------------------------------------------------------------------ FILE_BEGIN SOURCE: GTPX_STANDARD PATH: 99_reports/TEST-REPORT-001.gtpx MODIFIED: 2026-04-24 23:35:43 UTC SIZE_BYTES: 2677 ------------------------------------------------------------------------ === META === { "id": "GTPX-TEST-REPORT-001", "title": "GTPX Test Report 001", "version": "0.1.0", "status": "draft", "updated": "2026-04-25", "authority": "99_reports/TEST-REPORT-001.gtpx", "type": "test_report", "project": "GTPX", "depends_on": [ "06_protocol/GTPX-REQUEST-MODEL.gtpx", "06_protocol/GTPX-RESPONSE-MODEL.gtpx", "07_validation/GTPX-VALIDATION-MODEL.gtpx", "09_runtime/GTPX-RUNTIME-MODEL.gtpx" ] } === DATA === { "purpose": "Defines results of initial GTPX full system dry-run tests.", "test_suite": "GTPX_CORE_FLOW", "tests": [ { "test_id": "TEST-001", "name": "Valid Request", "input_condition": "All required fields present and valid", "expected_result": "valid", "actual_result": "valid", "status": "pass" }, { "test_id": "TEST-002", "name": "Missing Context", "input_condition": "CONTEXT section missing", "expected_result": "blocked", "actual_result": "blocked", "status": "pass" }, { "test_id": "TEST-003", "name": "Hash Mismatch", "input_condition": "Invalid PAYLOAD_HASH", "expected_result": "invalid", "actual_result": "invalid", "status": "pass" }, { "test_id": "TEST-004", "name": "Undeclared Source", "input_condition": "Source used but not declared", "expected_result": "invalid", "actual_result": "invalid", "status": "pass" }, { "test_id": "TEST-005", "name": "Unauthorized Patch", "input_condition": "PATCH proposed without permission", "expected_result": "invalid", "actual_result": "invalid", "status": "pass" } ], "summary": { "total_tests": 5, "passed": 5, "failed": 0, "blocked": 0 }, "observations": [ "Core execution flow is deterministic.", "Validation correctly blocks invalid inputs.", "Contract enforcement prevents unauthorized actions.", "Hash validation correctly detects mismatch." ], "identified_gaps": [ "Hash algorithm not formally defined.", "Authority level scale not defined.", "Source scoring not defined.", "Error-to-status mapping needs formal specification." ] } === RULES === { "all_tests_must_be_defined": true, "expected_and_actual_results_must_match": true, "test_status_must_be_explicit": true, "gaps_must_be_reported": true } === STATUS === { "state": "draft", "open_questions": [ "Confirm if additional stress tests are required.", "Confirm if multi-agent tests should be added." ], "next_step": "Define missing core parameters before v1.0 stabilization." } ------------------------------------------------------------------------ FILE_END PATH: 99_reports/TEST-REPORT-001.gtpx ------------------------------------------------------------------------ ======================================================================== BUNDLE_LOAD_CONFIRMATION ======================================================================== The complete bundle has been generated. The receiving AI must confirm whether it has read all sections from BUNDLE_START to END_OF_BUNDLE. If any section is missing, truncated, inconsistent, or unreadable, the response must be BLOCKED. Expected analysis target: - Review PRQ documents - Compare PRQ documents with GTPX definitions - Identify gaps, conflicts, missing models, and next steps - Do not propose implementation until PRQ and architecture are stable ======================================================================== END_OF_BUNDLE ========================================================================