From d04239b788e8133fef3643476cf820efa56f03e1 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:04:09 +0900
Subject: [PATCH 1/8] add llms.txt with Be Framework core concepts

---
 llms.txt | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 llms.txt

diff --git a/llms.txt b/llms.txt
new file mode 100644
index 0000000..b8387cc
--- /dev/null
+++ b/llms.txt
@@ -0,0 +1,108 @@
+# Be Framework
+
+> Objects don't DO things—they BECOME things.
+
+Be Framework is a PHP framework for ontological programming where transformation (metamorphosis) replaces procedural action.
+
+## Core Philosophy
+
+A patient doesn't "get triaged." They **become** an emergency case or an observation case, based on the transcendent wisdom of medical protocol.
+
+## Key Concepts
+
+### Domain Ontology (Semantic Variables)
+Semantic variables define what CAN exist in a domain—not just validation rules, but the vocabulary of existence. This declarative foundation serves as documentation that both humans and AI can read to understand your domain.
+
+```php
+final class BodyTemperature
+{
+    #[Validate]
+    public function validate(float $bodyTemperature): void
+    {
+        if ($bodyTemperature < 30.0 || $bodyTemperature > 45.0) {
+            throw new LethalVitalException();
+        }
+    }
+}
+```
+
+### Reason (Transcendence)
+Domain logic becomes a first-class citizen: injectable, testable, and explicitly visible.
+
+```php
+final readonly class JTASProtocol
+{
+    /** @return 'emergency'|'observation' */
+    public function assess(float $bodyTemperature, int $heartRate): string
+    {
+        if ($bodyTemperature >= 39.0 || $heartRate >= 120) {
+            return 'emergency';
+        }
+        return 'observation';
+    }
+}
+```
+
+### Metamorphosis Pattern
+Input → Being → Final transformation through the Becoming class.
+
+```php
+$becoming = new Becoming($injector, 'Be\\App\\Semantic');
+$patient = new PatientArrival(bodyTemperature: 39.5, heartRate: 90);
+$result = $becoming($patient);
+// $result IS an EmergencyCase or ObservationCase
+```
+
+### Type-Driven Branching
+The `$being` property (Union type) determines which Final class receives the transformation.
+
+```php
+#[Be([EmergencyCase::class, ObservationCase::class])]
+final readonly class TriageAssessment
+{
+    public Emergency|Observation $being;
+
+    public function __construct(
+        #[Input] public float $bodyTemperature,
+        #[Input] public int $heartRate,
+        #[Inject] JTASProtocol $protocol
+    ) {
+        $urgency = $protocol->assess($bodyTemperature, $heartRate);
+        $this->being = ($urgency === 'emergency')
+            ? new Emergency()
+            : new Observation();
+    }
+}
+```
+
+### Type IS Capability
+Different Final types have different methods—the type determines what actions are possible.
+
+```php
+// EmergencyCase has assignER()
+// ObservationCase has assignWaitingArea()
+$result->assignER();  // Only possible for EmergencyCase
+```
+
+## Key Attributes
+
+- `#[Be([TargetClass::class])]` - Declares metamorphosis destination(s)
+- `#[Input]` - Receives data from previous stage
+- `#[Inject]` - Receives transcendent capability (DI)
+- `#[Validate]` - Semantic validation method marker
+
+## Transformation Flow
+
+```
+Input (with #[Be([Being::class])])
+    ↓ Becoming executes
+Being (with #[Be([Final1::class, Final2::class])])
+    ↓ $being property determines branch
+Final (capability-specific type)
+```
+
+## Documentation
+
+- English: https://be-framework.github.io/manuals/1.0/en/
+- Japanese: https://be-framework.github.io/manuals/1.0/ja/
+- Repository: https://github.com/be-framework/be-framework

From b92c84cd7fca7408152725f7186ae7d681b42121 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:34:55 +0900
Subject: [PATCH 2/8] fix: restructure llms.txt and add llms-full.txt

