configuration/algorithm/data/code.validation.data.json
configuration/algorithm/data/code.validation.data.json is a file in GovLab Context. 804 lines of code and 0 definitions.
{
"category": "codebase-verification",
"tier": "process",
"check": {
"by": ["the authoritative verification suite, whose output is the only completion signal"],
"population": "every file the suite checks",
"freshness": "a verdict stands until the code changes or a fix is applied",
"refusal": "the loop reports no completion until the suite passes, and stops at its iteration bound with the residue reported",
"observation": "none: compliance is decided on the suite's output",
"evidence": "none: the catalog states this check as a class, so a watched run belongs to each system that adopts it",
"authority": "the suite's output, which a completion claim cites"
},
"records": [
{
"id": "verification-loop",
"stage": "verify",
"axis": "verification",
"mathType": "dynamical-systems",
"yields": "boolean | counter",
"title": "Verification Loop",
"exemplar": {
"before": "A one-shot fix attempt, unverified — some violations remain, and neither the developer nor the model notices.",
"after": "init → verify → classify failures → fix → re-verify → repeat until pass or iteration limit",
"lang": "flow",
"medium": "composite"
},
"intent": "Initialize verification context, execute the verification suite, classify failures, remediate violations, and repeat until pass or iteration limit.",
"invariant": "Architectural compliance is achieved through bounded verify-classify-fix cycles, not one-shot remediation.",
"flow": [
"Init",
"Verify",
"Classify",
"Fix",
"Reverify",
"Pass|Limit"
],
"productions": [
{
"lhs": "VerificationLoop",
"rhs": "<Initialization> \"→\" <VerificationRun> \"→\" (<PassReport> | <ViolationClassification> \"→\" <RemediationCycle> \"→\" <VerificationLoop>)"
},
{"lhs": "LoopExit",
"rhs": "\"passed\" | \"max_iterations_reached\""}
],
"composes": ["violation-classification"],
"force": ["correctness_verification"]
},
{
"id": "context-initialization",
"stage": "orient",
"axis": "ontology",
"mathType": "set-theory",
"yields": "set | boolean",
"title": "Context Initialization",
"exemplar": {
"before": "Failures interpreted with no known rule context, so fixes miss the point.",
"after": "discover architecture docs + design guidance → init result containers + iteration counter + max attempts",
"lang": "flow",
"medium": "composite"
},
"intent": "Discover architecture documents, load design guidance, initialize result containers, set iteration counters, and define maximum remediation attempts.",
"invariant": "Verification requires a known rule context before failures can be interpreted.",
"flow": [
"DiscoverRules",
"LoadGuidance",
"InitializeState",
"SetBounds"
],
"productions": [
{
"lhs": "ContextInitialization",
"rhs": "<RuleDiscovery> \"→\" <GuidanceLoad> \"→\" <VerificationState> \"→\" <IterationBound>"
},
{
"lhs": "VerificationState",
"rhs": "\"verification_results\" \",\" \"iteration_count\" \",\" \"max_iterations\""
}
],
"composes": ["iteration-bound"],
"force": [
"runtime_extensibility",
"correctness_verification"
]
},
{
"id": "verification-execution",
"stage": "verify",
"axis": "verification",
"mathType": "logic",
"yields": "boolean",
"grounds": ["reasoning:ver-evidence"],
"title": "Verification Execution",
"exemplar": {
"before": "Compliance asserted from confidence, not from the verifier's output.",
"after": "run verification suite → capture raw output → parse errors + warnings → pass = errors.length == 0",
"lang": "flow",
"medium": "composite"
},
"intent": "Run the configured verification procedure, capture raw output, parse errors and warnings, and derive pass status from zero-error condition.",
"invariant": "Compliance status must be based on executable verification output, not inferred confidence.",
"flow": [
"ExecuteSuite",
"CaptureOutput",
"ParseErrors",
"ParseWarnings",
"PassBoolean"
],
"productions": [
{
"lhs": "VerificationExecution",
"rhs": "<VerificationCommand> \"→\" <RawOutput> \"→\" <ParsedResult>"
},
{"lhs": "ParsedResult",
"rhs": "<ErrorSet> \",\" <WarningSet> \",\" <PassStatus>"},
{"lhs": "PassStatus",
"rhs": "\"errors.length == 0\""}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "early-success-exit",
"stage": "terminate",
"axis": "termination",
"mathType": "set-theory",
"yields": "set | boolean",
"title": "Early Success Exit",
"exemplar": {
"before": "A clean verification result still triggers unnecessary remediation.",
"after": "parsed result → is pass? → report zero-violations success and terminate, no mutation",
"lang": "flow",
"medium": "composite"
},
"intent": "If verification has no errors, report successful compliance and terminate without remediation.",
"invariant": "A clean verification result is terminal and must not trigger unnecessary mutation.",
"flow": [
"VerificationResult",
"IsPass?",
"ReportSuccess|Continue"
],
"productions": [
{"lhs": "EarlyExit",
"rhs": "<ParsedResult> \"→\" <PassCheck> \"→\" <SuccessReport>"},
{"lhs": "PassCheck",
"rhs": "\"true\" | \"false\""},
{"lhs": "SuccessReport",
"rhs": "\"zero_violations\""}
],
"composes": [],
"force": [
"state_transaction",
"correctness_verification"
]
},
{
"id": "violation-classification",
"stage": "derive",
"axis": "reasoning",
"mathType": "logic",
"yields": "boolean",
"title": "Violation Classification",
"exemplar": {
"before": "Errors fixed by ad hoc text editing, not by their semantics.",
"after": "each error → category{file_limit | import | naming | base_class | css_token | dom_factory | console | lifecycle} → matching strategy",
"lang": "flow",
"medium": "composite"
},
"intent": "For each verification error, classify the violation into a known remediation category and attach the matching strategy.",
"invariant": "Fixes must be selected by violation semantics, not by ad hoc text editing.",
"flow": [
"Error",
"Category",
"Strategy"
],
"productions": [
{"lhs": "ViolationClassification",
"rhs": "<ErrorSet> \"→\" <CategorizedViolationSet>"},
{
"lhs": "Category",
"rhs": "\"file_limit\" | \"import_pattern\" | \"naming\" | \"base_class\" | \"css_token\" | \"dom_factory\" | \"console\" | \"lifecycle\" | \"unknown\""
},
{"lhs": "CategorizedViolation",
"rhs": "<Error> \",\" <Category> \",\" <RemediationStrategy>"}
],
"composes": [],
"force": [
"semantic_consistency",
"correctness_verification"
]
},
{
"id": "severity-ordered-remediation",
"stage": "intent",
"axis": "teleology",
"mathType": "optimization",
"yields": "boolean | ranking",
"grounds": ["reasoning:tel-priority"],
"title": "Severity-Ordered Remediation",
"exemplar": {
"before": "A cosmetic warning fixed before a structural blocker.",
"after": "classified violations → group by category → order by severity → fix highest architectural risk first",
"lang": "flow",
"medium": "composite"
},
"intent": "Group classified violations by category, order groups by severity, and apply fixes from highest architectural risk to lowest.",
"invariant": "Remediation should resolve structural blockers before cosmetic or secondary violations.",
"flow": [
"CategorizedViolations",
"SeveritySort",
"OrderedFixQueue"
],
"productions": [
{
"lhs": "SeverityOrdering",
"rhs": "<ViolationCategorySet> \"→\" <SeverityRank> \"→\" <OrderedViolationQueue>"
},
{"lhs": "SeverityRank",
"rhs": "\"critical\" | \"high\" | \"medium\" | \"low\""}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "iteration-bound",
"stage": "terminate",
"axis": "termination",
"mathType": "dynamical-systems",
"yields": "boolean | counter",
"grounds": ["reasoning:ter-stop"],
"title": "Iteration Bound",
"exemplar": {
"before": "Automated remediation loops forever on an unfixable violation.",
"after": "increment iteration → compare to max → {continue | stop, manual review required}",
"lang": "flow",
"medium": "composite"
},
"intent": "Increment iteration count before remediation, compare it to the maximum allowed attempts, and stop with partial success when the bound is exceeded.",
"invariant": "Automated remediation must be bounded to avoid infinite repair loops.",
"flow": [
"Increment",
"CompareLimit",
"Continue|PartialExit"
],
"productions": [
{
"lhs": "IterationBound",
"rhs": "<IterationCount> \"→\" <Increment> \"→\" <LimitCheck> \"→\" <LoopDecision>"
},
{"lhs": "LoopDecision",
"rhs": "\"continue_remediation\" | \"stop_manual_review_required\""}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "file-scoped-fix",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "File-Scoped Fix",
"exemplar": {
"before": "A fix edits broadly, breaking things the verifier didn't flag.",
"after": "violation → read file → analyze → transform per design guidance → write updated content",
"lang": "flow",
"medium": "composite"
},
"intent": "Read the violating file, analyze the violation type, transform content according to design guidance, write the updated content, and preserve compatibility with verification rules.",
"invariant": "Each fix is a localized transformation constrained by architectural guidance.",
"flow": [
"ReadFile",
"AnalyzeViolation",
"Transform",
"WriteFile"
],
"productions": [
{
"lhs": "FileScopedFix",
"rhs": "<Violation> \"→\" <FileRead> \"→\" <ViolationAnalysis> \"→\" <DesignGuidedTransformation> \"→\" <FileWrite>"
},
{
"lhs": "DesignGuidedTransformation",
"rhs": "<CurrentContent> \",\" <ViolationType> \",\" <DesignGuide> \"→\" <UpdatedContent>"
}
],
"composes": [],
"force": [
"contract_compatibility",
"correctness_verification"
]
},
{
"id": "file-limit-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "File Limit Remediation",
"exemplar": {
"before": "An oversized file trimmed by deleting code instead of splitting responsibility.",
"after": "oversized file → split responsibilities into compliant artifacts → preserve imports/exports → rewire references → size <= limit",
"lang": "flow",
"medium": "composite"
},
"intent": "When a file exceeds the allowed size, split responsibilities into smaller compliant artifacts, preserve imports and exports, and rewire references.",
"invariant": "Size violations usually indicate excessive responsibility concentration.",
"flow": [
"OversizedFile",
"ResponsibilitySplit",
"NewArtifacts",
"ReferenceUpdate",
"SizeCheck"
],
"productions": [
{
"lhs": "FileLimitFix",
"rhs": "<OversizedArtifact> \"→\" <ResponsibilityPartition> \"→\" <ArtifactSplit> \"→\" <ReferenceRewrite> \"→\" <LineLimitValidation>"
},
{"lhs": "LineLimitValidation",
"rhs": "\"line_count <= configured_limit\""}
],
"composes": [],
"force": [
"modularity",
"correctness_verification"
]
},
{
"id": "import-boundary-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Import Boundary Remediation",
"exemplar": {
"before": "A cross-boundary import error silenced without restoring the boundary.",
"after": "invalid import → boundary rule{same-module | shared | adapter} → approved path → rewrite → verify dependency direction",
"lang": "flow",
"medium": "composite"
},
"intent": "Detect invalid cross-boundary imports, locate the approved dependency path or shared abstraction, rewrite imports, and verify dependency direction.",
"invariant": "Import fixes must restore architectural boundaries rather than merely silence errors.",
"flow": [
"InvalidImport",
"BoundaryRule",
"ApprovedPath",
"RewriteImport",
"DependencyCheck"
],
"productions": [
{
"lhs": "ImportBoundaryFix",
"rhs": "<ImportViolation> \"→\" <BoundaryPolicy> \"→\" <AllowedReference> \"→\" <ImportRewrite> \"→\" <DependencyValidation>"
},
{
"lhs": "BoundaryPolicy",
"rhs": "\"same_module_only\" | \"shared_boundary_required\" | \"adapter_boundary_required\""
}
],
"composes": [],
"force": [
"modularity",
"correctness_verification"
]
},
{
"id": "naming-convention-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Naming Convention Remediation",
"exemplar": {
"before": "A file renamed but its references left dangling.",
"after": "invalid name → naming rule → compliant identifier → rename → update all references (identity migration)",
"lang": "flow",
"medium": "composite"
},
"intent": "Compare file, folder, class, or symbol names against naming rules, derive compliant names, rename artifacts, and update all references.",
"invariant": "Naming remediation requires identity migration, not isolated renaming.",
"flow": [
"InvalidName",
"NamingRule",
"NewName",
"Rename",
"ReferenceUpdate"
],
"productions": [
{
"lhs": "NamingFix",
"rhs": "<NamingViolation> \"→\" <NamingConvention> \"→\" <CompliantIdentifier> \"→\" <RenameOperation> \"→\" <ReferenceConsistencyCheck>"
}
],
"composes": [],
"force": [
"correctness_verification",
"architecture_evolution"
]
},
{
"id": "base-class-compliance-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Base-Class Compliance Remediation",
"exemplar": {
"before": "A class missing its required base 'fixed' by silencing the rule.",
"after": "class role → expected base → refactor inheritance/composition → migrate duplicated lifecycle into hooks → verify behavior represented",
"lang": "flow",
"medium": "composite"
},
"intent": "Detect classes missing required base abstraction, refactor inheritance or composition according to role rules, migrate duplicated lifecycle logic into hooks, and verify behavior remains represented.",
"invariant": "Base-class violations are architectural adoption failures.",
"flow": [
"NonCompliantClass",
"ExpectedBase",
"RefactorExtension",
"HookMigration",
"Verify"
],
"productions": [
{
"lhs": "BaseClassFix",
"rhs": "<ClassRole> \"→\" <ExpectedBaseAbstraction> \"→\" <InheritanceOrCompositionUpdate> \"→\" <LifecycleHookMigration> \"→\" <ComplianceCheck>"
},
{
"lhs": "ComplianceCheck",
"rhs": "\"class_extends_expected_base\" | \"uses_required_composition_boundary\""
}
],
"composes": [],
"force": [
"semantic_consistency",
"correctness_verification"
]
},
{
"id": "css-token-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "CSS Token Remediation",
"exemplar": {
"before": "A hardcoded color left in place, the rule disabled instead.",
"after": "hardcoded style value → resolve design token{existing | new | manual review} → replace → style validation",
"lang": "flow",
"medium": "composite"
},
"intent": "Replace hardcoded style values with approved design tokens, verify token availability, and run style validation.",
"invariant": "Presentation constants should resolve through design-system tokens.",
"flow": [
"HardcodedStyle",
"TokenLookup",
"Replacement",
"StyleValidation"
],
"productions": [
{
"lhs": "CssTokenFix",
"rhs": "<HardcodedStyleValue> \"→\" <DesignTokenResolution> \"→\" <TokenReplacement> \"→\" <StyleValidation>"
},
{
"lhs": "DesignTokenResolution",
"rhs": "\"existing_token\" | \"new_token_required\" | \"manual_review_required\""
}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "dom-factory-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "DOM Factory Remediation",
"exemplar": {
"before": "Direct document.createElement kept, the rule ignored.",
"after": "direct DOM{querySelector, createElement, innerHTML, direct event} → approved creation boundary → factory rewrite → lifecycle check",
"lang": "flow",
"medium": "composite"
},
"intent": "Replace direct DOM manipulation with the approved DOM factory, component factory, or rendering abstraction.",
"invariant": "DOM creation must flow through the sanctioned construction boundary.",
"flow": [
"DirectDOM",
"FactoryBoundary",
"Rewrite",
"BehaviorCheck"
],
"productions": [
{
"lhs": "DomFactoryFix",
"rhs": "<DirectDomUsage> \"→\" <ApprovedCreationBoundary> \"→\" <FactoryRewrite> \"→\" <LifecycleCompatibilityCheck>"
},
{
"lhs": "DirectDomUsage",
"rhs": "\"document.querySelector\" | \"document.createElement\" | \"innerHTML\" | \"direct_event_binding\""
}
],
"composes": [],
"force": [
"modularity",
"correctness_verification",
"object_creation"
]
},
{
"id": "console-usage-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Console Usage Remediation",
"exemplar": {
"before": "A console.log left in and the rule bypassed.",
"after": "console call → logger severity mapping{log→info, warn→warn, error→error} → replace → verify no direct console remains",
"lang": "flow",
"medium": "composite"
},
"intent": "Replace direct console calls with the approved logging abstraction, preserve severity and message context, and verify no direct console usage remains.",
"invariant": "Observability should be centralized behind a logging contract.",
"flow": [
"ConsoleCall",
"LoggerMapping",
"Replacement",
"SearchNoConsole"
],
"productions": [
{
"lhs": "ConsoleFix",
"rhs": "<ConsoleUsage> \"→\" <LoggerSeverityMapping> \"→\" <LoggerReplacement> \"→\" <ConsoleAbsenceCheck>"
},
{
"lhs": "LoggerSeverityMapping",
"rhs": "\"console.log→info\" | \"console.warn→warn\" | \"console.error→error\""
}
],
"composes": [],
"force": [
"contract_compatibility",
"semantic_consistency",
"correctness_verification",
"observability_traceability",
"event_messaging"
]
},
{
"id": "lifecycle-symmetry-remediation",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Lifecycle Symmetry Remediation",
"exemplar": {
"before": "A resource acquired with no release path, leaking.",
"after": "lifecycle violation → acquired resources → add destroy/teardown → verify created == destroyed",
"lang": "flow",
"medium": "composite"
},
"intent": "Detect resources created without corresponding cleanup, add destroy or teardown paths, and verify create/destroy symmetry.",
"invariant": "Lifecycle compliance requires every acquired resource to have a release path.",
"flow": [
"AcquireResource",
"MissingRelease?",
"AddCleanup",
"SymmetryCheck"
],
"productions": [
{
"lhs": "LifecycleFix",
"rhs": "<LifecycleViolation> \"→\" <AcquiredResourceSet> \"→\" <CleanupRequirementSet> \"→\" <DestroyPathUpdate> \"→\" <SymmetryValidation>"
},
{"lhs": "SymmetryValidation",
"rhs": "\"created_resources == destroyed_resources\""}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "stylelint-post-fix",
"stage": "act",
"axis": "formalization",
"mathType": "computation",
"yields": "procedure",
"title": "Stylelint Post-Fix",
"exemplar": {
"before": "The next architectural cycle runs on style-broken code.",
"after": "remediation → run style validation → fix style errors → block re-verification until style passes",
"lang": "flow",
"medium": "composite"
},
"intent": "After remediation, run style validation, parse style errors, apply style-specific corrections, and block re-verification until style checks pass or are reported.",
"invariant": "Syntax and style conformance must be restored before the next architectural verification cycle.",
"flow": [
"Remediation",
"Stylelint",
"StyleErrors?",
"FixStyle",
"Continue"
],
"productions": [
{
"lhs": "StylePostValidation",
"rhs": "<RemediatedArtifacts> \"→\" <StyleValidationRun> \"→\" (<StylePass> | <StyleFixCycle>)"
},
{
"lhs": "StyleFixCycle",
"rhs": "<StyleErrorSet> \"→\" <StyleCorrectionSet> \"→\" <StyleValidationRun>"
}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "reverification-gate",
"stage": "verify",
"axis": "verification",
"mathType": "logic",
"yields": "boolean",
"grounds": ["reasoning:ver-evidence"],
"title": "Reverification Gate",
"exemplar": {
"before": "Local corrections trusted as global compliance.",
"after": "fixes applied → local validation → rerun the full authoritative verification suite",
"lang": "flow",
"medium": "composite"
},
"intent": "After fixes and style validation, rerun the full verification suite rather than trusting local corrections.",
"invariant": "Only the authoritative verification suite can confirm global compliance.",
"flow": [
"FixesApplied",
"LocalValidation",
"FullVerification"
],
"productions": [
{
"lhs": "ReverificationGate",
"rhs": "<RemediationResult> \"→\" <PostFixValidation> \"→\" <VerificationExecution>"
}
],
"composes": ["verification-execution"],
"force": ["correctness_verification"]
},
{
"id": "partial-success-reporting",
"stage": "commit",
"axis": "representation",
"mathType": "information-theory",
"yields": "hash | novelty-score",
"title": "Partial Success Reporting",
"exemplar": {
"before": "Iteration bound hit and the run silently reports success.",
"after": "max iterations → remaining violations categorized → mark result manual-review-required (visible, actionable residue)",
"lang": "flow",
"medium": "composite"
},
"intent": "When iteration bounds are exhausted, report remaining violations, categorize unresolved issues, and mark the result as requiring manual review.",
"invariant": "Bounded automation should fail visibly with actionable residue.",
"flow": [
"MaxIterations",
"RemainingViolations",
"ManualReviewReport"
],
"productions": [
{
"lhs": "PartialSuccessReport",
"rhs": "<IterationLimitReached> \"→\" <RemainingViolationSet> \"→\" <ManualReviewRequired>"
},
{
"lhs": "ManualReviewRequired",
"rhs": "\"remaining_errors\" \",\" \"remaining_warnings\" \",\" \"blocked_categories\""
}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "completion-report",
"stage": "commit",
"axis": "representation",
"mathType": "information-theory",
"yields": "hash | novelty-score",
"title": "Completion Report",
"exemplar": {
"before": "A report that mixes fixed violations with tolerated warnings.",
"after": "final state → {total iterations, fixed count, remaining warnings, final status{passed | partial | failed}}",
"lang": "flow",
"medium": "composite"
},
"intent": "Report total iterations, fixed error count, remaining warnings, and final verification status.",
"invariant": "Completion output should separate fixed violations from tolerated or remaining warnings.",
"flow": [
"FinalState",
"Iterations",
"FixedCount",
"WarningCount",
"Report"
],
"productions": [
{
"lhs": "CompletionReport",
"rhs": "<FinalVerificationState> \",\" <IterationCount> \",\" <FixedCount> \",\" <RemainingWarningCount>"
},
{"lhs": "FinalVerificationState",
"rhs": "\"passed\" | \"partial_success\" | \"failed\""}
],
"composes": [],
"force": ["correctness_verification"]
},
{
"id": "codebase-verification-kernel",
"principleRef": "verification",
"grounds": ["reasoning:derivation-loop"],
"mathType": "computation",
"yields": "procedure",
"derivationMap": [
{"stage": "orient",
"record": "context-initialization"},
{"stage": "derive",
"record": "violation-classification"},
{"stage": "intent",
"record": "severity-ordered-remediation"},
{"stage": "act",
"record": "file-scoped-fix"},
{"stage": "verify",
"record": "verification-execution"},
{"stage": "commit",
"record": "completion-report"},
{"stage": "terminate",
"record": "iteration-bound"}
],
"title": "Codebase Verification Kernel",
"exemplar": {
"before": "Compliance claimed after one edit, never re-verified.",
"after": "context → verify → parse → pass? → classify → severity-order fix → style validate → reverify → repeat until zero errors or bound",
"lang": "flow",
"medium": "composite"
},
"intent": "Load compliance context, run verification, parse results, exit on pass, classify violations on failure, remediate by severity, run post-fix style validation, and repeat until zero errors or iteration limit.",
"invariant": "Codebase verification is a bounded remediation state machine driven by authoritative compliance output.",
"flow": [
"Context",
"Verify",
"Parse",
"Pass?",
"Classify",
"Fix",
"StyleValidate",
"Reverify",
"Report"
],
"productions": [
{
"lhs": "CodebaseVerificationKernel",
"rhs": "<ContextInitialization> \"→\" <VerificationExecution> \"→\" (<EarlyExit> | <ViolationClassification> \"→\" <IterationBound> \"→\" <SeverityOrdering> \"→\" <FileScopedFix> \"→\" <StylePostValidation> \"→\" <ReverificationGate>) \"→\" <CompletionReport>"
},
{"lhs": "SuccessCondition",
"rhs": "\"verification_errors == 0\""},
{"lhs": "FailureBound",
"rhs": "\"iteration_count > max_iterations\""}
],
"composes": [
"context-initialization",
"verification-execution",
"violation-classification",
"iteration-bound",
"file-scoped-fix",
"reverification-gate",
"completion-report"
],
"force": ["correctness_verification"]
},
{
"id": "compliance-verification-concern",
"title": "<Compliance Verification Concern>",
"intent": "<Load rules> → <Run authoritative verifier> → <Parse failures> → <Classify by violation type> → <Apply bounded fixes> → <Run local post-fix validation> → <Rerun verifier> → <Exit on pass or bound>",
"invariant": "Any programmatic compliance workflow should be treated as a bounded verification-remediation loop whose only completion signal is the authoritative verifier passing.",
"flow": [
"Rules",
"Verify",
"Errors",
"Categories",
"Fixes",
"LocalValidation",
"Reverify",
"Report"
],
"productions": [
{
"lhs": "ComplianceConcern",
"rhs": "<RuleContext> \"→\" <AuthoritativeVerification> \"→\" <ViolationRegistry> \"→\" <RemediationQueue> \"→\" <BoundedMutationCycle> \"→\" <Reverification> \"→\" <FinalStatus>"
},
{"lhs": "FinalStatus",
"rhs": "\"passed\" | \"partial_success_manual_review\" | \"failed\""}
],
"composes": [],
"force": ["correctness_verification"],
"meta": true
}
]
}