test(agent-workspace): cover repeated snippet section anchoring

Jacobinwwey · Jacobinwwey · commit ee1f568555c5 · 2026-07-06T21:30:22.000+08:00
diff --git a/Knowledge_Base/ragrepeatedspan/repeated snippet target section.md b/Knowledge_Base/ragrepeatedspan/repeated snippet target section.md
@@ -0,0 +1,15 @@
+# Repeated Snippet Target Section
+
+Repeated snippet target probe validates source anchoring when the same clause appears in multiple sections.
+
+## Repeated Snippet Distractor Section
+
+The repeated snippet uses shared repeated wording.
+
+Distractor section context belongs to the first occurrence and must not guide the target answer.
+
+## Repeated Snippet Target Section
+
+The repeated snippet uses shared repeated wording.
+
+Target section context says the second occurrence controls the answer.
diff --git a/docs/diataxis/en/explanation/development-progress-dashboard.md b/docs/diataxis/en/explanation/development-progress-dashboard.md
@@ -62,6 +62,7 @@ Fresh implementation evidence in this slice:
 - The runtime probe `conflicting_multi_document_evidence_probe_en`, backed by `Knowledge_Base/ragmulticonflict`, now verifies that contradictory `+/-0.10 mm` and `+/-0.50 mm` calibration-tolerance facts across two scoped documents produce a cross-document `conflict` fragment, stay visible in the one public answer, and degrade under `context_assembly`.
 - The runtime probe `full_document_scan_remote_conflict_probe_en`, backed by `Knowledge_Base/ragfullscan`, now verifies the corrected source-boundary rule: the local paragraph window is not the maximum range. Two selected documents are read in full, remote appendix facts outside the matched opening spans are scanned for structured conflict evidence, and only the budgeted `RagContextPack` is capped before model-visible answer composition.
 - Focused provenance tests now verify that repeated snippet text does not force the first textual occurrence when offsets are stale. If an offset candidate does not contain the evidence snippet but the line-range candidate does, `evidenceContextAssembler.ts` uses the line provenance to select the intended source block and parent section.
+- The runtime probe `repeated_snippet_target_section_probe_en`, backed by `Knowledge_Base/ragrepeatedspan`, now verifies the same repeated-snippet risk at the conversation/release layer: the selected source document is still read as a full document and retained in trace, but the one public answer prefers clauses from the target section's leaf heading and does not leak the distractor section context. The section-aware filter is disabled for compare queries so existing two-sided material answers remain forward-compatible.
 - Focused hard-negative tests now verify that an unavailable graph-neighbor source window is not treated as complete graph evidence merely because a graph-neighbor direct span or title exists. `evidenceContextAssembler.ts` records `source_resolver_returned_no_content:graph_neighbor_support`, and `ragSufficiencyJudge.ts` keeps the answer `borderline/partial_coverage` with `graph_neighbor_evidence_missing` until grounded neighbor source context is available.
 - Focused graph-window ambiguity tests now verify that compare intent filters high-confidence `sequence` / `prerequisite` successors when `contrast` / `analogy` neighbors exist, while still failing open to structural successors when the graph has no compare-aligned neighbor. The runtime verifier now also asserts the graph diagnostics for the `graphintent` compare probes: at least two intent-aligned successor candidates, at least one intent-misaligned successor candidate, and no misaligned-successor fallback.
 
diff --git a/docs/diataxis/zh/explanation/development-progress-dashboard.md b/docs/diataxis/zh/explanation/development-progress-dashboard.md
@@ -127,6 +127,7 @@
 - `conflicting_multi_document_evidence_probe_en` 现在由 `Knowledge_Base/ragmulticonflict` 支撑，验证两个 scoped 文档中的 `+/-0.10 mm` 与 `+/-0.50 mm` calibration-tolerance 矛盾会进入跨文档 `conflict` RAG role，保留在单条公开回答中，并保持 `borderline/conflict` 降级。
 - `full_document_scan_remote_conflict_probe_en` 现在由 `Knowledge_Base/ragfullscan` 支撑，验证修正后的 source-boundary 规则：局部段落窗口不是最大范围。两个被选文档会先完整读入，命中开头段落之外的远端 appendix 事实也会参与结构化冲突扫描；真正被硬限制的是进入公开回答编排前的有界 `RagContextPack`。
 - focused provenance 测试现在验证 repeated snippet 不会在 offset 陈旧时强制落到第一处文本命中。如果 offset 候选不包含 evidence snippet，而 line-range 候选包含它，`evidenceContextAssembler.ts` 会使用 line provenance 选择正确 source block 与 parent section。