---
 llms-full.txt | 243 ++++++++++++++++++++++++++++++++++++++++++++++++++
 llms.txt      | 111 +++--------------------
 2 files changed, 257 insertions(+), 97 deletions(-)
 create mode 100644 llms-full.txt

diff --git a/llms-full.txt b/llms-full.txt
new file mode 100644
index 0000000..d129d43
--- /dev/null
+++ b/llms-full.txt
@@ -0,0 +1,243 @@
+# Be Framework - Full Documentation
+
+> Objects don't DO things—they BECOME things.
+
+Be Framework is a PHP framework for ontological programming where transformation (metamorphosis) replaces procedural action.
+
+## Core Philosophy
+
+A patient doesn't "get triaged." They **become** an emergency case or an observation case, based on the transcendent wisdom of medical protocol.
+
+## Key Concepts
+
+### Domain Ontology (Semantic Variables)
+
+Semantic variables define what CAN exist in a domain—not just validation rules, but the vocabulary of existence. This declarative foundation serves as documentation that both humans and AI can read to understand your domain.
+
+```php
+final class BodyTemperature
+{
+    #[Validate]
+    public function validate(float $bodyTemperature): void
+    {
+        if ($bodyTemperature < 30.0 || $bodyTemperature > 45.0) {
+            throw new LethalVitalException();
+        }
+    }
+}
+```
+
+### Reason (Transcendence)
+
+Domain logic becomes a first-class citizen: injectable, testable, and explicitly visible.
+
+```php
+final readonly class JTASProtocol
+{
+    /** @return 'emergency'|'observation' */
+    public function assess(float $bodyTemperature, int $heartRate): string
+    {
+        if ($bodyTemperature >= 39.0 || $heartRate >= 120) {
+            return 'emergency';
+        }
+        return 'observation';
+    }
+}
+```
+
+### Metamorphosis Pattern
+
+Input → Being → Final transformation through the Becoming class.
+
+```php
+$becoming = new Becoming($injector, 'Be\\App\\Semantic');
+$patient = new PatientArrival(bodyTemperature: 39.5, heartRate: 90);
+$result = $becoming($patient);
+// $result IS an EmergencyCase or ObservationCase
+```
+
+### Type-Driven Branching
+
+The `$being` property (Union type) determines which Final class receives the transformation.
+
+```php
+#[Be([EmergencyCase::class, ObservationCase::class])]
+final readonly class TriageAssessment
+{
+    public Emergency|Observation $being;
+
+    public function __construct(
+        #[Input] public float $bodyTemperature,
+        #[Input] public int $heartRate,
+        #[Inject] JTASProtocol $protocol
+    ) {
+        $urgency = $protocol->assess($bodyTemperature, $heartRate);
+        $this->being = ($urgency === 'emergency')
+            ? new Emergency()
+            : new Observation();
+    }
+}
+```
+
+### Type IS Capability
+
+Different Final types have different methods—the type determines what actions are possible.
+
+```php
+// EmergencyCase has assignER()
+// ObservationCase has assignWaitingArea()
+$result->assignER();  // Only possible for EmergencyCase
+```
+
+## Key Attributes
+
+- `#[Be([TargetClass::class])]` - Declares metamorphosis destination(s)
+- `#[Input]` - Receives data from previous stage
+- `#[Inject]` - Receives transcendent capability (DI)
+- `#[Validate]` - Semantic validation method marker
+
+## Transformation Flow
+
+```
+Input (with #[Be([Being::class])])
+    ↓ Becoming executes
+Being (with #[Be([Final1::class, Final2::class])])
+    ↓ $being property determines branch
+Final (capability-specific type)
+```
+
+## Project Structure
+
+```
+src/
+├── Input/          # Starting points (raw data)
+├── Being/          # Intermediate transformations
+├── Final/          # Destinations (capability-specific types)
+├── Reason/         # Transcendent wisdom (domain logic)
+├── Semantic/       # Domain ontology (what CAN exist)
+├── Exception/      # Domain exceptions
+└── Module/         # DI configuration
+```
+
+## Example: Emergency Triage
+
+### Input Class
+
+```php
+#[Be([TriageAssessment::class])]
+final readonly class PatientArrival
+{
+    public function __construct(
+        public float $bodyTemperature,
+        public int $heartRate
+    ) {}
+}
+```
+
+### Being Class
+
+```php
+#[Be([EmergencyCase::class, ObservationCase::class])]
+final readonly class TriageAssessment
+{
+    public Emergency|Observation $being;
+
+    public function __construct(
+        #[Input] public float $bodyTemperature,
+        #[Input] public int $heartRate,
+        #[Inject] JTASProtocol $protocol
+    ) {
+        $urgency = $protocol->assess($bodyTemperature, $heartRate);
+        $this->being = ($urgency === 'emergency')
+            ? new Emergency()
+            : new Observation();
+    }
+}
+```
+
+### Final Classes
+
+```php
+final readonly class EmergencyCase
+{
+    public string $priority = 'IMMEDIATE';
+    public string $color = 'RED';
+
+    public function __construct(
+        #[Input] public float $bodyTemperature,
+        #[Input] public int $heartRate,
+        #[Input] public Emergency $being
+    ) {}
+
+    public function assignER(): string
+    {
+        return "Secure ER Room 1 immediately.";
+    }
+}
+
+final readonly class ObservationCase
+{
+    public string $priority = 'DELAYED';
+    public string $color = 'GREEN';
+
+    public function __construct(
+        #[Input] public float $bodyTemperature,
+        #[Input] public int $heartRate,
+        #[Input] public Observation $being
+    ) {}
+
+    public function assignWaitingArea(): string
+    {
+        return "Move to waiting area.";
+    }
+}
+```
+
+### Execution
+
+```php
+$injector = new Injector(new AppModule());
+$becoming = new Becoming($injector, 'Be\\App\\Semantic');
+
+$patient = new PatientArrival(bodyTemperature: 39.5, heartRate: 90);
+$result = $becoming($patient);
+
+echo $result->priority;     // "IMMEDIATE"
+echo $result->assignER();   // "Secure ER Room 1 immediately."
+```
+
+## Why Being Over Doing
+
+### Traditional (Doing)
+
+```php
+$patient = new Patient($temp, $hr);
+if ($triageService->isEmergency($patient)) {
+    $patient->setStatus('emergency');
+    $this->erService->assign($patient);
+}
+```
+
+Problems:
+- Patient can exist in invalid state
+- Status can be changed at any time
+- `erService->assign()` can be called on any patient
+
+### Be Framework (Being)
+
+```php
+$patient = new PatientArrival($temp, $hr);
+$result = $becoming($patient);
+$result->assignER();  // Type-safe: only possible for EmergencyCase
+```
+
+Benefits:
+- Non-survivable states cannot exist
+- Type IS the status (immutable)
+- Capabilities belong to existence
+
+## Documentation
+
+- English: https://be-framework.github.io/manuals/1.0/en/
+- Japanese: https://be-framework.github.io/manuals/1.0/ja/
+- Repository: https://github.com/be-framework/be-framework
diff --git a/llms.txt b/llms.txt
index b8387cc..5e8b503 100644
--- a/llms.txt
+++ b/llms.txt
@@ -4,105 +4,22 @@
 
 Be Framework is a PHP framework for ontological programming where transformation (metamorphosis) replaces procedural action.
 
