docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md

@@ -211,6 +211,110 @@ Given the useful investigation structure the Engine can already derive, how shou
 
 The next phase should begin from this methodology question, not from a preselected technical solution.
 
+## Granular Answer-Fragment Learning (RTO.14–17)
+
+Recent experiments explored what happens when further answers are made inside the same focused investigation (RTO.14–17).
+
+### What RTO.14–17 proved
+
+The experiments demonstrated that an LLM can:
+
+- Retain prior focused knowledge across turns
+- Revise uncertainty in response to new information
+- Separate focused understanding from decision significance
+- Carry coherent reasoning across several turns inside a single investigation
+
+This learning was valuable and should be preserved as experimental evidence. The apparatus created during RTO.14–17 remains available and relevant.
+
+### What RTO.14–17 began recreating
+
+Pushing that design further exposed that we had reproduced the original structural assumption at a lower level:
+
+- **Original global pattern:**
+  ```text
+  whole case state + new answer → LLM rewrites whole case state
+  ```
+- **Focused version (RTO.14–17):**
+  ```text
+  whole focused-investigation state + new answer → LLM rewrites whole focused-investigation state
+  ```
+
+The second version is much smaller and technically better, but it is still the same cumulative reconstruction pattern — just at a lower scope. Prompt growth from later RTO experiments helped expose this.
+
+**Learning:** Do not immediately respond by optimising or compressing the cumulative focused-state implementation. Reconsider whether accumulated state needs to be sent back through the LLM at all.
+
+### The granular answer-fragment hypothesis (working hypothesis — not yet architecture)
+
+The natural reasoning unit appears to be:
+
+> **one question → one answer → one interpretation/capture**
+
+Granularity's purpose is not merely token or latency optimisation. The small cycle is how the methodology makes a large problem manageable for the user. A difficult scenario is progressively decomposed into pieces small enough to reason about confidently.
+
+The working hypothesis is:
+
+```text
+user chooses a question
+→ user provides an answer
+→ Engine deconstructs that answer
+→ Engine captures the granular contribution
+→ resulting uncertainties/questions are exposed
+→ user chooses what to investigate next
+→ repeat
+```
+
+Each accepted answer can produce a small evidence-bearing reasoning fragment. Those fragments are remembered outside the LLM call. The larger investigation understanding and eventual graph emerge from composing those pieces over time. Only directly relevant prior knowledge may need to be supplied when a specific earlier fragment is being qualified, contradicted or refined.
+
+A software implementation may eventually represent granular contributions as things such as:
+
+- observations
+- uncertainties
+- assumptions
+- relationships
+- questions raised
+
+linked to the question/investigation that produced them. This illustrative list is not a production schema — it exists here only as a design hint.
+
+### Memory / graph principle
+
+The LLM does not necessarily need to own accumulated reasoning memory. The graph/state/notebook layer can remember the reasoning fragments. The LLM may be used to interpret a new answer, but a software implementation should not assume every new answer requires sending all accumulated investigation state back through the model and asking it to regenerate the whole current understanding.
+
+### Optional capability: "Help me answer" / "Answer for me"
+
+A software implementation may optionally offer something like:
+
+> **Help me answer** or **Answer for me**
+
+where the LLM proposes an answer. This is an optional application capability — not part of the core method. The methodology works without it.
+
+**Ownership rule:** A generated answer is a proposal, not gospel and not automatically evidence. The user must be able to accept it, edit it or reject it. Only an accepted contribution enters the normal reasoning/deconstruction flow. Where practical, provenance should remain distinguishable between:
+
+- user-supplied answer
+- LLM-proposed answer accepted/edited by user
+
+### Development principle reaffirmed: BUILD → BREAK → LEARN → STOP
+
+When an experiment exposes that an architectural assumption is breaking:
+
+```text
+do not immediately optimise the broken assumption
+do not add complexity to preserve it
+capture what was learned
+return to the methodology
+design the next smallest experiment from that learning
+```
+
+RTO.14–17 should therefore remain valuable evidence, not be deleted or described as mistakes. They helped reveal the next underlying assumption.
+
+## Methodology test for future development
+
+> **Could this reasoning operation be described in the Confidence Engine methodology and performed by a trained human facilitator without an LLM?**
+
+- If YES: the application may use an LLM to automate, accelerate or scale it
+- If NO: stop and ask whether the work is developing the Confidence Engine methodology or merely exploiting an LLM capability
+
+This does not apply to implementation mechanics such as JSON, APIs or databases. It applies to the underlying reasoning behaviour.
+
 ## Source basis
 
 - `01_Confidence_Engine_Founding_Principles`
