{ "content": { "icon": "bi-cpu", "id": "algorithms", "label": "Algorithms", "layout": "ontology", "sections": [ { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_evidence_before_generation[\"Evidence-Before-Generation\"]\n n_semantic_operation_boundary[\"Semantic Operation Boundary\"]\n n_capability_profile[\"Capability Profile\"]\n n_creation_history_collision[\"Creation History Collision\"]\n n_domain_cache_validation[\"Domain Cache Validation\"]\n n_scope_extraction[\"Scope Extraction\"]\n n_non_destructive_domain_investigation[\"Non-Destructive Domain Investigation\"]\n n_domain_knowledge_base[\"Domain Knowledge Base\"]\n n_risk_complexity_reversibility[\"Risk Complexity Reversibility\"]\n n_existing_pattern_extraction[\"Existing Pattern Extraction\"]\n n_knowledge_documentation_relevance[\"Knowledge Documentation Relevance\"]\n n_principle_extraction[\"Principle Extraction\"]\n n_adaptive_phase_boundary[\"Adaptive Phase Boundary\"]\n n_phase_validation_requirement[\"Phase Validation Requirement\"]\n n_portable_contract_composition[\"Portable Contract Composition\"]\n n_validation_strategy_composition[\"Validation Strategy Composition\"]\n n_replacement_safety[\"Replacement Safety\"]\n n_adapter_rendering[\"Adapter Rendering\"]\n n_audit_artifact[\"Audit Artifact\"]\n n_semantic_compliance_validation[\"Semantic Compliance Validation\"]\n n_evidence_grounding_validation[\"Evidence Grounding Validation\"]\n n_algorithmic_embodiment_validation[\"Algorithmic Embodiment Validation\"]\n n_final_generation_report[\"Final Generation Report\"]\n n_agent_generation_completion[\"Agent Generation Completion\"]\n n_agent_creator_kernel[\"Agent Creator Kernel\"]\n n_agent_generation_concern[\"\"]\n n_audit_artifact --> n_capability_profile\n n_agent_creator_kernel --> n_capability_profile\n n_agent_creator_kernel --> n_scope_extraction\n n_agent_creator_kernel --> n_domain_knowledge_base\n n_agent_creator_kernel --> n_principle_extraction\n n_agent_creator_kernel --> n_adapter_rendering\n n_agent_creator_kernel --> n_final_generation_report\n n_agent_creator_kernel --> n_agent_generation_completion\n n_agent_creator_kernel --> n_evidence_before_generation\n n_agent_creator_kernel --> n_risk_complexity_reversibility\n n_agent_creator_kernel --> n_adaptive_phase_boundary\n n_agent_creator_kernel --> n_creation_history_collision\n n_agent_creator_kernel --> n_phase_validation_requirement\n n_agent_creator_kernel --> n_evidence_grounding_validation" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-agent-creation", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Discover available context, inspect target-domain resources, extract concrete facts, construct a knowledge base, and generate only from verified evidence.", "term": "Intent" }, { "description": "Agent generation must be grounded in inspected domain structure, not assumptions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Request → Discover → Inspect → ExtractFacts → KnowledgeBase → Generate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EvidenceBeforeGeneration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nGeneratedAgent ::= \"allowed_only_if_evidence_grounded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent generated from the request text and prior model knowledge, never inspecting the target.", "kind": "code", "language": "text", "title": "Before" }, { "code": "request → discover resources → inspect domain → extract facts → knowledge base → generate only from verified evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-evidence-before-generation", "title": "Evidence-Before-Generation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Define required work as semantic operations, defer runtime execution details to adapters, and reject runtime-specific primitives from the portable core contract.", "term": "Intent" }, { "description": "The core agent contract describes what must happen; the adapter decides how it happens.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticVerb → AdapterMapping → RuntimeAction → Result", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticBoundary ::= \"→\" \"→\" \"→\" \nSemanticOperation ::= \"DECLARE_RESOURCE\" | \"DISCOVER_RESOURCES\" | \"READ_RESOURCE\" | \"SEARCH_CONTENT\" | \"ANALYZE_CONTENT\" | \"EXTRACT_FACTS\" | \"CALCULATE_METRIC\" | \"COMPOSE_ARTIFACT\" | \"VALIDATE_ARTIFACT\" | \"PERSIST_ARTIFACT\" | \"REPORT_RESULT\" | \"REQUEST_DECISION\"\nCoreConstraint ::= \"no_runtime_specific_paths_or_commands\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent core hardcodes a specific search command and an absolute path, so it only runs on one runtime.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic op{DISCOVER/READ/SEARCH/ANALYZE} → adapter maps to the runtime → the core carries no runtime path or command", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-operation-boundary", "title": "Semantic Operation Boundary" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect filesystem, search, execution, persistence, validation, and user-interaction capabilities; mark unsupported capabilities; substitute where safe; block where required capability is non-substitutable.", "term": "Intent" }, { "description": "Generated workflows must know what their runtime can do.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CapabilitySet → Probe → Available|Unavailable|Substituted → RuntimeMode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CapabilityProfile ::= \"→\" \"→\" \nCapabilityVerdict ::= \"full\" | \"degraded\" | \"blocked\"\nCapability ::= \"filesystem\" | \"search\" | \"execution\" | \"persistence\" | \"validation\" | \"user_interaction\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent assumes it can execute and write, then fails when it cannot.", "kind": "code", "language": "text", "title": "Before" }, { "code": "required capabilities{filesystem, search, execution, persistence, validation} → probe each → mode{full | degraded | blocked}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-capability-profile", "title": "Capability Profile" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Load existing agent and invocation registries, map existing identities, compare target name and domain, and require the developer's decision before refinement, renaming, replacement, or cancellation.", "term": "Intent" }, { "description": "Agent creation must not silently duplicate or overwrite prior work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetAgent → ExistingRegistry → NameCollision? → DomainCollision? → Decision", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CreationCollision ::= \"→\" \"→\" \"→\" \nAgentOperationMode ::= \"CREATE\" | \"REFINE\" | \"RENAME\" | \"REPLACE\" | \"CANCEL\"\nCollisionCheck ::= \"name_collision\" | \"domain_collision\" | \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new agent silently overwrites an existing one of the same name.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target name → existing registry → name/domain collision? → developer decision{CREATE|REFINE|RENAME|REPLACE|CANCEL}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-creation-history-collision", "title": "Creation History Collision" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Normalize the domain path, compute a domain hash, search cache entries, fingerprint the domain's sources, and reuse cached knowledge only when the entry's identity matches and its derivation fingerprint equals the current one.", "term": "Intent" }, { "description": "Prior domain intelligence can be reused only when freshness and identity are verified.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainPath → Normalize → Hash → CacheLookup → FingerprintCheck → UseCache|Investigate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainCache ::= \"→\" \"→\" \"→\" \"→\" \nCacheDecision ::= \"use_cached_domain\" | \"reject_stale_cache\" | \"no_cache_investigate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Stale cached domain intelligence reused as if it were current.", "kind": "code", "language": "text", "title": "Before" }, { "code": "domain path → normalize + hash → cache lookup → fingerprint of the domain's sources vs the entry's derivation fingerprint → {use cached | reject stale | investigate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-domain-cache-validation", "title": "Domain Cache Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Determine whether the target is a resource, directory, module, repository, or unknown scope; then extract interfaces, declarations, dependencies, systems, or boundaries appropriate to that scope.", "term": "Intent" }, { "description": "Investigation depth must match target-domain shape.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetPath → InvestigationType → ScopeModel → ResourceSet → InterfaceFacts", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ScopeExtraction ::= \"→\" \"→\" \nInvestigationDepth ::= \"single-resource\" | \"directory\" | \"module\" | \"repository\" | \"auto\"\nDomainScope ::= | | | ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A repository investigated at single-file depth, missing every boundary.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target → investigation depth{single-resource|directory|module|repository} → scope-matched facts{interfaces, deps, boundaries}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-scope-extraction", "title": "Scope Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Prepare static investigation, optionally prepare safe executable analysis, prohibit source mutation, execute or emulate analysis, and merge observable outputs into domain intelligence.", "term": "Intent" }, { "description": "Domain discovery may inspect and analyze, but must not mutate the source domain.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StaticPlan + OptionalExecutablePlan → Analyze → ExtractStructure → CacheResults", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainInvestigation ::= \"→\" \"→\" \nInvestigationPlan ::= \",\" \nExecutionConstraint ::= \"non_destructive\" \",\" \"observable_output_required\" \",\" \"source_mutation_forbidden\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [observability_traceability](/records/force/observability-traceability), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Investigation runs a script that mutates the source it is inspecting.", "kind": "code", "language": "text", "title": "Before" }, { "code": "static plan (+ optional safe executable) → analyze, never mutate the source → observable output → domain knowledge", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-non-destructive-domain-investigation", "title": "Non-Destructive Domain Investigation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Store target scope, discovered structure, purposes, dependencies, interfaces, patterns, statistics, timestamp, and evidence sources in a reusable knowledge object.", "term": "Intent" }, { "description": "Agent generation needs an explicit evidence substrate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainFacts → Statistics → EvidenceSources → KnowledgeBase", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainKnowledgeBase ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nStatistics ::= \"resource_count\" \",\" \"interface_count\" \",\" \"dependency_count\" \",\" \"resource_types\" \",\" \"architectural_patterns\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Generation proceeds with no explicit evidence substrate to cite.", "kind": "code", "language": "text", "title": "Before" }, { "code": "domain facts + structure + purposes + deps + interfaces + patterns + statistics + evidence sources → reusable knowledge base", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-domain-knowledge-base", "title": "Domain Knowledge Base" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Analyze domain dependencies, side effects, resource count, interface count, dependency patterns, and uncertainty factors to assign risk, complexity, reversibility, and uncertainty.", "term": "Intent" }, { "description": "Phase rigor should be proportional to domain risk and complexity.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeBase → RiskFactors → ComplexityScore → Reversibility → Uncertainty", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainCharacteristics ::= \",\" \",\" \",\" \nRiskLevel ::= \"low\" | \"medium\" | \"high\"\nReversibility ::= \"reversible\" | \"partially-reversible\" | \"irreversible\"\nUncertaintyLevel ::= \"low\" | \"medium\" | \"high\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent given the same phase count regardless of how risky its domain is.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge base → risk{low|medium|high} + complexity + reversibility{reversible|partial|irreversible} + uncertainty", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-risk-complexity-reversibility", "title": "Risk Complexity Reversibility" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Inspect existing agent specifications, count phase markers, validation gates, and semantic operations, extract reusable structures, and derive baseline design conventions.", "term": "Intent" }, { "description": "New agents should conform to proven local agent grammar where evidence exists.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ExistingSpecs → PhaseCount → GateCount → OperationUsage → ReusablePatterns", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ExistingPatternExtraction ::= \"→\" \"→\" \nStructuralMetricSet ::= \"phase_count\" \",\" \"validation_gate_count\" \",\" \"semantic_operation_count\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new agent invented in a shape that ignores the local agent grammar.", "kind": "code", "language": "text", "title": "Before" }, { "code": "existing specs → count{phases, gates, semantic ops} → reusable structures → baseline conventions", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-existing-pattern-extraction", "title": "Existing Pattern Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Discover knowledge documents, read descriptions, compare them against domain characteristics, score relevance, and exclude irrelevant documents from core reasoning.", "term": "Intent" }, { "description": "Supporting documents should influence generation only when relevant to the target domain.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeDocs → RelevanceAnalysis → RelevantDocs → PrincipleInput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "KnowledgeRelevance ::= \"→\" \"→\" \nRelevanceDecision ::= \"include\" | \"exclude\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every knowledge doc fed into reasoning, relevant or not.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge docs → read descriptions → score relevance vs domain → include relevant, exclude the rest", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-knowledge-documentation-relevance", "title": "Knowledge Documentation Relevance" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Start from structural principles, test applicability against domain characteristics, add domain-specific principles from relevant documents, and exclude runtime-specific principles from the core.", "term": "Intent" }, { "description": "Generated agents should embody portable design principles selected from evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructuralPrinciples + DomainDocs → Applicability → CorePrinciples", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PrincipleExtraction ::= \"→\" \"→\" \nCorePrinciple ::= \"phase_gated_execution\" | \"validation_boundaries\" | \"declaration_before_use\" | \"evidence_before_composition\" | \"adapter_separation\" | \"auditability\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Runtime-specific principles baked into the portable core.", "kind": "code", "language": "text", "title": "Before" }, { "code": "structural candidates + domain docs → test applicability → core principles{phase-gated, validation-boundaries, declaration-before-use, evidence-before-composition, adapter-separation, auditability}; runtime-specific excluded", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-principle-extraction", "title": "Principle Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select phase count from risk and complexity, assign phase boundaries, and strengthen validation density for high-risk or high-complexity domains.", "term": "Intent" }, { "description": "Agent structure should scale with domain difficulty.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Risk + Complexity + Uncertainty → PhaseCount → PhaseBoundaries", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseBoundarySelection ::= \",\" \",\" \"→\" \nPhaseStructure ::= | | \nThreePhase ::= \"Discovery\" \",\" \"Generation\" \",\" \"Verification\"\nFivePhase ::= \"Discovery\" \",\" \"Analysis\" \",\" \"Generation\" \",\" \"Verification\" \",\" \"Finalization\"\nSevenPhase ::= \"Discovery\" \",\" \"Analysis\" \",\" \"Planning\" \",\" \"Validation\" \",\" \"Generation\" \",\" \"Verification\" \",\" \"Finalization\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [performance_scaling](/records/force/performance-scaling), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A high-risk irreversible domain given a 3-phase agent.", "kind": "code", "language": "text", "title": "Before" }, { "code": "risk + complexity + uncertainty → phase count{3 | 5 | 7} → validation density proportional to difficulty", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-adaptive-phase-boundary", "title": "Adaptive Phase Boundary" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For every phase boundary, generate explicit validation requirements from the phase purpose, adapter-separation needs, evidence-grounding needs, and safety constraints.", "term": "Intent" }, { "description": "Every phase must end with verifiable exit conditions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PhaseSet → RequirementDerivation → ValidationGateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseValidation ::= \"→\" \"→\" \nPhaseValidationGate ::= \":\" \nRequirementSet ::= | \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A phase ends with no verifiable exit condition.", "kind": "code", "language": "text", "title": "Before" }, { "code": "phase → derive requirements{purpose, adapter-separation, evidence-grounding, safety} → a validation gate per phase", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-validation-requirement", "title": "Phase Validation Requirement" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose identity, purpose, methodology, domain scope, characteristics, capabilities, phases, validation strategy, constraints, and required outputs into a runtime-neutral agent contract.", "term": "Intent" }, { "description": "The portable contract is the canonical artifact; adapter outputs are renderings.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeBase + Principles + Phases → PortableContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PortableAgentContract ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nOutputContract ::= \"portable_agent_contract\" | \"invocation_contract\" | \"audit_report\" | \"final_report\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent authored directly as a runtime artifact, welded to one runtime.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge base + principles + phases → runtime-neutral contract{identity, purpose, domain model, capabilities, phase specs, validation strategy, constraints, outputs} = the canonical artifact", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-portable-contract-composition", "title": "Portable Contract Composition" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Define pre-generation, during-generation, and post-generation checks that enforce capabilities, creation history, evidence grounding, adapter separation, schema validity, and absence of unsupported assumptions.", "term": "Intent" }, { "description": "Generated artifacts must be validated throughout composition, not only afterward.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreChecks → DuringChecks → PostChecks → ValidationStrategy", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GenerationValidationStrategy ::= \",\" \",\" \nPreGenerationChecks ::= \"capabilities_detected\" \",\" \"history_checked\" \",\" \"domain_knowledge_available\"\nDuringGenerationChecks ::= \"phase_gates_enforced\" \",\" \"evidence_grounded_content\" \",\" \"adapter_separated\"\nPostGenerationChecks ::= \"schema_valid\" \",\" \"audit_complete\" \",\" \"unsupported_assumptions_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The artifact validated only after it is written, never during.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre{capabilities detected, history checked, knowledge available} + during{phase gates, evidence-grounded, adapter-separated} + post{schema valid, audit complete, no unsupported assumptions}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-validation-strategy-composition", "title": "Validation Strategy Composition" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "If replacing an existing artifact, require prior approval, archive existing artifacts, verify archive persistence, and block new persistence if archival cannot be confirmed.", "term": "Intent" }, { "description": "Destructive generation requires recoverability before mutation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ReplaceIntent → Approval → ArchiveExisting → VerifyArchive → Persist|Block", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReplacementSafety ::= \"→\" \"→\" \"→\" \nArchivePolicy ::= \"archive_required_if_replace\" | \"archive_not_required\"\nPersistenceDecision ::= \"safe_to_persist\" | \"blocked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An existing agent overwritten with no archive — the original is lost.", "kind": "code", "language": "text", "title": "Before" }, { "code": "REPLACE → require approval → archive existing → verify the archive → persist only if recoverable, else block", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-replacement-safety", "title": "Replacement Safety" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Render the portable contract into runtime-specific agent specification, invocation contract, and audit artifacts only through adapter-defined schemas and destinations.", "term": "Intent" }, { "description": "Runtime-specific artifacts are projections of the portable contract, not replacements for it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PortableContract → AdapterSchema → RenderedArtifact → Validate → Persist", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AdapterRendering ::= \"→\" \"→\" \"→\" \"→\" \nArtifactSet ::= \"agent_specification\" \",\" \"invocation_contract\" \",\" \"audit_report\"\nAdapterConstraint ::= \"adapter_may_add_metadata_but_not_alter_core_intent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The runtime artifact edited directly, diverging from the portable contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "portable contract → adapter schema → artifacts{agent spec, invocation contract, audit} → adapter may add metadata, never alter core intent", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-adapter-rendering", "title": "Adapter Rendering" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Record agent name, domain, operation mode, runtime environment, risk, complexity, reversibility, uncertainty, phase count, validation gates, evidence sources, capability profile, adapter identity, portability status, and timestamp.", "term": "Intent" }, { "description": "Generated agents require an inspectable provenance trail.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GenerationState → AuditFields → AuditReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AuditReport ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capability Profile](/records/algorithms/capability-profile)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A generated agent with no provenance — no record of how or from what it was built.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generation state → audit{identity, domain, mode, risk metrics, gates, evidence sources, capability profile, adapter identity, portability status}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "[Capability Profile](/records/algorithms/capability-profile)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-audit-artifact", "title": "Audit Artifact" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Re-read the persisted agent specification, search for semantic operations, phase markers, validation gates, and runtime-specific leakage, then mark compliant only when required counts pass and leakage is absent.", "term": "Intent" }, { "description": "Persistence is not enough; the stored artifact must still satisfy semantic structure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PersistedSpec → MarkerSearch → CountMetrics → LeakageCheck → ComplianceVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticCompliance ::= \"→\" \"→\" \"→\" \"→\" \nComplianceVerdict ::= \"compliant\" | \"non_compliant\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The in-memory plan judged compliant, but the stored artifact never re-checked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "re-read persisted spec → search{semantic ops, phase markers, gates} + leakage check → compliant only if counts pass and zero runtime leakage", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-compliance-validation", "title": "Semantic Compliance Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Search generated output for unsupported claims and evidence references, compare generated claims against the knowledge base, calculate grounding score, and reject artifacts below threshold.", "term": "Intent" }, { "description": "Generated architecture claims must trace back to evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedSpec → UnsupportedClaimSearch → EvidenceReferenceCheck → GroundingScore → Accept|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EvidenceGrounding ::= \"→\" \"→\" \"→\" \nGroundingVerdict ::= \"grounded\" | \"unsupported_claims_present\" | \"insufficient_evidence_references\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The generated agent asserts architecture claims that trace to nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated spec → find claims → compare against the knowledge base → grounding score → reject below threshold", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-evidence-grounding-validation", "title": "Evidence Grounding Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Verify that generated agents contain phase gates, declaration-before-use structure, calculated metrics, exact thresholds or comparisons, and iterative discovery patterns.", "term": "Intent" }, { "description": "The generated agent must embody the intended reasoning architecture, not merely describe it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedSpec → EmbodimentMarkers → Score → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AlgorithmicEmbodiment ::= \"→\" \"→\" \"→\" \nEmbodimentMarkerSet ::= \"phase_gates\" \",\" \"declaration_before_use\" \",\" \"calculated_metrics\" \",\" \"thresholds\" \",\" \"iterative_discovery\"\nEmbodimentVerdict ::= \"embodied\" | \"insufficiently_embodied\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent describes phase gates in prose but does not embody them.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated spec → markers{phase gates, declaration-before-use, calculated metrics, thresholds, iterative discovery} → embodied | insufficiently-embodied", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-algorithmic-embodiment-validation", "title": "Algorithmic Embodiment Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Summarize generated agent, target domain, operation mode, adapter, risk, complexity, reversibility, uncertainty, phase count, validation-gate count, compliance results, artifact references, degraded mode, and unsupported capabilities.", "term": "Intent" }, { "description": "The final report must distinguish generated artifacts, validation status, and limitations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationResults + ArtifactRefs + Limitations → FinalReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FinalGenerationReport ::= \",\" \",\" \",\" \",\" \nComplianceSummary ::= \"semantic_operations\" \",\" \"adapter\" \",\" \"evidence_grounding\" \",\" \"algorithmic_embodiment\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A report that conflates the artifact, its validation status, and its limitations.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validation results + artifact refs + limitations{degraded mode, unsupported capabilities} → report distinguishing all three", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-final-generation-report", "title": "Final Generation Report" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Accept the generated agent as complete only when semantic-compliance, evidence-grounding above threshold, and algorithmic-embodiment all pass and the audit trail is recorded; otherwise route to regeneration or a blocked report.", "term": "Intent" }, { "description": "Agent generation terminates as accepted only on a full validation pass — never a claim while any compliance, grounding, or embodiment gate is unmet.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationVerdicts → AuditPresence → Accept|Regenerate|Blocked", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentGenerationCompletion ::= \"→\" \"→\" \nAcceptanceVerdict ::= \"agent_accepted\" | \"regenerate_required\" | \"blocked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A generated agent declared ready while its evidence-grounding failed and its algorithmic embodiment was insufficient.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic compliance passed + evidence grounded above threshold + algorithmically embodied + audit recorded → agent_accepted; else regenerate | blocked", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-generation-completion", "title": "Agent Generation Completion" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Load configuration, detect capabilities, check creation history, validate cache, discover domain evidence, build knowledge base, analyze characteristics, extract principles, define phases, compose portable contract, render adapter artifacts, validate outputs, audit, and report.", "term": "Intent" }, { "description": "Agent creation is an evidence-gated compiler from target-domain structure into portable agent contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Config → Capabilities → History → Cache → Discovery → Knowledge → Analysis → Principles → Phases → Contract → AdapterRender → Validate → Audit → Report", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentCreatorKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Principle Extraction](/records/algorithms/principle-extraction), [Adapter Rendering](/records/algorithms/adapter-rendering), [Final Generation Report](/records/algorithms/final-generation-report), [Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation)", "term": "orient" }, { "description": "[Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility)", "term": "see" }, { "description": "[Principle Extraction](/records/algorithms/principle-extraction)", "term": "derive" }, { "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary)", "term": "intent" }, { "description": "[Creation History Collision](/records/algorithms/creation-history-collision)", "term": "constrain" }, { "description": "[Phase Validation Requirement](/records/algorithms/phase-validation-requirement)", "term": "project" }, { "description": "[Adapter Rendering](/records/algorithms/adapter-rendering)", "term": "act" }, { "description": "[Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation)", "term": "verify" }, { "description": "[Final Generation Report](/records/algorithms/final-generation-report)", "term": "commit" }, { "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A target domain turned straight into an agent by assumption, ungated.", "kind": "code", "language": "text", "title": "Before" }, { "code": "config → capabilities → history → cache → discover evidence → knowledge → risk analysis → principles → phases → portable contract → adapter render → validate{semantic/grounding/embodiment} → audit → report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "[Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Principle Extraction](/records/algorithms/principle-extraction), [Adapter Rendering](/records/algorithms/adapter-rendering), [Final Generation Report](/records/algorithms/final-generation-report), [Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-creator-kernel", "title": "Agent Creator Kernel" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → → → ", "term": "Intent" }, { "description": "Any generated agent should be treated as a compiled artifact whose source is inspected domain evidence and whose target is a portable, adapter-renderable contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Context → Capability → History → Evidence → Knowledge → Risk → Phases → Contract → Adapter → Validation → Audit → Report", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentGenerationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nValidationSet ::= \"semantic_compliance\" \",\" \"adapter_compliance\" \",\" \"evidence_grounding\" \",\" \"algorithmic_embodiment\" \",\" \"runtime_specific_leakage_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-generation-concern", "title": "" } ], "title": "Agent creation" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_hybrid_workflow_orchestration[\"Hybrid Workflow Orchestration\"]\n n_dsl_compliance_loading[\"DSL Compliance Loading\"]\n n_agent_workflow_file_modification_recovery[\"Agent Workflow File Modification Recovery\"]\n n_context_forking_configuration[\"Context Forking Configuration\"]\n n_verb_based_execution_classification[\"Verb-Based Execution Classification\"]\n n_workspace_configuration_discovery[\"Workspace Configuration Discovery\"]\n n_shared_document_workspace[\"Shared Document Workspace\"]\n n_workflow_type_document_selection[\"Workflow Type Document Selection\"]\n n_agent_sequence_definition[\"Agent Sequence Definition\"]\n n_agent_document_responsibility[\"Agent Document Responsibility\"]\n n_agent_activation_invocation[\"Agent Activation Invocation\"]\n n_parallel_batch_execution[\"Parallel Batch Execution\"]\n n_sequential_agent_execution[\"Sequential Agent Execution\"]\n n_four_dimensional_agent_graph[\"Four-Dimensional Agent Graph\"]\n n_handoff_signal[\"Handoff Signal\"]\n n_orchestrator_action[\"Orchestrator Action\"]\n n_workflow_coordination_sequence[\"Workflow Coordination Sequence\"]\n n_workflow_recovery_loop[\"Workflow Recovery Loop\"]\n n_checklist_integration[\"Checklist Integration\"]\n n_phase_documentation_template[\"Phase Documentation Template\"]\n n_workflow_principles_mapping[\"Workflow Principles Mapping\"]\n n_capability_invocation_protocol[\"Capability Invocation Protocol\"]\n n_template_assembly[\"Template Assembly\"]\n n_first_time_initiation[\"First-Time Initiation\"]\n n_workflow_validation_gate[\"Workflow Validation Gate\"]\n n_workflow_creation_kernel[\"Workflow Creation Kernel\"]\n n_workflow_orchestration_concern[\"\"]\n n_handoff_signal --> n_orchestrator_action\n n_orchestrator_action --> n_handoff_signal\n n_workflow_creation_kernel --> n_dsl_compliance_loading\n n_workflow_creation_kernel --> n_agent_workflow_file_modification_recovery\n n_workflow_creation_kernel --> n_context_forking_configuration\n n_workflow_creation_kernel --> n_workspace_configuration_discovery\n n_workflow_creation_kernel --> n_shared_document_workspace\n n_workflow_creation_kernel --> n_agent_sequence_definition\n n_workflow_creation_kernel --> n_handoff_signal\n n_workflow_creation_kernel --> n_workflow_coordination_sequence\n n_workflow_creation_kernel --> n_checklist_integration\n n_workflow_creation_kernel --> n_phase_documentation_template\n n_workflow_creation_kernel --> n_capability_invocation_protocol\n n_workflow_creation_kernel --> n_template_assembly\n n_workflow_creation_kernel --> n_workflow_validation_gate\n n_workflow_creation_kernel --> n_workflow_type_document_selection\n n_workflow_creation_kernel --> n_agent_activation_invocation\n n_workflow_creation_kernel --> n_first_time_initiation" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-agent-workflow", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Classify workflow phases by execution verb, run discovery and investigation agents in parallel forked contexts, run action and mutation agents sequentially, and coordinate all agents through shared artifacts and handoff signals.", "term": "Intent" }, { "description": "Multi-agent workflows should parallelize independent knowledge gathering while serializing state-changing work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowObjective → AgentPhases → ExecutionClassification → ParallelDiscovery → SequentialAction → Handoff", "kind": "code", "language": "text", "title": "Flow" }, { "code": "HybridWorkflowOrchestration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nExecutionMode ::= \"PARALLEL\" | \"SEQUENTIAL\"\nParallelPhase ::= \"DISCOVERY\" | \"INVESTIGATION\" | \"RESEARCH\" | \"ANALYSIS\" | \"EXPLORATION\"\nSequentialPhase ::= \"CREATE\" | \"WRITE\" | \"EXECUTE\" | \"VERIFY\" | \"IMPLEMENT\" | \"REFACTOR\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent runs sequentially, even independent discovery — the workflow crawls.", "kind": "code", "language": "text", "title": "Before" }, { "code": "objective → agent sequence → classify by verb → parallel discovery (forked context) + sequential action (normal context) → handoff", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-hybrid-workflow-orchestration", "title": "Hybrid Workflow Orchestration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Load grammar, keyword, operator, workflow, and checklist references before workflow generation, then require generated content to follow the declared DSL, naming, handoff, execution, forking, spawning, and capability rules.", "term": "Intent" }, { "description": "Workflow generation must begin by loading the language and orchestration contracts that constrain output.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DSLSources → Requirements → ComplianceGate → Proceed|Block", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DSLComplianceLoading ::= \"→\" \"→\" \nWorkflowRequirementSet ::= \"agent_dsl_syntax\" \",\" \"agent_oriented_content\" \",\" \"stable_filename_convention\" \",\" \"handoff_protocol\" \",\" \"hybrid_parallel_sequential\" \",\" \"context_isolation\" \",\" \"agent_spawn_mechanism\" \",\" \"capability_invocation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow generated free-form, ignoring the DSL and handoff contracts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "load DSL + keyword + workflow + checklist specs → require{agent-DSL syntax, handoff protocol, hybrid execution, context isolation, agent spawn} → compliance gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dsl-compliance-loading", "title": "DSL Compliance Loading" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "When a file modification conflict occurs, detect the error, re-read the current file, merge the intended delta into the current content, write the complete new version, verify persistence, and log recovery automatically without asking the developer.", "term": "Intent" }, { "description": "State-mutation conflicts are synchronization failures and should trigger deterministic recovery, not a prompt to the developer.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ModificationError → RereadMerge → CompleteRewrite → Verify", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FileModificationRecovery ::= \"→\" \"→\" \"→\" \"→\" \nRecoveryProtocol ::= \"reread-merge-complete-rewrite\" | \"snapshot-restore-on-failure\"\nForbiddenRecovery ::= \"retry_edit_without_recovery\" | \"ask_user_for_tool_error_recovery\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A stale-write conflict re-reads the file and retries the same edit, or stops to ask the developer.", "kind": "code", "language": "text", "title": "Before" }, { "code": "modification error → re-read current → merge the delta into full state → write complete version → verify → log; never retry-without-recovery, never ask for a tool error", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-workflow-file-modification-recovery", "title": "Agent Workflow File Modification Recovery" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Assign forked context to discovery, investigation, and documentation agents; assign normal context to action and validation agents; preserve model and parallel eligibility metadata per agent class.", "term": "Intent" }, { "description": "Context isolation improves independent analysis, while normal context preserves continuity for mutation and validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentClass → ContextMode → ParallelEligibility → ExecutionPolicy", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContextForkingConfiguration ::= \"→\" \"→\" \"→\" \nAgentClass ::= \"discovery\" | \"investigation\" | \"documentation\" | \"action\" | \"validation\"\nContextMode ::= \"fork\" | \"normal\"\nParallelPolicy ::= \"parallel_true\" | \"parallel_false\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent shares one context — discovery pollutes the action agent's state.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent class → discovery/investigation/documentation → fork ; action/validation → normal → per-class parallel eligibility preserved", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-context-forking-configuration", "title": "Context Forking Configuration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Extract the primary verb from each agent purpose, classify it against parallel or sequential verb sets, and bind execution mode, context, and parallel eligibility.", "term": "Intent" }, { "description": "Execution mode should be derived from action semantics, not arbitrary phase numbering.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentPurpose → PrimaryVerb → VerbClass → ExecutionMode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VerbExecutionClassification ::= \"→\" \"→\" \"→\" \nParallelVerb ::= \"ANALYZE\" | \"FIND\" | \"EXTRACT\" | \"READ\" | \"DISCOVER\" | \"INVESTIGATE\" | \"RESEARCH\" | \"EXPLORE\" | \"TRACE\"\nSequentialVerb ::= \"CREATE\" | \"WRITE\" | \"EXECUTE\" | \"VERIFY\" | \"IMPLEMENT\" | \"LINK\" | \"ITERATE\" | \"REFACTOR\" | \"DEPLOY\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Execution mode assigned by phase number, not by what the agent does.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent purpose → primary verb → {ANALYZE/FIND/DISCOVER → PARALLEL(fork)} | {CREATE/WRITE/VERIFY → SEQUENTIAL(normal)}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-verb-based-execution-classification", "title": "Verb-Based Execution Classification" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read workspace configuration, extract zones, semantic extensions, root path, agent definitions, shared zone, workflow zone, and task zone before generating any workflow artifacts.", "term": "Intent" }, { "description": "Workflow artifacts must be placed by discovered workspace configuration, not hardcoded paths.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkspaceConfig → Zones → AgentDefinitions → ArtifactBasePath", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkspaceConfigurationDiscovery ::= \"→\" \"→\" \"→\" \"→\" \nArtifactPathPolicy ::= \"shared_zone/workflow_name\" \",\" \"workflow_zone\" \",\" \"task_zone\" \",\" \"no_hardcoded_paths\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Artifact paths hardcoded — the workflow only runs in one layout.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workspace-config → zones + root + agent defs → artifact base = shared_zone/workflow_name; no hardcoded paths", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workspace-configuration-discovery", "title": "Workspace Configuration Discovery" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Pre-create workflow documents once, require every agent to read and edit the same documents, prohibit duplicate versions, and enforce single source of truth across phases.", "term": "Intent" }, { "description": "Multi-agent coordination should refine shared artifacts rather than create divergent outputs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CoreDocuments → PreCreate → AgentReadEdit → SingleSourceValidation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SharedDocumentWorkspace ::= \"→\" \"→\" \"→\" \"→\" \nSharedAccessProtocol ::= \"all_agents_same_documents\" \",\" \"orchestrator_creates\" \",\" \"agents_refine\" \",\" \"append_mode_false\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each agent writes its own output file; findings diverge across N versions.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre-create core documents once → every agent reads + edits the same set → no duplicate versions → single source of truth", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-shared-document-workspace", "title": "Shared Document Workspace" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Analyze workflow objective, classify workflow type, select five to eight semantically distinct core documents, and map each document to a non-overlapping purpose.", "term": "Intent" }, { "description": "Workflow coordination needs the right shared document set for the work type.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowObjective → WorkflowType → CoreDocuments → PurposeMap", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowDocumentSelection ::= \"→\" \"→\" \"→\" \nWorkflowType ::= \"cleanup\" | \"analysis\" | \"refactoring\" | \"documentation\" | \"implementation\" | \"security\" | \"performance\" | \"infrastructure\" | \"migration\"\nCoreDocumentConstraint ::= \"document_count_between_5_and_8\" \",\" \"distinct_logical_purpose\" \",\" \"semantic_names_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Generic output.md / results.md documents with overlapping purpose.", "kind": "code", "language": "text", "title": "Before" }, { "code": "objective → workflow_type{cleanup|analysis|refactoring|security|migration} → 5-8 distinct-purpose documents → one non-overlapping purpose each", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-type-document-selection", "title": "Workflow Type Document Selection" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "For each agent slot, create an agent object with name, type, phase, purpose, methodology, inputs, outputs, validation gates, document responsibilities, focus areas, edit protocol, agent activation, and 4D graph.", "term": "Intent" }, { "description": "An orchestration plan requires agent objects with executable metadata, not just agent names.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentCount → AgentObjectSet → AgentSequence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentSequenceDefinition ::= \"→\" \"→\" \nAgentObject ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A plan that is just a list of agent names, no executable metadata.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent_count → agent objects{name, type, phase, purpose, inputs, outputs, validation gates, doc responsibilities, execution mode, 4D graph}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-sequence-definition", "title": "Agent Sequence Definition" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each core document, require every agent to read current state, identify outdated or incorrect content, remove stale sections, replace with new discoveries, avoid duplicate findings, and maintain single source of truth.", "term": "Intent" }, { "description": "Shared-document workflows should use surgical refinement rather than additive accumulation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Document → Read → DetectStale → Remove → Replace → Deduplicate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentDocumentResponsibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nProhibitedDocumentOperation ::= \"append_only\" | \"duplicate_findings\" | \"new_version_file\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Agents append findings, accumulating duplicates and contradictions.", "kind": "code", "language": "text", "title": "Before" }, { "code": "document → read current state → detect contradictions → remove stale → replace with new → single source of truth (never append, never a new version file)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-document-responsibility", "title": "Agent Document Responsibility" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For every agent activation, construct a spawn invocation with agent type, prompt, description, model, and context; use forked context for parallel agents and normal context for sequential agents.", "term": "Intent" }, { "description": "Orchestrators must execute agents through the runtime spawn primitive, not simulate agent behavior in the main session.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentObject → SpawnInvocation → AgentExecution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentActivationInvocation ::= \"→\" \"→\" \nSpawnCall ::= \"agent_type\" \",\" \"prompt\" \",\" \"description\" \",\" \"model\" \",\" \"context_if_parallel\"\nForbiddenOrchestration ::= \"simulate_agent_execution_in_orchestrator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The orchestrator simulates the agent's work in its own session.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent object → spawn primitive{agent_type, prompt, model, context-if-parallel} → real activation; never simulate in the orchestrator", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-activation-invocation", "title": "Agent Activation Invocation" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Accumulate adjacent parallel agents into a batch, invoke all spawns in a single concurrent batch, wait for all completions, and merge findings through shared documents.", "term": "Intent" }, { "description": "Parallel agents should execute concurrently only when their work is investigation-safe and state-isolated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ParallelAgents → ConcurrentSpawnBatch → WaitAll → MergeFindings", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ParallelBatchExecution ::= \"→\" \"→\" \"→\" \nConcurrentSpawnBatch ::= \"single_batch_concurrent_spawn\"\nParallelSafety ::= \"context_fork\" \",\" \"discovery_or_investigation_only\" \",\" \"shared_artifact_refinement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Parallel agents launched in separate messages, so they run one after another anyway.", "kind": "code", "language": "text", "title": "Before" }, { "code": "adjacent parallel agents → one concurrent batch of forked-context spawns → wait for all → merge via shared documents", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-parallel-batch-execution", "title": "Parallel Batch Execution" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Execute state-changing or validation agents one at a time in normal context, pass handoff context from the previous phase, wait for completion signal, then activate the next agent.", "term": "Intent" }, { "description": "Mutating workflow phases must serialize to prevent conflicting edits and ambiguous state.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreviousHandoff → SpawnCall → WaitCompletion → NextHandoff", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SequentialAgentExecution ::= \"→\" \"→\" \"→\" \nSequentialConstraint ::= \"one_spawn_at_a_time\" \",\" \"wait_for_completion\" \",\" \"context_normal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two mutating agents launched at once, producing conflicting edits.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prior handoff → one normal-context spawn at a time → wait for completion → activate the next", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-sequential-agent-execution", "title": "Sequential Agent Execution" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "For each agent, build sequential dependencies, lateral parallel peers, diagonal artifact/data dependencies, and propagation effects including superseded state, propagated contracts, and breakage risks.", "term": "Intent" }, { "description": "Multi-agent workflows need topology, not only order.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Agent → Z + X + Y + W Graph", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FourDAgentGraph ::= \"→\" \",\" \",\" \",\" \nSequentialAxis ::= \"Z: prior_required_agents\"\nLateralAxis ::= \"X: peer_parallel_agents\"\nDiagonalAxis ::= \"Y: cross_phase_artifact_dependencies\"\nPropagationAxis ::= \"W: superseded_state, propagated_contracts, breaks_if_changed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent records only its order, not its cross-phase data or downstream ripple.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent → Z{prior required agents} + X{peer parallel} + Y{cross-phase artifact deps} + W{superseded state, propagated contracts, breaks-if-changed}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-four-dimensional-agent-graph", "title": "Four-Dimensional Agent Graph" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Require every agent to end with a structured handoff signal containing completed agent, phase status, artifact location, next agent, execution mode, context used, findings, files, validation status, parallel results, 4D graph, and orchestrator action.", "term": "Intent" }, { "description": "Handoffs are control messages that preserve workflow state across agent boundaries.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentCompletion → HandoffContext → OrchestratorAction", "kind": "code", "language": "text", "title": "Flow" }, { "code": "HandoffSignal ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nOrchestratorAction ::= \"ACTIVATE_NEXT_AGENT\" | \"PAUSE_FOR_USER\" | \"WORKFLOW_COMPLETE\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action)", "term": "Composes" }, { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent finishes with a prose summary the orchestrator cannot route on.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent completion → handoff{completed, phase status, artifacts, next agent, execution mode, context, findings, validation, 4D graph, orchestrator_action}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-handoff-signal", "title": "Handoff Signal" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Interpret handoff action as activate next agent, pause for the developer, or complete workflow; automatically continue unless a critical decision or repeated recovery failure requires the developer's involvement.", "term": "Intent" }, { "description": "The orchestrator is a control loop driven by structured handoff actions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "HandoffSignal → ActionType → Execute|Pause|Complete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "OrchestratorActionHandling ::= \"→\" \"→\" \nActionType ::= \"ACTIVATE_NEXT_AGENT\" | \"PAUSE_FOR_USER\" | \"WORKFLOW_COMPLETE\"\nContinuationRule ::= \"never_ask_should_I_continue\" \",\" \"use_orchestrator_action\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Composes" }, { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Composed by" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The orchestrator asks the developer 'should I continue?' after every agent.", "kind": "code", "language": "text", "title": "Before" }, { "code": "handoff → orchestrator_action{ACTIVATE_NEXT_AGENT | PAUSE_FOR_USER | WORKFLOW_COMPLETE} → auto-continue unless a critical decision or repeated recovery failure", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-orchestrator-action", "title": "Orchestrator Action" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Pre-create documents, execute parallel batches where eligible, execute sequential agents one at a time, update checkpoints, validate single source of truth, and mark workflow completion.", "term": "Intent" }, { "description": "Coordination is the explicit execution trace for the whole workflow.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreCreateDocs → ParallelBatch|SequentialTask → Handoff → Checkpoint → Complete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowCoordinationSequence ::= \"→\" \"→\" \"→\" \nWorkflowCompletionState ::= \"WORKFLOW_PROGRESS_100_percent\" \",\" \"core_documents_refined\" \",\" \"final_output_ready\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Coordination left implicit — no record states the spawn order.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre-create docs → parallel batches where eligible + sequential tasks one at a time → handoffs → checkpoint updates → 100% complete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-coordination-sequence", "title": "Workflow Coordination Sequence" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "If an agent fails validation, read shared documents, identify unmet expectation, research the error pattern, relaunch the agent with adapted context, and pause for the developer after bounded recovery attempts.", "term": "Intent" }, { "description": "Agent failure should trigger bounded evidence-based recovery, not silent continuation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationFail → Diagnose → Research → Relaunch → RetryLimit|Recover", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowRecoveryLoop ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRecoveryDecision ::= \"continue_after_recovery\" | \"pause_for_user_after_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A failed agent is silently skipped and the workflow continues.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validation fail → read shared docs → diagnose unmet expectation → research the error → relaunch with adapted context → pause for the developer after the bound", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-recovery-loop", "title": "Workflow Recovery Loop" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Create a workflow progress checklist in the artifact workspace, include execution model metadata, phases in linear dependency order with severity metadata, task checkboxes, progress bars, success criteria, and agent-edit coordination rules.", "term": "Intent" }, { "description": "Workflow state must persist independently of any one agent context.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workflow → Checklist → AgentUpdates → ResumableProgress", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ChecklistIntegration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nChecklistCoordinationRule ::= \"orchestrator_precreates\" \",\" \"all_agents_edit_same_checklist\" \",\" \"phase_complete_before_handoff\" \",\" \"resume_by_reading_checklist\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow state lives only in the orchestrator context; a restart loses it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workflow → progress checklist{execution model, linear phases + severity metadata, task checkboxes, success criteria} → any agent resumes by reading it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-checklist-integration", "title": "Checklist Integration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each agent phase, render phase header, execution mode, context mode, methodology, 4D graph, artifact flow, focus areas, deliverable, and agent activation example.", "term": "Intent" }, { "description": "Workflow templates must document how each agent is activated and what it contributes.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentPhase → DocumentationSection → InvocationExample", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseDocumentationTemplate ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A phase documented with no execution mode, graph, or invocation example.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent phase → header + execution mode + context + methodology + 4D graph + artifacts + focus + deliverable + agent activation example", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-documentation-template", "title": "Phase Documentation Template" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Derive workflow principles from the agent sequence, first agent grounding role, final agent quality guarantee, intermediate agent contributions, automation, context awareness, recovery, scalability, hybrid execution, context forking, and workspace integration.", "term": "Intent" }, { "description": "A workflow should state the qualities guaranteed by its orchestration structure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentSequence → PrincipleSet → WorkflowValueStatement", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowPrinciplesMapping ::= \"→\" \"→\" \nWorkflowPrinciple ::= \"grounded_in_codebase_reality\" | \"fully_automated\" | \"context_aware\" | \"self_recovering\" | \"dynamically_scalable\" | \"hybrid_execution\" | \"context_forking\" | \"workspace_integrated\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A workflow that never states what its structure guarantees.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent sequence → per-agent contribution{first grounds, final guarantees quality} → principles{grounded, automated, context-aware, self-recovering, scalable}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-principles-mapping", "title": "Workflow Principles Mapping" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Define specialized capability invocation patterns, classify which capabilities run forked or normal, include examples, and allow workflows to call capabilities for research, validation, calculation, and specialized subroutines.", "term": "Intent" }, { "description": "Workflows should support specialized capabilities without embedding every capability into every agent.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CapabilityNeed → CapabilityPattern → ContextMode → Invocation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CapabilityInvocationProtocol ::= \"→\" \"→\" \"→\" \nCapabilityInvocation ::= \"invoke(capability=name, args=args)\"\nCapabilityContextRule ::= \"discovery_capability_context_fork\" | \"validation_capability_context_normal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every capability baked into every agent instead of a shared, invocable one.", "kind": "code", "language": "text", "title": "Before" }, { "code": "capability need → select → invoke(capability, args){discovery → forked, validation → normal} → integrate result", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-capability-invocation-protocol", "title": "Capability Invocation Protocol" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Assemble frontmatter, workspace config, overview, phase documentation, checklist requirements, orchestration protocol, handoff format, coordination sequence, capability integration, workflow principles, and domain notes into one workflow artifact.", "term": "Intent" }, { "description": "The workflow template is a compiled orchestration contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Sections → FinalTemplate → OutputPath → Write", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemplateAssembly ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nOutputArtifact ::= \"{workflow_output_dir}/{workflow_name}-WORKFLOW.{workflow_ext}\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow sections written ad hoc, missing the handoff format or coordination.", "kind": "code", "language": "text", "title": "Before" }, { "code": "assemble{frontmatter, workspace config, overview, phase docs, checklist, orchestration protocol, handoff format, coordination, capabilities, principles} → {name}-WORKFLOW file", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-template-assembly", "title": "Template Assembly" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "After generating the workflow template, present a summary and request explicit first-run action: execute workflow, edit template, or cancel.", "term": "Intent" }, { "description": "Generation and first execution are separate approval states.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedWorkflow → UserChoice → Execute|Edit|Cancel", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FirstTimeInitiation ::= \"→\" \"→\" \"→\" \nUserChoice ::= \"Execute Workflow\" | \"Edit Template\" | \"Cancel\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The generated workflow auto-executes without the developer's go-ahead.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated workflow → summary → developer choice{Execute | Edit Template | Cancel} → generation and first execution are separate approvals", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-first-time-initiation", "title": "First-Time Initiation" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate DSL compliance, workspace discovery, dynamic agent count, execution classification, context configuration, 4D graphs, handoff protocol, hybrid execution, checklist integration, capability integration, template assembly, dynamic paths, uppercase filenames, and agent-oriented content.", "term": "Intent" }, { "description": "A workflow template is complete only when orchestration, artifact, context, and validation contracts all pass.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowTemplate → GateSet → Valid|Invalid", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowValidationGate ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nCompletionVerdict ::= \"workflow_template_valid\" | \"workflow_template_invalid\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A workflow shipped without checking its handoff, 4D graphs, or dynamic paths.", "kind": "code", "language": "text", "title": "Before" }, { "code": "template → checks{DSL, workspace, agent sequence, execution mode, 4D graph, handoff, checklist, capabilities, artifact paths} → valid | invalid", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-validation-gate", "title": "Workflow Validation Gate" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Load DSL and orchestration references, configure file recovery and context forking, discover workspace zones and agents, select shared documents, define dynamic agent sequence, classify execution mode, build 4D graphs, define handoff protocol, assemble coordination sequence, integrate checklist and capabilities, generate phase documentation, assemble template, and validate success criteria.", "term": "Intent" }, { "description": "Workflow creation is a compiler from objective and workspace configuration into an executable multi-agent orchestration contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Specs → Workspace → Documents → Agents → Graphs → Handoffs → Coordination → Checklist → Capabilities → Template → Validation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowCreationKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Handoff Signal](/records/algorithms/handoff-signal), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Template Assembly](/records/algorithms/template-assembly), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading)", "term": "orient" }, { "description": "[Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection)", "term": "derive" }, { "description": "[Agent Sequence Definition](/records/algorithms/agent-sequence-definition)", "term": "project" }, { "description": "[Agent Activation Invocation](/records/algorithms/agent-activation-invocation)", "term": "act" }, { "description": "[Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "verify" }, { "description": "[Template Assembly](/records/algorithms/template-assembly)", "term": "commit" }, { "description": "[First-Time Initiation](/records/algorithms/first-time-initiation)", "term": "terminate" } ], "kind": "glossary" }, { "code": "An objective turned straight into a hardcoded, single-threaded agent script.", "kind": "code", "language": "text", "title": "Before" }, { "code": "load specs → discover workspace → select docs → define agents → classify execution → 4D graphs → handoffs → coordinate → checklist + capabilities → assemble → validate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Handoff Signal](/records/algorithms/handoff-signal), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Template Assembly](/records/algorithms/template-assembly), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-creation-kernel", "title": "Workflow Creation Kernel" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → \"→\" \"→\" \"→\" \"→\" \nPurityConstraint ::= \"no_hidden_state\" \",\" \"no_hidden_time\" \",\" \"no_hidden_randomness\" \",\" \"referential_transparency\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Correctness Verification](/records/algorithms/correctness-verification), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "function scoreFoo(f) { return f.base * (Date.now() % 2 ? 1.1 : 1); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function scoreFoo(f: Foo, now: Date) { return f.base * rateAt(now); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-deterministic-core", "title": "Deterministic Core" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Define executable architecture rules, validate with static analysis, specification tests, property tests, and runtime checks, then block release when critical rules fail.", "term": "Intent" }, { "description": "Architecture must be continuously verified by fitness functions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Rule → Test → Evidence → Pass|Fail → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VerificationFitness ::= \"→\" \"→\" \"→\" \nVerificationMethod ::= \"type_check\" | \"static_analysis\" | \"schema_validation\" | \"contract_test\" | \"property_based_test\" | \"specification_test\" | \"formal_verification\" | \"runtime_validation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "reviewChecklist.push(\"domain must not import infra\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "test(\"domain imports no infra\", () => expect(importsOf(\"domain\")).not.toContain(\"infra\"));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-verification-fitness", "title": "Verification Fitness" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect invalid state early, fail fast for programmer errors, fail safe for recoverable runtime faults, fail secure for security-sensitive failures, and return typed errors.", "term": "Intent" }, { "description": "Error handling is a contract for containment, disclosure, and recovery.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Operation → Guard → ErrorClass → BoundaryPolicy → RecoveryOrAbort", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ErrorBoundary ::= \"→\" \"→\" \"→\" \"→\" \nFailurePolicy ::= \"fail_fast\" | \"fail_safe\" | \"fail_secure\" | \"graceful_degradation\" | \"fallback\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Construction Boundary](/records/algorithms/governed-construction-boundary)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [resilience_recovery](/records/force/resilience-recovery), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "try { doFoo(); } catch (e) { return null; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "try { return ok(doFoo()); } catch (e) {\n if (isProgrammerError(e)) throw e;\n Logger.error(\"doFoo failed\", e); return err(\"foo.retry\");\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-error-boundary", "title": "Error Boundary" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "Wrap remote or unreliable calls with timeout, retry, circuit breaker, bulkhead isolation, fallback, and backpressure policies.", "term": "Intent" }, { "description": "Resilience is controlled failure under resource and dependency stress.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Call → Timeout → RetryPolicy → CircuitBreaker → Bulkhead → Fallback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResilienceControl ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nRetryPolicy ::= \"bounded_attempts\" \",\" \"jittered_backoff\" \",\" \"idempotency_required\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Composed by" }, { "description": "[resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const r = await callFoo(url);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const r = await breaker.run(() => withTimeout(callFoo(url), 2000), { retries: 3, backoff: jitter });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-resilience-control", "title": "Resilience Control" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "Continuously health-check services, isolate failed instances, fail over to redundancy, roll back unsafe releases, and use canary or blue-green deployment for controlled exposure.", "term": "Intent" }, { "description": "Deployment safety requires observable health and reversible rollout.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Deploy → HealthCheck → TrafficShift → DetectFailure → Rollback|Promote", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RecoveryDeployment ::= \"→\" \"→\" \"→\" \nDeploymentStrategy ::= \"blue_green\" | \"canary\" | \"rolling\" | \"rollback\" | \"auto_remediation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[resilience_recovery](/records/force/resilience-recovery), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "deployAll(fooV2);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "canary(fooV2, { percent: 5, healthCheck });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-recovery-deployment", "title": "Recovery Deployment" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Attach correlation and causation identifiers to every operation, emit structured logs, metrics, traces, and audit records, then connect them into an explainable execution graph.", "term": "Intent" }, { "description": "A system is operable only when behavior can be reconstructed from evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Request → CorrelationID → Logs/Metrics/Traces → Audit → CausalGraph", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ObservabilityTrace ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTelemetryEvent ::= \"log\" | \"metric\" | \"trace_span\" | \"alert\" | \"audit_log\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Event and Messaging Consistency](/records/algorithms/event-and-messaging-consistency)", "term": "Composed by" }, { "description": "[observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "console.log(\"processing foo\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "logger.info(\"foo.process\", { correlationId: ctx.cid, causationId: ctx.parentId, fooId: foo.id });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-observability-trace", "title": "Observability Trace" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model events as a dependency graph, assign causal metadata, preserve happens-before relationships with sequence numbers, Lamport clocks or vector clocks where physical timestamps are insufficient, and reject or compensate for invalid ordering.", "term": "Intent" }, { "description": "Distributed correctness depends on causal ordering, not just timestamps.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Event → CausalMetadata → DependencyGraph → OrderingValidation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CausalityOrdering ::= \"→\" \"→\" \"→\" \nCausalMetadata ::= \"correlation_id\" | \"causation_id\" | \"sequence_number\" | \"lamport_clock\" | \"vector_clock\"\nDependencyGraph ::= \"DAG\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "events.sort((a, b) => a.timestamp - b.timestamp);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "events.sort(byVectorClock);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-causality-ordering", "title": "Causality Ordering" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Measure workload, identify bottlenecks, choose vertical or horizontal scaling, partition load, cache safe data, enforce rate limits, and benchmark continuously.", "term": "Intent" }, { "description": "Scalability is achieved by measured bottleneck removal, not speculative optimization.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workload → Profile → Bottleneck → ScaleStrategy → Benchmark → Feedback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PerformanceScaling ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nScalingStrategy ::= \"vertical_scaling\" | \"horizontal_scaling\" | \"load_balancing\" | \"sharding\" | \"partitioning\" | \"caching\" | \"stateless_replication\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[performance_scaling](/records/force/performance-scaling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "optimizeEverywhere(app);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const hot = profile(load).topBottleneck();\nscale(hot, hot.isCpuBound ? \"horizontal\" : \"cache\"); benchmark();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-performance-scaling", "title": "Performance Scaling" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Cache only data with defined freshness, key identity, invalidation triggers, consistency expectations, and fallback behavior.", "term": "Intent" }, { "description": "Caching is safe only when staleness and invalidation are explicit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Data → CacheKey → FreshnessPolicy → Invalidation → ReadThrough|Bypass", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CacheContract ::= \"→\" \"→\" \"→\" \"→\" \nConsistencyPolicy ::= \"strong\" | \"eventual\" | \"read_your_writes\" | \"bounded_staleness\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "cache.set(key, value);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "cache.set(fingerprint(inputs, deriverVersion), value, { invalidateOn: [\"FooChanged\"], consistency: \"read_your_writes\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cache-correctness", "title": "Cache Correctness" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Externalize configuration, standardize protocols, isolate platform assumptions behind adapters, package runtime dependencies, and validate parity across environments.", "term": "Intent" }, { "description": "Portable systems separate behavior from deployment substrate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Code → ExternalConfig → StandardProtocol → Container|Package → EnvironmentParity", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PortabilityContract ::= \"→\" \"→\" \"→\" \"→\" \nEnvironmentValidation ::= \"dev\" \",\" \"test\" \",\" \"staging\" \",\" \"production\" \",\" \"parity_check\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const db = connect(\"driver://prod-host:5432\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const db = connect(config.databaseUrl);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-portability-environment", "title": "Portability Environment" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, protect secrets, and enforce policy continuously.", "term": "Intent" }, { "description": "Security is a default-deny contract over identity, data, and operations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ThreatModel → Identity → Authorization → Validation → Protection → Audit", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SecurityPolicy ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nAccessDecision ::= \"RBAC\" | \"ABAC\" | \"least_privilege\" | \"zero_trust\"\nDataProtection ::= \"encryption_at_rest\" \",\" \"encryption_in_transit\" \",\" \"secrets_management\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Construction Boundary](/records/algorithms/governed-construction-boundary)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "if (user) allowFoo();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (!policy.can(user, \"foo:write\", resource)) throw forbidden();\nconst foo = validate(FooSchema, input);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-security-policy", "title": "Security Policy" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Separate control concerns from data execution, centralize policy/configuration/authentication/logging where beneficial, and decentralize runtime execution where autonomy is required.", "term": "Intent" }, { "description": "A control plane coordinates policy while data planes execute work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → ControlPlane → DistributedExecution → Feedback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ControlPlane ::= \"→\" \"→\" \"→\" \"→\" \nCentralizedCoordination ::= \"configuration\" | \"authentication\" | \"authorization\" | \"logging\" | \"orchestration\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Control Plane Coordination](/records/algorithms/control-plane-coordination)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every service reads its own ad-hoc config and does its own auth — policy is scattered and drifts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "policy{central} → control-plane{config, auth, orchestration} → data-planes{Foo, Bar execute work} → telemetry-feedback → policy-adjustment", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-control-plane", "title": "Control Plane" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Represent behavior as data, validate the model or DSL, compile or interpret it into runtime behavior, and restrict reflection or code generation behind safety contracts.", "term": "Intent" }, { "description": "Metaprogramming is safe when code-as-data has schema, validation, and bounded execution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Model → Schema → Compile|Interpret → RuntimeBehavior → SafetyCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DeclarativeMetaprogramming ::= \"→\" \"→\" \"→\" \"→\" \nTransformationEngine ::= \"reflection\" | \"introspection\" | \"compile_time_evaluation\" | \"runtime_code_generation\" | \"DSL_interpreter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "eval(fooExpression);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const ast = parse(fooDsl, GRAMMAR); validate(ast, SCHEMA); run(compile(ast), sandbox);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-declarative-metaprogramming", "title": "Declarative Metaprogramming" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Process data sequentially through bounded pipeline stages, preserve forward-only semantics where required, apply backpressure, checkpoint state where needed, and keep stages stateless unless state is explicitly modeled.", "term": "Intent" }, { "description": "Streaming systems are contracts over flow, order, pressure, and bounded memory.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Source → Stage → Stage → Sink → Checkpoint", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StreamingDataflow ::= \"→\" \"→\" \"→\" \"→\" \nPipelineStage ::= \"→\" \"→\" \nProcessingMode ::= \"single_pass\" | \"lazy_evaluation\" | \"sequential_access\" | \"forward_only\" | \"stateless\" | \"stateful_with_checkpoint\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [resilience_recovery](/records/force/resilience-recovery), [streaming_dataflow](/records/force/streaming-dataflow), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const all = await loadAllFoo(); return all.map(toBar).filter(isBaz);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooSource.pipe(mapStage(toBar)).pipe(filterStage(isBaz)).pipe(sink, { backpressure: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-streaming-dataflow", "title": "Streaming Dataflow" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Retrieve knowledge from indexed sources, validate relevance and freshness, ground generation in retrieved evidence, and distinguish known, inferred, and unsupported output.", "term": "Intent" }, { "description": "Retrieval-augmented systems must separate source evidence from generated synthesis.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Query → Retrieve → Rank → Ground → Generate → Cite|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RAGBoundary ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nEvidenceDisclosure ::= \"supported\" | \"partially_supported\" | \"unsupported_reject_or_disclose\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Profile Compose](/records/algorithms/profile-compose), [Delta Capture](/records/algorithms/delta-capture)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const answer = model.generate(query);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const ev = retrieve(query);\nconst g = generate(query, ev);\nreturn g.supported ? cite(g, ev) : disclose(\"unsupported\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-rag-knowledge-boundary", "title": "RAG Knowledge Boundary" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a concern, classify its force type, select the corresponding contract family, compose required invariants, bind implementation patterns, and attach validation gates.", "term": "Intent" }, { "description": "Architectural patterns are reusable only when selected by force, not by name.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concern → ForceType → ContractFamily → PatternSet → ValidationGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureSelection ::= \"→\" \"→\" \"→\" \"→\" \nForceFamily ::= \"modularity\" | \"compatibility\" | \"semantics\" | \"extension\" | \"state\" | \"correctness\" | \"resilience\" | \"security\" | \"scale\" | \"governance\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pattern chosen by name ('let's use Foo') before the force it must resolve is known.", "kind": "code", "language": "text", "title": "Before" }, { "code": "concern → force{change-isolation} → contract-family{deployment-boundary} → pattern{selected by force, not by name} → validation-gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-selection-meta-algorithm", "title": "Architecture Selection Meta-Algorithm" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For any architectural concern, define its intent, boundary, contract, invariants, allowed variation, forbidden leakage, validation strategy, observability model, and evolution policy.", "term": "Intent" }, { "description": "Every architecture principle can be operationalized as a bounded contract with verification and change rules.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Intent → Boundary → Contract → Invariant → Variation → Validation → Evolution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "UniversalConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nContract ::= \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A principle stated as prose ('be modular') with no operational contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "intent → boundary → contract{in, out, pre, post} → invariants → allowed-variation → forbidden-leakage → validation → observability → evolution", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-universal-architectural-concern-template", "title": "Universal Architectural Concern Template" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → ", "term": "Intent" }, { "description": "Architecture becomes reproducible when every named principle is reduced to a force, every force becomes a contract, every contract has invariants, and every invariant has validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Force → Contract → Pattern → Implementation → Verification → Operation → Evolution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalContractAlgebra ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nForce ::= \"change\" | \"dependency\" | \"semantic_consistency\" | \"runtime_extension\" | \"state_mutation\" | \"failure\" | \"scale\" | \"security\" | \"governance\" | \"intelligence\"\nBoundary ::= | | | | | | \nPattern ::= | | | | | | \nVerification ::= | | | | | | \nEvolution ::= | | | | | ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-contract-algebra", "title": "Architectural Contract Algebra" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For a module whose public surface is machine-derivable, make its metadata manifest the single documentation source of truth: authored narrative lives in mandated, shape-validated manifest fields (with self-expanding custom fields), the API surface is collected deterministically from the built type-declarations, one marker-layered document is compiled per module from both, and a governance router runs the context-detection rules on the manifest strings where a manifest governs (rendering each field to its markdown fragment first) and on the document itself where none exists. Beyond the module document, a manifest may declare typed documents — each a form plus concern that routes through the pure location function to a computed path — generated and drift-checked the same way, so the manifest is the single content generator with no separate template mechanism.", "term": "Intent" }, { "description": "A module's document is well-formed iff it recompiles byte-identical from its manifest docs-block plus its derived surface, its docs-block satisfies the mandated schema with every custom field a renderable shape, and every governed string passes the context rules reported at its manifest field; the manifest, where present, is the governed surface and the document is exempt and drift-checked.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Manifest → AuthoredField → DerivedSurface → SectionDeriver → MarkerLayer → Compilation → GovernanceRouter → DriftGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModuleDocument ::= \"+\" \"→\" \"→\" \"→\" \"→\" \nGovernanceRouter ::= \"→\" | \"→\" \nTypedDocument ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Document Truth Alignment](/records/algorithms/document-truth-alignment), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [contract_compatibility](/records/force/contract-compatibility), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A README hand-authored as prose that drifts from the exports it claims to document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "manifest.docs{authored} + derivedSurface{from .d.ts} → section-derivers → marker-template → compile → drift-gate{recompiles byte-identical, else fail}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Document Truth Alignment](/records/algorithms/document-truth-alignment), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-manifest-driven-documentation", "title": "Manifest-Driven Documentation" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For any reusable package that must stay agnostic of the applications consuming it, hardcode zero consumer-specific truths in package source; declare every consumer-specific value in one consumer-owned config of typed sections, load it through a framework the leaf packages never import, and hand each package only the section it needs through an injection surface — so a package drops into any consumer without a literal about that consumer leaking through its source.", "term": "Intent" }, { "description": "A package is consumer-agnostic iff every consumer-specific value it depends on arrives by injection at wiring time and no consumer token, path, or config-location appears in its source; the one consumer config is the single reader-visible source of those values and a static gate rejects any re-hardcoding.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConsumerValue → ConfigSection → FrameworkLoad → InjectionSurface → PackageConsumption → CouplingGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConsumerConfigSSOT ::= \"→\" \"→\" \"→\" \"→\" \"+\" \nInjectionSurface ::= \"|\" \"|\" \"|\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const ROOT = \"my-app\";\nconst cfg = read(\"../config/app.json\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export function createFoo(opts: { root: string; store: FooStore }) { return new Foo(opts); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-consumer-config-ssot", "title": "Consumer Config SSOT" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model behavior as a finite set of states with explicit legal transitions, so illegal state combinations are unrepresentable.", "term": "Intent" }, { "description": "Every runtime state is one of the declared states and every transition is a declared edge.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EnumerateStates → DefineEvents → DeclareTransitions → RejectUndeclared", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FiniteStateMachine ::= \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[State Pattern](/records/algorithms/state-pattern), [Structural Core](/records/algorithms/structural-core)", "term": "Composes" }, { "description": "[Statecharts](/records/algorithms/statecharts)", "term": "Composed by" }, { "description": "boolean-flag-soup (illegal-states)", "term": "Forces" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "let isOpen = false, isLoading = false, isError = false;\nfunction onClick() { isLoading = true; if (isOpen) isOpen = false; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooState = \"closed\" | \"loading\" | \"open\" | \"error\";\nconst transitions: Record>> = {\n closed: { open: \"loading\" },\n loading: { ready: \"open\", fail: \"error\" },\n open: { close: \"closed\" },\n error: { retry: \"loading\" },\n};\nfunction next(state: FooState, event: FooEvent): FooState { return transitions[state][event] ?? state; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[State Pattern](/records/algorithms/state-pattern), [Structural Core](/records/algorithms/structural-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-finite-state-machine", "title": "Finite State Machine" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Extend a flat state machine with hierarchy and parallel regions, so independent concerns compose without state explosion.", "term": "Intent" }, { "description": "Independent behavioral concerns live in separate parallel regions rather than a cross product of flat states.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "IdentifyIndependentConcerns → NestRelatedStates → SeparateParallelRegions → GuardTransitions", "kind": "code", "language": "text", "title": "Flow" }, { "code": "Statecharts ::= \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Finite State Machine](/records/algorithms/finite-state-machine), [Separation of Concerns](/records/algorithms/separation-of-concerns)", "term": "Composes" }, { "description": "flat-state-explosion (combinatorial-growth)", "term": "Forces" }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "type S = \"idleMuted\" | \"idleLoud\" | \"playingMuted\" | \"playingLoud\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooChart = {\n initial: \"idle\",\n states: { idle: {}, playing: {} },\n parallel: { volume: { states: { muted: {}, loud: {} } } },\n};", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Finite State Machine](/records/algorithms/finite-state-machine), [Separation of Concerns](/records/algorithms/separation-of-concerns)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-statecharts", "title": "Statecharts" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model concurrent flow as places, tokens, and transitions, so reachability and deadlock are analyzable before runtime.", "term": "Intent" }, { "description": "Concurrent progress is expressed as token flow through transitions whose enabling conditions are explicit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DefinePlaces → PlaceTokens → DefineTransitions → AnalyzeReachability → AssertNoDeadlock", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PetriNet ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Concurrency Correctness](/records/algorithms/concurrency-correctness), [Correctness Core](/records/algorithms/correctness-core)", "term": "Composes" }, { "description": "ad-hoc-lock-ordering (deadlock)", "term": "Forces" }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "acquire(a); acquire(b); work(); release(b); release(a);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const net = petriNet({\n places: { idle: 1, aHeld: 0, bHeld: 0 },\n transitions: [\n { name: \"takeA\", consume: { idle: 1 }, produce: { aHeld: 1 } },\n { name: \"takeB\", consume: { aHeld: 1 }, produce: { bHeld: 1 } },\n ],\n});\nassertNoDeadlock(reachableMarkings(net));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Concurrency Correctness](/records/algorithms/concurrency-correctness), [Correctness Core](/records/algorithms/correctness-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-petri-nets", "title": "Petri Nets" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Size a system from arrival and service rates, so capacity and wait time are predicted rather than guessed.", "term": "Intent" }, { "description": "Utilization stays below one and predicted wait time is derived from the arrival/service-rate model.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MeasureArrivalRate → MeasureServiceRate → ComputeUtilization → PredictWaitTime → SizeServers", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QueuingModel ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capacity Planning](/records/algorithms/capacity-planning), [Performance Core](/records/algorithms/performance-core)", "term": "Composes" }, { "description": "guess-based-capacity (saturation)", "term": "Forces" }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const workers = 4;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const rho = arrivalRate / (workers * serviceRate);\nif (rho >= 1) throw new Error(\"unstable queue: utilization >= 1\");\nconst avgWaitMs = mm1WaitTime({ arrivalRate, serviceRate, servers: workers });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Capacity Planning](/records/algorithms/capacity-planning), [Performance Core](/records/algorithms/performance-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-queuing-theory", "title": "Queuing Theory" } ], "title": "Architecture" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_architectural_relationship_record[\"Architectural Relationship Record\"]\n n_architecture_knowledge_graph[\"Architecture Knowledge Graph\"]\n n_architectural_force_classification[\"Architectural Force Classification\"]\n n_dependency_closure[\"Dependency Closure\"]\n n_reinforcement_propagation[\"Reinforcement Propagation\"]\n n_conflict_and_tension_resolution[\"Conflict and Tension Resolution\"]\n n_severity_policy[\"Severity Policy\"]\n n_violation_detection[\"Violation Detection\"]\n n_measurement_normalization[\"Measurement Normalization\"]\n n_refactor_selection[\"Refactor Selection\"]\n n_enforcement_gate[\"Enforcement Gate\"]\n n_architecture_assessment[\"Architecture Assessment\"]\n n_modular_boundary_compliance[\"Modular Boundary Compliance\"]\n n_contract_compatibility[\"Contract Compatibility\"]\n n_canonical_semantics[\"Canonical Semantics\"]\n n_self_description_and_discovery[\"Self-Description and Discovery\"]\n n_runtime_extensibility[\"Runtime Extensibility\"]\n n_pattern_selection[\"Pattern Selection\"]\n n_event_and_messaging_consistency[\"Event and Messaging Consistency\"]\n n_state_and_transaction_safety[\"State and Transaction Safety\"]\n n_correctness_verification[\"Correctness Verification\"]\n n_resilience_policy[\"Resilience Policy\"]\n n_observability_and_auditability[\"Observability and Auditability\"]\n n_performance_and_scalability[\"Performance and Scalability\"]\n n_security_governance[\"Security Governance\"]\n n_architecture_evolution_governance[\"Architecture Evolution Governance\"]\n n_control_plane_coordination[\"Control Plane Coordination\"]\n n_metaprogramming_safety[\"Metaprogramming Safety\"]\n n_model_lifecycle_governance[\"Model Lifecycle Governance\"]\n n_architectural_recommendation[\"Architectural Recommendation\"]\n n_architecture_fitness_function_generation[\"Architecture Fitness Function Generation\"]\n n_architecture_refactoring_roadmap[\"Architecture Refactoring Roadmap\"]\n n_concept_cluster_extraction[\"Concept Cluster Extraction\"]\n n_architecture_decision_support[\"Architecture Decision Support\"]\n n_relationship_schema_validation[\"Relationship Schema Validation\"]\n n_architecture_catalog_compiler[\"Architecture Catalog Compiler\"]\n n_master_architecture_governance_kernel[\"Master Architecture Governance Kernel\"]\n n_architectural_relationship_algebra[\"Architectural Relationship Algebra\"]\n n_architecture_assessment --> n_dependency_closure\n n_architecture_assessment --> n_violation_detection\n n_architecture_assessment --> n_measurement_normalization\n n_architecture_evolution_governance --> n_architecture_assessment\n n_architectural_recommendation --> n_dependency_closure\n n_architecture_fitness_function_generation --> n_architectural_relationship_record\n n_architecture_fitness_function_generation --> n_enforcement_gate\n n_architecture_fitness_function_generation --> n_severity_policy\n n_master_architecture_governance_kernel --> n_relationship_schema_validation\n n_master_architecture_governance_kernel --> n_concept_cluster_extraction\n n_master_architecture_governance_kernel --> n_dependency_closure\n n_master_architecture_governance_kernel --> n_violation_detection\n n_master_architecture_governance_kernel --> n_measurement_normalization\n n_master_architecture_governance_kernel --> n_refactor_selection\n n_master_architecture_governance_kernel --> n_enforcement_gate\n n_master_architecture_governance_kernel --> n_architecture_decision_support\n n_architectural_relationship_algebra --> n_dependency_closure\n n_architectural_relationship_algebra --> n_violation_detection\n n_architectural_relationship_algebra --> n_measurement_normalization\n n_architectural_relationship_algebra --> n_refactor_selection\n n_architectural_relationship_algebra --> n_enforcement_gate\n n_architectural_relationship_algebra --> n_architecture_evolution_governance" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-arch-relationships", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Represent every architectural concept as a typed relationship record containing scope, dependencies, reinforcing effects, enabled capabilities, conflicts, tensions, violations, detection signals, metrics, refactor actions, enforcement mechanisms, and severity.", "term": "Intent" }, { "description": "An architecture principle becomes operational when it is converted from a name into a measurable, enforceable relationship contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concept → Type → Scope → Requires → Violations → Detection → Measurement → Refactor → Enforcement → Severity", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalRelationshipRecord ::= \":\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nRecordType ::= \"Principle\" | \"Quality Attribute\" | \"Contract\" | \"Architecture Style\" | \"Pattern\" | \"Mechanism\" | \"Metric\" | \"Practice\"\nEnforcementSeverity ::= \"mandatory\" | \"recommended\" | \"contextual\" | \"discouraged\"\nMandatoryFor ::= \"contextual\" \"+\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Low Coupling' as a bare name in a list — not measurable, not enforceable.", "kind": "code", "language": "text", "title": "Before" }, { "code": "Low Coupling : Quality-Attribute, scope{module}, requires{Abstraction}, conflicts_with{Tight Coupling}, detected_by{cycle scan}, measured_by{coupling metric}, refactored_by{invert dependency}, enforced_by{dependency rule}, severity{mandatory}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-relationship-record", "title": "Architectural Relationship Record" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Parse all relationship records into a directed multigraph where concepts are nodes and fields such as requires, reinforces, enables, conflicts, tensions, detects, measures, refactors, and enforces are typed edges.", "term": "Intent" }, { "description": "The architecture catalog becomes reusable when its relationships can be traversed as a graph.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Records → Nodes → TypedEdges → Graph → QueryableArchitectureModel", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureGraph ::= \",\" \nConceptNode ::= \",\" \",\" \",\" \nRelationshipEdge ::= \"→\" \"→\" \nRelationType ::= \"requires\" | \"reinforces\" | \"enables\" | \"conflicts_with\" | \"tensions_with\" | \"violated_by\" | \"detected_by\" | \"measured_by\" | \"refactored_by\" | \"enforced_by\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A flat list of relationship records — no way to ask 'what does Foo require, transitively?'", "kind": "code", "language": "text", "title": "Before" }, { "code": "records → nodes{concepts} + typed-edges{requires, reinforces, enables, conflicts_with} → traversable graph", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-knowledge-graph", "title": "Architecture Knowledge Graph" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Given a design issue or desired quality, classify it into a force family, then select all concepts whose scope, type, violation signals, and enabled capabilities match that force.", "term": "Intent" }, { "description": "Architectural decisions should be selected by force and evidence, not by pattern name recognition.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Issue → ForceFamily → CandidateConcepts → ApplicableContracts", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ForceClassification ::= \"→\" \"→\" \"→\" \nForceFamily ::= \"modularity\" | \"contract_compatibility\" | \"semantic_consistency\" | \"domain_boundary\" | \"runtime_extensibility\" | \"object_creation\" | \"structural_mediation\" | \"behavioral_variation\" | \"event_messaging\" | \"state_transaction\" | \"correctness_verification\" | \"resilience_recovery\" | \"observability_traceability\" | \"causality_ordering\" | \"performance_scaling\" | \"security_governance\" | \"architecture_evolution\" | \"control_coordination\" | \"metaprogramming_modeling\" | \"streaming_dataflow\" | \"model_governance\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A design issue answered by pattern-name recall ('use a Factory').", "kind": "code", "language": "text", "title": "Before" }, { "code": "issue{concrete constructor everywhere} → force{object_creation} → concept-query → applicable{Construction Boundary}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-force-classification", "title": "Architectural Force Classification" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "For any target architectural concept, recursively collect its required concepts until no new requirements remain, then order the closure by dependency depth before implementation.", "term": "Intent" }, { "description": "A principle cannot be adopted safely unless its prerequisites are also satisfied.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetConcept → RequiresEdges → TransitiveClosure → DependencyOrder", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DependencyClosure ::= \"→\" \"→\" \"→\" \nRequiresTraversal ::= \"follow requires edges until fixed point\"\nTopologicalOrder ::= \"prerequisites_before_dependents\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Architectural Recommendation](/records/algorithms/architectural-recommendation), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Adopt Foo without checking what Foo needs — its prerequisites are silently unmet.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target{Foo} → follow requires-edges to fixed point → {Bar, Baz} → topological order{Baz, Bar, Foo}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dependency-closure", "title": "Dependency Closure" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "When a concept is implemented or strengthened, traverse its reinforces and enables edges to identify secondary quality gains and architecture capabilities unlocked.", "term": "Intent" }, { "description": "Architecture improvements produce second-order effects through reinforcing relationships.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ImplementedConcept → Reinforces + Enables → CapabilityImpact", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReinforcementPropagation ::= \"→\" \"→\" \"→\" \nImpactSet ::= \",\" \nQualityGain ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Foo implemented; its second-order gains go unnoticed and unclaimed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "satisfied{Foo} → reinforces → {Bar quality} → enables → {Baz capability} → impact set with confidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-reinforcement-propagation", "title": "Reinforcement Propagation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For each selected concept, collect conflicts and tensions, classify conflicts as prohibitive or resolvable, classify tensions as trade-offs, and require an explicit decision when severity or impact is high.", "term": "Intent" }, { "description": "Architecture is not only principle application; it is trade-off governance.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CandidateConcept → Conflicts + Tensions → TradeoffAnalysis → Decision", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConflictTensionResolution ::= \"→\" \"→\" \"→\" \nResolutionPolicy ::= \"reject_combination\" | \"accept_with_mitigation\" | \"document_tradeoff\" | \"require_architecture_decision\" | \"contextual_override\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two chosen concepts silently conflict at runtime; the developer never decided the trade-off.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidates{Foo, Bar} → conflict{prohibitive} → tension{trade-off} → policy{require architecture decision}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-conflict-and-tension-resolution", "title": "Conflict and Tension Resolution" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Interpret severity as an enforcement policy: mandatory concepts become gates, recommended concepts become review findings, contextual concepts require scope justification, and discouraged concepts require explicit exception approval.", "term": "Intent" }, { "description": "Severity converts architecture knowledge into governance behavior.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Severity → EnforcementMode → GateBehavior", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SeverityPolicy ::= \"→\" \nEnforcementMode ::= \"blocking_gate\" | \"review_warning\" | \"context_required\" | \"exception_required\" | \"informational\"\nSeverityMapping ::= \"mandatory → blocking_gate\" | \"recommended → review_warning\" | \"contextual → context_required\" | \"discouraged → exception_required\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Anti-Pattern Rule Compiler](/records/algorithms/anti-pattern-rule-compiler), [Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation)", "term": "Composed by" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every finding treated the same — a style nit blocks like a critical flaw.", "kind": "code", "language": "text", "title": "Before" }, { "code": "severity{mandatory} → blocking-gate ; severity{recommended} → review-warning ; severity{contextual} → context-required", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-severity-policy", "title": "Severity Policy" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For each concept applicable to the current scope, execute its detected_by signals against the implementation, map observations to violated_by patterns, and produce evidence-backed violation records.", "term": "Intent" }, { "description": "A principle violation must be grounded in observable implementation signals.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ApplicableConcept → DetectionSignals → Observations → ViolationRecords", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ViolationDetection ::= \"→\" \"→\" \"→\" \nViolationRecord ::= \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Foo is violated' asserted from opinion, with no observable signal.", "kind": "code", "language": "text", "title": "Before" }, { "code": "concept{Foo} → detected_by signals run on code → observations → violation-record{concept, pattern, evidence, severity}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-violation-detection", "title": "Violation Detection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Convert each concept’s measured_by field into executable or reviewable metrics, collect metric values, normalize them to comparable scores, and attach confidence based on measurement quality.", "term": "Intent" }, { "description": "Architectural assessment requires metrics with provenance, not free-form judgment.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MeasuredBy → MetricDefinition → Measurement → NormalizedScore → Confidence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MeasurementNormalization ::= \"→\" \"→\" \"→\" \nMetricDefinition ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Architecture judged by free-form opinion, no comparable numbers.", "kind": "code", "language": "text", "title": "Before" }, { "code": "measured_by{coupling} → metric-definition{scope, method, threshold} → values → normalized score + confidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-measurement-normalization", "title": "Measurement Normalization" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a violation record, select refactor actions from the concept’s refactored_by field, rank actions by severity, dependency closure, blast radius, and expected reinforcement gain.", "term": "Intent" }, { "description": "Refactoring should be selected from the violated concept’s remediation contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Violation → RefactorCandidates → RiskRank → SelectedPlan", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RefactorSelection ::= \"→\" \"→\" \"→\" \nRefactorRanking ::= \"severity\" \",\" \"required_dependency_count\" \",\" \"blast_radius\" \",\" \"reinforcement_gain\" \",\" \"rollback_feasibility\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A fix chosen ad hoc, unrelated to the violated concept's remediation contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "violation{Foo} → refactored_by candidates → rank{severity, blast-radius, reinforcement-gain} → refactor plan", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-refactor-selection", "title": "Refactor Selection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Translate each concept’s enforced_by field into static checks, contract tests, schema validation, CI gates, policy rules, runtime monitors, review gates, or architecture fitness functions.", "term": "Intent" }, { "description": "Enforcement converts architectural intent into repeatable control.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EnforcementDescriptor → GateType → ValidationProcedure → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EnforcementGate ::= \"→\" \"→\" \"→\" \nGateType ::= \"static_analysis\" | \"architecture_test\" | \"schema_validation\" | \"contract_test\" | \"lint_rule\" | \"fitness_function\" | \"runtime_monitor\" | \"policy_as_code\" | \"review_gate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'enforced_by: review' — a reviewer's promise that erodes under deadline.", "kind": "code", "language": "text", "title": "Before" }, { "code": "enforced_by{Foo} → gate-type{static-analysis | contract-test | fitness-function} → pass/fail in CI", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-enforcement-gate", "title": "Enforcement Gate" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select concepts relevant to a target scope, compute dependency closure, detect violations, measure evidence, rank findings by severity, and emit a prioritized architecture assessment.", "term": "Intent" }, { "description": "Assessment is graph query plus evidence collection plus severity policy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Scope → RelevantConcepts → DependencyClosure → Detection → Measurement → Findings", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureAssessment ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nFindingPrioritization ::= \"mandatory_first\" \",\" \"high_blast_radius\" \",\" \"high_reinforcement_gain\" \",\" \"low_refactor_cost\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization)", "term": "Composes" }, { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'The architecture is fine' — an unscoped, evidence-free claim.", "kind": "code", "language": "text", "title": "Before" }, { "code": "scope → relevant concepts → dependency-closure → violation-detection → measurement → prioritized findings", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-assessment", "title": "Architecture Assessment" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Evaluate SRP, separation of concerns, cohesion, coupling, encapsulation, information hiding, abstraction, modularity, composability, replaceability, and autonomy as a connected boundary cluster.", "term": "Intent" }, { "description": "Modular design is not one principle; it is a mutually reinforcing cluster around responsibility, dependency, and visibility.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Module → Responsibility → Cohesion → Coupling → Visibility → BoundaryHealth", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModularBoundaryCompliance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nBoundaryScore ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Modularity judged as one vague impression.", "kind": "code", "language": "text", "title": "Before" }, { "code": "modules → responsibility + cohesion + coupling + visibility-leak → boundary score{per-dimension}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-modular-boundary-compliance", "title": "Modular Boundary Compliance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For APIs, services, data, schemas, and protocols, validate explicit contracts, preconditions, postconditions, invariants, versioning, backward compatibility, forward compatibility, and interoperability.", "term": "Intent" }, { "description": "Compatibility is the contract cluster that allows independent evolution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Boundary → Contract → Version → CompatibilityMatrix → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContractCompatibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nCompatibilityMatrix ::= \"producer_current_consumer_current\" | \"producer_new_consumer_old\" | \"producer_old_consumer_new\" | \"unknown_field_handling\" | \"breaking_diff_check\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A schema changed and downstreams broke — compatibility was never checked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "boundary-contract → schema/semantic validation → version-policy → compatibility-matrix{new-producer/old-consumer} → verdict", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-contract-compatibility", "title": "Contract Compatibility" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect duplicated or conflicting models, schemas, terms, rules, and data definitions; select or create canonical authority; normalize variants; enforce single source of truth.", "term": "Intent" }, { "description": "Semantic consistency requires canonical authority and explicit translation where contexts differ.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concepts → Conflicts → CanonicalAuthority → Normalization → Enforcement", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CanonicalSemantics ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSemanticArtifact ::= \"schema\" | \"domain_model\" | \"field\" | \"term\" | \"rule\" | \"configuration\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Three models of 'Foo' drift apart; no single authority.", "kind": "code", "language": "text", "title": "Before" }, { "code": "artifacts{Foo-a, Foo-b} → conflict-detection → canonical authority → normalize variants → SSOT gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-canonical-semantics", "title": "Canonical Semantics" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Require components, services, APIs, plugins, and runtime structures to declare metadata, capabilities, contracts, dependencies, configuration, and health so they can be discovered and validated.", "term": "Intent" }, { "description": "Dynamic architecture requires self-description before runtime binding.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Component → Manifest → CapabilityDeclaration → Discovery → ContractValidation → Binding", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SelfDescribingDiscovery ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nManifest ::= \"identity\" \",\" \"version\" \",\" \"capabilities\" \",\" \"dependencies\" \",\" \"contracts\" \",\" \"configuration\" \",\" \"health\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A runtime component's capabilities are unknowable without reading its source.", "kind": "code", "language": "text", "title": "Before" }, { "code": "entity → manifest{identity, capabilities, contracts} → discovery → conformance-validation → bind only if it matches", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-self-description-and-discovery", "title": "Self-Description and Discovery" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect repeated core modification for variants, define extension points, create plugin contracts, register implementations, discover them dynamically, and isolate failures.", "term": "Intent" }, { "description": "Extensibility is controlled variation behind stable runtime contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "VariantPressure → ExtensionPoint → PluginContract → Registry → Discovery → Isolation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RuntimeExtensibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRegistrationPolicy ::= \"manual_registration\" | \"manifest_based\" | \"service_registry\" | \"convention_based\" | \"configuration_based\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Runtime Discovery](/records/algorithms/runtime-discovery)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every new variant edits the core switch statement.", "kind": "code", "language": "text", "title": "Before" }, { "code": "variant-pressure → extension-point → plugin-contract → registry → runtime-discovery → failure-isolation", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Runtime Discovery](/records/algorithms/runtime-discovery)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-runtime-extensibility", "title": "Runtime Extensibility" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select creational, structural, or behavioral patterns based on the problem force: creation variation, interface mismatch, access control, behavior variation, notification, workflow reuse, or coordination complexity.", "term": "Intent" }, { "description": "Design patterns are remedies for specific force shapes, not generic decorations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProblemForce → PatternFamily → CandidatePattern → ApplicabilityCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternSelection ::= \"→\" \"→\" \"→\" \nPatternFamily ::= \"creational\" | \"structural\" | \"behavioral\"\nCandidatePattern ::= \"factory\" | \"factory_method\" | \"abstract_factory\" | \"builder\" | \"prototype\" | \"adapter\" | \"facade\" | \"proxy\" | \"bridge\" | \"decorator\" | \"strategy\" | \"template_method\" | \"observer\" | \"mediator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pattern applied as decoration ('let's add a Facade') with no force to justify it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "force{interface mismatch} → family{structural} → candidate{Adapter} → applicability verdict", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-selection", "title": "Pattern Selection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For asynchronous systems, validate event contracts, message schemas, idempotent consumers, outbox publication, correlation metadata, ordering guarantees, retry behavior, and dead-letter handling.", "term": "Intent" }, { "description": "Event-driven architecture is safe only when messages are contracts and consumers are replay-safe.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StateChange → EventContract → Outbox → Broker → IdempotentConsumer → Trace", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EventMessagingConsistency ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nEventClassification ::= \"domain_event\" | \"integration_event\" | \"stream_event\"\nPublicationReliability ::= \"transactional_outbox\" | \"append_only_log\" | \"broker_acknowledgement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Observability Trace](/records/algorithms/observability-trace)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [observability_traceability](/records/force/observability-traceability), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[Event Messaging](/records/algorithms/event-messaging): Event messaging describes how state changes are published and consumed; this record validates that the published messages are contracts and that consumers are safe to replay.", "term": "Distinct from" } ], "kind": "glossary" }, { "code": "Events published ad hoc; a consumer replays and double-applies.", "kind": "code", "language": "text", "title": "Before" }, { "code": "state-change → event-contract → transactional-outbox → broker → idempotent-consumer → ordering + trace", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Observability Trace](/records/algorithms/observability-trace)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-event-and-messaging-consistency", "title": "Event and Messaging Consistency" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Identify state mutation boundaries, enforce unit-of-work scope, validate invariants, apply concurrency control, guarantee idempotency where retries exist, and isolate side effects.", "term": "Intent" }, { "description": "State correctness depends on explicit mutation boundaries and repeat-safe effects.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Command → TransactionBoundary → Invariant → Concurrency → Commit|Rollback → Idempotency", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StateTransactionSafety ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nConcurrencyControl ::= \"optimistic_locking\" | \"pessimistic_locking\" | \"serial_execution\" | \"state_isolation\"\nSideEffectPolicy ::= \"idempotent\" | \"outbox_published\" | \"compensatable\" | \"controlled_side_effect\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two mutations with no boundary; a crash between them corrupts state.", "kind": "code", "language": "text", "title": "Before" }, { "code": "command → transaction-boundary → invariant-check → concurrency-control → commit/rollback → idempotent side-effect", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-state-and-transaction-safety", "title": "State and Transaction Safety" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Push nondeterminism to boundaries, prefer pure deterministic core logic, validate specifications with static analysis, type checks, property tests, contract tests, formal methods where useful, and reproducible test environments.", "term": "Intent" }, { "description": "Correctness is achieved by deterministic design plus evidence-based verification.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Input → Canonicalize → DeterministicCore → Spec → Verification → Evidence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CorrectnessVerification ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nVerificationMethod ::= \"type_check\" | \"static_analysis\" | \"schema_validation\" | \"contract_test\" | \"property_based_test\" | \"specification_test\" | \"formal_verification\" | \"runtime_validation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Correctness asserted by 'it worked on my machine'.", "kind": "code", "language": "text", "title": "Before" }, { "code": "input → canonicalize → deterministic-core → spec → {type-check, property-test, contract-test} → evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-correctness-verification", "title": "Correctness Verification" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Classify failure modes, apply fail-fast, fail-safe, fail-secure, retry, timeout, circuit breaker, fallback, bulkhead, backpressure, health check, failover, and rollback policies according to dependency criticality.", "term": "Intent" }, { "description": "Resilience is controlled degradation under known failure modes.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FailureMode → Criticality → PolicySet → RuntimeGuard → Recovery", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResiliencePolicy ::= \"→\" \"→\" \"→\" \"→\" \nResiliencePattern ::= \"timeout\" | \"retry\" | \"circuit_breaker\" | \"fallback\" | \"bulkhead\" | \"backpressure\" | \"health_check\" | \"failover\" | \"rollback\" | \"auto_remediation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A remote call with no failure policy takes the whole system down.", "kind": "code", "language": "text", "title": "Before" }, { "code": "failure-modes → criticality → {timeout, retry, circuit-breaker, bulkhead} → runtime-guard → recovery", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-resilience-policy", "title": "Resilience Policy" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Attach correlation and causation identifiers, emit logs, metrics, traces, alerts, audit records, and runtime health signals, then reconstruct behavior as a causal execution graph.", "term": "Intent" }, { "description": "Operability requires reconstructable evidence across runtime boundaries.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Operation → Correlation → Telemetry → Audit → TraceGraph → Diagnosis", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ObservabilityAuditability ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTelemetryEvent ::= \"structured_log\" | \"metric\" | \"trace_span\" | \"alert\" | \"audit_log\" | \"health_signal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [observability_traceability](/records/force/observability-traceability), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An incident with no correlation ids — behavior can't be reconstructed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "operation → correlation-id + causation-id → {logs, metrics, traces, audit} → trace-graph → diagnosis", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-observability-and-auditability", "title": "Observability and Auditability" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Establish workload model, profile runtime behavior, benchmark repeatably, identify bottlenecks, analyze time and space complexity, select scaling strategy, optimize only measured bottlenecks, and enforce SLO gates.", "term": "Intent" }, { "description": "Performance engineering is evidence-driven bottleneck control, not speculative optimization.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workload → Profile → Benchmark → Bottleneck → Complexity → Scale|Optimize → SLO", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PerformanceScalability ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nScalingOrOptimizationPlan ::= \"vertical_scale\" | \"horizontal_scale\" | \"load_balance\" | \"shard\" | \"partition\" | \"cache\" | \"stream\" | \"rate_limit\" | \"algorithm_replacement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[performance_scaling](/records/force/performance-scaling), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Optimize by guesswork; add capacity and hope.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workload → profile → benchmark → bottleneck → complexity → scale/optimize the measured bottleneck → SLO gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-performance-and-scalability", "title": "Performance and Scalability" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, manage secrets, enforce policy as code, and continuously audit compliance.", "term": "Intent" }, { "description": "Security is an enforced policy graph over identity, data, operations, and infrastructure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ThreatModel → ControlSet → Policy → Enforcement → Audit", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SecurityGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSecurityControl ::= \"authentication\" | \"authorization\" | \"least_privilege\" | \"zero_trust\" | \"input_validation\" | \"output_encoding\" | \"encryption_at_rest\" | \"encryption_in_transit\" | \"secrets_management\" | \"audit_logging\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Security added as a late checklist, not a policy graph.", "kind": "code", "language": "text", "title": "Before" }, { "code": "threat-model → controls{authn, authz, validation, encryption, secrets} → policy-as-code → enforcement → continuous audit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-security-governance", "title": "Security Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Assess architecture against quality attributes, record decisions, analyze impact, track gaps, enforce standards with fitness functions, standardize patterns, and evolve through ADR-backed controlled change.", "term": "Intent" }, { "description": "Evolutionary architecture requires decision memory and continuous fitness validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Assessment → GapAnalysis → DecisionRecord → FitnessFunction → ChangePlan → Review", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureEvolutionGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nDecisionRecord ::= \"ADR\" \",\" \"context\" \",\" \"decision\" \",\" \"consequences\" \",\" \"status\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment)", "term": "Composes" }, { "description": "[Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra), [Version Provenance](/records/algorithms/version-provenance), [Type-Migration Centralization](/records/algorithms/type-migration-centralization)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Architecture drifts; no decision memory, no fitness checks.", "kind": "code", "language": "text", "title": "Before" }, { "code": "assessment → gap-analysis → ADR → fitness-functions → change-plan → review gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-evolution-governance", "title": "Architecture Evolution Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Separate control-plane policy from data-plane execution, centralize configuration, authentication, logging, or orchestration only where shared governance is beneficial, and preserve local autonomy where decentralization is required.", "term": "Intent" }, { "description": "Control centralization should govern policy without collapsing execution autonomy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → ControlPlane → DataPlane → Telemetry → PolicyAdjustment", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ControlPlaneCoordination ::= \"→\" \"→\" \"→\" \"→\" \nControlConcern ::= \"configuration\" | \"authentication\" | \"authorization\" | \"logging\" | \"orchestration\" | \"service_registry\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Control Plane](/records/algorithms/control-plane)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[Control Plane](/records/algorithms/control-plane): The control plane is the mechanism that coordinates policy; this record composes it and decides which concerns are centralized and which stay local.", "term": "Distinct from" } ], "kind": "glossary" }, { "code": "Every service does its own config + auth; policy scatters and drifts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "policy → control-plane{config, authn, orchestration} → data-planes execute → telemetry → governance adjustment", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Control Plane](/records/algorithms/control-plane)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-control-plane-coordination", "title": "Control Plane Coordination" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Treat code as data only through schemas, manifests, DSL grammars, reflection contracts, compile-time checks, runtime guards, and generated artifact validation.", "term": "Intent" }, { "description": "Metaprogramming is safe when generated behavior is bounded by a validated model.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Model → Schema → Transform → Generate|Interpret → Validate → Execute", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MetaprogrammingSafety ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTransformationEngine ::= \"reflection\" | \"introspection\" | \"compile_time_evaluation\" | \"runtime_code_generation\" | \"DSL_interpreter\" | \"model_driven_generator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Code-as-string eval'd with no schema or bound.", "kind": "code", "language": "text", "title": "Before" }, { "code": "model → schema → transform{reflection | DSL} → generated artifact → safety-validation → bounded execution", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-metaprogramming-safety", "title": "Metaprogramming Safety" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Register and version models, prompts, datasets, embeddings, retrieval sources and knowledge graphs, evaluate behavior against benchmarks, validate safety constraints, trace inference inputs through an inference contract, and monitor drift after deployment.", "term": "Intent" }, { "description": "Model-backed architecture requires governance over evidence, model behavior, inference, evaluation, and safety.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ModelArtifact → Registry → Evaluation → Safety → InferenceTrace → Monitoring", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModelLifecycleGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nModelArtifact ::= \"model\" | \"prompt\" | \"embedding_index\" | \"retrieval_source\" | \"knowledge_graph\" | \"dataset\" | \"evaluation\"\nInferenceContract ::= \"input_schema\" \",\" \"retrieval_context\" \",\" \"model_version\" \",\" \"output_schema\" \",\" \"explanation_or_trace\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A model shipped with no registry, eval, trace, or safety gate.", "kind": "code", "language": "text", "title": "Before" }, { "code": "artifacts{model, prompt, index} → governance-registry → evaluation → inference-contract → explainability-trace → safety + monitoring", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-model-lifecycle-governance", "title": "Model Lifecycle Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a target problem, query the graph for matching violated_by and detected_by signals, collect candidate concepts, compute required dependencies, remove conflicting concepts, rank by severity and reinforcement gain, then recommend an ordered implementation path.", "term": "Intent" }, { "description": "Recommendations are graph-derived paths from evidence to enforceable architecture change.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProblemEvidence → CandidateConcepts → DependencyClosure → ConflictPrune → Rank → Roadmap", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalRecommendation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSeverityRanking ::= \"mandatory_before_recommended\" \",\" \"contextual_when_scope_matches\" \",\" \"discouraged_requires_exception\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Dependency Closure](/records/algorithms/dependency-closure)", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Advice given from intuition, not from the graph or the evidence.", "kind": "code", "language": "text", "title": "Before" }, { "code": "problem-evidence → concept-match → dependency-closure → conflict-prune → severity rank → ordered roadmap", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Dependency Closure](/records/algorithms/dependency-closure)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-recommendation", "title": "Architectural Recommendation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Convert mandatory and high-impact recommended records into executable fitness functions by binding detected_by signals to checks, measured_by fields to thresholds, and enforced_by fields to pipeline gates.", "term": "Intent" }, { "description": "The catalog becomes self-enforcing when records compile into fitness functions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RelationshipRecord → DetectionCheck → MetricThreshold → EnforcementGate → FitnessFunction", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FitnessFunctionGeneration ::= \"→\" \"→\" \"→\" \"→\" \nFitnessFunction ::= \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Enforcement Gate](/records/algorithms/enforcement-gate), [Severity Policy](/records/algorithms/severity-policy)", "term": "Composes" }, { "description": "[streaming_dataflow](/records/force/streaming-dataflow), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Mandatory records sit as prose no check executes.", "kind": "code", "language": "text", "title": "Before" }, { "code": "record → detection-check + metric-threshold + enforcement-gate → executable fitness function", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Enforcement Gate](/records/algorithms/enforcement-gate), [Severity Policy](/records/algorithms/severity-policy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-fitness-function-generation", "title": "Architecture Fitness Function Generation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Group violations by shared refactor actions, order remediation by prerequisite concepts, apply low-risk structural fixes first, then enforce newly satisfied concepts through gates.", "term": "Intent" }, { "description": "Architecture repair is more efficient when refactors are grouped by shared conceptual cause.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Violations → SharedCause → RefactorGroup → DependencyOrder → Apply → Enforce", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RefactoringRoadmap ::= \"→\" \"→\" \"→\" \"→\" \nSharedCause ::= \"missing_boundary\" | \"missing_contract\" | \"semantic_drift\" | \"concrete_coupling\" | \"uncontrolled_state\" | \"missing_observability\" | \"manual_governance_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Violations fixed one-by-one in random order; shared causes re-fixed repeatedly.", "kind": "code", "language": "text", "title": "Before" }, { "code": "violations → cluster by shared-cause{missing-boundary} → refactor-groups → dependency-ordered plan → enforce", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-refactoring-roadmap", "title": "Architecture Refactoring Roadmap" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Group concepts into clusters by mutual requires, reinforces, enables, and shared scope; treat clusters as higher-order architectural concerns.", "term": "Intent" }, { "description": "Large principle catalogs become usable when concepts are clustered by relationship density.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Graph → EdgeDensity → Cluster → ConcernFamily", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConceptClusterExtraction ::= \"→\" \"→\" \"→\" \nConcernFamily ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A flat catalog of hundreds of concepts, unusable at scale.", "kind": "code", "language": "text", "title": "Before" }, { "code": "graph → relationship-density analysis → clusters → concern-families{core + supporting + conflict concepts}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concept-cluster-extraction", "title": "Concept Cluster Extraction" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "For each proposed design decision, compute satisfied concepts, violated concepts, tensions introduced, conflicts triggered, enabled capabilities, and enforcement cost; require ADR when trade-offs are nontrivial.", "term": "Intent" }, { "description": "A design decision should be evaluated as a graph delta.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Decision → GraphDelta → BenefitSet + RiskSet → ADRRequired?", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureDecisionSupport ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nDecisionGovernance ::= \"approve\" | \"approve_with_ADR\" | \"revise\" | \"reject\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A design decision judged by gut feel, not by its effect on the graph.", "kind": "code", "language": "text", "title": "Before" }, { "code": "decision → graph-delta{satisfied, violated, tensions, enabled} → enforcement-cost → approve / approve-with-ADR / revise / reject", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-decision-support", "title": "Architecture Decision Support" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate every concept record for required fields, known relation names, parseable scope, valid severity, nonempty detection and enforcement metadata, and resolvable references where possible.", "term": "Intent" }, { "description": "The architectural catalog itself must be governed as a schema-bearing artifact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Record → SchemaCheck → ReferenceCheck → CompletenessCheck → Valid|Invalid", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RelationshipSchemaValidation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRequiredFieldSet ::= \"type\" \",\" \"scope\" \",\" \"requires\" \",\" \"reinforces\" \",\" \"enables\" \",\" \"conflicts_with\" \",\" \"tensions_with\" \",\" \"violated_by\" \",\" \"detected_by\" \",\" \"measured_by\" \",\" \"refactored_by\" \",\" \"enforced_by\" \",\" \"severity\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Catalog records with missing fields and dangling references ship unchecked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "records → required-field validation → reference-resolution → severity validation → completeness score → catalog validity", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-relationship-schema-validation", "title": "Relationship Schema Validation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compile the relationship catalog into four executable artifacts: assessment rules, refactor playbooks, decision-support graphs, and governance gates.", "term": "Intent" }, { "description": "A comprehensive architecture catalog should compile into operational tooling.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Catalog → Rules + Playbooks + DecisionGraph + Gates", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureCatalogCompiler ::= \"→\" \"→\" \"→\" \"→\" \nAssessmentRule ::= \",\" \",\" \",\" \nRefactorPlaybook ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The catalog read only by the developer — no operational output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "graph → {assessment-rules, refactor-playbooks, decision-support-model, governance-gates}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-catalog-compiler", "title": "Architecture Catalog Compiler" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Parse the catalog, validate records, build the graph, classify target scope, select relevant concept clusters, compute dependency closure, detect violations, measure evidence, resolve conflicts, generate refactor plans, enforce gates, and record decisions.", "term": "Intent" }, { "description": "The catalog can be executed as a governance kernel for architecture assessment, remediation, and evolution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Catalog → Graph → Scope → Concepts → Detection → Metrics → Refactor → Enforcement → ADR", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MasterArchitectureGovernanceKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nGovernanceReport ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization), [Refactor Selection](/records/algorithms/refactor-selection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Architecture Decision Support](/records/algorithms/architecture-decision-support)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Assessment, remediation, and evolution done by disconnected manual steps.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validate → graph → scope → clusters → closure → detect → measure → resolve → refactor → enforce → ADR → governance report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization), [Refactor Selection](/records/algorithms/refactor-selection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Architecture Decision Support](/records/algorithms/architecture-decision-support)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-master-architecture-governance-kernel", "title": "Master Architecture Governance Kernel" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → ", "term": "Intent" }, { "description": "Coverage is complete when every (dimension x lens) surface the unit can fail in carries a surface, a technique, and an invariant with a non-unknown verdict.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SurfaceSpace → GridWalk → RequiredGaps → Priority → TechniqueInvariant → AuthoredTest → Verdict → Ledger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TestCoverageConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the evidence verdict, which is pass or fail only against a non-empty evidence set, the covered-surfaces check on each module's declaration", "term": "Checked by" }, { "description": "Every surface the unit can fail in", "term": "Population" }, { "description": "A verdict stands until the unit's code or its tests change", "term": "Freshness" }, { "description": "A required surface with no evidence stays unknown, and completion is refused while any required surface is unknown", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces' lists, which locate failures without certifying their absence", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evidence set, which a verdict is decided from, so a required surface without evidence stays unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-test-coverage-concern", "title": "" } ], "title": "Test coverage" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_pag_document_declaration[\"PAG Document Declaration\"]\n n_pag_keyword_ontology[\"PAG Keyword Ontology\"]\n n_pag_node_decomposition[\"PAG Node Decomposition\"]\n n_pag_validation_gate[\"PAG Handoff Gate\"]\n n_pag_explicit_control_flow[\"PAG Explicit Control Flow\"]\n n_pag_constraint_boundary[\"PAG Invariant Record\"]\n n_pag_tool_invocation[\"PAG Semantic Operation\"]\n n_pag_coordination_construct[\"PAG Structure Declaration\"]\n n_pag_ambiguity_reduction[\"PAG Ambiguity Reduction\"]\n n_pag_authoring_kernel[\"PAG Authoring Kernel\"]\n n_pag_well_formedness_validation[\"PAG Well-Formedness Validation\"]\n n_pag_instruction_concern[\"\"]\n n_pag_authoring_kernel --> n_pag_document_declaration\n n_pag_authoring_kernel --> n_pag_keyword_ontology\n n_pag_authoring_kernel --> n_pag_node_decomposition\n n_pag_authoring_kernel --> n_pag_validation_gate\n n_pag_authoring_kernel --> n_pag_explicit_control_flow\n n_pag_authoring_kernel --> n_pag_tool_invocation\n n_pag_authoring_kernel --> n_pag_coordination_construct\n n_pag_authoring_kernel --> n_pag_constraint_boundary\n n_pag_authoring_kernel --> n_pag_well_formedness_validation\n n_pag_well_formedness_validation --> n_pag_validation_gate\n n_pag_well_formedness_validation --> n_pag_explicit_control_flow" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-pag", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Bind a document to a declared type and its default verb (THIS ) after the YAML frontmatter and before any node, then declare in the meta block what the document is for, which sources ground which, what it trusts, what it may touch and what it declares outside itself, and how far repair may recurse.", "term": "Intent" }, { "description": "A PAG document announces what kind of instruction it is, and what it may touch, before it instructs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Frontmatter → TypeDeclaration → DefaultVerb → MetaBlock → Jurisdiction → DeclaredContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagDocumentDeclaration ::= \"→\" \"→\" \"→\" \nPagDocumentType ::= \"AGENT\" | \"WORKFLOW\" | \"PROTOCOL\" | \"POLICY\" | \"CHECKLIST\" | \"TEMPLATE\" | \"TASK\" | \"INSTRUCTION\" | \"PROMPT\" | \"COMMAND\" | \"TEST\" | \"DEBUG\" | \"VERIFICATION\" | \"DISTILLATION\" | \"AUDIT\" | \"TRANSLATION\" | \"COMPOSITION\"\nPagDocumentVerb ::= \"IS\" | \"ENFORCES\" | \"EXECUTES\" | \"PERFORMS\" | \"PROVIDES\" | \"IMPLEMENTS\" | \"DEFINES\" | \"MANAGES\" | \"COORDINATES\" | \"HAS\" | \"GENERATES\" | \"RESOLVES\" | \"FINDS\" | \"FIXES\" | \"VERIFIES\" | \"CLASSIFIES\" | \"DISTILLS\" | \"ABSTRACTS\" | \"ELIMINATES\" | \"AUDITS\" | \"MEASURES\" | \"SCORES\" | \"CORRECTS\" | \"RENDERS\" | \"COMPOSES\" | \"FOLDS\"\nPagMetaField ::= \"objective\" | \"priority\" | \"trust\" | \"jurisdiction\" | \"recursion_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A document instructs with no declared type — its semantic contract, its authority and its jurisdiction are implicit.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frontmatter → THIS {AGENT|WORKFLOW|CHECKLIST} {IS|EXECUTES|ENFORCES} description → META block{objective, priority, trust, jurisdiction, recursion_limit} → declared contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-document-declaration", "title": "PAG Document Declaration" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Draw every operative token from a fixed, uppercase, code-frequent vocabulary partitioned into semantic categories, each token grounded to a record in the reasoning ontology, and bind targets to sources through explicit prepositions, so the model completes recognized structured patterns rather than interpreting prose.", "term": "Intent" }, { "description": "Explicit high-frequency uppercase tokens, each grounded to a reasoning record, reduce interpretive variance; prose does not.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProseIntent → KeywordCategory → UppercaseToken → ReasoningGround → PrepositionBinding → StructuredDirective", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagKeywordOntology ::= \"→\" \"→\" \"→\" \"→\" \nPagKeywordCategory ::= \"semantic_operation\" | \"node\" | \"action\" | \"control_flow\" | \"declaration\" | \"modifier\" | \"coordination\" | \"state_machine\" | \"dag\" | \"priority_queue\" | \"flowchart\" | \"document_type\" | \"document_verb\" | \"meta\" | \"validation\" | \"report\" | \"invariant\" | \"contextual\"\nPagPreposition ::= \"FROM\" | \"TO\" | \"INTO\" | \"WITH\" | \"USING\" | \"AGAINST\" | \"IN\" | \"AS\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Get the data and check it' — prose the model must interpret.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prose intent → uppercase token{READ_RESOURCE|ANALYZE_CONTENT|VALIDATE_ARTIFACT} + preposition{FROM|INTO|AGAINST} → structured directive, low interpretive variance", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-keyword-ontology", "title": "PAG Keyword Ontology" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Group directives into nodes, each one decision on one reasoning axis, headed by its layer, axis, math type and the shape its decision yields, tagged with the substrate stage its artifact comes to be at, and contracted so that its input names the prior node's output or a declared slot, its transform is stated in semantic operations, and its output is the one record the next node reads.", "term": "Intent" }, { "description": "Each node is one bounded decision whose data flow from the prior node is declared by identity, never inferred from a name.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DirectiveSet → NodeHeader → GenesisStage → Contract → DeclaredInput → NodeOutput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagNodeDecomposition ::= \"→\" \"→\" \nPagNodeHeader ::= \"#\" \"NODE\" \"—\" \"[\" \"·\" \"·\" \"·\" \"yields:\" \"]\"\nPagNodeContract ::= \"CONTRACT:\" \"input:\" \"transform:\" \"output:\" \nPagScopeRule ::= \"declare_before_use\" \",\" \"document_wide_scope\" \",\" \"prior_output_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [domain_boundary](/records/force/domain-boundary), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Directives poured in one flat block, forward-referencing later work, with no statement of what each block decides or what shape its decision takes.", "kind": "code", "language": "text", "title": "Before" }, { "code": "directives → nodes{# NODE n — NAME [layer · axis · math type · yields: shape], @genesis, CONTRACT input/transform/output, one gate} → a node reads only the prior node's output → explicit data flow", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-node-decomposition", "title": "PAG Node Decomposition" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Close every node with a handoff gate of three-to-five checks, each a claim about the output with the evidence that settles it and the population it was measured over, a refusal condition named before any irreversible write, the standing of the read set beside the verdict, and a result line that routes pass to the next node, each failure to the earliest node that owns its repair, and unknown to blocked.", "term": "Intent" }, { "description": "A node boundary is trusted only when its checks carry evidence and a population, its writes are refused before they land, and its unknown is routed; unknown is not pass.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "NodeOutput → CheckWithEvidence → Population → Refusal → Standing → ThreeVerdicts → ResultLine", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagHandoffGate ::= \"→\" \"→\" \"→\" \"→\" \nPagCheckLine ::= \"[check]\" \"(evidence:\" \")\" \"over:\" \"measured:\" \"/\" \nPagVerdict ::= \"pass\" | \"fail\" | \"unknown\"\nPagResultLine ::= \"result:\" \"pass\" \"→\" \"|\" \"→\" \"REPAIR\" \"(owner:\" \")\" \"|\" \"unknown\" \"→\" \"BLOCKED\"\nPagGateConstraint ::= \"evidence_per_check\" \",\" \"population_declared\" \",\" \"three_to_five_checks\" \",\" \"refusal_before_write\" \",\" \"unknown_routed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence), [ver-population](/records/reasoning/node-ver-population), [ver-refusal](/records/reasoning/node-ver-refusal), [ver-standing](/records/reasoning/node-ver-standing), [ter-block](/records/reasoning/node-ter-block)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A node ends with 'looks good' — a vague assertion with no evidence, no population, no refusal, and only two verdicts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "node output → 3-5 checks{[check] claim (evidence: what settles it) over: set measured: n / N} + refuse: condition before write + standing: moved-set + result: pass → next | failure → REPAIR (owner) | unknown → BLOCKED", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-validation-gate", "title": "PAG Handoff Gate" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Express branching with IF / ELSE IF / ELSE, iteration with FOR EACH over a collection (never a bare FOR), and failure handling with TRY / CATCH, every conditional colon-terminated and every branch a complete directive sequence.", "term": "Intent" }, { "description": "Control flow is explicit and colon-delimited so the model does not infer structure from prose sequence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Condition → BranchSet → IterationForm → FailureForm → DeterministicPath", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagControlFlow ::= | | \nPagIteration ::= \"FOR\" \"EACH\" \"IN\" \":\" \nPagControlConstraint ::= \"colon_terminated\" \",\" \"for_each_not_for\" \",\" \"complete_branch_directives\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Branching and iteration inferred from prose order; a bare FOR, a missing colon.", "kind": "code", "language": "text", "title": "Before" }, { "code": "IF/ELSE IF/ELSE + FOR EACH x IN collection + TRY/CATCH → every conditional colon-terminated, complete branch directives", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-explicit-control-flow", "title": "PAG Explicit Control Flow" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "State every behavioral invariant as a record with four slots: the property in a form that could be false, the set it quantifies over, the parties it binds, and the objector, the check that would disagree if the property stopped holding or none as declared debt, so an unwatched invariant is visible rather than assumed.", "term": "Intent" }, { "description": "An invariant is stated with its property, its set, its parties and its objector, or it is indistinguishable from a property a reader happened to infer.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorPolicy → Property → Set → Parties → Objector → InvariantRecord", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagInvariantBlock ::= \"#\" \"CROSS-NODE\" \"INVARIANTS\" +\nPagInvariantRecord ::= \"INVARIANT\" \":\" \"over:\" \"binds:\" \"objector:\" ( | \"none\")\nPagInvariantQuality ::= \"falsifiable\" \",\" \"quantified\" \",\" \"delivered\" \",\" \"watched\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Behavioral rules as a bullet list under ALWAYS and NEVER — no set the rule ranges over, no party it binds, nothing that would disagree if it stopped holding.", "kind": "code", "language": "text", "title": "Before" }, { "code": "INVARIANT name: property over: set binds: parties objector: check | none → each invariant stated in a form that could be false, with what watches it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-constraint-boundary", "title": "PAG Invariant Record" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Name every external effect as one of the semantic operations (discover, read, search, analyze, extract, calculate, compose, validate, persist, execute, request a decision, report) with a uniform WITH / USING parameter clause and an INTO / arrow result binding, so the document names what it does and an adapter binding resolves how, and no host's tool name enters the document.", "term": "Intent" }, { "description": "Every external effect is a semantic operation with explicit parameters and an explicit result binding, and the host's tools are the adapter's data.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticOperation → OperationTarget → ParameterClause → ResultBinding → AdapterBinding", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagToolInvocation ::= \nPagSemanticOperation ::= \"DISCOVER_RESOURCES\" | \"READ_RESOURCE\" | \"SEARCH_CONTENT\" | \"ANALYZE_CONTENT\" | \"EXTRACT_FACTS\" | \"CALCULATE_METRIC\" | \"COMPOSE_ARTIFACT\" | \"VALIDATE_ARTIFACT\" | \"PERSIST_ARTIFACT\" | \"EXECUTE_TOOL\" | \"REQUEST_DECISION\" | \"REPORT_RESULT\"\nPagResultBinding ::= \"INTO\" | \"→\" | \"AS\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An external effect described in prose, or named by one host's tool, so the document runs in one place only.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic operation{READ_RESOURCE|PERSIST_ARTIFACT|EXECUTE_TOOL|REQUEST_DECISION} + WITH/USING params + INTO/→ result → a named effect the adapter binds to a host's tool", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-tool-invocation", "title": "PAG Semantic Operation" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Make a document's structure explicit with the declaration that names it: a DAG for a dependency graph, a STATE_MACHINE for a lifetime or a set of derived states, a PRIORITY_QUEUE for a ranking, a FLOWCHART for the rendered projection of a declared structure, and for a shared surface the coordination model's SURFACE, RECORD and ITEM with their typed edges, derived states and the one post-and-wait operation, so ordering, ownership and state are declared as structure rather than narrated as prose.", "term": "Intent" }, { "description": "Ordering, ownership and state are declared through explicit structure constructs a check can read, never implied by textual order.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructureNeed → StructureDeclaration → DeclaredEdges → DerivedState → ReadableStructure", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagStructure ::= | | | | \nPagStructureForm ::= \"DAG\" | \"STATE_MACHINE\" | \"PRIORITY_QUEUE\" | \"FLOWCHART\" | \"SURFACE\"\nPagSurface ::= \"SURFACE\" \":\" (\"RECORD\" \"subject:\" *)+\nPagEdgeKind ::= \"PARENT\" | \"SATISFIED_BY\" | \"BLOCKS\" | \"ANSWERS\" | \"REFUTES\" | \"SUPERSEDES\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[control_coordination](/records/force/control-coordination), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Concurrency, ordering, lifetimes and ownership implied by the order sentences appear in.", "kind": "code", "language": "text", "title": "Before" }, { "code": "a declared structure → DAG{dependency graph} | STATE_MACHINE{lifetime, derived states} | PRIORITY_QUEUE{ranking} | FLOWCHART{rendered projection} | SURFACE{RECORD, ITEM, typed edges, WAIT} → the structure is explicit and a check can read it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-coordination-construct", "title": "PAG Structure Declaration" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Replace interpretive prose with explicit structured tokens so the model completes recognized patterns, while accepting that output stays probabilistic: the grammar reduces input ambiguity, it does not constrain output tokens or guarantee determinism.", "term": "Intent" }, { "description": "PAG shapes the input toward consistent completion and does not always apply; it reduces the variance of the output without making it deterministic.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProseAmbiguity → TokenStructure → PatternRecognition → ReducedVariance", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagAmbiguityReduction ::= \"→\" \"→\" \nPagApplicabilityBound ::= \"input_shaping_only\" \",\" \"probabilistic_output\" \",\" \"not_always_applicable\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Prose intent claimed to guarantee deterministic model output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prose → structured tokens → reduced interpretation load; input-shaping only, output stays probabilistic (less variance, never deterministic)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-ambiguity-reduction", "title": "PAG Ambiguity Reduction" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose a PAG document as frontmatter and typed declaration, then a meta block with jurisdiction, then nodes each headed by its layer, axis, math type and yields, contracted to read the prior node's output, and closed by a handoff gate with evidence, population, refusal and the three verdicts, drawing directives from the semantic operations, control flow and structure declarations, and closing with invariant records and a report.", "term": "Intent" }, { "description": "A well-formed PAG document is a node-gated, keyword-typed, invariant-bounded instruction contract whose every verdict carries its population.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Declaration → MetaBlock → Nodes → Gates → Directives → Invariant → Report → PagDocument", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagAuthoringKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "Composes" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [model_governance](/records/force/model-governance), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration)", "term": "orient" }, { "description": "[PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology)", "term": "see" }, { "description": "[PAG Node Decomposition](/records/algorithms/pag-node-decomposition)", "term": "project" }, { "description": "[PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "constrain" }, { "description": "[PAG Semantic Operation](/records/algorithms/pag-tool-invocation)", "term": "act" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate)", "term": "verify" }, { "description": "[PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "terminate" } ], "kind": "glossary" }, { "code": "An instruction written as prose, ungated, untyped and unwatched.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frontmatter + typed declaration → meta block with jurisdiction → nodes each headed, contracted and closed by a handoff gate → directives{semantic operations, control flow, structure declarations} → INVARIANT records → REPORT", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-authoring-kernel", "title": "PAG Authoring Kernel" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Scan a PAG document for structural and epistemic defects, each named for the shape it catches — a retired unit head, a node without a gate, a check without evidence, a gate without a population or with an empty one, an unknown left unrouted, a write without a refusal, an artifact without freshness, a node declared twice, an input naming no source, an invariant missing its set, parties or objector, a bare invariant block, a lowercase keyword, a bare FOR, a missing colon, a vague condition — and emit a token-based, regex-free verdict.", "term": "Intent" }, { "description": "A PAG document is trusted only after a deterministic well-formedness scan whose defect set is the epistemology's failure taxonomy, never because it reads fluently.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PagDocument → DefectScan → DefectSet → WellFormednessVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagWellFormedness ::= \"→\" \"→\" \nPagDefect ::= \"retired_unit_head\" | \"node_without_gate\" | \"node_tag_malformed\" | \"node_declared_twice\" | \"input_without_source\" | \"check_without_evidence\" | \"gate_without_population\" | \"empty_population\" | \"result_missing\" | \"unknown_unrouted\" | \"write_without_refusal\" | \"artifact_without_freshness\" | \"invariant_without_set\" | \"invariant_without_parties\" | \"invariant_without_objector\" | \"bare_invariant_block\" | \"gate_too_few_conditions\" | \"gate_too_many_conditions\" | \"vague_condition\" | \"for_without_each\" | \"lowercase_keyword\" | \"missing_colon\" | \"no_declaration\"\nPagWellFormednessVerdict ::= \"well_formed\" | \"ill_formed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow)", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A PAG document trusted because it reads fluently.", "kind": "code", "language": "text", "title": "Before" }, { "code": "document → defect scan{retired unit head, node without gate, check without evidence, gate without population, empty population, unknown unrouted, write without refusal, artifact without freshness, node declared twice, input without source, invariant without set/parties/objector, bare invariant block, lowercase keyword, for without each, missing colon, vague condition} → well-formed | ill-formed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-well-formedness-validation", "title": "PAG Well-Formedness Validation" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "Any PAG artifact should be treated as a structured instruction contract whose tokens are drawn from a fixed ontology grounded in the reasoning collection, whose nodes are closed by evidence-bearing gates that carry their population and route unknown to blocked, and whose invariants name their objector, reducing interpretive ambiguity without guaranteeing deterministic output.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DocumentType → Keywords → Nodes → Gates → OperationsAndStructure → Invariant → WellFormedness", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagInstructionConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [model_governance](/records/force/model-governance), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-instruction-concern", "title": "" } ], "title": "Pattern Abstract Grammar" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_analysis_workspace[\"Analysis Workspace\"]\n n_registry_baseline[\"Registry Baseline\"]\n n_compliance_gap[\"Compliance Gap\"]\n n_semantic_domain_partitioning[\"Semantic Domain Partitioning\"]\n n_behavioral_signature_extraction[\"Behavioral Signature Extraction\"]\n n_cross_class_pattern_detection[\"Cross-Class Pattern Detection\"]\n n_behavioral_inconsistency[\"Behavioral Inconsistency\"]\n n_sequential_chain_duplication[\"Sequential Chain Duplication\"]\n n_temporal_coupling_detection[\"Temporal Coupling Detection\"]\n n_relational_graph_duplication[\"Relational Graph Duplication\"]\n n_causal_wiring_duplication[\"Causal Wiring Duplication\"]\n n_anomaly_outlier_detection[\"Anomaly Outlier Detection\"]\n n_conceptual_duplication_detection[\"Conceptual Duplication Detection\"]\n n_fractal_scale_duplication[\"Fractal Scale Duplication\"]\n n_anti_pattern_classification[\"Anti-Pattern Classification\"]\n n_anti_pattern_priority_matrix[\"Anti-Pattern Priority Matrix\"]\n n_abstraction_boundary_principle[\"Abstraction Boundary Principle\"]\n n_base_class_candidate_selection[\"Base-Class Candidate Selection\"]\n n_concrete_vs_abstract_responsibility_split[\"Concrete-vs-Abstract Responsibility Split\"]\n n_template_method_lifecycle[\"Template Method Lifecycle\"]\n n_base_schematic_composition[\"Base Schematic Composition\"]\n n_migration_ordering[\"Migration Ordering\"]\n n_backup_verified_migration[\"Backup-Verified Migration\"]\n n_anti_pattern_elimination_verification[\"Anti-Pattern Elimination Verification\"]\n n_registry_regeneration[\"Registry Regeneration\"]\n n_anti_reintroduction_gate[\"Anti-Reintroduction Gate\"]\n n_distillation_metrics[\"Distillation Metrics\"]\n n_pattern_distillation_history[\"Pattern Distillation History\"]\n n_pattern_distillation_completion_truthfulness[\"Pattern Distillation Completion Truthfulness\"]\n n_pattern_distiller_kernel[\"Pattern Distiller Kernel\"]\n n_pattern_distillation_concern[\"\"]\n n_pattern_distiller_kernel --> n_analysis_workspace\n n_pattern_distiller_kernel --> n_registry_baseline\n n_pattern_distiller_kernel --> n_compliance_gap\n n_pattern_distiller_kernel --> n_semantic_domain_partitioning\n n_pattern_distiller_kernel --> n_cross_class_pattern_detection\n n_pattern_distiller_kernel --> n_anti_pattern_classification\n n_pattern_distiller_kernel --> n_base_class_candidate_selection\n n_pattern_distiller_kernel --> n_base_schematic_composition\n n_pattern_distiller_kernel --> n_registry_regeneration\n n_pattern_distiller_kernel --> n_distillation_metrics\n n_pattern_distiller_kernel --> n_behavioral_signature_extraction\n n_pattern_distiller_kernel --> n_anti_pattern_priority_matrix\n n_pattern_distiller_kernel --> n_migration_ordering\n n_pattern_distiller_kernel --> n_backup_verified_migration\n n_pattern_distiller_kernel --> n_anti_pattern_elimination_verification\n n_pattern_distiller_kernel --> n_pattern_distillation_history\n n_pattern_distiller_kernel --> n_pattern_distillation_completion_truthfulness" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-pattern-distillation", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Create a unique analysis session, allocate phase/metric/migration artifact locations, load baseline documentation and registries, write a manifest, and block continuation if required context is unavailable.", "term": "Intent" }, { "description": "Architectural refactoring must begin from an auditable workspace with explicit input provenance.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Session → Workspace → ContextLoad → Manifest → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AnalysisWorkspace ::= \"→\" \"→\" \"→\" \"→\" \nInitializationGate ::= \"workspace_exists\" \",\" \"manifest_written\" \",\" \"baseline_docs_loaded\" \",\" \"registry_loaded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Refactoring begins ad hoc, with no auditable record of what it started from.", "kind": "code", "language": "text", "title": "Before" }, { "code": "session → workspace{phase/metric/migration locations} → load baseline + registries → manifest → block if required context missing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-analysis-workspace", "title": "Analysis Workspace" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read existing architectural registries, extract known base abstractions, count implementations, measure hierarchy depth, and record the current abstraction state before proposing changes.", "term": "Intent" }, { "description": "New abstractions must be compared against existing architecture before being created.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Registry → ExistingAbstractions → ImplementationCounts → HierarchyMetrics → Baseline", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RegistryBaseline ::= \"→\" \"→\" \"→\" \"→\" \nImplementationMetricSet ::= \"total_base_classes\" \",\" \"total_implementations\" \",\" \"implementation_count_by_base\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new base abstraction created without measuring what already exists.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry → existing bases + implementation counts + hierarchy depth → current abstraction state, before proposing a change", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-registry-baseline", "title": "Registry Baseline" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Discover implementation classes by role, detect which ones conform to expected base abstractions, calculate noncompliance counts, and compute architectural compliance rate.", "term": "Intent" }, { "description": "Pattern distillation must distinguish missing adoption from missing abstraction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleClasses → ExpectedBaseRule → ConformingSet + NonconformingSet → ComplianceRate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ComplianceGap ::= \"→\" \"→\" \"→\" \nBaseExpectation ::= \"extends\" \nGapReport ::= \"noncompliant_count\" \",\" \"compliant_count\" \",\" \"compliance_rate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'The Foos don't extend a base' — but is the base missing, or just its adoption?", "kind": "code", "language": "text", "title": "Before" }, { "code": "role classes → expected base rule → conforming vs nonconforming → compliance rate distinguishing missing adoption from missing abstraction", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-compliance-gap", "title": "Compliance Gap" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Group implementation resources by semantic role, such as manager, repository, handler, service, controller, adapter, or worker, then analyze each family separately.", "term": "Intent" }, { "description": "Reusable abstractions emerge from families of similar responsibility, not arbitrary files.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ResourceSet → RoleClassifier → SemanticDomains → DomainMetrics", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticDomainPartitioning ::= \"→\" \"→\" \nSemanticDomain ::= \",\" \",\" \",\" \nRoleClassification ::= \"manager\" | \"repository\" | \"handler\" | \"service\" | \"controller\" | \"adapter\" | \"worker\" | \"unknown\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [performance_scaling](/records/force/performance-scaling), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Abstractions drawn from arbitrary files instead of families of like responsibility.", "kind": "code", "language": "text", "title": "Before" }, { "code": "resources → classify by role{manager|repository|handler|service|adapter} → per-family analysis", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-domain-partitioning", "title": "Semantic Domain Partitioning" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "For each class in a semantic domain, inspect constructor behavior, lifecycle hooks, error handling, state management, dependency acquisition, and public orchestration methods.", "term": "Intent" }, { "description": "Base-class candidates require behavioral evidence, not just naming similarity.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ClassResource → BehaviorScan → Signature → DomainSignatureSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BehavioralSignature ::= \",\" \",\" \",\" \",\" \",\" \nLifecycleBehavior ::= \"initialize\" \",\" \"destroy\" \",\" \"onInitialize\" \",\" \"onDestroy\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[structural](/records/reasoning/lens-structure), [behavioral](/records/reasoning/lens-behavior)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "A base-class candidate proposed on naming similarity alone.", "kind": "code", "language": "text", "title": "Before" }, { "code": "class → scan{constructor, lifecycle hooks, error handling, state, dependencies, public methods} → behavioral signature (evidence, not names)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-behavioral-signature-extraction", "title": "Behavioral Signature Extraction" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Search across semantic domains for repeated imports, repeated initialization, repeated lifecycle code, repeated error handling, repeated state setup, and repeated dependency wiring.", "term": "Intent" }, { "description": "Duplication becomes an abstraction candidate when it appears across multiple implementations with the same role.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainSignatures → CrossClassSearch → DuplicatePatternSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CrossClassPatternDetection ::= \"→\" \"→\" \nCrossClassPattern ::= \",\" \",\" \",\" \nPatternRole ::= \"initialization\" | \"lifecycle\" | \"error_handling\" | \"state_management\" | \"dependency_management\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[structural](/records/reasoning/lens-structure), [frequency](/records/reasoning/lens-frequency)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "One duplicated block noticed; the family-wide repetition stays invisible.", "kind": "code", "language": "text", "title": "Before" }, { "code": "signatures → search repeated{imports, init, lifecycle, error, state, deps} across the role family → cross-class pattern + occurrence count", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cross-class-pattern-detection", "title": "Cross-Class Pattern Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Detect multiple competing implementations of the same behavior, count each variation, compute dominant-pattern consistency, and flag low-consistency behavior for normalization.", "term": "Intent" }, { "description": "Inconsistent behavior is an architectural smell even when code is not textually duplicated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorFamily → VariationCounts → ConsistencyRate → NormalizeCandidate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BehavioralInconsistency ::= \"→\" \"→\" \"→\" \nConsistencyMetric ::= \"max_variation_count / total_variation_count\"\nInconsistencyVerdict ::= \"consistent\" | \"weakly_consistent\" | \"inconsistent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[behavioral](/records/reasoning/lens-behavior)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Three competing implementations of one behavior, none textually duplicated, so nothing flags.", "kind": "code", "language": "text", "title": "Before" }, { "code": "behavior family → variation counts → consistency = dominant/total → {consistent | weakly | inconsistent} → normalize the inconsistent", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-behavioral-inconsistency", "title": "Behavioral Inconsistency" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "For each class in the role family, extract the ordered sequence of orchestration steps, align sequences across the family, and surface repeated ordered chains that no textual-duplication scan would catch.", "term": "Intent" }, { "description": "Order-sensitive repetition is duplication even when no contiguous block is textually identical.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → OrderedCallSequence → SequenceAlignment → RepeatedChainSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SequentialChainDuplication ::= \"→\" \"→\" \nRepeatedOrderedChain ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "[ana-sequential](/records/reasoning/node-ana-sequential)", "term": "Grounds" }, { "description": "[sequential](/records/reasoning/lens-sequential)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Two classes call the same steps in the same order, but no single block is textually identical, so frequency scanning finds nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → extract ordered call-sequence per class → align sequences → repeated ordered chain + occurrence count", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-sequential-chain-duplication", "title": "Sequential Chain Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect must-precede and must-follow ordering constraints between operations in each class, intersect them across the role family, and surface the shared temporal-coupling contract that a base lifecycle would centralize.", "term": "Intent" }, { "description": "A lifecycle ordering constraint re-encoded across a family is a shared contract, not a per-class detail.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → OrderingConstraintSet → CrossFamilyIntersection → SharedCouplingContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemporalCouplingDetection ::= \"→\" \"→\" \nOrderingConstraint ::= \"must_precede\" | \"must_follow\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[ana-temporal](/records/reasoning/node-ana-temporal)", "term": "Grounds" }, { "description": "[temporal](/records/reasoning/lens-time)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Every class re-encodes 'call setup before use, teardown after' as scattered ad-hoc ordering, and the shared lifecycle contract stays invisible.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → must-precede/must-follow constraints per class → intersect across family → shared temporal-coupling contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-temporal-coupling-detection", "title": "Temporal Coupling Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Build the dependency-acquisition subgraph for each class, test for isomorphic subgraphs across the role family, and surface repeated object-graph wiring that a base or factory would assemble once.", "term": "Intent" }, { "description": "A dependency subgraph reassembled across a family is duplicated structure, distinct from duplicated statements.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → DependencySubgraph → SubgraphIsomorphism → RepeatedWiringSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RelationalGraphDuplication ::= \"→\" \"→\" \nRepeatedWiringSubgraph ::= \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[ana-relational](/records/reasoning/node-ana-relational)", "term": "Grounds" }, { "description": "[relational](/records/reasoning/lens-relation)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The same object graph — acquire A, wire B onto A, hand both to C — is reassembled by hand in every class.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → dependency-acquisition subgraph per class → subgraph isomorphism across family → repeated wiring subgraph", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-relational-graph-duplication", "title": "Relational Graph Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Extract cause-to-effect edges (event to handler, failure to recovery, state change to reaction) per class, match trigger/reaction pairs across the role family, and surface repeated causal wiring that a base policy would centralize.", "term": "Intent" }, { "description": "Repeated trigger-to-reaction wiring is duplicated causal policy even when the surrounding code differs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → CausalEdgeSet → TriggerReactionMatch → RepeatedCausalWiringSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CausalWiringDuplication ::= \"→\" \"→\" \nCausalEdge ::= \"causes\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "[ana-causal](/records/reasoning/node-ana-causal)", "term": "Grounds" }, { "description": "[causal](/records/reasoning/lens-cause)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The same trigger-to-reaction wiring — this event runs that handler, that failure invokes this recovery — is duplicated across the family.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → cause→effect edges per class → match trigger/reaction pairs across family → repeated causal-wiring set", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-causal-wiring-duplication", "title": "Causal Wiring Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Score each class's deviation from the dominant behavioral signature, identify the outliers, and name why each deviates, so inconsistency is localized to the deviant implementation rather than reported as an aggregate rate.", "term": "Intent" }, { "description": "Inconsistency is an anomaly to be localized to a deviant implementation, not merely a family-level ratio.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorFamily → DominantSignature → DeviationScore → OutlierSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AnomalyOutlierDetection ::= \"→\" \"→\" \"→\" \nOutlier ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[ana-anomaly](/records/reasoning/node-ana-anomaly)", "term": "Grounds" }, { "description": "[anomaly](/records/reasoning/lens-anomaly)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "A family shares one behavior — except the one class that does it differently, and a consistency ratio only reports 'weakly consistent' without naming the deviant.", "kind": "code", "language": "text", "title": "Before" }, { "code": "behavior family → per-class deviation score against the dominant signature → outlier set + why each deviates → normalize or justify", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anomaly-outlier-detection", "title": "Anomaly Outlier Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Derive a name-independent semantic signature for each behavior (intent, input-to-output shape, effects), cluster behaviors by meaning rather than identifier, and surface same-meaning/different-name clusters that only the semantic lens can detect.", "term": "Intent" }, { "description": "Same meaning under different names is duplication that textual, structural, and frequency lenses are blind to.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → SemanticSignature → MeaningCluster → ConceptualDuplicateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConceptualDuplicationDetection ::= \"→\" \"→\" \nSemanticSignature ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[ana-semantic](/records/reasoning/node-ana-semantic)", "term": "Grounds" }, { "description": "[semantic](/records/reasoning/lens-meaning)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Two implementations mean the same thing under different names, so no textual, structural, or frequency scan flags them.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → semantic signature per behavior (intent, inputs→outputs, effects) → cluster by meaning not name → same-meaning/different-name set + novelty score", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-conceptual-duplication-detection", "title": "Conceptual Duplication Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Test whether a duplication shape recurs at more than one scale (method, class, module), and determine the scale at which the abstraction belongs, so single-scale scanning does not abstract at the wrong level.", "term": "Intent" }, { "description": "A shape that recurs across scales must be abstracted at the scale where it is invariant, not only where it was first noticed.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CandidateShape → MultiScaleRecurrence → ScaleInvariance → AbstractionScale", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FractalScaleDuplication ::= \"→\" \"→\" \nScaleInvarianceVerdict ::= \"method_scale\" | \"class_scale\" | \"module_scale\" | \"scale_invariant\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ana-fractal](/records/reasoning/node-ana-fractal)", "term": "Grounds" }, { "description": "[fractal](/records/reasoning/lens-fractal)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The distiller scans one scale — the class family — and misses that the same shape repeats at the method level and again at the module level.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidate shape → test recurrence at method / class / module scale → scale-invariant duplication + the scale the abstraction belongs at", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-fractal-scale-duplication", "title": "Fractal Scale Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Convert duplicated, inconsistent, and architecture-violating findings into anti-pattern records with type, occurrence count, impact, effort, severity, and affected resources.", "term": "Intent" }, { "description": "Refactoring targets should be normalized into comparable anti-pattern contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Finding → AntiPatternRecord → PriorityInput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiPatternClassification ::= \"→\" \nAntiPattern ::= \",\" \",\" \",\" \",\" \",\" \",\" \nAntiPatternType ::= \"copy_paste_duplication\" | \"behavioral_inconsistency\" | \"architectural_violation\" | \"conceptual_duplication\" | \"structural_duplication\" | \"sequential_duplication\" | \"temporal_coupling\" | \"relational_duplication\" | \"causal_duplication\" | \"scale_duplication\"\nPriorityRank ::= \"critical\" | \"high\" | \"medium\" | \"low\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Findings kept as loose notes, not comparable across the backlog.", "kind": "code", "language": "text", "title": "Before" }, { "code": "findings → anti-pattern records{type, occurrence, impact, effort, severity, affected resources}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-classification", "title": "Anti-Pattern Classification" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Assign numeric impact and effort scores, calculate priority, sort anti-patterns, and group them into remediation bands.", "term": "Intent" }, { "description": "Distillation should address high-value anti-patterns first.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern → ImpactScore + EffortScore → Priority → SortedBacklog", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PriorityMatrix ::= \"→\" \"→\" \nScoredAntiPattern ::= \",\" \",\" \",\" \nPriorityValue ::= \"*\" \nPriorityBand ::= \"priority_1\" | \"priority_2\" | \"priority_3\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Refactoring picks a target by gut feel, not value.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-patterns → impact * effort → priority → sorted into remediation bands", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-priority-matrix", "title": "Anti-Pattern Priority Matrix" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Evaluate each high-priority anti-pattern against boundary principles: universal, invariant, foundational, enforcing, and cognitive-load-reducing.", "term": "Intent" }, { "description": "A base abstraction is justified only when the behavior belongs below the subclass boundary.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern → BoundaryPrinciples → PrinciplesMet → AbstractionEligible", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundaryPrincipleEvaluation ::= \"→\" \"→\" \nBoundaryPrincipleSet ::= \"universal\" \",\" \"invariant\" \",\" \"foundational\" \",\" \"enforcing\" \",\" \"reducing_load\"\nEligibilityVerdict ::= \"base_candidate\" | \"utility_candidate\" | \"composition_candidate\" | \"local_refactor_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Duplication abstracted into a base whether or not the behavior belongs below the subclass boundary.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-pattern → boundary principles{universal, invariant, foundational, enforcing, load-reducing} → {base | utility | composition | local-refactor}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-abstraction-boundary-principle", "title": "Abstraction Boundary Principle" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Promote an anti-pattern to a base-class candidate only when it satisfies enough boundary principles and applies across a meaningful portion of the semantic domain.", "term": "Intent" }, { "description": "Inheritance should encode stable lifecycle or invariant behavior, not incidental reuse.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern + DomainCoverage + BoundaryScore → Candidate|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BaseClassCandidateSelection ::= \",\" \",\" \"→\" \nCandidateVerdict ::= \"create_base_class\" | \"prefer_composition\" | \"prefer_utility\" | \"reject_abstraction\"\nDomainCoverage ::= \"occurrence_count / total_domain_classes\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Incidental reuse promoted to inheritance.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-pattern + domain coverage + boundary score → verdict{create_base | prefer_composition | prefer_utility | reject}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-base-class-candidate-selection", "title": "Base-Class Candidate Selection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Partition the family's behavior into what is invariant across every member (the topology preserved under substitution) and what varies per member (the novelty); the invariant set becomes the concrete base, the variant set becomes the abstract seam. The concrete/abstract boundary is derived from the evidence, not read off a fixed lifecycle vocabulary — so the split holds for any paradigm, not only OOP class lifecycles.", "term": "Intent" }, { "description": "The concrete/abstract boundary is the invariant/variant boundary of the family, discovered from evidence — never a pre-assumed lifecycle template.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FamilyBehaviorSet → InvariantPartition + VariantPartition → ConcreteBase + AbstractSeam", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResponsibilitySplit ::= \"→\" \",\" \"→\" \",\" \nInvariantSet ::= \"behavior identical across every family member\"\nVariantSet ::= \"behavior that differs per family member\"\nAbstractSeam ::= \",\" \nSeamKind ::= \"hook\" | \"abstract_method\" | \"injected_strategy\" | \"parameter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[substrate-node:invariant](/records/reasoning/substrate-node-invariant), [ont-novelty](/records/reasoning/node-ont-novelty)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The split is drawn from a fixed OOP lifecycle vocabulary (constructor/initialize/destroy/onInitialize/executeCore), which pre-decides the shape whether or not the family's behavior matches it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "family behavior → partition INVARIANT (identical across every member) from VARIANT (differs per member) → invariant set = concrete base, variant set = the abstract seam; the hook names are read from the variant behavior, not assumed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concrete-vs-abstract-responsibility-split", "title": "Concrete-vs-Abstract Responsibility Split" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Define public lifecycle methods that enforce guard checks, call shared setup or cleanup, invoke subclass hooks, and centralize error handling.", "term": "Intent" }, { "description": "Template method converts repeated lifecycle code into one predictable behavioral contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PublicMethod → Guard → SharedBehavior → Hook → ErrorPolicy → Result", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemplateLifecycle ::= \"→\" \"→\" \"→\" \"→\" \nLifecycleMethod ::= \"initialize\" | \"destroy\" | \"execute\" | \"process\"\nSubclassHook ::= \"onInitialize\" | \"onDestroy\" | \"onExecute\" | \"onProcess\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each subclass re-implements the same guard-setup-cleanup lifecycle.", "kind": "code", "language": "text", "title": "Before" }, { "code": "public lifecycle method → guard → shared setup/cleanup → subclass hook → centralized error handling → one predictable contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-template-method-lifecycle", "title": "Template Method Lifecycle" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Generate the base abstraction from the selected candidate, enforce size constraints, split if oversized, and record which anti-patterns the abstraction eliminates.", "term": "Intent" }, { "description": "Generated abstractions must remain small enough to be maintainable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Candidate → GenerateBase → SizeCheck → SplitIfNeeded → BaseArtifact", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BaseSchematicComposition ::= \"→\" \"→\" \"→\" \nConstraintCheck ::= \"line_count <= max_allowed_lines\" \",\" \"name_matches_convention\" \",\" \"location_matches_architecture\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A base generated so large it becomes the new god object.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidate → generate base → size <= max (split if oversized) + name + location conventions → persistable base", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-base-schematic-composition", "title": "Base Schematic Composition" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Sort target classes by complexity from lowest to highest, migrate simpler implementations first, and use early migrations to validate the abstraction before complex adoption.", "term": "Intent" }, { "description": "Migration risk decreases when the base pattern is proven on low-complexity cases first.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetClasses → ComplexityMetric → SortedMigrationOrder", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MigrationOrdering ::= \"→\" \"→\" \nComplexityScore ::= \"line_count\" | \"method_count\" | \"dependency_count\" | \"state_property_count\"\nMigrationQueue ::= \"ascending_complexity\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [causality_ordering](/records/force/causality-ordering), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The most complex implementation migrated first, and the base is wrong before it's proven.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target classes → complexity score → migrate ascending complexity → prove the base on simple cases first", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-migration-ordering", "title": "Migration Ordering" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each target class, create a recoverable checkpoint, refactor it to extend or use the abstraction, verify the removed anti-pattern no longer exists, and restore from backup on failure.", "term": "Intent" }, { "description": "Structural migration must be reversible per target artifact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Backup → Refactor → Verify → Commit|Restore", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MigrationExecution ::= \"→\" \"→\" \"→\" \"→\" \nMigrationOutcome ::= \"committed\" | \"restored_from_checkpoint\" | \"failed_with_log\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [streaming_dataflow](/records/force/streaming-dataflow), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A refactor breaks a target and there is no way back.", "kind": "code", "language": "text", "title": "Before" }, { "code": "per target → checkpoint → refactor to the base → verify the anti-pattern is gone → commit | restore from checkpoint", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-backup-verified-migration", "title": "Backup-Verified Migration" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "After migration, search the entire target scope for old duplicate patterns, allow only approved base-location occurrences, and fail completion if unapproved duplicates remain.", "term": "Intent" }, { "description": "Refactoring is incomplete until the old pattern is gone.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnownAntiPattern → ScopeSearch → RemainingOccurrences → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiPatternElimination ::= \"→\" \"→\" \"→\" \nEliminationVerdict ::= \"eliminated\" | \"remaining_unapproved_occurrences\" | \"base_only_occurrence\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Distillation declared done while the old pattern still lives at three sites.", "kind": "code", "language": "text", "title": "Before" }, { "code": "known anti-pattern → search the whole scope → allow only approved base-location occurrences → fail completion on unapproved duplicates", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-elimination-verification", "title": "Anti-Pattern Elimination Verification" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "After creating or migrating abstractions, regenerate or update the architecture registry, reread it, and confirm the new base and migrated implementations are represented.", "term": "Intent" }, { "description": "Architecture metadata must reflect the new implementation truth.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RefactorResult → RegistryRegeneration → RegistryReadback → RepresentationCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RegistryRegeneration ::= \"→\" \"→\" \"→\" \nRegistryVerification ::= \"new_base_present\" \",\" \"implementation_count_updated\" \",\" \"old_pattern_absent_or_marked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The registry still reflects the pre-refactor architecture.", "kind": "code", "language": "text", "title": "Before" }, { "code": "migration result → regenerate registry → reread → confirm new base + migrated implementations represented", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-registry-regeneration", "title": "Registry Regeneration" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "After eliminating an anti-pattern, author or strengthen the custom lint rule that statically forbids its reintroduction and any bypass of the new base, build the rule plugin, and regenerate the rule catalog, so the distilled boundary is enforced by a gate rather than by discipline.", "term": "Intent" }, { "description": "A distilled pattern is incomplete until a gate forbids its reintroduction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DistilledBoundary → LintRuleAuthored → PluginBuilt → CatalogRegenerated → EnforcedBoundary", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiReintroductionGate ::= \"→\" \"→\" \"→\" \"→\" \nEnforcementVerdict ::= \"gate_active\" | \"gate_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The distilled base eliminates the duplication today, but nothing stops the developer or the model from reintroducing the same anti-pattern — the gate held only for this run, by discipline.", "kind": "code", "language": "text", "title": "Before" }, { "code": "distilled boundary → author/strengthen a custom lint rule forbidding the anti-pattern + the base-bypass → build the plugin → regenerate the rule catalog → the boundary is enforced structurally", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-reintroduction-gate", "title": "Anti-Reintroduction Gate" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Calculate duplication reduction, code reduction, adoption rate, lines saved, maintenance burden reduction, and cognitive-load reduction after migration.", "term": "Intent" }, { "description": "Refactoring should produce measurable architectural ROI.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BeforeMetrics + AfterMetrics → ReductionMetrics → ROISummary", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationMetrics ::= \",\" \"→\" \nFinalMetricSet ::= \"duplication_reduction\" \",\" \"code_reduction\" \",\" \"base_class_adoption\" \",\" \"lines_saved\" \",\" \"maintenance_burden_reduction\" \",\" \"cognitive_load_reduction\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "ROI asserted ('much cleaner now') with no numbers.", "kind": "code", "language": "text", "title": "Before" }, { "code": "before + after → {duplication reduction, code reduction, adoption rate, lines saved, maintenance + cognitive-load reduction}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-distillation-metrics", "title": "Distillation Metrics" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Append the completed analysis summary to a durable history log, store metric snapshots, and preserve lessons learned for future abstraction decisions.", "term": "Intent" }, { "description": "Refactoring intelligence improves when outcomes become reusable historical evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Summary → HistoryAppend → MetricSnapshot → LessonsLearned", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationHistory ::= \"→\" \"→\" \"→\" \nReusableLearning ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each distillation forgets the last — the same lessons re-learned.", "kind": "code", "language": "text", "title": "Before" }, { "code": "summary → durable history log + metric snapshots + lessons → reusable evidence for future abstraction decisions", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-history", "title": "Pattern Distillation History" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Mark pattern distillation complete only if workspace, baseline, semantic analysis, anti-pattern classification, abstraction selection, migration, verification, registry update, anti-reintroduction gate, and metrics logging all pass.", "term": "Intent" }, { "description": "Completion is an evidence state, not an assertion — and it includes a gate that forbids the anti-pattern's return.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PhaseGates → VerificationResults → Metrics → Complete|Incomplete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationCompletion ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \"→\" \nCompletionVerdict ::= \"pattern_distillation_complete\" | \"pattern_distillation_incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Done' asserted while verification, registry-update, and the anti-reintroduction gate never ran.", "kind": "code", "language": "text", "title": "Before" }, { "code": "gates{workspace, baseline, semantic, anti-pattern, abstraction, migration, verification, registry, enforcement, metrics} all pass → complete; else incomplete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-completion-truthfulness", "title": "Pattern Distillation Completion Truthfulness" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Initialize an analysis workspace, read registry baselines, partition semantic domains, extract behavioral signatures, detect anti-patterns, prioritize them, evaluate abstraction boundaries, compose base schematics, migrate targets, verify elimination, update registries, calculate ROI, and persist history.", "term": "Intent" }, { "description": "Pattern distillation is a forensic compiler from repeated behavioral evidence into predictable implementation architecture.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workspace → Registry → Semantics → AntiPatterns → Abstraction → Migration → Verification → Metrics → History", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternDistillerKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Registry Regeneration](/records/algorithms/registry-regeneration), [Distillation Metrics](/records/algorithms/distillation-metrics)", "term": "Composes" }, { "description": "[Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Premature Abstraction](/records/architecture/premature-abstraction)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace)", "term": "orient" }, { "description": "[Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)", "term": "see" }, { "description": "[Anti-Pattern Classification](/records/algorithms/anti-pattern-classification)", "term": "derive" }, { "description": "[Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix)", "term": "intent" }, { "description": "[Migration Ordering](/records/algorithms/migration-ordering)", "term": "project" }, { "description": "[Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "act" }, { "description": "[Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification)", "term": "verify" }, { "description": "[Pattern Distillation History](/records/algorithms/pattern-distillation-history)", "term": "commit" }, { "description": "[Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness)", "term": "terminate" } ], "kind": "glossary" }, { "code": "Repeated behavior abstracted by intuition, migrated irreversibly, never verified.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workspace → baseline → semantics → anti-patterns → abstraction boundary → base schematic → reversible migration → elimination proof → registry regenerate → ROI → history", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Registry Regeneration](/records/algorithms/registry-regeneration), [Distillation Metrics](/records/algorithms/distillation-metrics)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distiller-kernel", "title": "Pattern Distiller Kernel" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → → ", "term": "Intent" }, { "description": "Any repeated implementation behavior should become a shared abstraction only when evidence proves it is universal, invariant, foundational, enforceable, and cognitively load-reducing.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → Semantics → AntiPattern → Boundary → Abstraction → Migration → Verification → Metrics", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternDistillationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nAbstractionBoundary ::= \"universal\" \",\" \"invariant\" \",\" \"foundational\" \",\" \"enforcing\" \",\" \"reducing_load\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-concern", "title": "" } ], "title": "Pattern distillation" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_profile_compose[\"Profile Compose\"]\n n_delta_capture[\"Delta Capture\"]\n n_idempotent_merge[\"Idempotent Merge\"]\n n_version_provenance[\"Version Provenance\"]\n n_deterministic_merge_core[\"Deterministic Merge Core\"]\n n_persistence_fork[\"Persistence Fork\"]\n n_seed_composition[\"Seed Composition\"]\n n_living_profile_kernel[\"Living Profile Kernel\"]\n n_living_accumulation_concern[\"\"]\n n_living_profile_kernel --> n_seed_composition\n n_living_profile_kernel --> n_delta_capture\n n_living_profile_kernel --> n_idempotent_merge\n n_living_profile_kernel --> n_version_provenance\n n_living_profile_kernel --> n_persistence_fork\n n_living_profile_kernel --> n_profile_compose\n n_living_accumulation_concern --> n_version_provenance\n n_living_accumulation_concern --> n_persistence_fork" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-living-profile", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing the RAG Knowledge Boundary, read the durable profile document (or an empty one), strip volatile metadata, and project a compact view injected into reasoning as retrieved memory rather than ground truth.", "term": "Intent" }, { "description": "Accumulated knowledge is disclosed as supported evidence, not authority; the consumer still grounds every use against live source.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Store → ReadDoc|Empty → StripVolatileMetadata → CompactView → ContextInjection", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ProfileCompose ::= \"→\" ( | ) \"→\" \"→\" \"→\" \nCompactKnowledgeView ::= \"without\" \nContextEvidence ::= \"disclosed_as_memory\" \",\" \"not_ground_truth\" \",\" \"reverifiable_against_source\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulated profile knowledge treated as ground truth, never re-verified.", "kind": "code", "language": "text", "title": "Before" }, { "code": "profile store → read doc (or empty) → strip volatile metadata → compact view → injected as disclosed memory, reverifiable against source", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-profile-compose", "title": "Profile Compose" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing the RAG Knowledge Boundary, accept a structured knowledge delta the reasoning turn self-reports inline, admit only facts verified within that same turn, and reject speculation without a separate extraction pass.", "term": "Intent" }, { "description": "A durable fact enters the profile only from evidence produced in the same turn; unsupported claims are rejected, never guessed into memory.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructuredTurn → KnowledgeDelta|Null → VerifiedThisTurnFilter → AdmissibleDelta", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DeltaCapture ::= \"→\" ( | ) \"→\" \"→\" \nEvidenceFilter ::= \"verified_this_turn\" \"→\" \"supported\" | \"unverified\" \"→\" \"unsupported_reject\"\nAdmissibleDelta ::= ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A speculative claim written into durable memory without same-turn evidence.", "kind": "code", "language": "text", "title": "Before" }, { "code": "structured turn → knowledge delta → keep only facts verified this turn → admissible delta; unverified rejected", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-delta-capture", "title": "Delta Capture" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Idempotent Side Effect, assign each fact a stable identity, apply the delta per field kind, deduplicate and cap, and guarantee that re-applying the same delta yields the same document.", "term": "Intent" }, { "description": "Merge is idempotent and bounded — the same delta applied twice is a no-op, and no axis grows without limit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Doc + Delta → StableFactIdentity → PerFieldKindMerge → DedupeAndCap → MergedDoc", "kind": "code", "language": "text", "title": "Flow" }, { "code": "IdempotentMerge ::= \",\" \"→\" \"→\" \"→\" \"→\" \nFieldKind ::= \"scalar_overwrite\" | \"set_union\" | \"list_append_dedupe_cap\"\nDedupeAndCap ::= \"dedupe_by_stable_identity\" \",\" \"cap_list_axis_to_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Idempotent Side Effect](/records/algorithms/idempotent-side-effect)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[state_transaction](/records/force/state-transaction)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Re-applying the same delta grows an axis and changes the document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "doc + delta → stable fact identity → per-field-kind merge{overwrite | union | append-dedupe-cap} → double-apply is a no-op", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Idempotent Side Effect](/records/algorithms/idempotent-side-effect)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-idempotent-merge", "title": "Idempotent Merge" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Specializing Governance Evolution, detect whether the merge changed state, and only on real change bump the version, timestamp it, and append a modification record — leaving a no-op untouched.", "term": "Intent" }, { "description": "A no-op delta bumps nothing; every real change is auditable and reversible, and a version is never mutated in place without a provenance record.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MergedDoc → ChangeDetect → (NoOp | VersionBump + Timestamp + ModificationRecord) → VersionedDoc", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VersionProvenance ::= \"→\" \"→\" ( | )\nChangeDetection ::= \"merged_equals_prior\" \"→\" \"no_op\" | \"merged_differs\" \"→\" \"versioned\"\nVersionedOutcome ::= \",\" \",\" \nModificationRecord ::= \"at\" \",\" \"changed_axes\" \",\" \"prior_version\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel), [](/records/algorithms/living-accumulation-concern), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A version bumped and mutated in place even on a no-op merge.", "kind": "code", "language": "text", "title": "Before" }, { "code": "merged doc → change detect → {no-op: untouched | real change: bump + timestamp + modification record}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-version-provenance", "title": "Version Provenance" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Deterministic Core, keep compose and merge pure functions over immutable inputs with the clock injected, so identical inputs reproduce identical outputs.", "term": "Intent" }, { "description": "No hidden time, state, or randomness — the clock is a parameter, and merge is referentially transparent.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "(Doc, Delta, Clock) → PureMerge → (Doc', Modification|Null)", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ProfileMergeCore ::= \",\" \",\" \"→\" \"→\" ( \",\" )\nPurityConstraint ::= \"no_hidden_state\" \",\" \"no_hidden_time\" \",\" \"no_hidden_randomness\" \",\" \"referential_transparency\"\nInjectedClock ::= \"now_supplied_by_adapter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Merge reads the wall clock internally, so identical inputs differ.", "kind": "code", "language": "text", "title": "Before" }, { "code": "(doc, delta, injected clock) → pure merge → (doc', modification|null); no hidden time/state/randomness", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-deterministic-merge-core", "title": "Deterministic Merge Core" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Port Adapter, resolve the durable store by connection mode — an authoritative per-owner store when the trusted arm is connected, a read-only mirror otherwise — and write back only where accumulation is trusted.", "term": "Intent" }, { "description": "Authoritative accumulation happens only against the trusted store; the fallback is a read mirror, never a divergent source of truth.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConnectionMode → AuthoritativeStore|LimitedMirror → ScopedKey → Persist|MirrorReadOnly", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PersistenceFork ::= \"→\" ( | ) \"→\" \"→\" \nConnectionMode ::= \"trusted_arm_connected\" | \"disconnected_limited\"\nPersistenceOutcome ::= \"persist_write_back\" | \"mirror_read_only\"\nScopedOwnerKey ::= \"stable_owner_identity\" \",\" \"sanitized\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Port Adapter](/records/algorithms/port-adapter)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel), [](/records/algorithms/living-accumulation-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulation written to a fallback mirror, creating a divergent source of truth.", "kind": "code", "language": "text", "title": "Before" }, { "code": "connection mode → {trusted arm connected: authoritative per-owner store, write back | disconnected: read-only mirror}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Port Adapter](/records/algorithms/port-adapter)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-persistence-fork", "title": "Persistence Fork" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing Canonical Data, overlay the accumulated knowledge onto the frozen baseline scope as additive context without mutating the baseline.", "term": "Intent" }, { "description": "The frozen baseline is an immutable source of truth; accumulated knowledge is additive context, never a rewrite of scope.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FrozenBaseline + ComposedKnowledge → AdditiveOverlay → TurnSeed", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SeedComposition ::= \",\" \"→\" \"→\" \nAdditiveOverlay ::= \"baseline_immutable\" \",\" \"knowledge_appended_not_merged_into_baseline\"\nTurnSeed ::= \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulated knowledge merged into the baseline, rewriting frozen scope.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frozen baseline + composed knowledge → additive overlay (baseline immutable) → turn seed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-seed-composition", "title": "Seed Composition" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose the accumulated knowledge onto the frozen baseline into a seed, run the reasoning turn, capture the inline verified delta, merge it idempotently under an injected clock, version only real change, and persist against the fork — looping per turn.", "term": "Intent" }, { "description": "A living profile is a versioned, idempotently accumulated, provenance-logged memory that grows only from verified per-turn evidence and never overrides frozen scope or live source.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Baseline → Compose → Seed → Turn → Delta → Merge(Clock) → Version → Persist → (next turn)", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingProfileKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nKernelInvariant ::= \"grows_only_from_verified_evidence\" \",\" \"never_overrides_frozen_scope\" \",\" \"never_overrides_live_source\" \",\" \"bounded_and_idempotent\" \",\" \"auditable_and_reversible\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Seed Composition](/records/algorithms/seed-composition), [Delta Capture](/records/algorithms/delta-capture), [Idempotent Merge](/records/algorithms/idempotent-merge), [Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork), [Profile Compose](/records/algorithms/profile-compose)", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[Versioning](/records/architecture/versioning)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Seed Composition](/records/algorithms/seed-composition)", "term": "orient" }, { "description": "[Delta Capture](/records/algorithms/delta-capture)", "term": "verify" }, { "description": "[Idempotent Merge](/records/algorithms/idempotent-merge)", "term": "act" }, { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "commit" } ], "kind": "glossary" }, { "code": "Per-turn evidence written to memory ungated, unbounded, unversioned.", "kind": "code", "language": "text", "title": "Before" }, { "code": "compose → seed → turn → capture verified delta → idempotent merge (injected clock) → version only real change → persist against the fork → loop", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Seed Composition](/records/algorithms/seed-composition), [Delta Capture](/records/algorithms/delta-capture), [Idempotent Merge](/records/algorithms/idempotent-merge), [Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork), [Profile Compose](/records/algorithms/profile-compose)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-profile-kernel", "title": "Living Profile Kernel" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "Any per-turn evidence stream becomes durable memory only when accumulation is idempotent, bounded, provenance-logged, deterministic at its core, and additive to an immutable baseline it may never rewrite.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → Admissibility → IdempotentMerge → Provenance → Persistence → AdditiveOverlay", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingAccumulationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nIdempotentBoundedMerge ::= \"stable_identity\" \",\" \"dedupe\" \",\" \"cap\" \",\" \"double_apply_is_no_op\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [streaming_dataflow](/records/force/streaming-dataflow)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-accumulation-concern", "title": "" } ], "title": "Living profile" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_living_plan_state[\"Living Plan State\"]\n n_boundary_reconciliation[\"Boundary Reconciliation\"]\n n_phase_close_gate[\"Phase Close Gate\"]\n n_plan_phase_verification[\"Plan Phase Verification\"]\n n_governed_autonomous_plan_loop[\"Governed Autonomous Plan Loop\"]\n n_governed_plan_concern[\"\"]\n n_phase_close_gate --> n_boundary_reconciliation\n n_plan_phase_verification --> n_boundary_reconciliation\n n_governed_autonomous_plan_loop --> n_living_plan_state\n n_governed_autonomous_plan_loop --> n_boundary_reconciliation\n n_governed_autonomous_plan_loop --> n_phase_close_gate\n n_governed_autonomous_plan_loop --> n_plan_phase_verification\n n_governed_plan_concern --> n_living_plan_state\n n_governed_plan_concern --> n_phase_close_gate" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-governed-plan-loop", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Treat the plan as durable append/update-only state — tasks carrying status and grounding, a considerations backlog, and a dismissed-key set — maintained every turn and re-delivered on restart, so anything discovered mid-pass is retained instead of falling out of scope.", "term": "Intent" }, { "description": "Plan progress is authoritative persisted state, never inferred from transient conversation, and a completion is recorded only with evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EmitDelta → GuardTransition → AppendOnly → Persist → RenderFromState", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingPlanState ::= \"→\" \"→\" \"→\" \nTaskStatus ::= \"pending\" | \"active\" | \"done\"\nConsiderationStatus ::= \"open\" | \"confirmed\" | \"dismissed\"\nDoneTransition ::= \"requires\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [](/records/algorithms/governed-plan-concern)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[state_transaction](/records/force/state-transaction), [causality_ordering](/records/force/causality-ordering), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Plan progress inferred from the conversation, so a discovery mid-pass falls out of scope on restart.", "kind": "code", "language": "text", "title": "Before" }, { "code": "plan delta → transition guard{done requires grounding} → append/update-only durable state{tasks, considerations, dismissed keys} → render from state, restart-survivable", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-plan-state", "title": "Living Plan State" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Capture considerations during a phase but act on them only at the phase boundary — triage each open consideration against code and canon into a confirmed task or a dismissed resolved-false key, deduping new opens against the confirmed and dismissed sets before triage.", "term": "Intent" }, { "description": "A dismissed consideration never resurfaces and the backlog converges monotonically, so the loop cannot oscillate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Capture → DeferToBoundary → DedupBeforeTriage → Triage → DryPassOrBound", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundaryReconciliation ::= \"→\" \"→\" \"→\" \nTriage ::= \"confirm\" \"→\" | \"dismiss\" \"→\" \nDedup ::= \"newOpens\" \"against\" \"(confirmed | resolvedFalse)\"\nTermination ::= \"dryPass\" | \"maxReconcileRounds\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Recursion Control](/records/algorithms/recursion-control)", "term": "Composes" }, { "description": "[Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[causality_ordering](/records/force/causality-ordering), [resilience_recovery](/records/force/resilience-recovery), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Considerations acted on mid-phase, and a dismissed one resurfaces — the loop oscillates.", "kind": "code", "language": "text", "title": "Before" }, { "code": "capture during phase → act only at the boundary → dedup new opens vs (confirmed | dismissed) → triage{confirm → task | dismiss → resolved-false} → dry pass or bound", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Recursion Control](/records/algorithms/recursion-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-boundary-reconciliation", "title": "Boundary Reconciliation" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Make completion a gated state of the plan rather than a judgment call — a phase closes only when all tasks are done, a dry reconciliation pass holds, verify is clean for the chosen scope, and the coverage graph confirms the ripple set; otherwise the loop returns to execution.", "term": "Intent" }, { "description": "Completion can never be self-declared; closure is a composed evidence-bound gate whose failure routes back to execution, never to done.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AllTasksDone → DryPass → VerifyClean → CoverageConfirmed → CloseOrExecute", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseCloseGate ::= \"&\" \"&\" \"&\" \"→\" \nDecision ::= \"close\" | \"return_to_execute\"\nVerifyResult ::= \"scope:full\" | \"scope:work\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Validation Gate](/records/algorithms/validation-gate), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [](/records/algorithms/governed-plan-concern)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification), [state_transaction](/records/force/state-transaction)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The phase is self-declared done.", "kind": "code", "language": "text", "title": "Before" }, { "code": "all tasks done & dry reconciliation holds & verify clean (scope) & coverage graph confirms ripple → close | return to execute; never self-declared", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Validation Gate](/records/algorithms/validation-gate), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-close-gate", "title": "Phase Close Gate" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Before a composed plan reaches the developer, the engine loops it back through evidence, completeness, and adversarial-skepticism passes, reconciles the findings into the plan, and increments a loop-owned pass counter the model cannot forge; a render boundary blocks an unverified plan.", "term": "Intent" }, { "description": "A plan is never presented un-reviewed, and the verification flag is written only by deterministic engine code, never by model tokens.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AutoLoopback → ThreePassVerify → ReconcileFindings → LoopOwnedIncrement → PresentGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PlanPhaseVerification ::= \"→\" \"→\" \"→\" \"→\" \nVerifyPasses ::= \"evidence\" \",\" \"completeness\" \",\" \"adversarial\"\nPresentGate ::= \"verificationPasses >= 1\"\nCounter ::= \"loop_owned\" \"not_model_emitted\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Recursion Control](/records/algorithms/recursion-control)", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A plan presented to the developer un-reviewed, its verified flag set by model tokens.", "kind": "code", "language": "text", "title": "Before" }, { "code": "auto loopback → 3 passes{evidence, completeness, adversarial} → reconcile findings → loop-owned counter (not model-emitted) → render blocked until verified", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Recursion Control](/records/algorithms/recursion-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-plan-phase-verification", "title": "Plan Phase Verification" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Drive a large task to completion under gates — seed per phase, investigate, execute, self-inform from canon and self-audit, capture considerations, reconcile at the boundary, and close only when the plan is a mechanically resolved state, then re-seed the next phase.", "term": "Intent" }, { "description": "Autonomy is bounded by gates rather than disposition — the plan can only grow with code-verified work, completion is a gated state and not a judgment call, and every step is restart-survivable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SeedPhase → Investigate → Execute → GatedSelfAuditAndInform → CaptureConsiderations → BoundaryReconcile → CloseGate → ReSeedNextPhase", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedPlanLoop ::= \"→\" \"→\" \"→\" \"→\" \nActivityCycle ::= \"investigate\" \"→\" \"execute\" \"→\" \"verify\"\nSelfDrive ::= \"&\" \"&\" \nCompletion ::= \"gated_state\" \"not_judgment_call\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Phase-Separated Execution](/records/algorithms/phase-separated-execution)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" }, { "description": "[constrain](/records/stage/constrain)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state)", "term": "commit" }, { "description": "[Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "constrain" }, { "description": "[Plan Phase Verification](/records/algorithms/plan-phase-verification)", "term": "verify" }, { "description": "[Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A long task driven from conversation memory, self-declared done, losing mid-pass discoveries on restart.", "kind": "code", "language": "text", "title": "Before" }, { "code": "seed phase → investigate → execute → gated self-audit + canon self-inform → capture + reconcile at boundary → close only on a mechanically resolved gated state → re-seed next phase", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Phase-Separated Execution](/records/algorithms/phase-separated-execution)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-autonomous-plan-loop", "title": "Governed Autonomous Plan Loop" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "A large task reaches completion only under gates, never by disposition: the plan grows solely from code-verified work, completion is a gated state rather than a judgment call, and every step is restart-survivable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SeedPhase → GatedActivity → BoundaryReconcile → CloseGate → ReSeed", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedPlanConcern ::= \"→\" \"→\" \"→\" \"→\" \nGatedActivityCycle ::= \"investigate\" \"→\" \"execute\" \"→\" \"gated_self_audit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-plan-concern", "title": "" } ], "title": "Governed plan loop" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_quality_governance_loop[\"Quality Governance Loop\"]\n n_canonical_config_resolution[\"Canonical Config Resolution\"]\n n_stage_ordering[\"Stage Ordering\"]\n n_comment_normalization_remediation[\"Comment Normalization Remediation\"]\n n_custom_rule_derivation[\"Custom-Rule Derivation\"]\n n_machine_verdict_derivation[\"Machine Verdict Derivation\"]\n n_bounded_cascade_termination[\"Bounded Cascade Termination\"]\n n_quality_engine_concern[\"Quality-Engine Kernel\"]\n n_quality_governance_loop --> n_canonical_config_resolution\n n_quality_governance_loop --> n_stage_ordering\n n_quality_governance_loop --> n_comment_normalization_remediation\n n_quality_governance_loop --> n_machine_verdict_derivation\n n_quality_governance_loop --> n_bounded_cascade_termination\n n_quality_engine_concern --> n_canonical_config_resolution\n n_quality_engine_concern --> n_stage_ordering\n n_quality_engine_concern --> n_quality_governance_loop" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-quality-engine", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "On each update (an apply), normalize the proposal, resolve a CheckPlan, verify it, and on failure fix-then-reverify the downstream set until the verdict is clean or the pass bound is reached, then escalate.", "term": "Intent" }, { "description": "Every code update is a bounded verify-remediate loop keyed to the apply event, not the turn; the machine verdict — never the model's read — is its only completion signal.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Update → Normalize → Resolve → Verify → Clean? → Fix → Reverify → Clean|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QualityGovernanceLoop ::= \"→\" \"→\" \"→\" \"→\" ( | \"→\" )\nDownstreamFixCycle ::= \"→\" \"→\" \"→\" \nBoundedReverify ::= \"passCount <= MAX_CASCADE_PASSES\" \"AND\" \"in_scope_findings_strictly_decrease\" | \"escalate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Recursion Control](/records/algorithms/recursion-control), [Resilience Control](/records/algorithms/resilience-control)", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging)", "term": "Forces" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution)", "term": "derive" }, { "description": "[Stage Ordering](/records/algorithms/stage-ordering)", "term": "project" }, { "description": "[Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation)", "term": "act" }, { "description": "[Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation)", "term": "verify" }, { "description": "[Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A code edit judged clean by the model's read, not the machine verdict.", "kind": "code", "language": "text", "title": "Before" }, { "code": "apply → normalize → resolve CheckPlan → verify → {clean | fix in-scope + reverify, bounded, findings strictly decrease} → clean | escalate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Recursion Control](/records/algorithms/recursion-control), [Resilience Control](/records/algorithms/resilience-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-quality-governance-loop", "title": "Quality Governance Loop" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Expand one canonical config across selected profiles and native rules into per-tool config, resolve exactly one owner per contested surface, detect the four conflict kinds fail-closed, route loosening or self-certification to the developer's gate, and emit a resolved plan.", "term": "Intent" }, { "description": "A single canonical model expands to many tools without contradiction only when every contested surface has one owner and every conflict is caught before runtime.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CanonicalConfig → Expand → OwnershipResolution → ConflictDetection → HumanAuthorityRouting → ResolvedPlan|ConflictReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CanonicalConfigResolution ::= \"→\" \"→\" \"→\" \"→\" ( | )\nConflictKind ::= \"ownership_overlap\" | \"unsatisfiable_on_fixed\" | \"value_out_of_range\" | \"known_bad_pair\"\nResolution ::= \"single_owner_enabled\" | \"route_to_human_authority_gate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "One config expanded to many tools with contradictory, unowned rules.", "kind": "code", "language": "text", "title": "Before" }, { "code": "canonical config → per-tool expansion → one owner per contested surface → detect conflicts{ownership overlap, unsatisfiable, out-of-range, known-bad-pair} fail-closed → resolved plan | conflict report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-canonical-config-resolution", "title": "Canonical Config Resolution" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Build the runnability DAG from dependsOn, topologically order the cascade by the invalidates relation so fixes point forward, partition into normalization prefix, structural band, and semantic suffix, and permit back-edges only inside the suffix.", "term": "Intent" }, { "description": "The order determines the total work scope; a forward-pointing order makes each fix dirty only later stages, so the prefix converges once and the suffix is bounded.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Stages → RunnabilityDAG → InvalidatesTopoSort → BandPartition → OrderedStages", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StageOrdering ::= \"→\" \"→\" \"→\" \"→\" \nBandPartition ::= \"normalization_prefix\" \",\" \"structural_band\" \",\" \"semantic_suffix\"\nBackEdgePolicy ::= \"allowed_only_in_semantic_suffix_resolved_at_runtime\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Checks run in arbitrary order, so a fix re-dirties an already-passed stage forever.", "kind": "code", "language": "text", "title": "Before" }, { "code": "stages → runnability DAG (dependsOn) → topo-order by invalidates (fixes point forward) → bands{normalization prefix, structural, semantic suffix}; back-edges only in the suffix", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-stage-ordering", "title": "Stage Ordering" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Express the comment-strip rule once as canonical behavior, bind it per language from a comment-grammar descriptor, run the toolchain-free token-scan backing on the in-memory proposal and the real-AST backing in the sandbox, preserve directive comments, and trust a backing only after calibration and adversarial testing.", "term": "Intent" }, { "description": "An agnostic auto-fix is behavior-as-data compiled per language behind a safety boundary — adding a language is adding a descriptor, not code.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CanonicalRule + GrammarDescriptor → Compile → TokenScan|ASTBacking → DirectivePreservingStrip → CalibratedFix", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CommentNormalization ::= \"→\" \"→\" \"→\" \"→\" \nCompiledBacking ::= \"ast_lite_token_scan_in_memory\" | \"real_ast_via_tier_p_sandbox\"\nSafetyBoundary ::= \"tool_calibration\" \",\" \"adversarial_input_testing\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A comment-strip auto-fix hardcoded per language, so adding a language means new code.", "kind": "code", "language": "text", "title": "Before" }, { "code": "canonical rule + comment-grammar descriptor → compile per language → token-scan (in-memory) | real-AST (sandbox) → preserve directive comments → trust only after calibration + adversarial test", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-comment-normalization-remediation", "title": "Comment Normalization Remediation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Derive a candidate rule from repeated evidence through anti-pattern classification, boundary-principle evaluation, and candidate selection, migrate with rollback, verify elimination, and admit a tightening rule while routing a self-certifying or loosening rule through the developer's gate.", "term": "Intent" }, { "description": "A rule that governs the model's own output cannot be authored or loosened by the model; tightening is admitted, self-certification is gated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → AntiPattern → BoundaryPrinciple → Candidate → Migrate → Verify → Admit|HumanGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CustomRuleDerivation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSelfCertGate ::= \"tightening_admitted\" | \"self_certifying_or_loosening_routes_to_human_authority\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The model authors and loosens a rule that governs its own output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "repeated evidence → anti-pattern classify → boundary principle → candidate → migrate with rollback → verify elimination → {tightening admitted | self-certify/loosen routes to the developer's gate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-custom-rule-derivation", "title": "Custom-Rule Derivation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Derive the verify-stage verdict from the toolchain's machine output — exit codes and parsed findings — never from the model's reading, so a clean verdict is an observed machine fact.", "term": "Intent" }, { "description": "The verify verdict is machine-derived from exit codes and parsed findings; a model's judgment is never the completion signal.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CheckResults → ExitCodesAndFindings → MachineVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MachineVerdictDerivation ::= \"→\" \"→\" \nMachineVerdict ::= \"clean\" | \"violations\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pass declared from the model's reading of the diff, not the tool's exit.", "kind": "code", "language": "text", "title": "Before" }, { "code": "check results → exit codes + parsed findings → machine verdict{clean | violations}; the model's read is never the signal", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-machine-verdict-derivation", "title": "Machine Verdict Derivation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Terminate the verify-remediate cascade on the completion AND-gate — a clean verdict, or bounded progress where findings strictly decrease within the pass bound — escalating when neither holds.", "term": "Intent" }, { "description": "The cascade terminates on a clean machine verdict or a violated progress bound; it never loops unbounded and never stops on an unclean state without escalating.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PassResult → CompletionGate → Stop|Continue|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundedCascadeTermination ::= \"→\" \"→\" ( | | )\nCompletionGate ::= \"clean\" | \"findings_strictly_decrease\" \"AND\" \"passCount <= MAX_CASCADE_PASSES\" | \"escalate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A remediation cascade that loops until it happens to pass, or forever.", "kind": "code", "language": "text", "title": "Before" }, { "code": "each pass → {clean: stop | findings strictly decrease AND passCount <= MAX: continue | else: escalate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-bounded-cascade-termination", "title": "Bounded Cascade Termination" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Resolve a canonical policy into a per-ecosystem CheckPlan, order its stages by the invalidates relation, normalize the proposal, run generation checks on the server and project tools via the relay, derive a machine verdict, and drive a bounded downstream cascade to clean — holding no runtime execution in the engine itself.", "term": "Intent" }, { "description": "Language-agnostic code governance is a pure planner-plus-judge behind a port; execution lives in the relay and the loop, the verdict is machine-derived, and the config gate has already removed every runtime contradiction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → Resolve → Order → Normalize → Execute(G+P) → Verdict → Cascade → Clean|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QualityEngineKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nCheckPlanExecution ::= \"generation_checks_server_side\" \",\" \"project_commands_via_relay\"\nVerdictDerivation ::= \"exit_code\" | \"parse_findings\"\nEngineBoundary ::= \"pure_core_no_runtime_execution_behind_port_adapter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-quality-engine-concern", "title": "Quality-Engine Kernel" } ], "title": "Quality engine" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_composed_turn_contract[\"Composed Turn Contract\"]\n n_loop_owned_mode_selection[\"Loop-Owned Mode Selection\"]\n n_versioned_turn_provenance[\"Versioned Turn Provenance\"]\n n_mode_contract_validation[\"Mode Contract Validation\"]\n n_mode_driven_response_schema[\"\"]\n n_loop_owned_mode_selection --> n_composed_turn_contract\n n_loop_owned_mode_selection --> n_mode_contract_validation\n n_loop_owned_mode_selection --> n_versioned_turn_provenance\n n_mode_driven_response_schema --> n_composed_turn_contract\n n_mode_driven_response_schema --> n_loop_owned_mode_selection\n n_mode_driven_response_schema --> n_versioned_turn_provenance" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-mode-driven-response-schema", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose a model turn's validation schema and its instruction from one self-registering field registry, projected per mode, so the schema the response is graded against and the instruction the model is given can never drift.", "term": "Intent" }, { "description": "The per-mode validation schema and the per-mode instruction are projections of a single field registry; there is no second hand-authored contract surface, and adding or changing a field changes both at once.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RegisterField → SelectByMode → ProjectSchema → ProjectInstruction → StampVersion", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ComposedTurnContract ::= \"→\" \"→\" \nModeKey ::= \"(\" \"phase\" \",\" \"activity\" \")\"\nSchemaVersion ::= \"content_hash\" \"(\"
\")\"\nDeterminism ::= \"same_mode\" \"→\" \"byte_identical\" \"(\" \",\" \")\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Canonical Semantics](/records/algorithms/canonical-semantics), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The validation schema and the model's instruction hand-maintained twice, so they drift.", "kind": "code", "language": "text", "title": "Before" }, { "code": "field registry → project per (phase, activity) mode → schema + instruction from one source → same mode = byte-identical, changing a field changes both", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Canonical Semantics](/records/algorithms/canonical-semantics), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-composed-turn-contract", "title": "Composed Turn Contract" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "The loop assigns the (phase, activity) mode that selects which contract a response is validated against; the model's output carries no contract-selecting field, so a model can never grade itself against a contract it chose.", "term": "Intent" }, { "description": "The mode that selects the response contract is loop-assigned; the model has no field that selects the contract it is graded against.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LoopAssignMode → ComposeContract → ValidateAgainstContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LoopOwnedModeSelection ::= \"→\" \"→\" \nModeAuthority ::= \"loop_owned\" \"not_model_selected\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Contract Compatibility](/records/algorithms/contract-compatibility)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[security_governance](/records/force/security-governance), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract)", "term": "act" }, { "description": "[Mode Contract Validation](/records/algorithms/mode-contract-validation)", "term": "verify" }, { "description": "[Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance)", "term": "commit" } ], "kind": "glossary" }, { "code": "The model's output carries the field that selects which contract it's graded against.", "kind": "code", "language": "text", "title": "Before" }, { "code": "loop assigns (phase, activity) mode → compose contract → validate; the model can never grade itself against a contract it chose", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Contract Compatibility](/records/algorithms/contract-compatibility)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-loop-owned-mode-selection", "title": "Loop-Owned Mode Selection" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Persist each accepted model turn as an append-only, mode-tagged, schema-versioned, causally ordered record with change-only provenance, so the turn history is a queryable, auditable log and a turn is never graded against a schema version its stored state never saw.", "term": "Intent" }, { "description": "Turn records are append-only and single-writer causally ordered; a version is stamped by content and never mutated in place; a no-op change appends nothing.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StampVersion → AssignCausalOrder → AppendOnly → BumpOnChange → Query", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VersionedTurnProvenance ::= \"→\" \"→\" \nCausalOrder ::= \"single_writer_counter\" \"not\" \"disk_read_max\"\nProvenance ::= \"bump_on_real_change\" \"no_op_appends_nothing\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[observability_traceability](/records/force/observability-traceability), [state_transaction](/records/force/state-transaction), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A turn graded against a schema version its stored state never saw.", "kind": "code", "language": "text", "title": "Before" }, { "code": "accepted turn → stamp version by content → single-writer causal order → append-only, mode-tagged record; a no-op appends nothing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-versioned-turn-provenance", "title": "Versioned Turn Provenance" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate the model's response against the loop-selected mode contract and, on a validation miss, drive an error-specific self-healing retry bounded by the contract, so a response is accepted only when it satisfies the schema it is graded against.", "term": "Intent" }, { "description": "A response is accepted only against the mode contract the loop selected; a validation miss self-heals with error-specific remediation, never against a relaxed contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Response → ValidateAgainstContract → Valid|SelfHealRetry → Accepted|Rejected", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModeContractValidation ::= \",\" \"→\" \"→\" ( | \"→\" )\nSelfHealRetry ::= \"error_specific_remediation\" \"(\" \")\" \"bounded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A response accepted because it looked right, not because it satisfied the mode's schema.", "kind": "code", "language": "text", "title": "Before" }, { "code": "response + mode contract → validate → {valid | error-specific self-heal retry, bounded} → accepted | rejected", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-mode-contract-validation", "title": "Mode Contract Validation" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Make the model's structured output a mode-driven composed contract — the output mirror of composed input context: per loop-owned mode the schema and instruction are projected from one field registry, the response is validated and self-heals against it, the typed fields are governed, and every turn is persisted as a versioned queryable record — so the output has one source, cannot drift from its instruction, and can be audited.", "term": "Intent" }, { "description": "The response contract is composed per loop-owned mode from a single field registry; instruction and validation are the same source; a validation miss self-heals with error-specific remediation; output governance is advisory and never blocks the hard verify gate; and every accepted turn is a versioned, append-only record.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ComposeContract → ValidateByMode → SelfRemediate → GovernFields → PersistVersioned", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModeDrivenResponseSchema ::= \"→\" \"→\" \"→\" \"→\" \nSingleSource ::= \"instruction\" \"=\" \"validation\" \"=\" \"projection\" \"(\" \")\"\nSelfRemediation ::= \"error_specific_retry\" \"(\" \",\" \")\"\nGroundingAdvisory ::= \"typed_field\" \"→\" \"validator\" \"(\" \"advisory_not_blocking\" \")\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Contract Compatibility](/records/algorithms/contract-compatibility), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Contract Compatibility](/records/algorithms/contract-compatibility), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-mode-driven-response-schema", "title": "" } ], "title": "Mode-driven response schema" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_cascade_layer_partition[\"Cascade Layer Partition\"]\n n_token_source_of_truth[\"Token Source-of-Truth\"]\n n_type_keyed_appearance[\"Type-Keyed Appearance\"]\n n_custom_type_registration[\"Custom Type Registration\"]\n n_governed_construction_boundary[\"Governed Construction Boundary\"]\n n_placement_isolation[\"Placement Isolation\"]\n n_assembly_composition[\"Assembly Composition\"]\n n_layer_fitness_enforcement[\"Layer Fitness Enforcement\"]\n n_type_migration_centralization[\"Type-Migration Centralization\"]\n n_css_type_cascade_concern[\"CSS Type-Cascade Kernel\"]\n n_css_type_cascade_concern --> n_cascade_layer_partition\n n_css_type_cascade_concern --> n_token_source_of_truth\n n_css_type_cascade_concern --> n_type_keyed_appearance\n n_css_type_cascade_concern --> n_custom_type_registration\n n_css_type_cascade_concern --> n_placement_isolation\n n_css_type_cascade_concern --> n_assembly_composition\n n_css_type_cascade_concern --> n_layer_fitness_enforcement" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-css-cascade", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Declare one ordered set of named cascade layers once at the stylesheet root, assign every rule to exactly one layer, and let layer order — not selector specificity nor source order — decide precedence, so values, appearance, placement, and assembly can never fight for the same declaration.", "term": "Intent" }, { "description": "Style precedence must be a property of the layer a rule lives in, not of how specific its selector is; an unlayered rule silently outranks every layer and is therefore forbidden.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Root → LayerOrderDeclaration → PerFileLayerBinding → LayerPrecedence → DeterministicCascade", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CascadeLayerPartition ::= \"→\" \"→\" \nLayerOrderDeclaration ::= \"@layer\" \"tokens\" \",\" \"globals\" \",\" \"shell\" \",\" \"components\" \",\" \"app\"\nLayeredBinding ::= \"assigned_to\" \nPrecedencePolicy ::= \"app_over_components_over_shell_over_globals_over_tokens\" \",\" \"layer_beats_specificity\" \",\" \"no_unlayered_rule\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: red; }\n#page .foo { color: blue; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer tokens, globals, components, app;\n@layer globals { [data-el=\"foo\"] { color: var(--fg); } }\n@layer app { .foo-view { gap: var(--space-4); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cascade-layer-partition", "title": "Cascade Layer Partition" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Define every design primitive — color, space, radius, the type scale, size, duration, z-index — exactly once as a custom property in the tokens layer, and forbid any downstream literal where a token exists.", "term": "Intent" }, { "description": "Values are canonical data with a single source; a literal in globals, components, or app where a token exists is duplication, not styling.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Primitive → TokenDeclaration → DownstreamReference → NoLiteralWhereTokenExists", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TokenSourceOfTruth ::= \"→\" \"→\" \nTokenCategory ::= \"color\" | \"space\" | \"radius\" | \"type_scale\" | \"size\" | \"duration\" | \"z_index\"\nLiteralPolicy ::= \"reference_token\" | \"zero_value_exempt\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [performance_scaling](/records/force/performance-scaling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: #33bb55; }\n.bar { color: #33bb55; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer tokens { :root { --foo: #33bb55; } }\n@layer globals { [data-el=\"foo\"], [data-el=\"bar\"] { color: var(--foo); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-token-source-of-truth", "title": "Token Source-of-Truth" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "In the globals layer, define how every element and component type looks, its size, and its spacing exactly once, keyed only by element tag, `data-el` custom type, and the orthogonal `data-*` axes (`data-variant` paint, `data-size` scale, `data-gap` child rhythm, `data-tone` palette, `data-measure` width); never key appearance by a purpose-class, and let every value be a token.", "term": "Intent" }, { "description": "Appearance is a contract owned by a type, not by a use-site; a purpose-class in globals fragments one type's look across many call-sites and is forbidden.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Type → GlobalAppearanceRule → DefinedOncePerType → TokenizedValues", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TypeKeyedAppearance ::= \"→\" \"→\" \nTypeSelector ::= | \"[data-el=\" \"]\" | \"[data-\" (\"variant\"|\"size\"|\"gap\"|\"tone\"|\"measure\"|\"layout\") \"=\" \"]\"\nAppearanceProperty ::= \"look\" | \"size\" | \"spacing\" | \"intrinsic_rendering_behavior\"\nForbiddenKey ::= \"purpose_class\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data), [Domain Boundary](/records/algorithms/domain-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo-label { font-size: 12px; color: gray; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer globals { [data-el=\"foo\"] { font-size: var(--text-sm); color: var(--fg-muted); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data), [Domain Boundary](/records/algorithms/domain-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-type-keyed-appearance", "title": "Type-Keyed Appearance" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Extend the stylable element vocabulary beyond the native HTML tag set by registering each semantic type against a base tag and a `data-el` stamp; the registered type becomes a first-class node the globals layer binds one appearance contract to, so a concept no native tag can express — a field-label, an icon, a toast, an entry — is styled by its type, never by a class.", "term": "Intent" }, { "description": "The set of stylable types is open and self-registered, not limited to the HTML tag set; a new appearance contract is a newly registered type plus one global rule, never a new purpose-class.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticConcept → DefineElement(type, baseTag, dataEl) → TypeRegistry → DataElStamp → GlobalAppearanceContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CustomTypeRegistration ::= \"→\" \"→\" \"→\" \"→\" \nElementDefinition ::= \"type\" \",\" \"baseTag\" \",\" \"dataElToken\"\nRenderedTypeStamp ::= \"carrying\" \"data-el=\" \nAppearanceBinding ::= \"[data-el=\" \"]\" \"owns_exactly_one_global_appearance_rule\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Extension Point](/records/algorithms/extension-point), [Self-Description Manifest](/records/algorithms/self-description-manifest)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "**…**\n.foo { color: gray; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "defineElement({ type: \"foo\", baseTag: \"output\", dataEl: \"foo\" });\n@layer globals { [data-el=\"foo\"] { color: var(--fg-muted); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Extension Point](/records/algorithms/extension-point), [Self-Description Manifest](/records/algorithms/self-description-manifest)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-custom-type-registration", "title": "Custom Type Registration" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Route all DOM creation through one governed factory that resolves a node spec of shape `{ el, variant, size, gap, tone, measure, layout, class, on, children }` against the type, handler, and component registries, maps each axis key to its `data-*` attribute, treats `class` as a gated hook (icon-font glyph, `u-*` utility, or `c-*` component — never bespoke, never appearance), throws on any unknown type, handler, or component, and refuses an inline `style` attribute.", "term": "Intent" }, { "description": "The construction surface must be structurally incapable of producing a node that is unstyled-by-type or carries an inline style; the illegal state is unrepresentable, not merely linted after the fact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "NodeSpec → RegistryResolution → ScalarMapping → UnknownReject|InlineStyleReject → GovernedNode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedConstruction ::= \"→\" \"→\" \"→\" \"→\" \nNodeSpec ::= \"el\" \",\" \"variant?\" \",\" \"size?\" \",\" \"gap?\" \",\" \"tone?\" \",\" \"measure?\" \",\" \"layout?\" \",\" \"class?\" \",\" \"on?\" \",\" \"children?\"\nScalarApplication ::= \"each_axis_key→data-attr\" \",\" \"class=gated_iconfont_or_u_or_c\"\nGuardSet ::= \"throw_on_unknown_element\" \",\" \"throw_on_unknown_handler\" \",\" \"throw_on_unknown_component\" \",\" \"reject_style_attribute\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Construction Boundary](/records/algorithms/construction-boundary), [Error Boundary](/records/algorithms/error-boundary), [Security Policy](/records/algorithms/security-policy)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [object_creation](/records/force/object-creation)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const n = document.createElement(\"div\");\nn.className = \"foo\";\nn.style.color = \"red\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const n = dom({ el: \"foo\", tone: \"bar\", children: [text] });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Construction Boundary](/records/algorithms/construction-boundary), [Error Boundary](/records/algorithms/error-boundary), [Security Policy](/records/algorithms/security-policy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-construction-boundary", "title": "Governed Construction Boundary" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "In the components layer, set only where a component sits — position, offsets, stacking, overlay — keyed by its type, and never its look, size, or spacing, which remain owned by globals.", "term": "Intent" }, { "description": "Placement and appearance are separate contracts; a placement rule that also sets a look re-opens a type's appearance outside its single global definition and breaks the layer partition.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ComponentType → PlacementRule → PositionStackingOverlayOnly → NoAppearanceLeak", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PlacementIsolation ::= \"→\" \"→\" \nPlacementProperty ::= \"position\" | \"inset\" | \"top\" | \"right\" | \"bottom\" | \"left\" | \"z_index\" | \"float\" | \"clear\"\nForbiddenInComponents ::= \"color\" | \"font\" | \"size\" | \"spacing\" | \"border\" | \"radius\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary), [Coupling Control](/records/algorithms/coupling-control)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "@layer components { [data-el=\"foo\"] { position: fixed; inset-block-end: 1rem; color: white; } }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer components { [data-el=\"foo\"] { position: fixed; inset-block-end: var(--space-4); z-index: var(--z-overlay); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary), [Coupling Control](/records/algorithms/coupling-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-placement-isolation", "title": "Placement Isolation" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "In the app layer, compose views from structural containers and arrange their children with flex or grid and token-valued gaps, pad each container once so its children are full-width and fill the padded box, forbid horizontal margins, and never set or override any element's or component's look.", "term": "Intent" }, { "description": "Assembly arranges typed parts and owns child layout plus gutter discipline, but holds zero appearance authority, so a view can be recomposed without restyling a single type.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "View → ContainerSet → ChildArrangement → GutterConvention → NoAppearanceOverride", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AssemblyComposition ::= \"→\" \"→\" \"→\" \nChildArrangement ::= \"flex\" | \"grid\" | \"token_valued_gap\"\nGutterConvention ::= \"container_pads_once\" \",\" \"child_width_100\" \",\" \"no_horizontal_margin\" \",\" \"narrower_via_explicit_width\" \",\" \"zero_margin_exempt\"\nAppearanceAuthority ::= \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "@layer app { .foo-view .bar { margin: 0 12px; box-shadow: 0 1px 2px; } }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer app { .foo-view { display: grid; gap: var(--space-4); padding-inline: var(--space-4); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-assembly-composition", "title": "Assembly Composition" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Bind each layer invariant to a machine check — layer order declared once, placement properties barred from globals, class selectors barred from globals, literals barred where a token exists, no horizontal margin, all DOM through the factory, no inline style — run them as hard errors with no warn tier and no inline disables, and gate the push on a clean verdict.", "term": "Intent" }, { "description": "A layer contract holds only if a fitness function fails the build when it is broken; the factory makes appearance-by-type unrepresentable and the linters make any residue unshippable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LayerInvariant → FitnessFunction → StaticCheck → HardErrorNoWarn → PushGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LayerFitnessEnforcement ::= \"→\" \"→\" \nCssFitnessRule ::= \"layer_order\" | \"no_appearance_in_components_or_app\" | \"no_class_in_globals\" | \"layered_class_format_c_or_u\" | \"no_bespoke_class\" | \"tokens_only\" | \"axis_value_validation\" | \"no_horizontal_margin\"\nDomFitnessRule ::= \"factory_only_creation\" | \"no_inline_style\"\nGatePolicy ::= \"hard_error_no_warn_tier\" \",\" \"no_inline_disable\" \",\" \"block_push_on_fail\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Verification Fitness](/records/algorithms/verification-fitness)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [object_creation](/records/force/object-creation), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "reviewChecklist.push(\"no appearance in the app layer\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const rules = { \"no-appearance-in-app\": \"error\", \"factory-only-creation\": \"error\" };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Verification Fitness](/records/algorithms/verification-fitness)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-layer-fitness-enforcement", "title": "Layer Fitness Enforcement" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "To move an existing purpose-class or page-scoped stylesheet into this model, treat every appearance-bearing class rule as a migration unit, derive the element type it decorates, register a custom `data-el` type when no tag or variant expresses it, move its look, size, and spacing into one global rule keyed by that type, demote any residual position into components and any residual layout into app, and verify that zero appearance rule keyed by a purpose-class remains outside the globals layer.", "term": "Intent" }, { "description": "Migration is centralization by type: each scattered purpose-class appearance collapses into one type-keyed global rule, and completion is proven by the absence of appearance outside globals, not by a narrative claim.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PurposeClassRule → DeriveType → RegisterTypeIfNeeded → MoveAppearanceToGlobals → DemoteResidue → ZeroAppearanceClassOutsideGlobals", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TypeMigration ::= \"→\" \"→\" \"→\" \"→\" \nTypeDerivation ::= \"existing_tag\" | \"existing_variant\" | \"register_new_data_el_type\"\nResidueDemotion ::= \"placement→components\" \",\" \"layout→app\"\nZeroDuplicationVerdict ::= \"no_appearance_keyed_by_purpose_class_outside_globals\" | \"incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: white; background: blue; position: sticky; top: 0; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer globals { [data-el=\"foo\"] { color: var(--fg-on-accent); background: var(--bg-accent); } }\n@layer components { [data-el=\"foo\"] { position: sticky; top: 0; } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-type-migration-centralization", "title": "Type-Migration Centralization" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Declare one layer order, hold every value in tokens, key every appearance on a type — native or custom-registered — exactly once in globals, hold placement in components and assembly in app, create all DOM through a factory that stamps types and refuses inline style, and gate the whole contract behind machine fitness functions.", "term": "Intent" }, { "description": "Styling is reproducible when precedence is layer-decided, appearance is a per-type contract, the type vocabulary is open and factory-stamped, and every invariant has a build-failing check.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LayerOrder → Tokens → TypeKeyedGlobals → Placement → Assembly → GovernedFactory → Fitness", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CssTypeCascadeKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nStylingBoundary ::= \"values_in_tokens\" \",\" \"appearance_by_type_in_globals\" \",\" \"app_frame_in_shell\" \",\" \"structure_in_components\" \",\" \"assembly_in_app\"\nOpenTypeVocabulary ::= \"native_tag\" | \"registered_data_el_custom_type\"\nCascadeContract ::= \"layer_decides_precedence\" \",\" \"one_definition_per_property_per_type\" \",\" \"factory_and_linters_enforce\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Custom Type Registration](/records/algorithms/custom-type-registration), [Placement Isolation](/records/algorithms/placement-isolation), [Assembly Composition](/records/algorithms/assembly-composition), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [object_creation](/records/force/object-creation), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Custom Type Registration](/records/algorithms/custom-type-registration), [Placement Isolation](/records/algorithms/placement-isolation), [Assembly Composition](/records/algorithms/assembly-composition), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-css-type-cascade-concern", "title": "CSS Type-Cascade Kernel" } ], "title": "CSS cascade" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_taxonomy_jurisdiction[\"Taxonomy Jurisdiction\"]\n n_reshape_risk_priority[\"Reshape Risk Priority\"]\n n_path_role_walk[\"Path Role Walk\"]\n n_concern_classification[\"Concern Classification\"]\n n_name_projection[\"Name Projection\"]\n n_container_reshape[\"Container Reshape\"]\n n_vocabulary_admission_gate[\"Vocabulary Admission Gate\"]\n n_discovery_verification[\"Discovery Verification\"]\n n_taxonomy_ledger[\"Taxonomy Ledger\"]\n n_taxonomy_completion[\"Taxonomy Completion\"]\n n_container_ladder[\"Container Ladder\"]\n n_export_triage_ladder[\"Export Triage Ladder\"]\n n_dialect_resolution[\"Dialect Resolution\"]\n n_alignment_cadence[\"Alignment Cadence\"]\n n_taxonomy_kernel[\"Taxonomy Kernel\"]\n n_taxonomy_concern[\"\"]\n n_taxonomy_kernel --> n_taxonomy_jurisdiction\n n_taxonomy_kernel --> n_reshape_risk_priority\n n_taxonomy_kernel --> n_path_role_walk\n n_taxonomy_kernel --> n_concern_classification\n n_taxonomy_kernel --> n_name_projection\n n_taxonomy_kernel --> n_container_reshape\n n_taxonomy_kernel --> n_vocabulary_admission_gate\n n_taxonomy_kernel --> n_discovery_verification\n n_taxonomy_kernel --> n_taxonomy_ledger\n n_taxonomy_kernel --> n_taxonomy_completion" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-taxonomy", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read the registry's root, container, bucket and ignore declarations, enumerate every file under a declared root, and separate the governed set from the ignored set and from the folders declared as neither, so jurisdiction is read rather than inferred.", "term": "Intent" }, { "description": "No declaration, no enforcement: a file is governed only under a declared root, and a root folder in neither the container nor the bucket declaration is a finding rather than a new container.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Registry → GovernedRootSet → ContainerSet → GovernedFileSet → FlaggedFolderSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyJurisdiction ::= \"→\" \"→\" \nJurisdictionPartition ::= \",\" \",\" \nGovernedRootSet ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Whether a file is governed is decided per file as it comes up, so an undeclared tree is silently exempt and a stray root-level folder reads as legitimate.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry → governed roots → containers + buckets + ignore entries → the governed file set, and the flagged set of root folders declared as neither", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-jurisdiction", "title": "Taxonomy Jurisdiction" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Score each governed container by how much reference surface a rename disturbs — importer count and the number of surfaces that resolve by pattern rather than by literal path — and rank ascending, so the pilot is the lowest-risk container and the highest-risk one lands last.", "term": "Intent" }, { "description": "The container converted first is the one whose failure is cheapest to detect, not the one whose naming is worst.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ContainerSet → ReferenceSurfaceCount → RiskScore → OrderedContainerQueue", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReshapeRiskPriority ::= \"→\" \"→\" \nRiskScore ::= \"*\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Conversion starts wherever the tree looks worst, so the first container is the one with the most importers and the most pattern-resolved aggregators.", "kind": "code", "language": "text", "title": "Before" }, { "code": "containers → score(importer count x shape-discovered surface count) → ascending rank → pilot the lowest-risk container end to end first", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-reshape-risk-priority", "title": "Reshape Risk Priority" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Walk every governed path from its root, assign each folder depth a role from the declared grammar in the ordered sequence container then subject then concern, and emit the depth-to-role edge list together with the depths that repeat a role, revisit an earlier one, or exceed the cap.", "term": "Intent" }, { "description": "Each depth consumes a role strictly later than the depth before it, a role may be skipped but never repeated or revisited, and the file's parent always resolves to the concern role.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GovernedPath → DepthSequence → RoleAssignment → RoleEdgeList → DepthViolationSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PathRoleWalk ::= \"→\" \"→\" \",\" \nRoleAssignment ::= \"<\" \"<\" \nDepthViolation ::= \"over_cap\" | \"role_repeated\" | \"role_revisited\" | \"file_outside_concern\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A path is judged by whether it looks tidy, so a concern folder nested under a concern folder and a subject folder below its concern both read as ordinary nesting.", "kind": "code", "language": "text", "title": "Before" }, { "code": "path → assign each depth a role in the order container < subject < concern → depth<=cap and no role repeated or revisited → the role-assignment edge list plus the violating depths", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-path-role-walk", "title": "Path Role Walk" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Read each governed file, assign the narrowest accurate concern from the declared vocabulary by its primary responsibility, record a file that fits two concerns as a split candidate, and break an irreducible overlap by the domain-ward layer, so classification is judgment against the file rather than pattern-matching against its path.", "term": "Intent" }, { "description": "A concern is assigned by reading the file, never by its current location; a file that fits two concerns is a split candidate, not a tie to be broken arbitrarily.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GovernedFile → PrimaryResponsibility → CandidateConcernSet → AssignedConcern → SplitCandidateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConcernClassification ::= \"→\" \"→\" \"|\" \nCandidateConcernSet ::= \"→\" \"+\"\nAssignedConcern ::= \"|\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Principle" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A file is tagged from where it currently sits, so a saturated label absorbs several distinct roles and a two-role file is hidden under whichever word came first.", "kind": "code", "language": "text", "title": "Before" }, { "code": "read the file → narrowest accurate declared concern → one concern: classified; two concerns: split candidate; irreducible overlap: domain-ward layer wins", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concern-classification", "title": "Concern Classification" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Compose the target name from the assigned concern, the subject, and a variant taken only where a collision or a facet requires one, and derive the folder chain from that same concern, so the filename and its placement are one projection rather than two decisions.", "term": "Intent" }, { "description": "The concern tag terminates the filename and names the parent folder, so the name determines the placement and one unanchored pattern resolves either level.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AssignedConcern → SubjectSelection → VariantTrigger → TargetName → TargetFolderChain", "kind": "code", "language": "text", "title": "Flow" }, { "code": "NameProjection ::= \",\" \",\" \"→\" \",\" \nTargetName ::= \".\" ? \".\" \".\" \nTargetFolderChain ::= \"/\" ? \"/\" \nVariantTrigger ::= \"collision\" | \"facet\" | \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The new name is written by hand, so the tag lands mid-name, a compound swallows the concern, and the folder chain is chosen separately from the filename.", "kind": "code", "language": "text", "title": "Before" }, { "code": "(subject, variant?, concern, ext) → foo... with the tag terminating → the folder chain container/[subject]/ that the tag itself determines", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-name-projection", "title": "Name Projection" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Convert one container at a time: split the multi-role files first, move and rename each remaining file to its projected name and folder, update every importer in the same pass, move the mirrored tests to match the new concern folders, and re-point every surface whose pattern encoded the old form.", "term": "Intent" }, { "description": "A rename is one identity migration completed within a single container, references included; the gate is green before the next container starts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "OrderedContainerQueue → SplitExecution → MoveRename → ImporterUpdate → TestMirrorMove → SurfaceRepoint", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContainerReshape ::= \"→\" \"→\" \"→\" \"→\" \nReferenceUpdate ::= \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A rename tool rewrites every literal path across the whole tree at once, and the surfaces that resolve by pattern are never re-pointed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "one container → split candidates first → move and rename → update every importer → move the mirrored tests → re-point every shape-discovered surface → gate green before the next container", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-container-reshape", "title": "Container Reshape" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Hold every proposed word against the declared vocabularies and the rejection table, resolve and name the declared word that covers it where one does, refuse a word that names a process, an adjective, a grouping label, or a measurement, sort a surviving word by the is-a test into concerns or subjects, and admit it only by developer-approved registry edit.", "term": "Intent" }, { "description": "An undeclared word is a finding, never a license to add one, and a refusal names the covering word wherever the table resolves one; coverage is decided by the role a file plays, never by general-language synonymy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProposedWord → CoverageCheck → CoveringConcern → IsATest → AdmissionVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VocabularyAdmissionGate ::= \"→\" \"→\" \"→\" \nCoverageCheck ::= \"→\" \"→\" \"|\" \"uncovered\"\nRejectionTableIndex ::= \"→\" \nAdmissionVerdict ::= \"admit_concern\" | \"admit_subject\" | \"refuse_rename_file\" | \"refuse_covered_by\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Principle" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An unclassifiable file is answered by adding its word to the vocabulary, or by an ignore entry, and the check goes green either way; where a word is refused, the refusal names only what is wrong.", "kind": "code", "language": "text", "title": "Before" }, { "code": "proposed word → rejection-table index resolves the covering concern: refuse naming it, and rename the file → uncovered: is-a a role: concerns; has-a a thing: subjects → otherwise refuse; admission is a developer-approved registry edit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-vocabulary-admission-gate", "title": "Vocabulary Admission Gate" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For every shape-discovered surface touched by the reshape, compare the member set it collects against what it collected before, and issue the verdict from that comparison, so a collection that silently emptied is caught rather than read as a clean pass.", "term": "Intent" }, { "description": "A green gate is not evidence for a pattern-resolved surface; the verdict comes from the collected member set, and an unexplained drop is a failure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ShapeDiscoveredSurfaceSet → CollectedSetBefore → CollectedSetAfter → DiscoveryVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DiscoveryVerification ::= \"→\" \"→\" \nCollectedSetDelta ::= \"-\" \nDiscoveryVerdict ::= \"preserved\" | \"intended_change\" | \"silently_emptied\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Principle" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The gate is green after the rename, so the reshape is called done; the aggregator that collected by suffix now collects nothing and there is nothing left to check.", "kind": "code", "language": "text", "title": "Before" }, { "code": "per aggregator → collected member set before vs after → equal or intentionally changed: pass; silently emptied or shrunk: fail, and a green gate is not evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-discovery-verification", "title": "Discovery Verification" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Record the registry version, the conversion state of each container, and every admitted and refused word with its reasoning, so the taxonomy's history is durable evidence rather than a fact re-derived from the tree on each pass.", "term": "Intent" }, { "description": "A refusal is recorded with its reason, so the answer to why a word is absent is retrievable rather than lost.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RegistryVersion → ContainerConversionState → AdmissionRecordSet → TaxonomyLedger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyLedger ::= \",\" \",\" \nAdmissionRecord ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[observability_traceability](/records/force/observability-traceability), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Which containers are converted and which words were refused is remembered rather than recorded, so the same rejected word is proposed again and the vocabulary drifts from the document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry version + per-container conversion state + admitted and refused words → a durable ledger the next reshape and the next proposal both read", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-ledger", "title": "Taxonomy Ledger" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Mark the taxonomy complete only when every governed file resolves against the grammar at both levels, no split candidate is outstanding, and every shape-discovered surface has a preserved verdict, leaving it incomplete while any residual remains.", "term": "Intent" }, { "description": "Completion is the absence of residual findings, never a converted-container count, and never a finding removed by an ignore entry.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TaxonomyLedger → ResidualFindingSet → CompletionVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyCompletion ::= \"→\" \"→\" \nResidualFindingSet ::= \"+\" \"+\" \"+\" \nCompletionVerdict ::= \"taxonomy_complete\" | \"taxonomy_incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Principle" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Conversion is declared done on the container count, while unclassified files sit under an ignore entry and one aggregator still collects nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "every governed file placed and named to the grammar AND every split candidate resolved AND every surface verified preserved → complete; any residual → incomplete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-completion", "title": "Taxonomy Completion" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Decide what a folder found at a governed root is by asking, in order, whether it groups concern sets, holds one role, belongs under an existing container, or is not source at all, so a new container is declared only for a new grouping axis.", "term": "Intent" }, { "description": "A container is declared only for a grouping axis no existing container covers, and never to house a folder that resists placement or to shorten a path.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RootFolder → SubjectTest → ConcernTest → ExistingContainerTest → SourceTest → LadderVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContainerLadder ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nLadderVerdict ::= \"subject_folder\" | \"concern_folder\" | \"move_under_container\" | \"ignore_entry\" | \"propose_container\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A folder appears at a governed root, so it is declared a container, and the next folder that resists placement gets one too.", "kind": "code", "language": "text", "title": "Before" }, { "code": "folder at a root → groups concern sets that must not merge: subject folder → holds one role: concern folder → an existing container groups it: move it there → not source: ignore entry → only a new grouping axis: container, by approved edit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-container-ladder", "title": "Container Ladder" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Give each export nothing imports the first verdict that holds, in order: wire it where a call site repeats its work, stage it as capability awaiting a consumer, delete a superseded one with its references, or remove it with the duplicate it served.", "term": "Intent" }, { "description": "An unreferenced export is triaged one at a time while its file is being read, and a report that nothing imports it starts the ladder rather than concluding it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "UnreferencedExport → HandRolledCallSite → AwaitingConsumer → Superseded → ConsolidatedDuplicate → TriageVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ExportTriageLadder ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTriageVerdict ::= \"wire\" | \"stage\" | \"delete\" | \"remove_with_duplicate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The dead-code report lists exports nothing imports, and they are removed in bulk; a capability a call site was hand-rolling disappears with the evidence of the gap.", "kind": "code", "language": "text", "title": "Before" }, { "code": "unreferenced export → a call site hand-rolls it: wire it → capability awaiting a consumer: stage it in the allowlist → superseded with no consumer: delete with every reference → only consumer was a merged duplicate: remove with the duplicate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-export-triage-ladder", "title": "Export Triage Ladder" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Resolve a filename whose extension a dialect names by splitting its stem at that case's word boundaries, taking the longest trailing word run that is a declared tag as the concern and the leading words as the subject and an optional declared variant.", "term": "Intent" }, { "description": "A dialect changes how the slots are spelled and never which words may fill them, so every dialect file resolves against the same closed vocabularies as a dotted one.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Extension → DialectCase → WordRun → ConcernRun → HeadSlots → ResolvedSlots", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DialectResolution ::= \"→\" \"→\" \"→\" \",\" \"→\" \nDialectCase ::= \"camel\" | \"pascal\" | \"snake\" | \"kebab\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A language that names its files in another case is either left outside the grammar or forced into dotted names its own tools cannot find.", "kind": "code", "language": "text", "title": "Before" }, { "code": "extension → dialect case → stem split at word boundaries → longest trailing run that is a declared tag: concern → leading words: subject, then a declared variant → the same three slots the dotted grammar reads", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dialect-resolution", "title": "Dialect Resolution" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Accept a conversion record only when the alignment entry it cites was written against the protocol's current revision and fewer than the declared span of records cite that entry, so the rules are re-read at a bounded cadence.", "term": "Intent" }, { "description": "Editing the protocol reopens every record written against the earlier revision, and no alignment entry covers more than the declared span of records.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConversionRecord → AlignmentEntry → RevisionCheck → SpanCheck → AlignmentVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AlignmentCadence ::= \"→\" \"→\" \",\" \"→\" \nAlignmentVerdict ::= \"current\" | \"stale_revision\" | \"span_exceeded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A long conversion runs on a protocol read once at the start, and later files are classified under rulings that have faded from working context while every record still looks correct.", "kind": "code", "language": "text", "title": "Before" }, { "code": "conversion record → cites an alignment entry → the entry's hash equals the protocol's current hash and the run citing it is within the declared span → accepted; otherwise → re-read the protocol whole and write a new entry", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-alignment-cadence", "title": "Alignment Cadence" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Resolve jurisdiction from the registry, order the containers by reshape risk, walk each path into its ordered roles, classify each file to its narrowest concern, project the name and the folder chain together, reshape one container at a time, hold every proposed word at the admission gate, verify that pattern-resolved surfaces still collect what they collected, ledger the state, and terminate only when no residual finding remains.", "term": "Intent" }, { "description": "Placement and naming are one derivation from a declared vocabulary to a verified tree, in which every folder and every filename slot resolves to a declared word and one unanchored pattern resolves a concern at either level.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Jurisdiction → RiskPriority → RoleWalk → Classification → NameProjection → Reshape → AdmissionGate → DiscoveryVerification → Ledger → Completion", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Path Role Walk](/records/algorithms/path-role-walk), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Reshape](/records/algorithms/container-reshape), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [modularity](/records/force/modularity), [architecture_evolution](/records/force/architecture-evolution), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)", "term": "orient" }, { "description": "[Reshape Risk Priority](/records/algorithms/reshape-risk-priority)", "term": "intent" }, { "description": "[Path Role Walk](/records/algorithms/path-role-walk)", "term": "see" }, { "description": "[Concern Classification](/records/algorithms/concern-classification)", "term": "derive" }, { "description": "[Name Projection](/records/algorithms/name-projection)", "term": "project" }, { "description": "[Container Reshape](/records/algorithms/container-reshape)", "term": "act" }, { "description": "[Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)", "term": "constrain" }, { "description": "[Discovery Verification](/records/algorithms/discovery-verification)", "term": "verify" }, { "description": "[Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "commit" }, { "description": "[Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "terminate" } ], "kind": "glossary" }, { "code": "Naming and placement are conventions carried in reviewers' heads, so a path has more than one right answer, an undeclared word enters whenever a file resists classification, and no pattern resolves a concern tree-wide.", "kind": "code", "language": "text", "title": "Before" }, { "code": "jurisdiction → risk priority → role walk → classification → name projection → container reshape → admission gate → discovery verification → ledger → completion", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Path Role Walk](/records/algorithms/path-role-walk), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Reshape](/records/algorithms/container-reshape), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-kernel", "title": "Taxonomy Kernel" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → ", "term": "Intent" }, { "description": "Every governed folder and every filename slot resolves to a word from a closed declared vocabulary, the concern tag terminates the filename and names its parent folder, and no path exceeds the declared depth cap.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Jurisdiction → RoleWalk → Classification → NameProjection → Reshape → AdmissionGate → Verification → Ledger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyConcern ::= \"→\" \"→\" \"→\" \",\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-concern", "title": "" } ], "title": "Taxonomy" } ] }, "description": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a…", "id": "ontology", "label": "Algorithms", "tab": "algorithms", "title": "Algorithms — Ontology — Bane's Lab", "url": "https://banes-lab.com/ontology/algorithms" }