experiment: test initial graph edge coherence (Exp 50)

Passive diagnostic. Coherent and scattered inputs produce identical
edge topology — every unknown connects to the summary node (kind=state)
via depends_on regardless of semantics. Shared edges are wiring, not
coherence evidence.

docs/current-handoff.md

@@ -56,6 +56,10 @@ Experiment 47 created a test-only diagnostic helper (`inspectSharedUnknownAnchor
 
 Experiment 48 audited whether real graph updates populate usable unknown relationships. Three production paths inspected: `buildInitialGraph` (does NOT populate dependsOn/affects/parentId), emergent reasoning via `buildEmergentReasoningUnknown` (DOES populate dependsOn and parentId), decomposition children (DOES populate parentId). One test file created (16 tests, all pass). Conclusion: Insufficient Data — shared-anchor detection works through the emergent-unknown path only. Status closed.
 
+Experiment 49 tested whether any sequence of real production updates creates two or more active unknowns referencing the same populated relationship anchor. Results: no shared anchor found in production update sequences (both Cases A and B returned separate_anchors or insufficient_data). Structural capability exists but triggering logic never produces coexisting anchors. Status closed.
+
+Experiment 50 tested whether shared edge topology from `buildInitialGraph` provides a usable coherence signal. Coherent and scattered inputs both produce identical edge topology — every unknown connects to the same summary node (kind=state) via depends_on edges, regardless of semantics. Conclusion: production edges provide only a generic shared anchor, not meaningful coherence. Status pending Rob's review.
+
 ## 5. What Remains Open
 
 - The `too_broad` boundary sits exactly between three and four active unknowns; it is mechanically clear but conceptually uncertain — whether it aligns with genuine user confusion requires real-scenario validation;
@@ -108,7 +112,7 @@ Answer before continuing:
 
 ---
 
-*Created by Experiment 34. Updated by Experiments 38–49. Branch: `feature/user-workspace-ux-v0.7`.*
+*Created by Experiment 34. Updated by Experiments 38–50. Branch: `feature/user-workspace-ux-v0.7`.*
 
 ### Return-to-Work Note (Experiment 47)
 
@@ -117,3 +121,5 @@ Experiment 47 created a test-only diagnostic helper (`inspectSharedUnknownAnchor
 Experiment 48 passively audited whether real graph updates populate usable unknown relationships (the signal needed for the Exp-47 diagnostic). Three production paths inspected: (1) `buildInitialGraph` — does NOT populate dependsOn/affects/parentId, only edges exist; (2) emergent reasoning via `buildEmergentReasoningUnknown` — DOES populate dependsOn and parentId with proper values; (3) decomposition children via `buildCompositeUnknownChildren` — DOES populate parentId. One test file created (`tests/graph/unknown-relationship-population.test.js`, 16 tests, all pass). Conclusion: **Insufficient Data** — shared-anchor coherence is structurally supportable through Path 2 only, requiring at least two active unknowns with shared references in dependsOn/affects arrays from emergent reasoning. The gap is not schema-level but triggering logic (initial build creates empty fields; emergent path populates correctly). Status closed.
 
 Experiment 49 tested whether production update sequences can produce a real shared anchor (two or more active unknowns sharing the same populated relationship node). Two sequential-update scenarios via `applyValidatedProposal` (Cases A and B in the new test file) consistently returned `separate_anchors` or `insufficient_data` — no coexisting active unknowns reference the same anchor. The structural capability exists (fields populate correctly via emergent reasoning), but the triggering logic never produces shared anchors within tested flows. Control cases (C–F, 20 tests) confirmed the diagnostic works correctly on controlled fixtures and all produced nodes pass schema validation. Total: 36 new tests, all passing. Branch: `feature/user-workspace-ux-v0.7`. First file to inspect: `tests/graph/shared-anchor-production-path.test.js` for results, then `docs/design-evolution-log.md` Experiment 49 section.
+
+Experiment 50 tested whether shared graph edges from `buildInitialGraph` provide a meaningful coherence signal. Two inputs — one coherent (North West expansion), one scattered (business feels stuck) — passed through identical production edge-building path. Both produced the same edge topology: four unknowns, each connecting via depends_on to the summary node (kind=state). Node-level relationship fields remain empty in both cases. Conclusion: shared-edge connectivity is structural plumbing, not coherence evidence. No structural difference exists between coherent and scattered inputs at the production graph level. Status pending Rob's review. First file: `tests/graph/initial-edge-coherence.test.js`.

docs/design-evolution-log.md

@@ -3274,3 +3274,91 @@ The production flow creates at most one emergent reasoning unknown per update, v
 ### Pending Rob's review. No production code or graph schema modified.
 
 **Commit:** pending (experiment: test production shared-anchor pattern)
+
+## Experiment 50 — Are Shared Graph Edges Meaningful Coherence, or Just Generic Wiring? (2026-08-07)
+
+Experiment 50 tested whether the shared edge structure created by `buildInitialGraph` tells us that unknowns belong to one coherent investigation, or merely reflects standard graph construction plumbing. This was a passive diagnostic — no production code changed.
+
+### Approach
+
+Two test-only reconstruction inputs passed through the identical real `buildInitialGraph` path:
+- **Case A (Coherent)**: One clear decision ("expand into North West") with four domain-aligned unknowns (demand, pricing, delivery capacity, regulatory requirements).
+- **Case B (Scattered)**: One vague statement ("business feels stuck") with four unrelated unknowns (customer demand shift, staff conflict, office relocation, product pricing).
+
+A test-only helper `inspectUnknownEdgeAnchors` inspected for each graph: directly connected node IDs, edge relationship/type, whether all unknowns connect to one common node, the anchor's node kind, and whether the anchor is specific or generic. Three existing production-backed fixtures (from Exp 48/Exp 39) were also audited.
+
+### Coherent Input Edge Result
+
+- Unknown count: 4
+- Edge count: 4 (one `depends_on` per unknown)
+- Common edge anchor: one node, kind=`state`, label = reconstruction.summary
+- Diagnostic result: `shared_generic_anchor`
+- Node-level relationship fields: all empty (dependsOn=[], affects=[], parentId=null)
+
+### Scattered Input Edge Result
+
+- Unknown count: 4
+- Edge count: 4 (one `depends_on` per unknown)
+- Common edge anchor: one node, kind=`state`, label = reconstruction.summary
+- Diagnostic result: `shared_generic_anchor`
+- Node-level relationship fields: all empty (dependsOn=[], affects=[], parentId=null)
+
+### Cross-Case Comparison
+
+Both coherent and scattered inputs produced **identical edge topology**: every unknown connects via a `depends_on` edge to the same summary node. The anchor is always kind=`state`. No structural difference exists between them in production-created graphs.
+
+### Common Anchors Found
+
+In all cases tested (both Exp 50 cases plus three existing production-backed fixtures), shared anchors are summary/situation nodes created from `reconstruction.summary`. Kind is always `state`. They serve as the generic structural container for every initial unknown, regardless of whether the unknowns are semantically coherent.
+
+### Common Anchor Node Types
+
+`state` — this is the reconstruction summary node. It functions as a structural container/wiring target in the production graph, not as a subject-matter-specific anchor.
+
+### Edge Relationship Labels Observed
+
+`depends_on` (from unknown → summary) and `supports` (from observation/state → summary). Neither label carries semantic coherence information.
+
+### Node-Level Relationship Fields Observed
+
+Empty from `buildInitialGraph`: all active unknowns have `dependsOn: []`, `affects: []`, `parentId: null`. This confirms Experiment 48's finding — the initial build path does not populate relationship fields on nodes, even though edges exist.
+
+### Did Coherent and Scattered Cases Differ Structurally
+
+No. Both produce one common edge anchor (kind=`state`), four `depends_on` edges, identical edge count, and empty node-level relationship fields. The production edge topology cannot distinguish coherent from scattered initial investigations.
+
+### Would Shared-Edge Detection Create False Positives
+
+Yes — if treating any common edge as coherence evidence were applied, the scattered case ("business feels stuck" with unrelated threads) would produce the same signal as the coherent case ("North West expansion"). This is a false positive for coherence.
+
+### Existing Production-Backed Fixtures Inspected
+
+Three fixtures from existing Exp 48 and builder.test.js tests containing multiple unknowns:
+1. builder.test.js standard two-unknown scenario (revenue/complaints)
+2. Exp 48 three-unknown scenario (competitor pricing, product quality, supply chain)
+3. Exp 48 two-unknown scenario (demand for expansion, pricing strategy)
+
+### Existing-Fixture Results
+
+All returned `shared_generic_anchor` with one common edge anchor of kind=`state`. Node-level fields were empty in all cases. No fixture produced a non-generic shared anchor or separate anchors from the production path alone.
+
+### Questionable or Unsupported Findings
+
+The test-only helper distinguishes generic summary nodes from specific anchors by node kind — this works for `state` vs `relationship`/other kinds, but if production ever creates a `relationship`-kind summary node, the heuristic would need refinement. No such case exists in current production.
+
+### Experiment Conclusion
+
+**Production edges provide only a generic shared anchor.** Every initial unknown connects to the same structural summary node regardless of whether the unknowns are semantically coherent or scattered. Shared edge connectivity is wiring, not evidence of coherence. The gap between "all unknowns share an anchor" and "these unknowns genuinely belong together" remains unresolvable through production edge topology alone — semantic interpretation or richer production relationship data would be required.
+
+### Test Results Summary
+
+| Test File | Tests | Passed |
+|---|---|---|
+| `initial-edge-coherence.test.js` (Exp 50) | 26 | 26 |
+| `shared-anchor-production-path.test.js` (Exp 49) | 36 | 36 |
+| `unknown-relationship-population.test.js` (Exp 48) | 16 | 16 |
+| `builder.test.js` (focused regression) | 32 | 32 |
+
+### Pending Rob's review. No production code or graph schema modified.
+
+**Commit:** pending (experiment: test initial graph edge coherence)