+- `repeated_snippet_target_section_probe_en` 现在由 `Knowledge_Base/ragrepeatedspan` 支撑，把同类 repeated snippet 风险提升到 conversation / release 层验证：被选源文档仍按完整文档读入并保留在 trace 中，但单条公开回答会优先选择 target section 叶子 heading 下的 clause，不会泄漏 distractor section 的上下文。该 section-aware 过滤对 compare query 关闭，避免破坏既有双边材料对比回答的向前兼容性。
 
 后续推进方向：
 
diff --git a/docs/plans/2026-07-05-001-feat-rse-document-augmented-rag-plan.md b/docs/plans/2026-07-05-001-feat-rse-document-augmented-rag-plan.md
diff --git a/src/learning/KnowledgeWorkspaceConversationRegression.test.ts b/src/learning/KnowledgeWorkspaceConversationRegression.test.ts
@@ -272,6 +272,25 @@ function buildRegressionDocuments() {
                 'The calibration tolerance is +/-0.50 mm in the remote field appendix.',
             ].join('\n'),
         },
+        {
+            documentId: 'doc_repeated_snippet_target_probe',
+            sourcePath: 'Knowledge_Base/ragrepeatedspan/repeated snippet target section.md',
+            language: 'en',
+            workspaceId: 'ragrepeatedspan',
+            corpusId: 'ragrepeatedspan',
+            content: [
+                '# Repeated Snippet Target Section',
+                'Repeated snippet target probe validates source anchoring when the same clause appears in multiple sections.',
+                '',
+                '## Repeated Snippet Distractor Section',
+                'The repeated snippet uses shared repeated wording.',
+                'Distractor section context belongs to the first occurrence and must not guide the target answer.',
+                '',
+                '## Repeated Snippet Target Section',
+                'The repeated snippet uses shared repeated wording.',
+                'Target section context says the second occurrence controls the answer.',
+            ].join('\n'),
+        },
         {
             documentId: 'doc_graphintent_brittle_glass_vessel',
             sourcePath: 'Knowledge_Base/graphintent/brittle glass vessel.md',
@@ -669,6 +688,20 @@ describe('KnowledgeWorkspaceConversationRegression', () => {
                         ]),
                     }),
                 }),
+                expect.objectContaining({
+                    id: 'repeated_snippet_target_section_probe_en',
+                    expected: expect.objectContaining({
+                        minCitations: 1,
+                        requiredRagRoles: expect.arrayContaining(['direct_support', 'parent_context']),
+                        acceptedRagSufficiencyStatuses: expect.arrayContaining(['sufficient', 'borderline']),
+                        answerMustContain: expect.arrayContaining([
+                            'Target section context says the second occurrence controls the answer',
+                        ]),
+                        answerMustNotContain: expect.arrayContaining([
+                            'Distractor section context belongs to the first occurrence',
+                        ]),
+                    }),
+                }),
             ])
         );
     });
diff --git a/src/learning/KnowledgeWorkspaceConversationRegression.ts b/src/learning/KnowledgeWorkspaceConversationRegression.ts
@@ -510,6 +510,34 @@ export const KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressio
             requireScopedDocumentIds: false,
         },
     },