@@ -224,4 +328,4 @@ The next phase should begin from this methodology question, not from a preselect
 - `Confidence_Engine_Project_Context_Update_2026-08-17`
 - `Confidence_Engine_Current_Handoff_2026-08-17`
 
-This context update distinguishes established project principles from current implementation learning. The workspace/user-directed investigation model is recorded as the current hypothesis to test, not as a completed replacement architecture.
+This context update distinguishes established project principles from current implementation learning. The workspace/user-directed investigation model is recorded as the current hypothesis to test, not as a completed replacement architecture. The granular answer-fragment hypothesis (RTO.14–17) is recorded as working hypothesis, not yet accepted architecture.

docs/current-handoff.md

@@ -139,6 +139,36 @@ Recent work is preserved as valuable experimental learning. The graph/reconstruc
 
 The next phase starts from the workspace/methodology question, not from a preselected technical solution.
 
-See:
+### Required methodology-continuity context (read first)
+
+> **Before continuing any Confidence Engine reasoning development, load this document:**
+>
+> `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md`
+
+This is the durable methodology anchor. It covers:
+- What Confidence Engine is (reasoning method, not software or LLM)
+- What it is not
+- The granular answer-fragment hypothesis (working — not architecture)
+- RTO.14–17 learning and why they did not define the next architecture
+- The memory/graph separation principle
+- Optional capability: "Help me answer" / "Answer for me"
+- Methodology test for future development
+
+**Do not begin reasoning development from the latest experiment apparatus.** Always load this methodology continuity context first. Without it, a new session will reconstruct the project from recent technical experiments and lose sight of the method the application is meant to embody.
+
+### Current Git checkpoint
+
+- **Branch:** `feature/decision-closure-ownership-v0.47`
+- **HEAD:** `e1b54e407389c7f1c25ba20645540d404b9e9df9`
+- **Latest commit:** `e1b54e4 test(experiment): checkpoint granular answer fragment apparatus`
+
+### Status of RTO.14–17
+
+RTO.14–17 experiments proved that an LLM can retain focused knowledge and carry coherent reasoning across turns inside a single investigation. This was valuable evidence.
+
+**However, they also revealed that the cumulative reconstruction pattern was reproduced at a lower scope.** Do not treat RTO.14–17 as the automatic architecture direction to continue. The next reasoning direction is the granular answer-fragment hypothesis: independent user-chosen question/answer deconstruction without accumulated focused state being passed between LLM calls.
+
+**Prohibition:** Do not automatically continue into cumulative-state compression or fourth-turn experiments without first revisiting the methodology continuity document above.
+
+See also:
 - `docs/methodology-checkpoint-return-to-origin.md` — repository-facing checkpoint summary
-- `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md` — full methodology context (source)

docs/current-project-state.md

@@ -85,7 +85,7 @@ The following were built during Experiments 18–25B. They are isolated diagnost
 
 | When you need | Read this |
 |---|---|
-| Returning after a break | `docs/current-handoff.md` (first file) |
+| Returning after a break | **First:** `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md` (methodology continuity), then `docs/current-handoff.md` |
 | Where we are now | `docs/current-project-state.md` (this file) |
 | Current principles and reasoning guidance | `docs/current-working-principles.md` |
 | What to keep from code changes during UX work | `.claude/architecture-guardrails.md` |