-## Core Philosophy
-
-A patient doesn't "get triaged." They **become** an emergency case or an observation case, based on the transcendent wisdom of medical protocol.
-
-## Key Concepts
-
-### Domain Ontology (Semantic Variables)
-Semantic variables define what CAN exist in a domain—not just validation rules, but the vocabulary of existence. This declarative foundation serves as documentation that both humans and AI can read to understand your domain.
-
-```php
-final class BodyTemperature
-{
-    #[Validate]
-    public function validate(float $bodyTemperature): void
-    {
-        if ($bodyTemperature < 30.0 || $bodyTemperature > 45.0) {
-            throw new LethalVitalException();
-        }
-    }
-}
-```
-
-### Reason (Transcendence)
-Domain logic becomes a first-class citizen: injectable, testable, and explicitly visible.
-
-```php
-final readonly class JTASProtocol
-{
-    /** @return 'emergency'|'observation' */
-    public function assess(float $bodyTemperature, int $heartRate): string
-    {
-        if ($bodyTemperature >= 39.0 || $heartRate >= 120) {
-            return 'emergency';
-        }
-        return 'observation';
-    }
-}
-```
-
-### Metamorphosis Pattern
-Input → Being → Final transformation through the Becoming class.
-
-```php
-$becoming = new Becoming($injector, 'Be\\App\\Semantic');
-$patient = new PatientArrival(bodyTemperature: 39.5, heartRate: 90);
-$result = $becoming($patient);
-// $result IS an EmergencyCase or ObservationCase
-```
-
-### Type-Driven Branching
-The `$being` property (Union type) determines which Final class receives the transformation.
-
-```php
-#[Be([EmergencyCase::class, ObservationCase::class])]
-final readonly class TriageAssessment
-{
-    public Emergency|Observation $being;
-
-    public function __construct(
-        #[Input] public float $bodyTemperature,
-        #[Input] public int $heartRate,
-        #[Inject] JTASProtocol $protocol
-    ) {
-        $urgency = $protocol->assess($bodyTemperature, $heartRate);
-        $this->being = ($urgency === 'emergency')
-            ? new Emergency()
-            : new Observation();
-    }
-}
-```
-
-### Type IS Capability
-Different Final types have different methods—the type determines what actions are possible.
-
-```php
-// EmergencyCase has assignER()
-// ObservationCase has assignWaitingArea()
-$result->assignER();  // Only possible for EmergencyCase
-```
-
-## Key Attributes
+## Documentation
 