+    {
+        id: 'repeated_snippet_target_section_probe_en',
+        description: 'A repeated snippet query should use the target section occurrence instead of leaking the distractor section context.',
+        preloadTargets: ['ragrepeatedspan'],
+        activeTarget: 'ragrepeatedspan',
+        query: 'what is repeated snippet target section?',
+        expected: {
+            minCitations: 1,
+            scopeSource: 'explicit_request',
+            acceptedAnswerReleaseDecisions: ['release', 'revise'],
+            plannerTitleLikeQueries: ['repeated snippet target section'],
+            primarySourcePath: 'Knowledge_Base/ragrepeatedspan/repeated snippet target section.md',
+            answerMustContain: [
+                'Target section context says the second occurrence controls the answer',
+                'shared repeated wording',
+            ],
+            answerMustNotContain: [
+                'No scoped knowledge points matched',
+                'retrieval_candidates_below_threshold',
+                'Distractor section context belongs to the first occurrence',
+            ],
+            ragSourceBoundary: 'full_document',
+            requiredRagRoles: ['direct_support', 'parent_context'],
+            acceptedRagSufficiencyStatuses: ['sufficient', 'borderline'],
+            expectedRagDeterministic: true,
+            expectedRagLlmJudgeUsed: false,
+        },
+    },
     {
         id: 'contextbudget_source_window_truncation_en',
         description: 'A long scoped note should read the full source document while keeping the model-visible RAG pack budgeted.',
diff --git a/src/learning/answerReleaseReview.ts b/src/learning/answerReleaseReview.ts
@@ -945,6 +945,55 @@ function ragClauseAlreadyCovered(candidate: string, selectedClauses: string[]):
     });
 }
 
+const RAG_PUBLIC_QUERY_STOPWORDS = new Set([
+    'a', 'about', 'an', 'and', 'are', 'as', 'at', 'be', 'between', 'by', 'compare',
+    'contrast', 'difference', 'differences', 'do', 'does', 'from', 'how',
+    'in', 'is', 'it', 'me', 'of', 'on', 'or', 'plan', 'step', 'steps', 'tell', 'the', 'to', 'versus', 'vs', 'what',
+    'which', 'with',
+]);
+
+function extractRagPublicQueryTerms(message: string): string[] {
+    const terms = (String(message || '').toLowerCase().match(/[\p{L}\p{N}]+/gu) || [])
+        .map((term) => term.trim())
+        .filter((term) => term.length >= 2 && !RAG_PUBLIC_QUERY_STOPWORDS.has(term));
+    return Array.from(new Set(terms));
+}
+
+function isRagPublicCompareQuery(message: string): boolean {
+    const normalized = normalizeWhitespace(String(message || '').toLowerCase());
+    return /\b(?:compare|contrast|vs|versus|difference|differences)\b/u.test(normalized)
+        || normalized.includes('区别')
+        || normalized.includes('对比');
+}
+
+function collectRagPublicClauseQueryTerms(value: string, queryTerms: string[]): Set<string> {
+    const lower = String(value || '').toLowerCase();
+    return new Set(queryTerms.filter((term) => lower.includes(term)));
+}
+
+function collectRagPublicLeafHeadingQueryTerms(fragment: RagEvidenceFragment, queryTerms: string[]): Set<string> {
+    const headingPath = Array.isArray(fragment.headingPath) ? fragment.headingPath : [];
+    const leafHeading = normalizeWhitespace(String(headingPath[headingPath.length - 1] || ''));
+    if (!leafHeading) {
+        return new Set();
+    }
+    return collectRagPublicClauseQueryTerms(leafHeading, queryTerms);
+}
+
+type RagPublicEvidenceClauseSelectionOptions = {
+    queryTerms?: string[];
+    useLeafHeadingScore?: boolean;
+    preferBestLeafHeadingMatch?: boolean;
+    minimumLeafHeadingTermCount?: number;
+};
+
+type RagPublicEvidenceClauseCandidate = {
+    clause: string;
+    queryTerms: Set<string>;
+    headingQueryTerms: Set<string>;
+    order: number;
+};
+
 function splitRagPublicEvidenceClauses(fragment: RagEvidenceFragment): string[] {
     const title = normalizeWhitespace(String(fragment.title || '').trim());
     let cleaned = normalizeWhitespace(
@@ -999,22 +1048,55 @@ function collectRagPublicEvidenceClauses(
     context: AnswerReleaseReviewContext,
     roles: Set<RagEvidenceRole>,
     limit: number,
-    excludedClauses: string[] = []
+    excludedClauses: string[] = [],
+    options: RagPublicEvidenceClauseSelectionOptions = {}
 ): string[] {
     const clauses: string[] = [];
     const selected = [...excludedClauses];
+    const queryTerms = Array.isArray(options.queryTerms) ? options.queryTerms : [];
+    const candidates: RagPublicEvidenceClauseCandidate[] = [];
+    let order = 0;
     collectRagRoleFragments(context, roles).forEach((fragment) => {
-        if (clauses.length >= limit) {
-            return;
-        }
+        const headingQueryTerms = collectRagPublicLeafHeadingQueryTerms(fragment, queryTerms);
         splitRagPublicEvidenceClauses(fragment).forEach((clause) => {
-            if (clauses.length >= limit || ragClauseAlreadyCovered(clause, selected)) {
-                return;
-            }
-            selected.push(clause);
-            clauses.push(clause);
+            candidates.push({
+                clause,
+                queryTerms: collectRagPublicClauseQueryTerms(clause, queryTerms),
+                headingQueryTerms,
+                order,
+            });
+            order += 1;
         });
     });
+    const maxHeadingTermCount = candidates.reduce(
+        (max, candidate) => Math.max(max, candidate.headingQueryTerms.size),
+        0
+    );
+    const minimumLeafHeadingTermCount = Math.max(0, Math.floor(Number(options.minimumLeafHeadingTermCount || 0)));
+    const thresholdCandidates = minimumLeafHeadingTermCount > 0
+        ? candidates.filter((candidate) => candidate.headingQueryTerms.size >= minimumLeafHeadingTermCount)
+        : candidates;
+    const rankedCandidates = (
+        options.preferBestLeafHeadingMatch && maxHeadingTermCount > 0
+            ? thresholdCandidates.filter((candidate) => candidate.headingQueryTerms.size === maxHeadingTermCount)
+            : thresholdCandidates
+    ).sort((left, right) => {
+        const leftHeadingScore = options.useLeafHeadingScore ? left.headingQueryTerms.size : 0;
+        const rightHeadingScore = options.useLeafHeadingScore ? right.headingQueryTerms.size : 0;
+        const leftScore = left.queryTerms.size * 4 + leftHeadingScore * 6;
+        const rightScore = right.queryTerms.size * 4 + rightHeadingScore * 6;
+        if (rightScore !== leftScore) {
+            return rightScore - leftScore;
+        }
+        return left.order - right.order;
+    });
+    rankedCandidates.forEach((candidate) => {
+        if (clauses.length >= limit || ragClauseAlreadyCovered(candidate.clause, selected)) {
+            return;
+        }
+        selected.push(candidate.clause);
+        clauses.push(candidate.clause);
+    });
     return clauses;
 }
 
@@ -1028,12 +1110,19 @@ function buildRagGroundedRevisionAnswer(context: AnswerReleaseReviewContext): st
         context.graphContext?.anchorTitle || '',
         ...(context.ragContextPack?.fragments || []).slice(0, 4).map((fragment) => fragment.text),
     ].join(' '));
