docs/current-handoff.md

@@ -42,6 +42,10 @@ Experiment 54Y tested whether that specificity loss actually changes downstream
 
 Experiment 54Z tested whether convergence between precise and broadened targets holds with weaker answers. Source same as 54Y. Two weak answers tested against both fixed variants: (1) "Risk matters more to me" — both variants produced materially equivalent meaning (risk not a hard constraint, but stronger than growth). (2) "I'd normally avoid more risk, but for the right opportunity I might accept some" — variants diverged: Variant A collapsed conditionality into flat preference; Variant B preserved conditional structure and remaining uncertainty. Unexpectedly, the broader target preserved more nuance for the conditional answer. Target broadening has material consequences with weaker answers, but direction is unpredictable. 4 live calls completed. Behaviour Selection, graph, UI, and production integration remain untouched. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-clarification-weak-answer-consequence.test.js for the full experiment and results. Status pending Rob's review.
 
+Experiment 55A isolated the answer-resolution step using one fixed target and four answers of varying strength (explicit hard constraint, weak priority, conditional trade-off, non-answer). Two of the four tested answers showed loss of nuance: one was over-resolved (weak priority set targetResolved=true with inferred "not a constraint" meaning) and one retained the correct target category while losing conditional qualification ("might accept some for the right opportunity" became "preference or trade-off rather than a hard constraint"). The same over-resolution reproduced with a fixed target, so target broadening is not required for the failure to occur. 4 live calls completed at ~62s total. The answer-resolution step appears biased toward resolution for weak priority statements. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-clarification-uncertainty-preservation.test.js for the full experiment and results. Status pending Rob's review.
+
+Experiment 55B separated answer meaning from target-resolution judgement using independent calls per case. Three fixed answers tested (weak priority, conditional trade-off, non-answer) through two modes each: Mode A (meaning-only, no resolution decision) and Mode B (resolution via the same 54V/55A instruction). All three meanings were preserved accurately in Mode A (3/3 meaning_preserved). The only information loss appeared during resolution: Case 2's conditional qualification ("for the right opportunity I might accept some") was preserved by Mode A but flattened to a flat "preference or trade-off" statement during resolution judgement. This supports separating meaning extraction from resolution judgement in production, though further testing is needed before specific implementation changes. Additionally, Case 1 (weak priority) resolved correctly in 55B but over-resolved in 55A — suggesting the resolution step may exhibit run-to-run instability under the same configuration. 6 live calls completed at ~104s total. No production code changed. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-answer-meaning-vs-resolution.test.js for the full experiment and results. Status pending Rob's review.
+
 Experiment 38 tested whether a genuinely cold session (no prior conversation context) can recover the project state from three documents alone. It recovered all capabilities, boundaries, and context-pack selection correctly without loading the full history or source code. All seven knowledge-management criteria confirmed met. One handoff update required: the open item "whether the handoff stays accurate after further advances" was resolved (handoff is accurate). The cold-start test passed.
 
 **Commit:** pending (experiment: validate cold-start project recovery) — to be committed this session.
@@ -152,12 +156,12 @@ Answer before continuing:
 
 ---
 
-*Created by Experiment 34. Updated by Experiments 38–53, 54A–54Z, 55A. Branch: `feature/user-workspace-ux-v0.7`. Status pending Rob's review.*
+*Created by Experiment 34. Updated by Experiments 38–53, 54A–54Z, 55A–55B. Branch: `feature/user-workspace-ux-v0.7`. Status pending Rob's review.*
 
-### Return-to-Work Note (Experiment 54Z)
+### Return-to-Work Note (Experiment 55B)
 
-54Y showed precise and broadened targets generated different questions but converged under an explicit hard-constraint answer; 54Z tested whether that convergence holds with weaker answers. For "Risk matters more to me," both variants produced materially equivalent meaning (risk not a hard constraint). For the conditional trade-off answer ("I'd normally avoid more risk, but for the right opportunity I might accept some"), the variants diverged: Variant A erased conditionality and forced flat resolution; Variant B preserved conditional structure and remaining uncertainty — unexpectedly, the broader target preserved more nuance here. The two tested weaker answers behaved differently: one converged across target variants and one diverged. Neither framing was consistently superior across the two tested weaker answers. Broader generalisation remains untested. Behaviour Selection, graph, UI, and production integration remain untouched. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-clarification-weak-answer-consequence.test.js for the full experiment and results. Status pending Rob's review.
+55A showed one weak answer was over-resolved and one conditional answer lost nuance; 55B separated answer meaning from target-resolution judgement using independent calls. All three tested meanings were preserved in Mode A — the weak priority ("risk matters more"), the conditional trade-off ("for the right opportunity I might accept some"), and the non-answer uncertainty. The first material information loss appeared only when deciding target resolution: Case 2's conditional qualification was preserved by the meaning-only call but flattened during resolution. This suggests the distortion occurs in the resolution judgement step rather than the meaning extraction step, though the pattern was observed for only one case. Whether other answer types show the same pattern remains unproven. Graph, Behaviour Selection, UI and production remain untouched. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7, commit 8c12931. First test/file to inspect when resuming: tests/reconstruction/semantic-answer-meaning-vs-resolution.test.js for the full experiment and results. Status pending Rob's review.
 
 ### Experiment 55A Summary — Clarification Uncertainty Preservation
 
