@bastani/atomic 0.5.11 → 0.5.12-0

package/.agents/skills/audit/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: audit
+description: Run technical quality checks across accessibility, performance, theming, responsive design, and anti-patterns. Generates a scored report with P0-P3 severity ratings and actionable plan. Use when the user wants an accessibility check, performance audit, or technical quality review.
+version: 2.1.1
+user-invocable: true
+argument-hint: "[area (feature, page, component...)]"
+---
+
+## MANDATORY PREPARATION
+
+Invoke /impeccable — it contains design principles, anti-patterns, and the **Context Gathering Protocol**. Follow the protocol before proceeding — if no design context exists yet, you MUST run /impeccable teach first.
+
+---
+
+Run systematic **technical** quality checks and generate a comprehensive report. Don't fix issues — document them for other commands to address.
+
+This is a code-level audit, not a design critique. Check what's measurable and verifiable in the implementation.
+
+## Diagnostic Scan
+
+Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the criteria below.
+
+### 1. Accessibility (A11y)
+
+**Check for**:
+- **Contrast issues**: Text contrast ratios < 4.5:1 (or 7:1 for AAA)
+- **Missing ARIA**: Interactive elements without proper roles, labels, or states
+- **Keyboard navigation**: Missing focus indicators, illogical tab order, keyboard traps
+- **Semantic HTML**: Improper heading hierarchy, missing landmarks, divs instead of buttons
+- **Alt text**: Missing or poor image descriptions
+- **Form issues**: Inputs without labels, poor error messaging, missing required indicators
+
+**Score 0-4**: 0=Inaccessible (fails WCAG A), 1=Major gaps (few ARIA labels, no keyboard nav), 2=Partial (some a11y effort, significant gaps), 3=Good (WCAG AA mostly met, minor gaps), 4=Excellent (WCAG AA fully met, approaches AAA)
+
+### 2. Performance
+
+**Check for**:
+- **Layout thrashing**: Reading/writing layout properties in loops
+- **Expensive animations**: Animating layout properties (width, height, top, left) instead of transform/opacity
+- **Missing optimization**: Images without lazy loading, unoptimized assets, missing will-change
+- **Bundle size**: Unnecessary imports, unused dependencies
+- **Render performance**: Unnecessary re-renders, missing memoization
+
+**Score 0-4**: 0=Severe issues (layout thrash, unoptimized everything), 1=Major problems (no lazy loading, expensive animations), 2=Partial (some optimization, gaps remain), 3=Good (mostly optimized, minor improvements possible), 4=Excellent (fast, lean, well-optimized)
+
+### 3. Theming
+
+**Check for**:
+- **Hard-coded colors**: Colors not using design tokens
+- **Broken dark mode**: Missing dark mode variants, poor contrast in dark theme
+- **Inconsistent tokens**: Using wrong tokens, mixing token types
+- **Theme switching issues**: Values that don't update on theme change
+
+**Score 0-4**: 0=No theming (hard-coded everything), 1=Minimal tokens (mostly hard-coded), 2=Partial (tokens exist but inconsistently used), 3=Good (tokens used, minor hard-coded values), 4=Excellent (full token system, dark mode works perfectly)
+
+### 4. Responsive Design
+
+**Check for**:
+- **Fixed widths**: Hard-coded widths that break on mobile
+- **Touch targets**: Interactive elements < 44x44px
+- **Horizontal scroll**: Content overflow on narrow viewports
+- **Text scaling**: Layouts that break when text size increases
+- **Missing breakpoints**: No mobile/tablet variants
+
+**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets)
+
+### 5. Anti-Patterns (CRITICAL)
+
+Check against ALL the **DON'T** guidelines in the impeccable skill. Look for AI slop tells (AI color palette, gradient text, glassmorphism, hero metrics, card grids, generic fonts) and general design anti-patterns (gray on color, nested cards, bounce easing, redundant copy).
+
+**Score 0-4**: 0=AI slop gallery (5+ tells), 1=Heavy AI aesthetic (3-4 tells), 2=Some tells (1-2 noticeable), 3=Mostly clean (subtle issues only), 4=No AI tells (distinctive, intentional design)
+
+## Generate Report
+
+### Audit Health Score
+
+| # | Dimension | Score | Key Finding |
+|---|-----------|-------|-------------|
+| 1 | Accessibility | ? | [most critical a11y issue or "--"] |
+| 2 | Performance | ? | |
+| 3 | Responsive Design | ? | |
+| 4 | Theming | ? | |
+| 5 | Anti-Patterns | ? | |
+| **Total** | | **??/20** | **[Rating band]** |
+
+**Rating bands**: 18-20 Excellent (minor polish), 14-17 Good (address weak dimensions), 10-13 Acceptable (significant work needed), 6-9 Poor (major overhaul), 0-5 Critical (fundamental issues)
+
+### Anti-Patterns Verdict
+**Start here.** Pass/fail: Does this look AI-generated? List specific tells. Be brutally honest.
+
+### Executive Summary
+- Audit Health Score: **??/20** ([rating band])
+- Total issues found (count by severity: P0/P1/P2/P3)
+- Top 3-5 critical issues
+- Recommended next steps
+
+### Detailed Findings by Severity
+
+Tag every issue with **P0-P3 severity**:
+- **P0 Blocking**: Prevents task completion — fix immediately
+- **P1 Major**: Significant difficulty or WCAG AA violation — fix before release
+- **P2 Minor**: Annoyance, workaround exists — fix in next pass
+- **P3 Polish**: Nice-to-fix, no real user impact — fix if time permits
+
+For each issue, document:
+- **[P?] Issue name**
+- **Location**: Component, file, line
+- **Category**: Accessibility / Performance / Theming / Responsive / Anti-Pattern
+- **Impact**: How it affects users
+- **WCAG/Standard**: Which standard it violates (if applicable)
+- **Recommendation**: How to fix it
+- **Suggested command**: Which command to use (prefer: /animate, /quieter, /shape, /optimize, /adapt, /clarify, /layout, /distill, /delight, /audit, /harden, /polish, /bolder, /typeset, /critique, /colorize, /overdrive)
+
+### Patterns & Systemic Issues
+
+Identify recurring problems that indicate systemic gaps rather than one-off mistakes:
+- "Hard-coded colors appear in 15+ components, should use design tokens"
+- "Touch targets consistently too small (<44px) throughout mobile experience"
+
+### Positive Findings
+
+Note what's working well — good practices to maintain and replicate.
+
+## Recommended Actions
+
+List recommended commands in priority order (P0 first, then P1, then P2):
+
+1. **[P?] `/command-name`** — Brief description (specific context from audit findings)
+2. **[P?] `/command-name`** — Brief description (specific context)
+
+**Rules**: Only recommend commands from: /animate, /quieter, /shape, /optimize, /adapt, /clarify, /layout, /distill, /delight, /audit, /harden, /polish, /bolder, /typeset, /critique, /colorize, /overdrive. Map findings to the most appropriate command. End with `/polish` as the final step if any fixes were recommended.
+
+After presenting the summary, tell the user:
+
+> You can ask me to run these one at a time, all at once, or in any order you prefer.
+>
+> Re-run `/audit` after fixes to see your score improve.
+
+**IMPORTANT**: Be thorough but actionable. Too many P3 issues creates noise. Focus on what actually matters.
+
+**NEVER**:
+- Report issues without explaining impact (why does this matter?)
+- Provide generic recommendations (be specific and actionable)
+- Skip positive findings (celebrate what works)
+- Forget to prioritize (everything can't be P0)
+- Report false positives without verification
+
+Remember: You're a technical quality auditor. Document systematically, prioritize ruthlessly, cite specific code locations, and provide clear paths to improvement.

package/.agents/skills/bdi-mental-states/SKILL.md

@@ -0,0 +1,311 @@
+---
+name: bdi-mental-states
+description: This skill should be used when the user asks to "model agent mental states", "implement BDI architecture", "create belief-desire-intention models", "transform RDF to beliefs", "build cognitive agent", or mentions BDI ontology, mental state modeling, rational agency, or neuro-symbolic AI integration. Part of the context engineering skill suite — also activates when the user mentions "context engineering" or "context-engineering" in the context of belief-based agent reasoning.
+---
+
+# BDI Mental State Modeling
+
+Transform external RDF context into agent mental states (beliefs, desires, intentions) using formal BDI ontology patterns. This skill enables agents to reason about context through cognitive architecture, supporting deliberative reasoning, explainability, and semantic interoperability within multi-agent systems.
+
+## When to Activate
+
+Activate this skill when:
+- Processing external RDF context into agent beliefs about world states
+- Modeling rational agency with perception, deliberation, and action cycles
+- Enabling explainability through traceable reasoning chains
+- Implementing BDI frameworks (SEMAS, JADE, JADEX)
+- Augmenting LLMs with formal cognitive structures (Logic Augmented Generation)
+- Coordinating mental states across multi-agent platforms
+- Tracking temporal evolution of beliefs, desires, and intentions
+- Linking motivational states to action plans
+
+## Core Concepts
+
+### Mental Reality Architecture
+
+Separate mental states into two ontological categories because BDI reasoning requires distinguishing what persists from what happens:
+
+**Mental States (Endurants)** -- model these as persistent cognitive attributes that hold over time intervals:
+- `Belief`: Represent what the agent holds true about the world. Ground every belief in a world state reference.
+- `Desire`: Represent what the agent wishes to bring about. Link each desire back to the beliefs that motivate it.
+- `Intention`: Represent what the agent commits to achieving. An intention must fulfil a desire and specify a plan.
+
+**Mental Processes (Perdurants)** -- model these as events that create or modify mental states, because tracking causal transitions enables explainability:
+- `BeliefProcess`: Triggers belief formation/update from perception. Always connect to a generating world state.
+- `DesireProcess`: Generates desires from existing beliefs. Preserves the motivational chain.
+- `IntentionProcess`: Commits to selected desires as actionable intentions.
+
+### Cognitive Chain Pattern
+
+Wire beliefs, desires, and intentions into directed chains using bidirectional properties (`motivates`/`isMotivatedBy`, `fulfils`/`isFulfilledBy`) because this enables both forward reasoning (what should the agent do?) and backward tracing (why did the agent act?):
+
+```turtle
+:Belief_store_open a bdi:Belief ;
+    rdfs:comment "Store is open" ;
+    bdi:motivates :Desire_buy_groceries .
+
+:Desire_buy_groceries a bdi:Desire ;
+    rdfs:comment "I desire to buy groceries" ;
+    bdi:isMotivatedBy :Belief_store_open .
+
+:Intention_go_shopping a bdi:Intention ;
+    rdfs:comment "I will buy groceries" ;
+    bdi:fulfils :Desire_buy_groceries ;
+    bdi:isSupportedBy :Belief_store_open ;
+    bdi:specifies :Plan_shopping .
+```
+
+### World State Grounding
+
+Always ground mental states in world state references rather than free-text descriptions, because ungrounded beliefs break semantic querying and cross-agent interoperability:
+
+```turtle
+:Agent_A a bdi:Agent ;
+    bdi:perceives :WorldState_WS1 ;
+    bdi:hasMentalState :Belief_B1 .
+
+:WorldState_WS1 a bdi:WorldState ;
+    rdfs:comment "Meeting scheduled at 10am in Room 5" ;
+    bdi:atTime :TimeInstant_10am .
+
+:Belief_B1 a bdi:Belief ;
+    bdi:refersTo :WorldState_WS1 .
+```
+
+### Goal-Directed Planning
+
+Connect intentions to plans via `bdi:specifies`, and decompose plans into ordered task sequences using `bdi:precedes`, because this separation allows plan reuse across different intentions while keeping execution order explicit:
+
+```turtle
+:Intention_I1 bdi:specifies :Plan_P1 .
+
+:Plan_P1 a bdi:Plan ;
+    bdi:addresses :Goal_G1 ;
+    bdi:beginsWith :Task_T1 ;
+    bdi:endsWith :Task_T3 .
+
+:Task_T1 bdi:precedes :Task_T2 .
+:Task_T2 bdi:precedes :Task_T3 .
+```
+
+## T2B2T Paradigm
+
+Implement Triples-to-Beliefs-to-Triples as a bidirectional pipeline because agents must both consume external RDF context and produce new RDF assertions. Structure every T2B2T implementation in two explicit phases:
+
+**Phase 1: Triples-to-Beliefs** -- Translate incoming RDF triples into belief instances. Use `bdi:triggers` to connect the external world state to a `BeliefProcess`, and `bdi:generates` to produce the resulting belief. This preserves provenance from source data through to internal cognition:
+```turtle
+:WorldState_notification a bdi:WorldState ;
+    rdfs:comment "Push notification: Payment request $250" ;
+    bdi:triggers :BeliefProcess_BP1 .
+
+:BeliefProcess_BP1 a bdi:BeliefProcess ;
+    bdi:generates :Belief_payment_request .
+```
+
+**Phase 2: Beliefs-to-Triples** -- After BDI deliberation selects an intention and executes a plan, project the results back into RDF using `bdi:bringsAbout`. This closes the loop so downstream systems can consume agent outputs as standard linked data:
+```turtle
+:Intention_pay a bdi:Intention ;
+    bdi:specifies :Plan_payment .
+
+:PlanExecution_PE1 a bdi:PlanExecution ;
+    bdi:satisfies :Plan_payment ;
+    bdi:bringsAbout :WorldState_payment_complete .
+```
+
+## Notation Selection by Level
+
+Choose notation based on the C4 abstraction level being modeled, because mixing notations at the wrong level obscures rather than clarifies the cognitive architecture:
+
+| C4 Level | Notation | Mental State Representation |
+|----------|----------|----------------------------|
+| L1 Context | ArchiMate | Agent boundaries, external perception sources |
+| L2 Container | ArchiMate | BDI reasoning engine, belief store, plan executor |
+| L3 Component | UML | Mental state managers, process handlers |
+| L4 Code | UML/RDF | Belief/Desire/Intention classes, ontology instances |
+
+## Justification and Explainability
+
+Attach `bdi:Justification` instances to every mental entity using `bdi:isJustifiedBy`, because unjustified mental states make agent reasoning opaque and untraceable. Each justification should capture the evidence or rule that produced the mental state:
+
+```turtle
+:Belief_B1 a bdi:Belief ;
+    bdi:isJustifiedBy :Justification_J1 .
+
+:Justification_J1 a bdi:Justification ;
+    rdfs:comment "Official announcement received via email" .
+
+:Intention_I1 a bdi:Intention ;
+    bdi:isJustifiedBy :Justification_J2 .
+
+:Justification_J2 a bdi:Justification ;
+    rdfs:comment "Location precondition satisfied" .
+```
+
+## Temporal Dimensions
+
+Assign validity intervals to every mental state using `bdi:hasValidity` with `TimeInterval` instances, because beliefs without temporal bounds cannot be garbage-collected or conflict-checked during diachronic reasoning:
+
+```turtle
+:Belief_B1 a bdi:Belief ;
+    bdi:hasValidity :TimeInterval_TI1 .
+
+:TimeInterval_TI1 a bdi:TimeInterval ;
+    bdi:hasStartTime :TimeInstant_9am ;
+    bdi:hasEndTime :TimeInstant_11am .
+```
+
+Query mental states active at a specific moment using SPARQL temporal filters. Use this pattern to resolve conflicts when multiple beliefs about the same world state overlap in time:
+
+```sparql
+SELECT ?mentalState WHERE {
+    ?mentalState bdi:hasValidity ?interval .
+    ?interval bdi:hasStartTime ?start ;
+              bdi:hasEndTime ?end .
+    FILTER(?start <= "2025-01-04T10:00:00"^^xsd:dateTime &&
+           ?end >= "2025-01-04T10:00:00"^^xsd:dateTime)
+}
+```
+
+## Compositional Mental Entities
+
+Decompose complex beliefs into constituent parts using `bdi:hasPart` relations, because monolithic beliefs force full replacement on partial updates. Structure composite beliefs so that each sub-belief can be independently updated, queried, or invalidated:
+
+```turtle
+:Belief_meeting a bdi:Belief ;
+    rdfs:comment "Meeting at 10am in Room 5" ;
+    bdi:hasPart :Belief_meeting_time , :Belief_meeting_location .
+
+# Update only location component without touching time
+:BeliefProcess_update a bdi:BeliefProcess ;
+    bdi:modifies :Belief_meeting_location .
+```
+
+## Integration Patterns
+
+### Logic Augmented Generation (LAG)
+
+Use LAG to constrain LLM outputs with ontological structure, because unconstrained generation produces triples that violate BDI class restrictions. Serialize the ontology into the prompt context, then validate generated triples against it before accepting them:
+
+```python
+def augment_llm_with_bdi_ontology(prompt, ontology_graph):
+    ontology_context = serialize_ontology(ontology_graph, format='turtle')
+    augmented_prompt = f"{ontology_context}\n\n{prompt}"
+
+    response = llm.generate(augmented_prompt)
+    triples = extract_rdf_triples(response)
+
+    is_consistent = validate_triples(triples, ontology_graph)
+    return triples if is_consistent else retry_with_feedback()
+```
+
+### SEMAS Rule Translation
+
+Translate BDI ontology patterns into executable production rules when deploying to rule-based agent platforms. Map each cognitive chain link (belief-to-desire, desire-to-intention) to a HEAD/CONDITIONALS/TAIL rule, because this preserves the deliberative semantics while enabling runtime execution:
+
+```prolog
+% Belief triggers desire formation
+[HEAD: belief(agent_a, store_open)] /
+[CONDITIONALS: time(weekday_afternoon)] »
+[TAIL: generate_desire(agent_a, buy_groceries)].
+
+% Desire triggers intention commitment
+[HEAD: desire(agent_a, buy_groceries)] /
+[CONDITIONALS: belief(agent_a, has_shopping_list)] »
+[TAIL: commit_intention(agent_a, buy_groceries)].
+```
+
+## Guidelines
+
+1. Model world states as configurations independent of agent perspectives, providing referential substrate for mental states.
+
+2. Distinguish endurants (persistent mental states) from perdurants (temporal mental processes), aligning with DOLCE ontology.
+
+3. Treat goals as descriptions rather than mental states, maintaining separation between cognitive and planning layers.
+
+4. Use `hasPart` relations for meronymic structures enabling selective belief updates.
+
+5. Associate every mental entity with temporal constructs via `atTime` or `hasValidity`.
+
+6. Use bidirectional property pairs (`motivates`/`isMotivatedBy`, `generates`/`isGeneratedBy`) for flexible querying.
+
+7. Link mental entities to `Justification` instances for explainability and trust.
+
+8. Implement T2B2T through: (1) translate RDF to beliefs, (2) execute BDI reasoning, (3) project mental states back to RDF.
+
+9. Define existential restrictions on mental processes (e.g., `BeliefProcess ⊑ ∃generates.Belief`).
+
+10. Reuse established ODPs (EventCore, Situation, TimeIndexedSituation, BasicPlan, Provenance) for interoperability.
+
+## Competency Questions
+
+Validate implementation against these SPARQL queries:
+
+```sparql
+# CQ1: What beliefs motivated formation of a given desire?
+SELECT ?belief WHERE {
+    :Desire_D1 bdi:isMotivatedBy ?belief .
+}
+
+# CQ2: Which desire does a particular intention fulfill?
+SELECT ?desire WHERE {
+    :Intention_I1 bdi:fulfils ?desire .
+}
+
+# CQ3: Which mental process generated a belief?
+SELECT ?process WHERE {
+    ?process bdi:generates :Belief_B1 .
+}
+
+# CQ4: What is the ordered sequence of tasks in a plan?
+SELECT ?task ?nextTask WHERE {
+    :Plan_P1 bdi:hasComponent ?task .
+    OPTIONAL { ?task bdi:precedes ?nextTask }
+} ORDER BY ?task
+```
+
+## Gotchas
+
+1. **Conflating mental states with world states**: Mental states reference world states via `bdi:refersTo`, they are not world states themselves. Mixing them collapses the perception-cognition boundary and breaks SPARQL queries that filter by type.
+
+2. **Missing temporal bounds**: Every mental state needs validity intervals for diachronic reasoning. Without them, stale beliefs persist indefinitely and conflict detection becomes impossible.
+
+3. **Flat belief structures**: Use compositional modeling with `hasPart` for complex beliefs. Monolithic beliefs force full replacement when only one attribute changes.
+
+4. **Implicit justifications**: Always link mental entities to explicit `Justification` instances. Unjustified mental states cannot be audited or traced.
+
+5. **Direct intention-to-action mapping**: Intentions specify plans which contain tasks; actions execute tasks. Skipping the plan layer removes the ability to reuse, reorder, or share execution strategies.
+
+6. **Ontology over-complexity**: Start with 5-10 core classes and properties (Belief, Desire, Intention, WorldState, Plan, plus key relations). Expanding the ontology prematurely inflates prompt context and slows SPARQL queries without improving reasoning quality.
+
+7. **Reasoning cost explosion**: Keep belief chains to 3 levels or fewer (belief -> desire -> intention). Deeper chains become prohibitively expensive for LLM inference and rarely improve decision quality over shallower alternatives.
+
+## Integration
+
+- **RDF Processing**: Apply after parsing external RDF context to construct cognitive representations
+- **Semantic Reasoning**: Combine with ontology reasoning to infer implicit mental state relationships
+- **Multi-Agent Communication**: Integrate with FIPA ACL for cross-platform belief sharing
+- **Temporal Context**: Coordinate with temporal reasoning for mental state evolution
+- **Explainable AI**: Feed into explanation systems tracing perception through deliberation to action
+- **Neuro-Symbolic AI**: Apply in LAG pipelines to constrain LLM outputs with cognitive structures
+
+## References
+
+Internal references:
+- [BDI Ontology Core](./references/bdi-ontology-core.md) - Read when: implementing BDI class hierarchies or defining ontology properties from scratch
+- [RDF Examples](./references/rdf-examples.md) - Read when: writing Turtle serializations of mental states or debugging triple structure
+- [SPARQL Competency Queries](./references/sparql-competency.md) - Read when: validating an implementation against competency questions or building custom queries
+- [Framework Integration](./references/framework-integration.md) - Read when: deploying BDI models to SEMAS, JADE, or LAG pipelines
+
+Primary sources:
+- Zuppiroli et al. "The Belief-Desire-Intention Ontology" (2025) — Read when: implementing formal BDI class hierarchies or validating ontology alignment
+- Rao & Georgeff "BDI agents: From theory to practice" (1995) — Read when: understanding the theoretical foundations of practical reasoning agents
+- Bratman "Intention, plans, and practical reason" (1987) — Read when: grounding implementation decisions in the philosophical basis of intentionality
+
+---
+
+## Skill Metadata
+
+**Created**: 2026-01-07
+**Last Updated**: 2026-03-17
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 2.0.0

package/.agents/skills/bdi-mental-states/references/bdi-ontology-core.md

@@ -0,0 +1,207 @@
+# BDI Ontology Core Patterns
+
+Core ontology design patterns for Belief-Desire-Intention mental state modeling.
+
+## Class Hierarchy
+
+### Mental Entities (Endurants)
+
+```
+bdi:MentalEntity
+├── bdi:Belief          # Informational dimension
+├── bdi:Desire          # Motivational dimension  
+├── bdi:Intention       # Deliberative dimension
+├── bdi:Goal            # Description of desired end state
+└── bdi:Plan            # Structured action sequence
+```
+
+### Mental Processes (Perdurants)
+
+```
+bdi:MentalProcess
+├── bdi:BeliefProcess      # Forms/updates beliefs from perception
+├── bdi:DesireProcess      # Generates desires from beliefs
+├── bdi:IntentionProcess   # Commits to desires as intentions
+├── bdi:Planning           # Transforms intentions into plans
+└── bdi:PlanExecution      # Executes plan actions
+```
+
+### Supporting Entities
+
+```
+bdi:WorldState        # Configuration of environment
+bdi:Justification     # Evidential basis for mental states
+bdi:Task              # Atomic unit of planned action
+bdi:Action            # Execution of a task
+bdi:TimeInterval      # Temporal validity bounds
+bdi:TimeInstant       # Point in time reference
+```
+
+## Object Properties
+
+### Motivational Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `motivates` | Belief | Desire | Belief provides reason for desire |
+| `isMotivatedBy` | Desire | Belief | Inverse of motivates |
+| `fulfils` | Intention | Desire | Intention commits to achieving desire |
+| `isFulfilledBy` | Desire | Intention | Inverse of fulfils |
+| `isSupportedBy` | Intention | Belief | Beliefs supporting intention viability |
+
+### Generative Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `generates` | MentalProcess | MentalEntity | Process creates mental state |
+| `isGeneratedBy` | MentalEntity | MentalProcess | Inverse of generates |
+| `modifies` | MentalProcess | MentalEntity | Process updates existing state |
+| `suppresses` | MentalProcess | MentalEntity | Process deactivates state |
+| `isTriggeredBy` | MentalProcess | MentalEntity | State initiates process |
+
+### Referential Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `refersTo` | MentalEntity | WorldState | Mental state about world |
+| `perceives` | Agent | WorldState | Agent observes world |
+| `bringsAbout` | Action | WorldState | Action causes world change |
+| `reasonsUpon` | MentalProcess | MentalEntity | Input to reasoning |
+
+### Structural Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `hasPart` | MentalEntity | MentalEntity | Meronymic composition |
+| `specifies` | Intention | Plan | Intention defines plan |
+| `addresses` | Plan | Goal | Plan achieves goal |
+| `hasComponent` | Plan | Task | Plan contains tasks |
+| `precedes` | Task | Task | Task ordering |
+
+### Temporal Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `atTime` | Entity | TimeInstant | Point occurrence |
+| `hasValidity` | MentalEntity | TimeInterval | Persistence bounds |
+| `hasStartTime` | TimeInterval | TimeInstant | Interval start |
+| `hasEndTime` | TimeInterval | TimeInstant | Interval end |
+
+### Justification Relations
+
+| Property | Domain | Range | Description |
+|----------|--------|-------|-------------|
+| `isJustifiedBy` | MentalEntity | Justification | Evidential support |
+| `justifies` | Justification | MentalEntity | Inverse relation |
+
+## Ontological Restrictions
+
+### Belief Restrictions
+
+```turtle
+bdi:Belief rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:refersTo ;
+    owl:someValuesFrom bdi:WorldState
+] .
+
+bdi:Belief rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:hasValidity ;
+    owl:maxCardinality 1
+] .
+```
+
+### Desire Restrictions
+
+```turtle
+bdi:Desire rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:isMotivatedBy ;
+    owl:someValuesFrom bdi:Belief
+] .
+```
+
+### Intention Restrictions
+
+```turtle
+bdi:Intention rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:fulfils ;
+    owl:cardinality 1
+] .
+
+bdi:Intention rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:isSupportedBy ;
+    owl:someValuesFrom bdi:Belief
+] .
+```
+
+### Mental Process Restrictions
+
+```turtle
+bdi:BeliefProcess rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:generates ;
+    owl:allValuesFrom bdi:Belief
+] .
+
+bdi:DesireProcess rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:generates ;
+    owl:allValuesFrom bdi:Desire
+] .
+
+bdi:IntentionProcess rdfs:subClassOf [
+    a owl:Restriction ;
+    owl:onProperty bdi:generates ;
+    owl:allValuesFrom bdi:Intention
+] .
+```
+
+## DOLCE Alignment
+
+The BDI ontology aligns with DOLCE Ultra Lite (DUL) foundational ontology:
+
+| BDI Class | DUL Superclass | Rationale |
+|-----------|----------------|-----------|
+| `Agent` | `dul:Agent` | Intentional entity capable of action |
+| `Belief` | `dul:InformationObject` | Information-bearing entity |
+| `Desire` | `dul:Description` | Describes desired state |
+| `Intention` | `dul:Description` | Describes committed course |
+| `Goal` | `dul:Goal` | Desired end state description |
+| `Plan` | `dul:Plan` | Organized action sequence |
+| `WorldState` | `dul:Situation` | Configuration of entities |
+| `MentalProcess` | `dul:Event` | Temporally extended occurrence |
+| `Task` | `dul:Task` | Unit of planned work |
+| `Action` | `dul:Action` | Performed task instance |
+
+## Reused Ontology Design Patterns
+
+### EventCore Pattern
+Used for mental processes with temporal aspects and participant roles.
+
+### Situation Pattern  
+Used for world state configurations that mental states reference.
+
+### TimeIndexedSituation Pattern
+Used for associating mental states with validity intervals.
+
+### BasicPlan Pattern
+Used for goal-plan-task structures linking intentions to actions.
+
+### Provenance Pattern
+Used for justification tracking and evidential chains.
+
+## Namespace Declarations
+
+```turtle
+@prefix bdi: <https://w3id.org/fossr/ontology/bdi/> .
+@prefix dul: <http://www.ontologydesignpatterns.org/ont/dul/DUL.owl#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+```
+