+    const queryTerms = extractRagPublicQueryTerms(context.message);
+    const isCompareQuery = isRagPublicCompareQuery(context.message);
     const directClauses = collectRagPublicEvidenceClauses(context, new Set(['direct_support']), 1);
     const documentClauses = collectRagPublicEvidenceClauses(
         context,
         new Set(['parent_context', 'adjacent_context']),
         2,
-        directClauses
+        directClauses,
+        {
+            queryTerms,
+            useLeafHeadingScore: !isCompareQuery,
+            preferBestLeafHeadingMatch: !isCompareQuery,
+        }
     );
     const hasConflictEvidence = context.ragSufficiencyReview?.degradationState === 'conflict'
         || (context.ragSufficiencyReview?.reasons || []).some((reason) => String(reason || '').includes('conflict_evidence_present'));
@@ -1049,7 +1138,15 @@ function buildRagGroundedRevisionAnswer(context: AnswerReleaseReviewContext): st
         context,
         new Set(['graph_neighbor_support']),
         1,
-        [...directClauses, ...documentClauses, ...conflictClauses]
+        [...directClauses, ...documentClauses, ...conflictClauses],
+        isCompareQuery
+            ? {}
+            : {
+                queryTerms,
+                useLeafHeadingScore: true,
+                preferBestLeafHeadingMatch: true,
+                minimumLeafHeadingTermCount: queryTerms.length >= 3 ? queryTerms.length : 0,
+            }
     );
     const fallback = normalizeWhitespace(String(
         context.knowledgePoints[0]?.evidenceSnippet
diff --git a/src/learning/conversationComposer.ts b/src/learning/conversationComposer.ts