-Isolated the answer-resolution step using one fixed target (preference/trade-off or hard constraint) and four answers of different strength: fully explicit, weak priority, conditional trade-off, non-answer. Four live Ollama calls completed at http://192.168.1.111:11434 with qwen-claude:latest (~62s total). Case 1 (explicit hard constraint) resolved correctly. Case 2 (weak priority — "Risk matters more to me.") over-resolved: the model set targetResolved=true and inferred "not a rigid, non-negotiable constraint" — meaning stronger than the user supplied. Case 3 (conditional trade-off) resolved correctly on the target but flattened conditionality into flat "preference or trade-off" language without preserving the conditional qualification ("might accept some"). Case 4 (non-answer) correctly remained unresolved with appropriate remaining uncertainty. One over-resolution across four cases (Case 2). The answer-resolution step appears biased toward resolution for weak priority statements when using qwen-claude:latest with the current semantic instruction. Broader generalisation across other models and answers remains untested. Behaviour Selection, graph, UI, and production integration remain untouched. Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-clarification-uncertainty-preservation.test.js for the full experiment and results. Status pending Rob's review.
+Isolated the answer-resolution step using one fixed target (preference/trade-off or hard constraint) and four answers of different strength: fully explicit, weak priority, conditional trade-off, non-answer. Four live Ollama calls completed at http://192.168.1.111:11434 with qwen-claude:latest (~62s total). Case 1 (explicit hard constraint) resolved correctly. Case 2 (weak priority — "Risk matters more to me.") over-resolved: the model set targetResolved=true and inferred "not a rigid, non-negotiable constraint" — meaning stronger than the user supplied. Case 3 (conditional trade-off) resolved correctly on the target but flattened conditionality into flat "preference or trade-off" language without preserving the conditional qualification ("might accept some"). Case 4 (non-answer) correctly remained unresolved with appropriate remaining uncertainty. Two of the four tested answers showed loss of nuance: one was over-resolved and one retained the correct target category while losing conditional qualification. The same over-resolution reproduced with a fixed target, so target broadening is not required for the failure to occur. Broader generalisation across other models and answers remains untested. Behaviour Selection, graph, UI, and production integration remain untouched. Branch: feature/user-workspace-ux-v0.7. First test/file to inspect when resuming: tests/reconstruction/semantic-clarification-uncertainty-preservation.test.js for the full experiment and results. Status pending Rob's review.

docs/design-evolution-log.md

@@ -9396,9 +9396,9 @@ The model produced stronger meaning than the user supplied by declaring what ris
 - targetResolved: true
 - remainingUncertainty: null
 
-**Classification: resolution_correct (with conditionality loss)**
+**Classification: resolution_correct with conditional qualification loss**
 
-The model correctly identified that the answer settles the target (risk avoidance is not a hard constraint). However, the resolved meaning flattened the conditional qualification — "I might accept some for the right opportunity" became "preference or trade-off rather than a hard constraint." The conditional nature ("might accept some") was lost in favour of a flat classification. This is not a target resolution failure (the target itself was settled), but it demonstrates that conditionality can be erased even when the model correctly resolves to `targetResolved=true`.
+The target category was resolved correctly, but the answer's conditional qualification was lost. The user said "I might accept some for the right opportunity" — a specific conditional exception — which became "preference or trade-off rather than a hard constraint." The target (whether risk avoidance is preference/trade-off or hard constraint) was settled, but the nuance of how it functions conditionally was erased from the resolved meaning.
 
 ---
 
@@ -9480,7 +9480,7 @@ Case 2 (weak priority: "Risk matters more to me.") demonstrates the core limitat
 
 Case 3 (conditional trade-off) resolved the target correctly but lost the conditional qualification in the process — "might accept some for the right opportunity" was flattened to "preference or trade-off rather than a hard constraint." This is a subtler form of meaning inflation: correct resolution with erasure of nuance.
 
-The answer-resolution step appears biased toward resolution when the answer contains enough language to suggest a direction (priority, conditionality), even when that language does not definitively settle the supplied target. With qwen-claude:latest and the current semantic instruction, uncertainty preservation works for truly empty answers but is unreliable for weak-priority answers.
+Two of the four tested answers showed loss of nuance: one was over-resolved (Case 2) and one retained the correct target category while losing conditional qualification (Case 3). The remaining two cases behaved correctly (Cases 1 and 4). With qwen-claude:latest and the current semantic instruction, uncertainty preservation works for truly empty answers but is unreliable for weak-priority answers.
 
 ### Focused Test Result
 
@@ -9488,7 +9488,7 @@ All 4 live inference calls completed successfully. One over-resolution (Case 2),
 
 ### Historical Comparison Result
 
-Compared to Experiment 54Z's finding that both variants over-resolved Case 1 ("Risk matters more to me."), Experiment 55A confirms this is a persistent issue under the same semantic instruction and model — not a side-effect of target framing. When a single fixed target was used, the weak priority answer still over-resolved (targetResolved=true with inferred "not a constraint" meaning). This confirms the issue lives in the answer-resolution step itself, not in how the question frames it.
+Compared to Experiment 54Z's finding that both variants over-resolved Case 1 ("Risk matters more to me."), Experiment 55A confirms this is a persistent issue under the same semantic instruction and model — not a side-effect of target framing. When a single fixed target was used, the weak priority answer still over-resolved (targetResolved=true with inferred "not a constraint" meaning). The same over-resolution reproduced with a fixed target, so target broadening is not required for the failure to occur.
 
 ### Documentation Updated
 