-- `#[Be([TargetClass::class])]` - Declares metamorphosis destination(s)
-- `#[Input]` - Receives data from previous stage
-- `#[Inject]` - Receives transcendent capability (DI)
-- `#[Validate]` - Semantic validation method marker
+- [Overview](/manuals/1.0/en/01-overview.html): Framework philosophy
+- [Getting Started](/manuals/1.0/en/getting-started.html): Quick start guide
+- [Tutorial](/manuals/1.0/en/tutorial.html): Emergency Triage example
+- [Input Classes](/manuals/1.0/en/02-input-classes.html): Starting points
+- [Being Classes](/manuals/1.0/en/03-being-classes.html): Intermediate transformations
+- [Final Objects](/manuals/1.0/en/04-final-objects.html): Destinations
+- [Semantic Variables](/manuals/1.0/en/06-semantic-variables.html): Domain validation
+- [Type-Driven Metamorphosis](/manuals/1.0/en/07-type-driven-metamorphosis.html): Branching patterns
+- [Reason Layer](/manuals/1.0/en/08-reason-layer.html): Transcendence
 
-## Transformation Flow
+## Full Documentation
 
-```
-Input (with #[Be([Being::class])])
-    ↓ Becoming executes
-Being (with #[Be([Final1::class, Final2::class])])
-    ↓ $being property determines branch
-Final (capability-specific type)
-```
+For detailed API and examples, see [llms-full.txt](/llms-full.txt)
 
-## Documentation
+## Repository
 
-- English: https://be-framework.github.io/manuals/1.0/en/
-- Japanese: https://be-framework.github.io/manuals/1.0/ja/
-- Repository: https://github.com/be-framework/be-framework
+https://github.com/be-framework/be-framework

From 0e2fd866bc09195d0410cb9bf9c24900d68d0a18 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:36:51 +0900
Subject: [PATCH 3/8] docs: improve llms-full.txt with naming conventions and
 error handling

---
 llms-full.txt | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/llms-full.txt b/llms-full.txt
index d129d43..03ee284 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -96,8 +96,44 @@ $result->assignER();  // Only possible for EmergencyCase
 - `#[Inject]` - Receives transcendent capability (DI)
 - `#[Validate]` - Semantic validation method marker
 
