Causal Flow 下对称支持递归下游红边

client/src/causal_flow.html

@@ -308,7 +308,7 @@
                         <span class="semantic-submode-group" id="gen_attr_dag_show_downstream_influence_group">
                             <label class="semantic-submode-label">
                                 <input type="checkbox" id="gen_attr_dag_show_downstream_influence"
-                                    title="When checked, direct attribution focus also shows outgoing edges from the selected or hovered token as downstream influence. Causal Flow Mode keeps showing upstream attribution chains only."
+                                    title="When checked, focus also shows outgoing edges as downstream influence (red). Direct mode: one hop. Causal Flow Mode: recursive — propagate as arrive × one-hop weight (sum at merges); display scales each source’s outs so strongest = arrive."
                                     data-i18n="title">
                                 Show downstream influence
                             </label>

client/src/features/causal_flow/genAttributeBundledDemoManifest.generated.ts

@@ -3,4 +3,4 @@
  */
 export type GenAttributeBundledDemoFeaturedStyle = 'bold';
 export type GenAttributeBundledDemoManifestEntry = { readonly slug: string; readonly label: string; readonly featured?: GenAttributeBundledDemoFeaturedStyle };
-export const GEN_ATTRIBUTE_BUNDLED_DEMOS: readonly GenAttributeBundledDemoManifestEntry[] = [{"slug":"Write a sonnet about love","label":"Poem | Write a sonnet about love","featured":"bold"},{"slug":"写一首绝句，主题是春天","label":"写诗 | 写一首绝句，主题是春天","featured":"bold"},{"slug":"过拟合｜李白 将进酒","label":"过拟合｜李白 将进酒","featured":"bold"},{"slug":"CN-EN翻译","label":"CN->EN | 翻译"},{"slug":"注意力的具象化","label":"Attention｜注意力的具象化","featured":"bold"},{"slug":"注意力 诗 螺旋版","label":"Attention｜注意力的具象化 螺旋版"},{"slug":"CoT｜苏州所在省的省会","label":"CoT | 苏州所在省的省会","featured":"bold"},{"slug":"CoT｜苏州所在省的省会城市里最高的山","label":"CoT | 苏州所在省的省会的最高的山"},{"slug":"CoT｜反向传播归因动画","label":"CoT | 思维链的反向归因过程动画","featured":"bold"},{"slug":"CoT｜最长两条河的入海口｜草稿链","label":"CoT | 最长两条河的入海口｜草稿链","featured":"bold"},{"slug":"CoT｜多“跳”推理","label":"CoT | 多跳推理中“跳”的具象化"},{"slug":"strawberry里有几个r","label":"CoT | strawberry里有几个r"},{"slug":"Tool-call｜北京天气","label":"Tool-call｜北京天气","featured":"bold"},{"slug":"Tool | 马斯克","label":"CoT+Tool｜SpaceX 马斯克","featured":"bold"},{"slug":"闪电效果 | 马斯克","label":"闪电效果 | 马斯克"},{"slug":"Attention","label":"Attention"},{"slug":"注意力的算力开销对比","label":"注意力的算力开销对比"}];
+export const GEN_ATTRIBUTE_BUNDLED_DEMOS: readonly GenAttributeBundledDemoManifestEntry[] = [{"slug":"Write a sonnet about love","label":"Poem | Write a sonnet about love","featured":"bold"},{"slug":"写一首绝句，主题是春天","label":"写诗 | 写一首绝句，主题是春天","featured":"bold"},{"slug":"过拟合｜李白 将进酒","label":"过拟合｜李白 将进酒","featured":"bold"},{"slug":"CN-EN翻译","label":"CN->EN | 翻译"},{"slug":"注意力的具象化","label":"Attention｜注意力的具象化","featured":"bold"},{"slug":"注意力 诗 螺旋版","label":"Attention｜注意力的具象化 螺旋版"},{"slug":"CoT｜苏州所在省的省会","label":"CoT | 苏州所在省的省会","featured":"bold"},{"slug":"CoT｜苏州所在省的省会城市里最高的山","label":"CoT | 苏州所在省的省会的最高的山"},{"slug":"CoT｜反向传播归因动画","label":"CoT | 思维链的反向归因过程动画","featured":"bold"},{"slug":"CoT｜最长两条河的入海口｜草稿链","label":"CoT | 最长两条河的入海口｜草稿链","featured":"bold"},{"slug":"CoT｜多“跳”推理","label":"CoT | 多跳推理中“跳”的具象化"},{"slug":"strawberry里有几个r","label":"CoT | strawberry里有几个r"},{"slug":"Tool-call｜北京天气","label":"Tool-call｜北京天气","featured":"bold"},{"slug":"Tool | 马斯克","label":"CoT+Tool｜SpaceX 马斯克","featured":"bold"},{"slug":"闪电效果 | 马斯克","label":"闪电效果 | 马斯克"},{"slug":"Attention","label":"Attention"}];