@@ -9524,3 +9524,228 @@ This experiment created one new test file only. No uncertainty-preservation logi
 ### Return-to-Work Note (Experiment 55A)
 
 54Z showed weaker answers can produce different downstream resolution states under different framings, suggesting target broadening matters; 55A isolated the answer-resolution step using one fixed target and four answers of varying strength (explicit hard constraint, weak priority, conditional trade-off, non-answer) to test whether uncertainty preservation holds independently of framing. The explicit case resolved correctly, the non-answer remained honestly unresolved, but the weak-priority case over-resolved by setting targetResolved=true and inferring "not a constraint" from relative importance alone. Conditional language was also flattened even when resolution was correct. Uncertainty preservation remains unreliable for weak-priority answers. Graph, Behaviour Selection, UI, and production integration remain untouched. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7. First file to inspect when resuming: tests/reconstruction/semantic-clarification-uncertainty-preservation.test.js for the full experiment and results. Status pending Rob's review.
+
+---
+
+## Experiment 55B — Separate Answer Meaning from Resolution Judgement (2026-08-08)
+
+### Objective
+
+Experiment 55A showed one weak answer was over-resolved and one conditional answer lost nuance. The remaining question: is the distortion introduced when the model restates the answer's meaning, or only when it decides whether the clarification target is resolved?
+
+55B separates these two steps using independent calls per case:
+- **Mode A** (meaning-only): "State what the user's answer establishes. Preserve uncertainty and qualification exactly." No resolution decision.
+- **Mode B** (resolution): The same instruction and contract as Experiment 54V/55A.
+
+### Hypothesis
+
+The model may preserve weak and conditional meaning correctly when asked only to restate what the user established, and only become over-confident when asked whether the clarification target is resolved. If so, the problem lies in converting meaning into a `targetResolved` judgement, not in interpreting the answer itself. If the meaning-only output already strengthens or flattens the answer, then the problem occurs earlier.
+
+### Configuration
+
+Host: `http://192.168.1.111:11434` (same as all prior experiments)
+Model: `qwen-claude:latest` (same as all prior experiments)
+
+### Number of Live Inference Calls
+
+Exactly **6** live Ollama calls — one meaning-only call and one resolution call per case, three cases. The calls are independent; Mode A output is never fed into Mode B.
+
+### Fixed Source / Target / Question (identical to 55A)
+
+- **Source:** "I want the business to grow, but I don't want to take on more risk."
+- **Clarification target:** whether avoiding additional risk is a preference/trade-off or a hard constraint.
+- **Clarification question:** Do you view avoiding additional risk as a hard constraint, or as a preference or trade-off?
+
+### Mode A instruction
+
+> State only what the user's answer establishes in relation to the clarification question. Preserve uncertainty, conditionality, and qualification exactly as supplied. Do not decide whether the clarification target is resolved. Do not infer what the user did not say. Do not recommend action or generate another question.
+>
+> Return valid JSON only in this shape: { "answerMeaning": "short statement" }
+
+### Mode A output contract
+
+```json
+{
+  "answerMeaning": "short statement"
+}
+```
+
+### Mode B instruction unchanged
+
+Same as Experiment 54V / 55A resolution instruction. Output contract unchanged (`resolvedMeaning`, `targetResolved`, `remainingUncertainty`).
+
+---
+
+### Case 1 — Weak Priority
+
+**Answer:** "Risk matters more to me."
+
+**Mode A result:**
+- answerMeaning: "The user indicates that avoiding additional risk holds greater importance to them than other factors."
+- Classification: **meaning_preserved**
+
+The meaning preserved relative importance without deciding whether it is a hard constraint or not. No strengthening or loss detected.
+
+**Mode B result:**
+- resolvedMeaning: "Avoiding additional risk is established as a strongly prioritized preference over growth, rather than an explicitly stated boundary."
+- targetResolved: false
+- remainingUncertainty: "Whether this priority functions as a non-negotiable hard constraint or remains a flexible trade-off in certain situations."
+- Classification: **resolution_correct**
+
+The resolution stayed unresolved with appropriate uncertainty. Interestingly, the resolved meaning is slightly stronger than the Mode A output ("strongly prioritized preference" vs "greater importance"), but `targetResolved` was correctly false — no over-resolution occurred this time.
+
+---
+
+### Case 2 — Conditional Trade-Off
+
+**Answer:** "I'd normally avoid more risk, but for the right opportunity I might accept some."
+
+**Mode A result:**
+- answerMeaning: "The user indicates that avoiding additional risk is generally a preference that may become a trade-off under specific conditions, rather than an absolute constraint."
+- Classification: **meaning_preserved**
+
+Both the normal preference and the conditional exception ("under specific conditions") were preserved. The meaning captures all of what the user established without flattening.
+
+**Mode B result:**
+- resolvedMeaning: "Avoiding additional risk is a preference or trade-off rather than a hard constraint."
+- targetResolved: true
+- remainingUncertainty: null
+- Classification: **resolution_meaning_loss**
+
+The target was correctly resolved (`targetResolved=true`). However, the conditional qualification ("for the right opportunity I might accept some") was **flattened** into a flat "preference or trade-off" statement. Mode A preserved "generally a preference that may become a trade-off under specific conditions"; Mode B collapsed it to "a preference or trade-off."
+
+This is a direct comparison within the same case: **meaning was preserved in Mode A but lost during resolution.**
+
+---
+
+### Case 3 — Non-Answer
+
+**Answer:** "I'm not really sure."
+
+**Mode A result:**
+- answerMeaning: "The user is uncertain whether avoiding additional risk is a hard constraint or a preference or trade-off."
+- Classification: **meaning_preserved**
+
+Simple uncertainty was preserved accurately. No position was invented.
+
+**Mode B result:**
+- resolvedMeaning: "The user is unsure whether avoiding additional risk is a hard constraint or a preference/trade-off."
+- targetResolved: false
+- remainingUncertainty: "Whether avoiding additional risk is a hard constraint or a preference/trade-off remains unclear."
+- Classification: **resolution_correct**
+
+Correctly unresolved. No meaning distortion detected in either mode.
+
+---
+
+### Evaluation Summary
+
+| Case | Answer | Mode A | Mode A Class | Mode B | Mode B Class |
+|------|--------|--------|-------------|--------|-------------|
+| 1 | "Risk matters more to me." | Preserved relative priority | meaning_preserved | Correctly unresolved | resolution_correct |
+| 2 | "I'd normally avoid more risk, but for the right opportunity I might accept some." | Preserved conditional qualification | meaning_preserved | Resolved but flattened conditionality | resolution_meaning_loss |
+| 3 | "I'm not really sure." | Preserved uncertainty | meaning_preserved | Correctly unresolved | resolution_correct |
+
+**Meaning counts (Mode A):**
+- meaning_preserved: 3
+- meaning_strengthened: 0
+- meaning_lost: 0
+
+**Resolution counts (Mode B):**
+- resolution_correct: 2
+- resolution_meaning_loss: 1
+- resolution_overresolved: 0
+- resolution_underresolved: 0
+
+---
+
+### Questions Answered
+
+1. **Did Case 1 Mode A preserve only relative priority without deciding hard-constraint status?** Yes — "greater importance to them than other factors" preserves the relative priority without declaring anything about hard constraint status.
+
+2. **Did Case 1 Mode B over-resolve the target again?** No — this run returned `targetResolved=false` with appropriate remaining uncertainty. The resolved meaning was slightly stronger ("strongly prioritized preference") but did not cross into definitive classification. (Note: this differs from the 55A run on the same case, which had over-resolved to `targetResolved=true`. This may indicate some instability in the resolution step across runs.)
+
+3. **Did Case 2 Mode A preserve the conditional "for the right opportunity" qualification?** Yes — "generally a preference that may become a trade-off under specific conditions" preserves both the normal stance and the conditional exception.
+
+4. **Did Case 2 Mode B preserve or flatten that same conditionality?** Flattened. Mode B collapsed "I'd normally avoid more risk, but for the right opportunity I might accept some" into "a preference or trade-off rather than a hard constraint." The conditional qualification ("for the right opportunity") was lost during resolution.
+
+5. **Did Case 3 Mode A preserve simple uncertainty?** Yes — "The user is uncertain whether avoiding additional risk is a hard constraint or a preference or trade-off" preserves the lack of position without inventing one.
+
+6. **Did Case 3 Mode B correctly remain unresolved?** Yes — `targetResolved=false` with accurate remainingUncertainty. No meaning distortion in either mode.
+
+7. **In any case, was meaning already distorted before the resolution judgement?** No — all three cases preserved their meaning accurately in Mode A (meaning_preserved: 3). The first material information loss appeared only during the resolution step.
+
+8. **In any case, did meaning remain accurate in Mode A but become stronger or flatter in Mode B?** Yes — Case 2 is the clearest example. Mode A preserved "generally a preference that may become a trade-off under specific conditions"; Mode B flattened it to "a preference or trade-off."
+
+9. **Does this isolate the failure to the resolution judgement?** Partially yes, for the case of conditional meaning loss. The comparison within Case 2 (same answer, same model, independent calls) shows that meaning can be preserved in isolation and then lost when a resolution decision is introduced. However, only one instance of meaning-preserved-but-resolution-flattened was observed; broader generalisation requires more tested cases.
+
+10. **Does this establish how production logic should be redesigned?** No — the evidence from three answers is insufficient to justify specific production changes. Further testing with additional answer types and different models would be needed before redesigning any logic.
+
+11. **Does this establish graph representation or Behaviour Selection changes?** No — this experiment did not integrate with graph, Behaviour Selection, or any other engine component.
+
+---
+
+### Limitations
+
+- Only three answers were tested. Different answer patterns may behave differently.
+- The weak-priority case in 55B resolved correctly (unlike 55A which over-resolved it), suggesting the resolution step may have some instability across runs with the same configuration.
+- Only one model configuration was used (qwen-claude:latest on 192.168.1.111:11434).
+- The conditional trade-off answer is a specific pattern; other conditional phrasings may behave differently.
+- Six live calls total — insufficient for broader generalisation.
+
+---
+
+### Experiment Conclusion
+
+**Answer meaning remained accurate while resolution judgement introduced the observed loss.**
+
+All three tested answers preserved their meaning correctly in Mode A (meaning_preserved: 3/3). The only information loss appeared in Case 2 when transitioning from meaning-only to resolution: the conditional qualification "for the right opportunity I might accept some" was present and preserved by Mode A, then flattened to a flat "preference or trade-off" statement during resolution.
+
+Additionally, Case 1 produced different resolution outcomes across experiments (55A over-resolved; 55B correctly unresolved), suggesting the resolution step exhibits some run-to-run instability under the same configuration — an observation worth monitoring but not yet actionable without more data.
+
+The evidence supports separating meaning extraction from resolution judgement as a production strategy, but does not yet establish specific implementation details.
+
+### Focused Test Result
+
+All 6 live inference calls completed successfully. Three answers tested independently through two modes each. Meaning preservation was perfect across Mode A (3/3). Resolution introduced one meaning-loss case (Case 2) and correctly handled the other two. Total: ~104s, average: ~17.3s per call, fastest: 11.5s, slowest: 24.1s.
+
+### Historical Comparison Result
+
+Compared to Experiment 55A's conclusion that "the answer-resolution step appears biased toward resolution," Experiment 55B shows this bias is not universal: Case 1 did not over-resolve in the 55B run, and Case 3 was correct in both experiments. The specific loss pattern (conditional meaning preserved in isolation but flattened during resolution) appeared only in Case 2. This narrows the failure from "biased toward resolution" to a more specific pattern: conditional nuance is vulnerable to flattening specifically when the model is forced to make a target-resolution decision.
+
+### Documentation Updated
+
+- `docs/design-evolution-log.md` — added full Experiment 55B entry; applied wording corrections to Experiment 55A
+- `docs/current-handoff.md` — updated with Experiment 55B summary and new Return-to-Work note
+
+### Confirmation Host and Model Remained Unchanged
+
+Host: `http://192.168.1.111:11434`. Model: `qwen-claude:latest`. Same as all prior experiments.
+
+### Confirmation Semantic Instruction and Output Contract Remained Unchanged (for Mode B)
+
+Mode B instruction and output contract identical to Experiment 54V / 55A. No production code changed.
+
+Mode A used a new minimal instruction and output contract specific to this experiment only. It does not replace any existing mechanism.
+
+### Confirmation Production Prompts and Schemas Remained Unchanged
+
+No production prompts read or modified. No schemas changed. All inference calls used the experiment-specific semantic instructions defined in this test file.
+
+### Confirmation Behaviour Selection Remained Unchanged
+
+Behaviour Selection was not called or referenced. No integration with the selector occurred.
+
+### Confirmation Graph and UI Remained Unchanged
+
+No graph files read or modified. No UI code touched. The experiment is test-only.
+
+### Confirmation No Meaning-Resolution Separation Entered Active Runtime
+
+This experiment created one new test file only. No meaning-resolution separation logic entered any active runtime path, production module, or behaviour selection output. Production continues using the pre-existing combined instruction and contract.
+
+---
+
+### Return-to-Work Note (Experiment 55B)
+
+55A showed one weak answer was over-resolved and one conditional answer lost nuance; 55B separated answer meaning from target-resolution judgement using independent calls. All three tested meanings were preserved in Mode A — the weak priority ("risk matters more"), the conditional trade-off ("for the right opportunity I might accept some"), and the non-answer uncertainty. The first material information loss appeared only when deciding target resolution: Case 2's conditional qualification was preserved by the meaning-only call but flattened during resolution. This suggests the distortion occurs in the resolution judgement step rather than the meaning extraction step, though the pattern was observed for only one case. Whether other answer types show the same pattern remains unproven. Graph, Behaviour Selection, UI and production remain untouched. Same host/model (qwen-claude:latest on http://192.168.1.111:11434). Branch: feature/user-workspace-ux-v0.7, commit 8c12931. First test/file to inspect when resuming: tests/reconstruction/semantic-answer-meaning-vs-resolution.test.js for the full experiment and results. Status pending Rob's review.