@@ -110,5 +110,17 @@ First document to read: `docs/current-project-state.md`. Then consult `.claude/a
 Implementation status last checked against source: Experiment 43.
 The current-state document was verified as accurate by focused code inspection of API routes, orchestrator imports/calls, and cross-module traces for all passive classifiers. No corrections were required.
 
-**Branch:** `feature/reasoning-fidelity-v0.8`
-**Current HEAD:** `ec398dc` (experiment: validate evidence versus clarification routing)
+## 10. Post-v0.8 Methodology Learning
+
+Since the handoff document was written, further learning has emerged from Return-to-Origin work (RTO.14–17):
+
+**What proved useful:** An LLM can retain prior focused knowledge, revise uncertainty, and carry coherent reasoning across turns inside a single investigation.
+
+**What was exposed:** Pushing that approach further reproduced the original cumulative-state reconstruction pattern at a lower scope (`focused-investigation state + new answer → LLM rewrites focused state`). This is the same structural assumption we challenged at the global-graph level — just compressed.
+
+**Current working hypothesis (not yet architecture):** The natural reasoning unit is one question → one answer → one interpretation/capture. Each accepted answer produces a small evidence-bearing reasoning fragment, remembered outside the LLM call. The larger investigation understanding emerges from composing those fragments over time. Only directly relevant prior knowledge needs to be supplied when qualifying a specific earlier fragment.
+
+**Next experiment direction:** Test independent user-chosen question/answer deconstruction without accumulated focused state being passed between LLM calls. See `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md` for full context.
+
+> **Branch:** `feature/decision-closure-ownership-v0.47`
+> **Current HEAD:** `e1b54e4` (experiment: checkpoint granular answer fragment apparatus)

docs/methodology-checkpoint-return-to-origin.md

@@ -122,14 +122,32 @@ That matters directly to RDB Solutions: the aim is to create products and method
 
 ---
 
+## Granular Answer-Fragment Learning (RTO.14–17)
+
+Recent experiments proved that an LLM can retain prior focused knowledge, revise uncertainty, and carry coherent reasoning across turns inside a single investigation. This work was valuable.
+
+However, further exploration exposed that the cumulative reconstruction pattern was reproduced at a lower scope: `focused state + new answer → LLM rewrites focused state`. Prompt growth helped reveal this.
+
+**The granular hypothesis (working — not architecture):** The natural reasoning unit is one question → one answer → one interpretation/capture. Each accepted answer produces a small evidence-bearing fragment. Those fragments are remembered outside the LLM. The larger understanding emerges from composing them. Only directly relevant prior knowledge needs to be supplied when refining a specific earlier fragment.
+
+**Do not immediately optimise the cumulative focused-state implementation.** Reconsider whether accumulated state needs to be sent back through the LLM at all.
+
+## Development principle: BUILD → BREAK → LEARN → STOP
+
+When an experiment exposes that an architectural assumption is breaking, capture what was learned and return to the methodology before designing the next experiment. RTO.14–17 remain valuable evidence.
+
+## Methodology test for future development
+
+> Could this reasoning operation be described in the Confidence Engine methodology and performed by a trained human facilitator without an LLM?
+> - If YES: the application may use an LLM to automate, accelerate or scale it
+> - If NO: stop and reconsider whether the work is developing the methodology or merely exploiting an LLM capability
+
 ## Deliberately Unanswered Next Question
 
 > Given the useful investigation structure the Engine can already derive, how should that structure be surfaced so a person can see, choose, defer, investigate and return to open questions while the Engine continues to guide and challenge their thinking toward justified confidence?
 
 The next phase should begin from this methodology question, not from a preselected technical solution.
 
----
-
 ## Source
 
 Full methodology context: `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md`  

docs/task-context-packs.md

@@ -5,11 +5,15 @@
 ## Pack 1 — Engine Experiment Work
 
 ### Always read
-- `docs/current-project-state.md`
+- `docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md` (methodology continuity — required before any reasoning development)
+- `docs/current-handoff.md` (current state, Git checkpoint, experiment log)
 - `docs/current-working-principles.md`
 - `.claude/architecture-guardrails.md`
 - `docs/current-implementation-verification.md`
 
+### First document to read for Confidence Engine reasoning work:
+**`docs/Confidence_Engine_Return_to_Origin_Methodology_Context_2026-08-18.md`** — the durable methodology anchor. Do not load experiment apparatus before this document. A new session must understand the method before examining recent technical experiments.
+
 ### Then read only when relevant
 - the specific implementation file;
 - its focused tests;
@@ -22,7 +26,8 @@
 ### Stop and ask or record a gap when
 - current documentation and source disagree;
 - the task requires an undocumented contract;
-- the experiment begins expanding into several capabilities.
+- the experiment begins expanding into several capabilities;
+- you cannot describe the reasoning operation in Confidence Engine methodology terms (could a trained human facilitator perform it without an LLM?).
 
 ### Live experiment execution route