client/src/pages/causal_flow/index.ts

@@ -1155,7 +1155,8 @@ function applyDagRecursiveAttributionSubmodeUi(): void {
     const recursive = dagRecursiveAttributionInput?.checked ?? false;
     const forward = recursive && currentDagRecursiveEdgeAnimationDirection() === 'forward';
     if (dagShowDownstreamInfluenceGroup) {
-        dagShowDownstreamInfluenceGroup.hidden = recursive;
+        // 直接模式与因果流 forward 均显示；backward 仅上游蓝链，隐藏下游选项。
+        dagShowDownstreamInfluenceGroup.hidden = recursive && !forward;
     }
     if (dagRecursiveEdgeAnimationDirectionGroup) {
         dagRecursiveEdgeAnimationDirectionGroup.hidden = !recursive;

client/src/shared/lang/translations.ts

@@ -179,8 +179,8 @@ export const translations: Translations = {
             '未勾选：原始直接归因（仅一跳前驱，默认）。勾选：因果流模式（↯）— 从焦点 token 向上追溯到信息来源。来源：prompt；高惊讶或 teacher-forced 的生成 token（MI 衰减可截断链）。传导：高置信中间 token，归因穿过。蓝边：传播份额；节点环：归因停留（解释落点处更强）。建议与「向高惊讶目标衰减归因」配合使用。DAG 上：↯ 播放焦点传播链；无焦点时 ▶ 步进重放生成过程。',
         'Direction for focus-chain batch animation when you press propagation play (↯) on the DAG with a focused token in Causal Flow Mode.':
             '因果流模式下，对已聚焦 token 在 DAG 上按传播播放（↯）时，焦点传播链分批动画的方向。',
-        'When checked, direct attribution focus also shows outgoing edges from the selected or hovered token as downstream influence. Causal Flow Mode keeps showing upstream attribution chains only.':
-            '勾选后，直接归因焦点下还会显示从选中/悬浮 token 出发的下游影响出边。因果流模式仍只显示向上游的归因链。',
+        'When checked, focus also shows outgoing edges as downstream influence (red). Direct mode: one hop. Causal Flow Mode: recursive — propagate as arrive × one-hop weight (sum at merges); display scales each source’s outs so strongest = arrive.':
+            '勾选后，焦点下额外显示下游影响出边（红）。直接模式：一跳。因果流模式：递归——传播为 arrive × 一跳边权（汇合相加）；显示时将每个源的出边缩放到最强 = arrive。',
         'Total duration or per-step simulated cost. DAG step replay (▶) divides evenly or uses a fixed per-token cost; propagation chain animation (↯) scales each frame by attribution weight.':
             '总时长或单步模拟开销。DAG 步进重放（▶）按步均分或固定单步开销；传播链动画（↯）按各层归因权重缩放每帧模拟开销。',
         'Total seconds. DAG step replay (▶) divides evenly across steps; propagation chain (↯) splits by layer weight. Saved locally; applied when you press play or select a focus node.':

client/src/shared/prediction_attribution/causal_flow/genAttributeDagEdgeRenderStrength.ts

@@ -190,3 +190,35 @@ export function buildMaxNormalizedRenderStrengthByKey(
     }
     return byKey;
 }
+
+/**
+ * 下游红边渲染：每源出边 `display = arrive × (raw / maxRaw)`，故最强出边 = arrive；
+ * 再对 display 做全表 max 归一得到 opacity。传播原值仍在 `sharesByKey`（tooltip）。
+ */
+export function buildDownstreamArriveScaledRenderStrengthByKey(
+    sharesByKey: Map<string, number>,
+    arriveById: ReadonlyMap<string, number>,
+    maxOpacity = 1,
+): Map<string, number> {
+    const maxRawBySource = new Map<string, number>();
+    for (const [key, share] of sharesByKey) {
+        if (!(share > 0) || !Number.isFinite(share)) continue;
+        const sep = key.indexOf('->');
+        if (sep <= 0) continue;
+        const src = key.slice(0, sep);
+        const prev = maxRawBySource.get(src) ?? 0;
+        if (share > prev) maxRawBySource.set(src, share);
+    }
+    const displayByKey = new Map<string, number>();
+    for (const [key, share] of sharesByKey) {
+        const sep = key.indexOf('->');
+        if (sep <= 0) continue;
+        const src = key.slice(0, sep);
+        const maxRaw = maxRawBySource.get(src) ?? 0;
+        if (maxRaw <= 0) continue;
+        const arrive = arriveById.get(src) ?? 0;
+        if (!(arrive > 0) || !Number.isFinite(arrive)) continue;
+        displayByKey.set(key, arrive * (share / maxRaw));
+    }
+    return buildMaxNormalizedRenderStrengthByKey(displayByKey, maxOpacity);
+}

client/src/shared/prediction_attribution/causal_flow/genAttributeDagFocusAttribution.ts

@@ -24,6 +24,12 @@ export type DagFocusAttributionLink = {
 export type ComputeFocusAttributionOptions = {
     maxIncomingDepth: number;
     includeDownstreamInfluence: boolean;
+    /**
+     * 下游影响出边深度：`1` = 仅焦点一跳出边；`Infinity` = 递归
+     *（传播：`arrive ×` 一跳边权，汇合 sum；显示：每源最强出边刻度 = arrive）。
+     * 仅在 `includeDownstreamInfluence` 时有效；默认 `1`。
+     */
+    maxOutgoingDepth?: number;
     allowedEdgeKeys?: ReadonlySet<string>;
     /** 与「Decay attribution to high-surprisal targets」一致；默认 false。 */
     decayAttributionToHighSurprisalTarget?: boolean;
@@ -98,8 +104,66 @@ function compareNodesByOffsetDesc<T extends DagFocusAttributionNode>(
     return nb.end - na.end;
 }
 
+/** 下游影响处理序：offset 升序（因果边单调 ⇒ 先上游后下游）。 */
+function compareNodesByOffsetAsc<T extends DagFocusAttributionNode>(
+    graph: DirectedGraph<T>,
+    a: string,
+    b: string,
+): number {
+    return compareNodesByOffsetDesc(graph, b, a);
+}
+
+/**
+ * 从焦点沿出边向前累积影响强度（非份额：汇合 sum、不归 1、不乘传导 prop）。
+ * `strength = arrive × w`（`w` = {@link directAttributionStrength}）；
+ * 渲染侧另将每源出边缩放到最强 = arrive（不改本 map）。
+ */
+function accumulateDownstreamInfluence<T extends DagFocusAttributionNode>(
+    graph: DirectedGraph<T>,
+    focusId: string,
+    focusStart: number,
+    maxOutgoingDepth: number,
+    decay: boolean,
+    allowedEdgeKeys: ReadonlySet<string> | undefined,
+    activeNodeIds: Set<string>,
+    downstreamEdgeStrengthByKey: Map<string, number>,
+    arriveById: Map<string, number>,
+): void {
+    const remainingDepthByNodeId = new Map<string, number>([[focusId, maxOutgoingDepth]]);
+
+    const processOrder = graph
+        .mapNodes((id) => id)
+        .filter((id) => (graph.getNodeAttributes(id) as T).start >= focusStart)
+        .sort((a, b) => compareNodesByOffsetAsc(graph, a, b));
+
+    for (const nodeId of processOrder) {
+        const arrive = arriveById.get(nodeId) ?? 0;
+        const remainingDepth = remainingDepthByNodeId.get(nodeId) ?? 0;
+        if (arrive < DAG_MIN_ATTRIBUTION_SHARE || remainingDepth <= 0) continue;
+
+        graph.forEachOutEdge(nodeId, (_edgeId, edgeAttrs, srcId, tgtId) => {
+            const link = edgeAttrs as unknown as DagFocusAttributionLink;
+            const edgeKey = dagLinkEndpointKey(srcId, tgtId);
+            if (allowedEdgeKeys && !allowedEdgeKeys.has(edgeKey)) return;
+
+            const edgeWeight = directAttributionStrength(link, decay);
+            const strength = arrive * edgeWeight;
+            if (strength < DAG_MIN_ATTRIBUTION_SHARE) return;
+
+            downstreamEdgeStrengthByKey.set(edgeKey, strength);
+            activeNodeIds.add(tgtId);
+            arriveById.set(tgtId, (arriveById.get(tgtId) ?? 0) + strength);
+            remainingDepthByNodeId.set(
+                tgtId,
+                Math.max(remainingDepthByNodeId.get(tgtId) ?? 0, remainingDepth - 1),
+            );
+        });
+    }
+}
+
 /**
  * 从焦点沿入边反向传播归因份额（`start ≤ focus.start` 的节点按 offset 降序单遍）。
+ * 可选：沿出边向前累积下游影响强度（见 {@link accumulateDownstreamInfluence}）。
  * 前提：每条边 `src → tgt` 满足 `src.start < tgt.start`（context 前缀 + 合成边）。
  */
 export function computeFocusAttributionState<T extends DagFocusAttributionNode>(
@@ -114,6 +178,7 @@ export function computeFocusAttributionState<T extends DagFocusAttributionNode>(
     const activeNodeIds = new Set<string>([focusId]);
     const incomingEdgeShareByKey = new Map<string, number>();
     const downstreamEdgeStrengthByKey = new Map<string, number>();
+    const downstreamArriveById = new Map<string, number>([[focusId, 1]]);
     const nodeShareById = new Map<string, number>([[focusId, 1]]);
     const remainingDepthByNodeId = new Map<string, number>([[focusId, options.maxIncomingDepth]]);
 
@@ -152,14 +217,24 @@ export function computeFocusAttributionState<T extends DagFocusAttributionNode>(
     }
 
     if (options.includeDownstreamInfluence) {
-        graph.forEachOutEdge(focusId, (_edgeId, edgeAttrs, srcId, tgtId) => {
-            const link = edgeAttrs as unknown as DagFocusAttributionLink;
-            const strength = directAttributionStrength(link, decay);
-            if (strength < DAG_MIN_ATTRIBUTION_SHARE) return;
-            downstreamEdgeStrengthByKey.set(dagLinkEndpointKey(srcId, tgtId), strength);
-            activeNodeIds.add(tgtId);
-        });
+        accumulateDownstreamInfluence(
+            graph,
+            focusId,
+            focusStart,
+            options.maxOutgoingDepth ?? 1,
+            decay,
+            options.allowedEdgeKeys,
+            activeNodeIds,
+            downstreamEdgeStrengthByKey,
+            downstreamArriveById,
+        );
     }
 
-    return { activeNodeIds, incomingEdgeShareByKey, downstreamEdgeStrengthByKey, nodeShareById };
+    return {
+        activeNodeIds,
+        incomingEdgeShareByKey,
+        downstreamEdgeStrengthByKey,
+        downstreamArriveById,
+        nodeShareById,
+    };
 }

client/src/shared/prediction_attribution/causal_flow/genAttributeDagRecursiveEdgeAnimation.ts

@@ -62,6 +62,8 @@ export type DagFocusAttributionState = {
     activeNodeIds: Set<string>;
     incomingEdgeShareByKey: Map<string, number>;
     downstreamEdgeStrengthByKey: Map<string, number>;
+    /** 下游影响传播的节点到达量（焦点为 1）；供红边渲染将每源最强出边刻度钉在 arrive。 */
+    downstreamArriveById: Map<string, number>;
     nodeShareById: Map<string, number>;
 };
 

client/src/shared/prediction_attribution/causal_flow/genAttributeDagView.ts

@@ -20,6 +20,7 @@ import {
     DAG_NODE_STROKE_OPACITY_BASE,
 } from './genAttributeDagEdgeDisplay';
 import {
+    buildDownstreamArriveScaledRenderStrengthByKey,
     buildMaxNormalizedRenderStrengthByKey,
     DAG_LIGHTNING_SLOW_MO_DEFAULT,
     DAG_LIGHTNING_THRESHOLD_TAU_DEFAULT,
@@ -645,7 +646,7 @@ export type GenAttributeDagHandle = {
     enterLightningTauPreview(): void;
     /** 结束 {@link enterLightningTauPreview}。 */
     exitLightningTauPreview(): void;
-    /** 是否在直接归因焦点上额外展示从焦点出发的下游影响出边。 */
+    /** 是否在焦点上额外展示下游影响出边（直接一跳 / 因果流递归）。 */
     setShowDownstreamInfluence(show: boolean): void;
     /** prompt 层节点是否已注入（即 {@link setPromptTokenSpans} 至少成功添加过一个节点） */
     hasPromptSpans(): boolean;
@@ -777,7 +778,7 @@ type DagLinkHighlightDisplay = {
     recursiveAttributionShare?: number;
 };
 
-/** 焦点下边的视觉规则：传播归因看“向上原因链”，直接看“一跳关系 + 可选下游影响”。 */
+/** 焦点下边的视觉规则：传播蓝边看向上原因链；可选红边看下游影响（一跳或递归）。 */
 function resolveDagLinkHighlightDisplay(
     d: DagLink,
     edgeKey: string,
@@ -895,7 +896,7 @@ export type InitGenAttributeDagViewOptions = {
     getReplayPacing?: () => DagRecursiveEdgeReplayPacing;
     /** forward 是否 slide 有 share 的 prompt 等节点；默认 `{ forwardSlideSharedNodes: false }`。 */
     getPropagationPlaybackOptions?: () => DagPropagationPlaybackOptions;
-    /** 直接归因模式下是否展示从焦点出发的下游影响出边；默认 `false`。 */
+    /** 是否展示从焦点出发的下游影响出边（直接一跳 / 因果流递归）；默认 `false`。 */
     showDownstreamInfluence?: boolean;
     /** 边 Top-P 覆盖阈值（候选池内累计份额）；默认 {@link DAG_EDGE_TOP_P_COVERAGE_DEFAULT}。 */
     edgeTopPCoverage?: number;
@@ -1652,10 +1653,20 @@ export function initGenAttributeDagView(
 
     function refreshNodeLinkHighlight(): void {
         const focusId = effectiveFocusId();
+        const propagationPlaybackPhase = recursiveEdgeAnimation.getPlaybackPhase();
+        const includeDownstreamInfluence =
+            showDownstreamInfluence &&
+            !(
+                recursiveAttributionEnabled &&
+                (recursiveEdgeAnimation.getDirection() === 'backward' ||
+                    propagationPlaybackPhase === 'playing' ||
+                    propagationPlaybackPhase === 'paused')
+            );
         const focusState = focusId
             ? computeFocusAttributionState(graph, incomingLinksByTarget, focusId, {
                 maxIncomingDepth: recursiveAttributionEnabled ? Number.POSITIVE_INFINITY : 1,
-                includeDownstreamInfluence: !recursiveAttributionEnabled && showDownstreamInfluence,
+                includeDownstreamInfluence,
+                maxOutgoingDepth: recursiveAttributionEnabled ? Number.POSITIVE_INFINITY : 1,
                 decayAttributionToHighSurprisalTarget: dagDecayAttributionToHighSurprisalTargetEnabled,
             })
             : null;
@@ -1707,9 +1718,12 @@ export function initGenAttributeDagView(
                       useAnimationIncomingHighlight ? animOverlay.incomingMaxForRender : undefined,
                   );
         const downstreamHighlightRenderByKey =
-            focusState == null
+            focusState == null || !includeDownstreamInfluence
                 ? new Map<string, number>()
-                : buildMaxNormalizedRenderStrengthByKey(focusState.downstreamEdgeStrengthByKey);
+                : buildDownstreamArriveScaledRenderStrengthByKey(
+                      focusState.downstreamEdgeStrengthByKey,
+                      focusState.downstreamArriveById,
+                  );
         grayRenderCache ??= buildGrayRenderStrengthByEdgeKey(graph, incomingLinksByTarget);
         const grayRenderByKey = grayRenderCache;
         const {
@@ -1764,7 +1778,6 @@ export function initGenAttributeDagView(
         );
         const nodeDisplay = (d: DagNode): string | null =>
             hideExcludedTokens && nodeLowVisReasonById.get(d.id) != null ? 'none' : null;
-        const propagationPlaybackPhase = recursiveEdgeAnimation.getPlaybackPhase();
         const lightningEffectEnabled = getPropagationPlaybackOptions().lightningEffect;
         const lightningPreviewActive =
             lightningEffectEnabled &&
@@ -2021,7 +2034,8 @@ export function initGenAttributeDagView(
             const incident =
                 linkFocusState != null &&
                 (linkFocusState.incomingEdgeShareByKey.has(edgeKey) ||
-                    (focusState?.downstreamEdgeStrengthByKey.has(edgeKey) ?? false));
+                    (includeDownstreamInfluence &&
+                        (focusState?.downstreamEdgeStrengthByKey.has(edgeKey) ?? false)));
             const parent = incident ? linkGFront : linkG;
             const parentNode = parent.node()!;
             if (this.parentNode !== parentNode) {

client/src/tests/prediction_attribution/genAttributeDagFocusAttribution.test.ts

@@ -191,5 +191,170 @@ console.log('3. 直接归因（一跳）不含 tool_call');
     }
 }
 
+/**
+ * F[0,1) → A[1,2) → B[2,3)
+ *          ↘ C[2,4)
+ * 传播：FA=0.4；A 出边 AB=0.5、AC=0.3 → 二跳 0.4×0.5 / 0.4×0.3（显示侧另做 per-source max 归一）
+ */
+function buildDownstreamChainFixture(): {
+    graph: DirectedGraph<DagNodeAttrs>;
+    incomingLinksByTarget: Map<string, DagLink[]>;
+    ids: { f: string; a: string; b: string; c: string };
+} {
+    const f = '0_1';
+    const a = '1_2';
+    const b = '2_3';
+    const c = '2_4';
+    const graph = new DirectedGraph<DagNodeAttrs>();
+    graph.addNode(f, mkNode(f, 'F', 0, 0, 1));
+    graph.addNode(a, mkNode(a, 'A', 1, 1, 2));
+    graph.addNode(b, mkNode(b, 'B', 2, 2, 3));
+    graph.addNode(c, mkNode(c, 'C', 3, 2, 4));
+    const incomingLinksByTarget = new Map<string, DagLink[]>();
+    addEdge(graph, incomingLinksByTarget, {
+        source: f,
+        target: a,
+        attributionShare: 0.4,
+        normalizedScore: 0.4,
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: a,
+        target: b,
+        attributionShare: 0.5,
+        normalizedScore: 0.5,
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: a,
+        target: c,
+        attributionShare: 0.3,
+        normalizedScore: 0.3,
+    });
+    return { graph, incomingLinksByTarget, ids: { f, a, b, c } };
+}
+
+console.log('4. 下游影响一跳：仅焦点出边');
+{
+    const { graph, incomingLinksByTarget, ids } = buildDownstreamChainFixture();
+    const state = computeFocusAttributionState(graph, incomingLinksByTarget, ids.f, {
+        maxIncomingDepth: 1,
+        includeDownstreamInfluence: true,
+        maxOutgoingDepth: 1,
+        decayAttributionToHighSurprisalTarget: false,
+    });
+    assert('state 非空', state != null);
+    if (state) {
+        assertClose(
+            '一跳 F→A = 0.4',
+            state.downstreamEdgeStrengthByKey.get(`${ids.f}->${ids.a}`) ?? 0,
+            0.4,
+        );
+        assert('一跳无 A→B', !state.downstreamEdgeStrengthByKey.has(`${ids.a}->${ids.b}`));
+        assert('一跳无 A→C', !state.downstreamEdgeStrengthByKey.has(`${ids.a}->${ids.c}`));
+        assertHas('active 含 A', state.activeNodeIds, ids.a);
+        assert('active 不含 B', !state.activeNodeIds.has(ids.b));
+    }
+}
+
+console.log('5. 下游影响递归：arrive × 一跳出边，汇合 sum');
+{
+    const { graph, incomingLinksByTarget, ids } = buildDownstreamChainFixture();
+    const state = computeFocusAttributionState(graph, incomingLinksByTarget, ids.f, {
+        maxIncomingDepth: Number.POSITIVE_INFINITY,
+        includeDownstreamInfluence: true,
+        maxOutgoingDepth: Number.POSITIVE_INFINITY,
+        decayAttributionToHighSurprisalTarget: false,
+    });
+    assert('state 非空', state != null);
+    if (state) {
+        assertClose(
+            'F→A = 0.4',
+            state.downstreamEdgeStrengthByKey.get(`${ids.f}->${ids.a}`) ?? 0,
+            0.4,
+        );
+        assertClose(
+            'A→B = 0.4×0.5',
+            state.downstreamEdgeStrengthByKey.get(`${ids.a}->${ids.b}`) ?? 0,
+            0.2,
+        );
+        assertClose(
+            'A→C = 0.4×0.3',
+            state.downstreamEdgeStrengthByKey.get(`${ids.a}->${ids.c}`) ?? 0,
+            0.12,
+        );
+        assertHas('active 含 B', state.activeNodeIds, ids.b);
+        assertHas('active 含 C', state.activeNodeIds, ids.c);
+    }
+}
+
+console.log('6. 下游递归多路汇合 sum；高惊讶只淡化入边不挡外扩');
+{
+    // F → A (0.5), F → A2 (0.5), A→B (1), A2→B (1)；再 B→C (0.8)
+    // arrive(B)=0.5+0.5=1；B→C = 1×0.8=0.8（即便 B 高惊讶也不乘 prop）
+    const f = '0_1';
+    const a = '1_2';
+    const a2 = '1_3';
+    const b = '3_4';
+    const c = '4_5';
+    const graph = new DirectedGraph<DagNodeAttrs>();
+    graph.addNode(f, mkNode(f, 'F', 0, 0, 1));
+    graph.addNode(a, mkNode(a, 'A', 1, 1, 2));
+    graph.addNode(a2, mkNode(a2, 'A2', 2, 1, 3));
+    const bNode = mkNode(b, 'B', 3, 3, 4);
+    bNode.dagTargetProb = 0.01; // 高惊讶
+    graph.addNode(b, bNode);
+    graph.addNode(c, mkNode(c, 'C', 4, 4, 5));
+    const incomingLinksByTarget = new Map<string, DagLink[]>();
+    addEdge(graph, incomingLinksByTarget, {
+        source: f,
+        target: a,
+        attributionShare: 0.5,
+        mutualInformationRatio: 1,
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: f,
+        target: a2,
+        attributionShare: 0.5,
+        mutualInformationRatio: 1,
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: a,
+        target: b,
+        attributionShare: 1,
+        mutualInformationRatio: 0.2, // 入 B 淡化
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: a2,
+        target: b,
+        attributionShare: 1,
+        mutualInformationRatio: 0.2,
+    });
+    addEdge(graph, incomingLinksByTarget, {
+        source: b,
+        target: c,
+        attributionShare: 0.8,
+        mutualInformationRatio: 1,
+    });
+
+    const state = computeFocusAttributionState(graph, incomingLinksByTarget, f, {
+        maxIncomingDepth: Number.POSITIVE_INFINITY,
+        includeDownstreamInfluence: true,
+        maxOutgoingDepth: Number.POSITIVE_INFINITY,
+        decayAttributionToHighSurprisalTarget: true,
+    });
+    assert('state 非空', state != null);
+    if (state) {
+        // A→B = 0.5×(1×0.2)=0.1；A2→B 同理 0.1；arrive(B)=0.2
+        assertClose('A→B faded', state.downstreamEdgeStrengthByKey.get(`${a}->${b}`) ?? 0, 0.1);
+        assertClose('A2→B faded', state.downstreamEdgeStrengthByKey.get(`${a2}->${b}`) ?? 0, 0.1);
+        // B→C = arrive(B)×0.8×1 = 0.2×0.8 = 0.16（不因 B 高惊讶再乘 prop）
+        assertClose(
+            'B→C = sum(arrive)×out，不乘 prop(B)',
+            state.downstreamEdgeStrengthByKey.get(`${b}->${c}`) ?? 0,
+            0.16,
+        );
+        assertClose('arrive(B) = 0.2', state.downstreamArriveById.get(b) ?? 0, 0.2);
+    }
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

client/src/tests/prediction_attribution/genAttributeDagPropagationPlayback.test.ts

@@ -523,6 +523,7 @@ console.log('6. createDagRecursiveEdgeAnimationController pause/resume');
         activeNodeIds: new Set(['p', 'a', 'b', focusId]),
         incomingEdgeShareByKey: incoming,
         downstreamEdgeStrengthByKey: new Map<string, number>(),
+        downstreamArriveById: new Map<string, number>(),
         nodeShareById: nodeShare,
     };
     const ctx = {
@@ -593,6 +594,7 @@ console.log('7. backward skips first prompt region slide');
             activeNodeIds: new Set(['p', 'a', 'b', focusId]),
             incomingEdgeShareByKey: incoming,
             downstreamEdgeStrengthByKey: new Map<string, number>(),
+            downstreamArriveById: new Map<string, number>(),
             nodeShareById: nodeShare,
         };
         const ctx = {