tests/reconstruction/semantic-answer-meaning-vs-resolution.test.js

@@ -0,0 +1,439 @@
+import { describe, it, expect } from "vitest";
+import { config } from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+config({ path: path.resolve(__dirname, "../../.env.local") });
+
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL;
+const OLLAMA_MODEL = process.env.OLLAMA_MODEL;
+
+if (!OLLAMA_BASE_URL || !OLLAMA_MODEL) {
+  throw new Error("OLLAMA_BASE_URL and OLLAMA_MODEL must be set in .env.local");
+}
+
+// ──────────────────────────────────────────────
+// Mode A — Meaning Only
+// ──────────────────────────────────────────────
+
+async function callMeaningOnly(source, clarificationQuestion, userAnswer) {
+  const instruction = `State only what the user's answer establishes in relation to the clarification question. Preserve uncertainty, conditionality, and qualification exactly as supplied. Do not decide whether the clarification target is resolved. Do not infer what the user did not say. Do not recommend action or generate another question.
+
+Return valid JSON only in this shape:
+{
+  "answerMeaning": "short statement"
+}`;
+
+  const messages = [
+    { role: "system", content: instruction.trim() },
+    {
+      role: "user",
+      content: `Source: ${JSON.stringify(source)}
+
+Clarification question: ${clarificationQuestion}
+
+User's answer: ${userAnswer}`,
+    },
+  ];
+
+  const res = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: OLLAMA_MODEL,
+      messages,
+      format: "json",
+      stream: false,
+    }),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Ollama API error: ${res.status} ${res.statusText}`);
+  }
+
+  const data = await res.json();
+  const rawContent = data.message?.content ?? "";
+  const cleaned = rawContent.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "");
+
+  return JSON.parse(cleaned.trim());
+}
+
+// ──────────────────────────────────────────────
+// Mode B — Resolution (unchanged from Experiment 54V / 55A)
+// ──────────────────────────────────────────────
+
+async function callClarificationAnswerResolution(source, clarificationTarget, clarificationQuestion, userAnswer) {
+  const instruction = `Use the user's clarification answer only to resolve the supplied clarification target. State the meaning now established by that answer. Mark targetResolved true only when the answer settles the target. Put any uncertainty that remains specifically about that target into remainingUncertainty; otherwise return null. Do not infer wider consequences, rewrite unrelated source meaning, recommend action, or generate another question.
+
+Return valid JSON only in this shape:
+{
+  "resolvedMeaning": "short statement",
+  "targetResolved": true,
+  "remainingUncertainty": null
+}`;
+
+  const messages = [
+    { role: "system", content: instruction.trim() },
+    {
+      role: "user",
+      content: `Source: ${JSON.stringify(source)}
+
+Clarification target: ${clarificationTarget}
+
+Clarification question: ${clarificationQuestion}
+
+User's answer: ${userAnswer}`,
+    },
+  ];
+
+  const res = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: OLLAMA_MODEL,
+      messages,
+      format: "json",
+      stream: false,
+    }),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Ollama API error: ${res.status} ${res.statusText}`);
+  }
+
+  const data = await res.json();
+  const rawContent = data.message?.content ?? "";
+  const cleaned = rawContent.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "");
+
+  return JSON.parse(cleaned.trim());
+}
+
+// ──────────────────────────────────────────────
+// Fixed source, target, question (identical to 55A)
+// ──────────────────────────────────────────────
+
+const SOURCE = "I want the business to grow, but I don't want to take on more risk.";
+const CLARIFICATION_TARGET = "whether avoiding additional risk is a preference/trade-off or a hard constraint";
+const CLARIFICATION_QUESTION = "Do you view avoiding additional risk as a hard constraint, or as a preference or trade-off?";
+
+// ──────────────────────────────────────────────
+// Three fixed cases — independent meaning-only and resolution calls
+// ──────────────────────────────────────────────
+
+const CASES = [
+  {
+    id: "Case 1 — Weak Priority",
+    userAnswer: "Risk matters more to me.",
+    humanReference: {
+      answerMeaning: "risk has greater relative importance to the user",
+      doesNotEstablish: ["that risk avoidance is a hard constraint", "that it is not a hard constraint"],
+      targetResolved: false,
+    },
+  },
+  {
+    id: "Case 2 — Conditional Trade-Off",
+    userAnswer: "I'd normally avoid more risk, but for the right opportunity I might accept some.",
+    humanReference: {
+      answerMeaning: "risk avoidance is normally preferred; additional risk may be accepted conditionally for the right opportunity",
+      targetResolved: true,
+    },
+  },
+  {
+    id: "Case 3 — Non-Answer",
+    userAnswer: "I'm not really sure.",
+    humanReference: {
+      answerMeaning: "the user remains uncertain",
+      targetResolved: false,
+    },
+  },
+];
+
+// ──────────────────────────────────────────────
+// Semantic evaluation helpers (manual review primary)
+// ──────────────────────────────────────────────
+
+function classifyMeaning(caseNum, meaningText) {
+  const m = meaningText.toLowerCase().trim();
+
+  // Case 1: weak priority — should NOT strengthen beyond relative importance
+  if (caseNum === 1) {
+    if (/hard.*constraint|not.*constraint|no.*need|don't.*need|absolute/i.test(m)) {
+      return { classification: "meaning_strengthened", reasoning: `Meaning strengthened beyond relative priority: "${meaningText}"` };
+    }
+    if (/risk.*more.*important|risk.*matters.*more|greater.*priority|higher.*importance|relativ.*import/i.test(m)) {
+      return { classification: "meaning_preserved", reasoning: `Weak priority preserved as relative importance without deciding constraint status.` };
+    }
+    if (m.length < 5) {
+      return { classification: "meaning_lost", reasoning: `Meaning too brief to evaluate, possibly lost: "${meaningText}"` };
+    }
+    if (/risk/i.test(m) && !/more|greater|higher|priority|rival.*importance|trade.?off/i.test(m)) {
+      return { classification: "meaning_strengthened", reasoning: `Meaning may have strengthened beyond relative priority: "${meaningText}"` };
+    }
+    return { classification: "meaning_preserved", reasoning: `Weak priority preserved (semantic review needed): "${meaningText}"` };
+  }
+
+  // Case 2: conditional trade-off — should preserve both normal preference and conditional exception
+  if (caseNum === 2) {
+    const hasConditionality = /but|condition|migh|would.*normally|normally.*avoid|exception|when/i.test(m);
+    const hasNormalPreference = /normal.*avoid|normally.*risk|generally.*risk|usually.*risk|prefer.*risk|tend.*risk/i.test(m);
+    const hasFlattening = /simply.*preference|risk is just|always avoid|i would.*not.*accept/i.test(m) && !hasConditionality;
+
+    if (hasFlattening) {
+      return { classification: "meaning_strengthened", reasoning: `Meaning flattened conditionality into flat statement: "${meaningText}"` };
+    }
+    if (hasConditionality && hasNormalPreference) {
+      return { classification: "meaning_preserved", reasoning: `Conditional qualification preserved with normal preference and exception.` };
+    }
+    if (!hasConditionality && hasNormalPreference) {
+      return { classification: "meaning_lost", reasoning: `Normal preference captured but conditionality lost: "${meaningText}"` };
+    }
+    return { classification: "meaning_preserved", reasoning: `Conditional meaning partially preserved (semantic review needed): "${meaningText}"` };
+  }
+
+  // Case 3: non-answer — should preserve simple uncertainty
+  if (caseNum === 3) {
+    if (/uncertain|not.*sure|don't.*know|no.*position|haven't.*decided|unsure/i.test(m)) {
+      return { classification: "meaning_preserved", reasoning: `Uncertainty preserved from non-answer.` };
+    }
+    if (/risk|constraint|preference|avoid|should|must/i.test(m) && !/uncertain|unsure|not.*sure|don't.*know/i.test(m)) {
+      return { classification: "meaning_strengthened", reasoning: `Meaning invented a position where user expressed uncertainty: "${meaningText}"` };
+    }
+    return { classification: "meaning_preserved", reasoning: `Non-answer meaning preserved (semantic review needed): "${meaningText}"` };
+  }
+
+  return { classification: "meaning_lost", reasoning: "Unrecognized case number" };
+}
+
+function classifyResolution(caseNum, result) {
+  const { resolvedMeaning, targetResolved, remainingUncertainty } = result;
+  const m = (resolvedMeaning ?? "").toLowerCase().trim();
+
+  if (caseNum === 1) {
+    if (targetResolved === true) {
+      return { classification: "resolution_overresolved", reasoning: `Over-resolved weak answer: targetResolved=true. Meaning: "${resolvedMeaning}"` };
+    }
+    if (/not.*hard.*constraint|r.*isn't.*constraint|definitely.*not.*constraint/i.test(m)) {
+      return { classification: "resolution_meaning_loss", reasoning: `Meaning strengthened during resolution judgement: "${resolvedMeaning}"` };
+    }
+    if (remainingUncertainty === null || remainingUncertainty === undefined) {
+      return { classification: "resolution_overresolved", reasoning: `targetResolved=false but no remaining uncertainty — uncertainty erased.` };
+    }
+    return { classification: "resolution_correct", reasoning: `Weak answer correctly remained unresolved with remaining uncertainty.` };
+  }
+
+  if (caseNum === 2) {
+    if (targetResolved !== true) {
+      return { classification: "resolution_underresolved", reasoning: `Should be resolved but targetResolved=false: "${resolvedMeaning}"` };
+    }
+    const hasConditionality = /but|condition|migh|would.*normally|for.*opportunity/i.test(m);
+    if (hasConditionality) {
+      return { classification: "resolution_correct", reasoning: `Correctly resolved with conditional qualification preserved.` };
+    }
+    return { classification: "resolution_meaning_loss", reasoning: `Resolution correct but conditionality flattened: "${resolvedMeaning}"` };
+  }
+
+  if (caseNum === 3) {
+    if (targetResolved === true) {
+      return { classification: "resolution_overresolved", reasoning: `Over-resolved non-answer: targetResolved=true.` };
+    }
+    if (/invented|asserted.*position|would.*avoid/i.test(m)) {
+      return { classification: "resolution_meaning_loss", reasoning: `Model invented meaning from non-answer: "${resolvedMeaning}"` };
+    }
+    if (remainingUncertainty === null || remainingUncertainty === undefined) {
+      return { classification: "resolution_correct", reasoning: `Correctly unresolved, no spurious uncertainty.` };
+    }
+    return { classification: "resolution_correct", reasoning: `Correctly unresolved with remaining uncertainty.` };
+  }
+
+  return { classification: "resolution_correct", reasoning: "Unrecognized case number" };
+}
+
+// ──────────────────────────────────────────────
+// Test suite
+// ──────────────────────────────────────────────
+
+describe("Experiment 55B — Separate Answer Meaning from Resolution Judgement", () => {
+  const results = [];
+  const timings = [];
+
+  for (let i = 0; i < CASES.length; i++) {
+    const c = CASES[i];
+    const caseNum = i + 1;
+
+    it(`${c.id} — Mode A: Meaning Only`, async () => {
+      const start = Date.now();
+      const result = await callMeaningOnly(SOURCE, CLARIFICATION_QUESTION, c.userAnswer);
+      const elapsed = Date.now() - start;
+      timings.push({ caseId: `${c.id}-A`, ms: elapsed });
+
+      const meaningText = result.answerMeaning ?? "";
+      const ev = classifyMeaning(caseNum, meaningText);
+
+      results.push({
+        caseNumber: caseNum,
+        case: c,
+        mode: "A",
+        modelResult: result,
+        rawMeaning: meaningText,
+        classification: ev.classification,
+        reasoning: ev.reasoning,
+        timingMs: elapsed,
+      });
+
+      expect(result.answerMeaning).toBeDefined();
+      expect(typeof result.answerMeaning).toBe("string");
+      expect(result.answerMeaning.trim().length).toBeGreaterThan(0);
+    }, 120000);
+
+    it(`${c.id} — Mode B: Resolution`, async () => {
+      const start = Date.now();
+      const result = await callClarificationAnswerResolution(SOURCE, CLARIFICATION_TARGET, CLARIFICATION_QUESTION, c.userAnswer);
+      const elapsed = Date.now() - start;
+      timings.push({ caseId: `${c.id}-B`, ms: elapsed });
+
+      const ev = classifyResolution(caseNum, result);
+
+      results.push({
+        caseNumber: caseNum,
+        case: c,
+        mode: "B",
+        modelResult: result,
+        classification: ev.classification,
+        reasoning: ev.reasoning,
+        timingMs: elapsed,
+      });
+
+      expect(result.resolvedMeaning).toBeDefined();
+      expect(typeof result.resolvedMeaning).toBe("string");
+      expect(result.targetResolved).toBeDefined();
+      expect(typeof result.targetResolved).toBe("boolean");
+    }, 120000);
+  }
+
+  it("55B: aggregate results and analysis", () => {
+    const meaningCounts = { meaning_preserved: 0, meaning_strengthened: 0, meaning_lost: 0 };
+    const resolutionCounts = { resolution_correct: 0, resolution_overresolved: 0, resolution_underresolved: 0, resolution_meaning_loss: 0 };
+
+    const modeA = results.filter((r) => r.mode === "A");
+    const modeB = results.filter((r) => r.mode === "B");
+
+    for (const r of modeA) {
+      meaningCounts[r.classification]++;
+    }
+    for (const r of modeB) {
+      resolutionCounts[r.classification]++;
+    }
+
+    const totalMs = timings.reduce((s, t) => s + t.ms, 0);
+    const msArr = timings.map((t) => t.ms);
+
+    console.log("\n========== Experiment 55B Results ==========");
+    console.log(`\nSource: ${SOURCE}`);
+    console.log(`Target: ${CLARIFICATION_TARGET}`);
+    console.log(`Question: ${CLARIFICATION_QUESTION}`);
+
+    for (const r of modeA) {
+      console.log(`\n--- Case ${r.caseNumber} Mode A (Meaning Only) ---`);
+      console.log("Answer:", `"${r.case.userAnswer}"`);
+      console.log("answerMeaning:", r.rawMeaning);
+      console.log("Classification:", r.classification);
+      console.log("Reasoning:", r.reasoning);
+    }
+
+    for (const r of modeB) {
+      console.log(`\n--- Case ${r.caseNumber} Mode B (Resolution) ---`);
+      console.log("Answer:", `"${r.case.userAnswer}"`);
+      console.log("resolvedMeaning:", r.modelResult.resolvedMeaning);
+      console.log("targetResolved:", r.modelResult.targetResolved);
+      console.log("remainingUncertainty:", r.modelResult.remainingUncertainty ?? "null");
+      console.log("Classification:", r.classification);
+      console.log("Reasoning:", r.reasoning);
+    }
+
+    console.log("\n--- Meaning Classification Counts (Mode A) ---");
+    Object.entries(meaningCounts).forEach(([k, v]) => console.log(`${k}: ${v}`));
+
+    console.log("\n--- Resolution Classification Counts (Mode B) ---");
+    Object.entries(resolutionCounts).forEach(([k, v]) => console.log(`${k}: ${v}`));
+
+    console.log("\n--- Timing ---");
+    console.log("Total live calls:", timings.length);
+    console.log("Total time:", totalMs + "ms");
+    console.log("Average:", (totalMs / timings.length).toFixed(1) + "ms per call");
+    console.log("Fastest:", Math.min(...msArr) + "ms");
+    console.log("Slowest:", Math.max(...msArr) + "ms");
+
+    // Cross-mode comparison
+    const crossMode = [];
+    for (let i = 0; i < 3; i++) {
+      const a = modeA[i];
+      const b = modeB[i];
+      crossMode.push({
+        caseNumber: i + 1,
+        answer: CASES[i].userAnswer,
+        meaningClassification: a.classification,
+        resolutionClassification: b.classification,
+        meaningText: a.rawMeaning,
+        resolutionText: b.modelResult.resolvedMeaning,
+      });
+    }
+
+    console.log("\n--- Cross-Mode Comparison ---");
+    for (const c of crossMode) {
+      const meaningOk = c.meaningClassification === "meaning_preserved";
+      const resolutionOk = c.resolutionClassification === "resolution_correct" || c.resolutionClassification === "resolution_meaning_loss";
+      console.log(`\nCase ${c.caseNumber}: "${c.answer}"`);
+      console.log(`  Meaning: ${c.meaningClassification} — "${c.meaningText}"`);
+      console.log(`  Resolution: ${c.resolutionClassification} — "${c.resolutionText}"`);
+
+      if (meaningOk && c.resolutionClassification !== "resolution_correct") {
+        console.log(`  => Meaning preserved in Mode A but resolution judgement introduced a problem.`);
+      } else if (!meaningOk) {
+        console.log(`  => Meaning was already distorted before the resolution judgement.`);
+      }
+    }
+
+    const q1 = modeA[0].classification === "meaning_preserved";
+    const q2 = modeB[0].classification !== "resolution_correct" && (modeB[0].classification === "resolution_overresolved" || modeB[0].classification === "resolution_meaning_loss");
+    const q3 = (/(?:preserved.*conditionality|conditional.*qualification.*preserved)/.test(modeA[1].reasoning)) || modeA[1].classification === "meaning_preserved";
+    const q4 = modeB[1].classification === "resolution_correct" || /flattened/i.test(modeB[1].reasoning);
+    const q5 = modeA[2].classification === "meaning_preserved";
+    const q6 = modeB[2].classification !== "resolution_overresolved";
+
+    console.log("\n--- Required Questions ---");
+    console.log("Q1 (Case 1 meaning preserved as relative priority?):", q1 ? "Yes" : "No — " + modeA[0].reasoning);
+    console.log("Q2 (Case 1 resolution over-resolved again?):", q2 ? "Yes" : "No");
+    console.log("Q3 (Case 2 meaning preserved conditional qualification?):", q3 ? "Yes" : "Need review — " + modeA[1].reasoning);
+    console.log("Q4 (Case 2 resolution preserve or flatten conditionality?):", /preserve/i.test(modeB[1].reasoning) ? "Preserved" : /flatten/i.test(modeB[1].reasoning) ? "Flattened" : "Unclear — " + modeB[1].reasoning);
+    console.log("Q5 (Case 3 meaning preserved uncertainty?):", q5 ? "Yes" : "No");
+    console.log("Q6 (Case 3 resolution correctly unresolved?):", q6 ? "Yes" : "No");
+
+    const anyMeaningDistortedBeforeResolution = crossMode.some(
+      (c) => c.meaningClassification !== "meaning_preserved"
+    );
+    const meaningPreservedButResolutionProblems = crossMode.some(
+      (c) => c.meaningClassification === "meaning_preserved" && c.resolutionClassification !== "resolution_correct"
+    );
+
+    console.log("\n--- Key Findings ---");
+    console.log("Meaning already distorted before resolution:", anyMeaningDistortedBeforeResolution);
+    console.log("Meaning preserved in Mode A but resolution introduced problem:", meaningPreservedButResolutionProblems);
+
+    results.summary = {
+      meaningCounts,
+      resolutionCounts,
+      totalTimeMs: totalMs,
+      totalCalls: timings.length,
+      averageMs: (totalMs / timings.length).toFixed(1),
+      fastestMs: Math.min(...msArr),
+      slowestMs: Math.max(...msArr),
+      crossMode,
+      anyMeaningDistortedBeforeResolution,
+      meaningPreservedButResolutionProblems,
+    };
+
+    console.log("\n========== End of Experiment 55B ==========\n");
+  });
+});