+## Naming Conventions
+
+### Semantic Variables
+
+Semantic class name matches constructor parameter name (camelCase):
+
+- `BodyTemperature` class validates `$bodyTemperature` parameter
+- `HeartRate` class validates `$heartRate` parameter
+
+### Destiny Markers and Final Classes
+
+Final class receives the destiny marker matching its `#[Input]` type:
+
+```php
+// Destiny markers (empty classes that ARE the distinction)
+final readonly class Emergency {}
+final readonly class Observation {}
+
+// Final classes receive matching destiny via #[Input]
+final readonly class EmergencyCase
+{
+    public function __construct(
+        #[Input] public Emergency $being  // Receives Emergency marker
+    ) {}
+}
+
+final readonly class ObservationCase
+{
+    public function __construct(
+        #[Input] public Observation $being  // Receives Observation marker
+    ) {}
+}
+```
+
 ## Transformation Flow
 
+### With Branching (Input → Being → Final)
+
 ```
 Input (with #[Be([Being::class])])
     ↓ Becoming executes
@@ -106,6 +142,39 @@ Being (with #[Be([Final1::class, Final2::class])])
 Final (capability-specific type)
 ```
 
+### Direct (Input → Final)
+
+When no branching is needed, Input can transform directly to Final:
+
+```php
+#[Be([Hello::class])]
+final readonly class HelloInput
+{
+    public function __construct(public string $name) {}
+}
+
+final readonly class Hello
+{
+    public function __construct(
+        #[Input] public string $name,
+        #[Inject] Greeting $greeting
+    ) {}
+}
+```
+
+## Error Handling
+
+When semantic validation fails, metamorphosis is rejected:
+
+```php
+try {
+    $becoming($input);
+} catch (SemanticVariableException $e) {
+    $messages = $e->getErrors()->getMessages('en');
+    // ["Vital signs indicate non-survivable conditions."]
+}
+```
+
 ## Project Structure
 
 ```

From 127bc1dfc6a5c0bd7a105c3fcef542eae5fcaa9f Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:38:58 +0900
Subject: [PATCH 4/8] fix: unify property initialization in Final class
 examples

---
 llms-full.txt | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/llms-full.txt b/llms-full.txt
index 03ee284..c549a16 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -229,14 +229,17 @@ final readonly class TriageAssessment
 ```php
 final readonly class EmergencyCase
 {
-    public string $priority = 'IMMEDIATE';
-    public string $color = 'RED';
+    public string $priority;
+    public string $color;
 
     public function __construct(
         #[Input] public float $bodyTemperature,
         #[Input] public int $heartRate,
         #[Input] public Emergency $being
-    ) {}
+    ) {
+        $this->priority = 'IMMEDIATE';
+        $this->color = 'RED';
+    }
 
     public function assignER(): string
     {
@@ -246,14 +249,17 @@ final readonly class EmergencyCase
 
 final readonly class ObservationCase
 {
-    public string $priority = 'DELAYED';
-    public string $color = 'GREEN';
+    public string $priority;
+    public string $color;
 
     public function __construct(
         #[Input] public float $bodyTemperature,
         #[Input] public int $heartRate,
         #[Input] public Observation $being
-    ) {}
+    ) {
+        $this->priority = 'DELAYED';
+        $this->color = 'GREEN';
+    }
 
     public function assignWaitingArea(): string
     {

From 439634d0bf1180d7b0165bc93b0e9d533b57c197 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:40:31 +0900
Subject: [PATCH 5/8] docs: add Domain Types section and PHPDoc literal type
 annotations

---
 llms-full.txt | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/llms-full.txt b/llms-full.txt
index c549a16..4697f63 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -96,6 +96,31 @@ $result->assignER();  // Only possible for EmergencyCase
 - `#[Inject]` - Receives transcendent capability (DI)
 - `#[Validate]` - Semantic validation method marker
 
+## Domain Types (PHPDoc Literal Types)
+
+Use PHPDoc literal string types to constrain values at the type level:
+
+```php
+final readonly class JTASProtocol
+{
+    /** @return 'emergency'|'observation' */
+    public function assess(float $bodyTemperature, int $heartRate): string
+    {
+        // ...
+    }
+}
+
+final readonly class EmergencyCase
+{
+    /** @var 'IMMEDIATE' */
+    public string $priority;
+    /** @var 'RED' */
+    public string $color;
+}
+```
+
+This makes the domain vocabulary explicit and enables static analysis tools (Psalm, PHPStan) to catch invalid values.
+
 ## Naming Conventions
 
 ### Semantic Variables
@@ -229,7 +254,9 @@ final readonly class TriageAssessment
 ```php
 final readonly class EmergencyCase
 {
+    /** @var 'IMMEDIATE' */
     public string $priority;
+    /** @var 'RED' */
     public string $color;
 
     public function __construct(
@@ -249,7 +276,9 @@ final readonly class EmergencyCase
 
 final readonly class ObservationCase
 {
+    /** @var 'DELAYED' */
     public string $priority;
+    /** @var 'GREEN' */
     public string $color;
 
     public function __construct(

From f4e6c0426521705507b61069b81a2b519a73f738 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:41:31 +0900
Subject: [PATCH 6/8] fix: use union types for domain vocabulary

---
 llms-full.txt | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/llms-full.txt b/llms-full.txt
index 4697f63..3bfde49 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -96,9 +96,9 @@ $result->assignER();  // Only possible for EmergencyCase
 - `#[Inject]` - Receives transcendent capability (DI)
 - `#[Validate]` - Semantic validation method marker
 
-## Domain Types (PHPDoc Literal Types)
+## Domain Types (PHPDoc Union Types)
 
-Use PHPDoc literal string types to constrain values at the type level:
+Use PHPDoc union types to define domain vocabulary:
 
 ```php
 final readonly class JTASProtocol
@@ -112,9 +112,9 @@ final readonly class JTASProtocol
 
 final readonly class EmergencyCase
 {
-    /** @var 'IMMEDIATE' */
+    /** @var 'IMMEDIATE'|'DELAYED' */
     public string $priority;
-    /** @var 'RED' */
+    /** @var 'RED'|'GREEN' */
     public string $color;
 }
 ```
@@ -254,9 +254,9 @@ final readonly class TriageAssessment
 ```php
 final readonly class EmergencyCase
 {
-    /** @var 'IMMEDIATE' */
+    /** @var 'IMMEDIATE'|'DELAYED' */
     public string $priority;
-    /** @var 'RED' */
+    /** @var 'RED'|'GREEN' */
     public string $color;
 
     public function __construct(
@@ -276,9 +276,9 @@ final readonly class EmergencyCase
 
 final readonly class ObservationCase
 {
-    /** @var 'DELAYED' */
+    /** @var 'IMMEDIATE'|'DELAYED' */
     public string $priority;
-    /** @var 'GREEN' */
+    /** @var 'RED'|'GREEN' */
     public string $color;
 
     public function __construct(

From 81217f657f5a49c6d77d97c3278beebd42d6d9b8 Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 17:45:27 +0900
Subject: [PATCH 7/8] docs: add AI agent usage section to FAQ

---
 manuals/1.0/en/faq.md | 16 +++++++++++++++-
 manuals/1.0/ja/faq.md | 16 +++++++++++++++-
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/manuals/1.0/en/faq.md b/manuals/1.0/en/faq.md
index 93a027d..76b7615 100644
--- a/manuals/1.0/en/faq.md
+++ b/manuals/1.0/en/faq.md
@@ -269,7 +269,21 @@ A mechanism for holding failures and history not as simple strings, but as struc
 
 ---
 
-## 11) Related Chapter Links
+## 11) Using AI Agents
+
+### Q27. How do I get AI to write Be Framework code?
+
+A. Simply ask the AI to read the llms-full.txt:
+
+```
+Please read https://be-framework.github.io/llms-full.txt
+```
+
+This file contains all the key concepts, naming conventions, and code examples needed for AI to understand and generate Be Framework code.
+
+---
+
+## 12) Related Chapter Links
 
 * **[Overview](./01-overview.html)**: First encounter with being-oriented programming
 * **[Metamorphosis](./05-metamorphosis.html)**: Inseparability of time and domain
diff --git a/manuals/1.0/ja/faq.md b/manuals/1.0/ja/faq.md
index 3973902..d08db44 100644
--- a/manuals/1.0/ja/faq.md
+++ b/manuals/1.0/ja/faq.md
@@ -296,7 +296,21 @@ $profile = $becoming(new UserInput($name, $email));
 
 ---
 
-## 11) 関連章へのリンク
+## 11) AIエージェントの活用
+
+### Q27. AIにBe Frameworkのコードを書かせるにはどうすればいいですか？
+
+A. AIにllms-full.txtを読むよう依頼するだけです:
+
+```
+https://be-framework.github.io/llms-full.txt を読んでください
+```
+
+このファイルには、AIがBe Frameworkを理解しコードを生成するために必要な、主要概念、命名規則、コード例がすべて含まれています。
+
+---
+
+## 12) 関連章へのリンク
 
 * **[概要](./01-overview.html)**: 存在指向プログラミングとの出会い
 * **[変容](./05-metamorphosis.html)**: 時間とドメインの不可分性

From a49940ff07c9aeea21fedfb1869cf5ad10e982cc Mon Sep 17 00:00:00 2001
From: Akihito Koriyama <akihito.koriyama@gmail.com>
Date: Wed, 7 Jan 2026 18:24:00 +0900
Subject: [PATCH 8/8] fix: use full URLs in llms.txt for AI agent compatibility

---
 llms.txt | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/llms.txt b/llms.txt
index 5e8b503..92689f6 100644
--- a/llms.txt
+++ b/llms.txt
@@ -6,19 +6,19 @@ Be Framework is a PHP framework for ontological programming where transformation
 
 ## Documentation
 
-- [Overview](/manuals/1.0/en/01-overview.html): Framework philosophy
-- [Getting Started](/manuals/1.0/en/getting-started.html): Quick start guide
-- [Tutorial](/manuals/1.0/en/tutorial.html): Emergency Triage example
-- [Input Classes](/manuals/1.0/en/02-input-classes.html): Starting points
-- [Being Classes](/manuals/1.0/en/03-being-classes.html): Intermediate transformations
-- [Final Objects](/manuals/1.0/en/04-final-objects.html): Destinations
-- [Semantic Variables](/manuals/1.0/en/06-semantic-variables.html): Domain validation
-- [Type-Driven Metamorphosis](/manuals/1.0/en/07-type-driven-metamorphosis.html): Branching patterns
-- [Reason Layer](/manuals/1.0/en/08-reason-layer.html): Transcendence
+- [Overview](https://be-framework.github.io/manuals/1.0/en/01-overview.html): Framework philosophy
+- [Getting Started](https://be-framework.github.io/manuals/1.0/en/getting-started.html): Quick start guide
+- [Tutorial](https://be-framework.github.io/manuals/1.0/en/tutorial.html): Emergency Triage example
+- [Input Classes](https://be-framework.github.io/manuals/1.0/en/02-input-classes.html): Starting points
+- [Being Classes](https://be-framework.github.io/manuals/1.0/en/03-being-classes.html): Intermediate transformations
+- [Final Objects](https://be-framework.github.io/manuals/1.0/en/04-final-objects.html): Destinations
+- [Semantic Variables](https://be-framework.github.io/manuals/1.0/en/06-semantic-variables.html): Domain validation
+- [Type-Driven Metamorphosis](https://be-framework.github.io/manuals/1.0/en/07-type-driven-metamorphosis.html): Branching patterns
+- [Reason Layer](https://be-framework.github.io/manuals/1.0/en/08-reason-layer.html): Transcendence
 
 ## Full Documentation
 
-For detailed API and examples, see [llms-full.txt](/llms-full.txt)
+For detailed API and examples, see [llms-full.txt](https://be-framework.github.io/llms-full.txt)
 
 ## Repository