Paper deep dive
Don't Scroll Back: Missing-Evidence Memory for Streaming Dialogue Summarization
Hyangsuk Min, Hwanjun Song
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 89%
Last extracted: 8/12/2026, 3:17:07 AM
Summary
The paper introduces 'streaming dialogue summarization,' a task requiring systems to summarize recent dialogue windows using selective memory from unbounded history under a fixed budget. The authors identify that the core challenge is recovering 'missing evidence' (contextual gaps) rather than just accessing history. They propose ReMEMBER, a framework that uses gap-conditioned retrieval and chunk refinement to extract evidence-dense memory. Experiments show ReMEMBER improves memory recall and gap-resolution completeness over baselines on dialogues up to 160K tokens.
Entities (12)
Relation Signals (10)
ReMEMBER → usescomponent → Gap-Conditioned Evidence Retrieval
confidence 95% · ReMEMBER operates in two stages: (i) Gap-conditioned evidence retrieval
ReMEMBER → usescomponent → Gap-Conditioned Chunk Refinement
confidence 95% · (ii) Gap-conditioned chunk refinement
ReMEMBER → improvesmetric → Memory Recall
confidence 90% · ReMEMBER improves memory recall and gap-resolution completeness over memory construction baselines
ReMEMBER → improvesmetric → Gap-Resolution Completeness
confidence 90% · ReMEMBER improves memory recall and gap-resolution completeness over memory construction baselines
Gap-Conditioned Evidence Retrieval → usesmodel → Qwen3-Embedding-0.6B
confidence 88% · Dense retrieval uses Qwen3-Embedding-0.6B (Zhang et al., 2025)
Gap-Conditioned Evidence Retrieval → usesmodel → Qwen3.5-4b
confidence 88% · We use Qwen3.5-4B (Qwen Team, 2026a) as the default for gap detection
Streaming Dialogue Summarization → evaluatedon → EverMemBench
confidence 85% · 15 workplace collaborative dialogues from EverMemBench (Hu et al., 2026)
Streaming Dialogue Summarization → evaluatedon → LoCoMo
confidence 85% · We source 35 long dialogues from chit-chat and workplace domains across three datasets (20 chit-chat from LoCoMo
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Users of modern platforms repeatedly need summaries of recent dialogue, but the window rarely contains enough context to be interpreted on its own. We formalize this setting as streaming dialogue summarization, where a system must summarize a current window using selective memory from an unbounded history under a fixed budget. We show that the central challenge is not how much history is accessed, but whether memory recovers the evidence that the current window presupposes. We construct a benchmark and evaluation protocol that separately assesses whether memory contains gap-resolving evidence and whether the generated summary reflects it. We propose ReMEMBER, a missing-evidence memory framework that conditions retrieval on unresolved window dependencies and refines retrieved chunks into evidence-dense memory under a fixed budget. Experiments on dialogues with histories up to 160K tokens show that ReMEMBER improves memory recall and gap-resolution completeness over memory construction baselines under the same budget.
Tags
Links
- Source: https://arxiv.org/abs/2608.09043v1
- Canonical: https://arxiv.org/abs/2608.09043v1
Trouble viewing inline? Open PDF directly →
Full Text
116,267 characters extracted from source content.
Expand or collapse full text
Don’t Scroll Back: Missing-Evidence Memory for Streaming Dialogue Summarization Hyangsuk Min, Hwanjun Song KAIST Users of modern platforms repeatedly need summaries of recent dialogue, but the window rarely contains enough context to be interpreted on its own. We formalize this setting as streaming dialogue summarization, where a system must summarize a current window using selective memory from an unbounded history under a fixed budget. We show that the central challenge is not how much history is accessed, but whether memory recovers the evidence that the current window presupposes. We construct a benchmark and evaluation protocol that separately assesses whether memory contains gap-resolving evidence and whether the generated summary reflects it. We propose ReMEMBER, a missing-evidence memory framework that conditions retrieval on unresolved window dependencies and refines retrieved chunks into evidence-dense memory under a fixed budget. Experiments on dialogues with histories up to 160K tokens show that ReMEMBER improves memory recall and gap-resolution completeness over memory construction baselines under the same budget. Date: Aug 10, 2026 Correspondence: Hwanjun Song at songhwanjun@kaist.ac.kr First Author: Hyangsuk Min at hyangsuk.min@kaist.ac.kr 1 Introduction Modern communication platforms, such as message apps (e.g., WhatsApp, WeChat) and collaborative workspaces (e.g., Slack, MS Teams), generate continuous streams of multi-turn dialogues (Yi et al., 2025; Kirstein et al., 2025; Deshpande et al., 2025). Users rarely seek a global summary, and instead repeatedly need summaries of recent segments (Wang et al., 2024; Ghebriout et al., 2025; Wu et al., 2025) to catch up on recent discussions or decisions. We refer to this as streaming dialogue summarization. The core challenge is that the current window is seldom self-contained. Speakers rely on shared history, leaving pronouns without antecedents, entities without attributes, and decisions without rationales. Summarizing the window alone yields ungrounded fragments, while resolving these dependencies requires retrieving evidence from earlier turns under a strict budget. Existing dialogue summarization, however, is largely designed under a closed-dialogue assumption (Zhu et al., 2025b; Jin et al., 2025), where the full conversation is available and a single global summary is produced. To scale to long dialogues, prior methods adopt either incremental summarization (Wu et al., 2025; Wang et al., 2025), which updates a running summary as new turns arrive, or hierarchical summarization (Kim and Kim, 2025; Li et al., 2025b; Ou and Lapata, 2025), which summarizes small segments independently and then merges them. While effective for constructing a global dialogue summary, they are misaligned with streaming scenarios. The former attenuates earlier context through repeated compression, while the latter favors global abstraction and discards the fine-grained evidence needed to interpret a specific window. Neither preserves the prior context that resolves dependencies in the current window. Figure 1: Context utilization in streaming dialogue summarization. Local-Only leaves contextual dependencies unresolved ( red) and Full-Context introduces irrelevant history ( gray). Selective Memory addresses both by retaining only necessary prior evidence for a self-contained summary ( green). One might simply feed the entire dialogue history to recover the missing context. In practice, however, histories routinely span tens to hundreds of thousands of tokens (Lee et al., 2025a), where this approach is computationally prohibitive and unreliable due to well-known long-context pathologies, including lost-in-the-middle effects (Liu et al., 2024a; Song et al., 2026), needle-in-a-haystack failures (Lee et al., 2025b), and inference overhead (Sun et al., 2025). As Figure 1 illustrates, neither full-context nor local-only summarization suffices. The central challenge of streaming dialogue summarization is thus one of memory, that is, selectively recovering the past context that the current window depends on, under a strict memory budget. To diagnose this challenge, we examine three representative memory paradigms, recency-based, summarization-based, and retrieval-based (Liu et al., 2024b; Wu et al., 2025; Li et al., 2025b). Our analysis identifies retrieval as the strongest existing paradigm, since it preserves explicit historical evidence and selects past turns relevant to the current window. Yet, even retrieval reveals two fundamental bottlenecks under streaming settings. On the construction side, retrieval is driven by what the window already expresses, while the memory it actually needs is defined by what the window leaves unresolved. On the utilization side, retrieved chunks mix resolving evidence with neighboring turns, repetitions, and topic drift, lowering evidence density under a fixed memory budget. In response, we propose ReMEMBER (Retrieving Missing Evidence Memory By Elicited Recall), a context-gap-centered memory framework for streaming dialogue summarization. ReMEMBER operates in two stages: (i) Gap-conditioned evidence retrieval, which elicits unresolved dependencies in the current window and issues targeted queries to retrieve historical chunks that resolve what standard retrieval overlooks; and (i) Gap-conditioned chunk refinement, which reduces memory noise by identifying the most relevant turn within each retrieved chunk and retaining only those turns within a fixed memory budget. This shifts memory construction from similarity-based chunk retrieval to evidence-dense memory construction. Memory stores not history that resembles the window, but evidence that completes it. Experiments on long-context chit-chat and workplace dialogues spanning up to 160K tokens show that ReMEMBER improves memory recall and gap-resolution completeness over recency-, summarization-, and retrieval-based memory baselines under the same budget. Our main contributions are summarized as: (1) We introduce streaming dialogue summarization as a new task with a benchmark that separately evaluates memory evidence and summary reflection; (2) We analyze representative memory paradigms and identify two bottlenecks of retrieval-based memory in streaming settings: similarity-driven construction and noisy memory utilization; (3) We propose ReMEMBER, a missing-evidence memory construction framework using gap-conditioned retrieval and turn-level chunk refinement to extract resolving evidence under a fixed budget; (4) We show that ReMEMBER improves memory recall and gap-resolution completeness over memory construction baselines, with consistent gains up to 160K tokens histories. 2 Related Work Long Dialogue Tasks. Long dialogue research studies how models use information when conversations exceed a single context window. Existing work includes multi-session response generation (Xu et al., 2022; Chen et al., 2025; Liu et al., 2025), which predicts the next utterance from accumulated history, long-dialogue understanding such as QA or entity tracking over a complete conversation (Kim et al., 2024a; Maharana et al., 2024; Bai et al., 2025; Lee et al., 2025a), and conversational search, which rewrites prior turns into explicit retrieval queries (Yoon et al., 2025; Zhu et al., 2025a). Streaming dialogue summarization departs from these settings in two respects. No retrieval target is specified, and the model must identify what the current window leaves unresolved. The output is not a response to a question but a coherent completion of the window, rendering its content interpretable rather than answering it. Dialogue Summarization. Dialogue summarization initially focused on compressing dialogue-specific structures, including multi-turn dependencies, speaker roles, topic shifts, and discourse relations (Tang et al., 2022; Jia et al., 2023; Gao et al., 2023b; Lin et al., 2023; Xiao et al., 2024; Yi et al., 2025). For longer dialogues, prior work scales summarization through incremental updates of a running summary (Hwang et al., 2024; Ravaut et al., 2024) or hierarchical compression of segmented chunks (Zhu et al., 2020; Li et al., 2021; Zhang et al., 2021). Query-focused and instructive dialogue summarization assumes an explicit information need is given with the input (Zhong et al., 2021; Wang et al., 2023a). However, these methods are largely formulated in closed settings, where the complete dialogue is available and the output is a global summary. This assumption does not specify which past information is necessary for interpreting a particular target window, making it insufficient for streaming dialogue summarization. Long-Context Memory Construction. Long-context memory modeling selects or compresses past information. Summarization-based memory maintains compact histories through recursive or bounded summaries (Wang et al., 2025; 2026), but compression may remove evidence needed for local contextual gaps. Retrieval-based memory fetches relevant past utterances (Zhong et al., 2024; Tan et al., 2025; Pan et al., 2025; Li et al., 2025a), but high-recall retrieval can introduce irrelevant or redundant context. Intent- and goal-driven memory improves selectivity through missing slots or user-centric needs (Du et al., 2026; Yan et al., 2026), but targets agent response generation rather than contextual evidence construction for summarization. Structured memory organizes history through timelines or self-questioning (Ong et al., 2025; Yang et al., 2026), but is optimized for general context management. These methods motivate long-history memory construction, but they do not construct evidence for resolving target-window gaps. Query Decomposition for Retrieval. Retrieval-oriented query reformulation improves evidence access by rewriting underspecified or complex inputs into explicit retrieval queries (Elgohary et al., 2019; Yoon et al., 2025; Zhu et al., 2025a). Related methods also use generated queries or hypothetical documents to guide retrieval (Mao et al., 2021; Gao et al., 2023a; Wang et al., 2023b). ReMEMBER shares the goal of targeted retrieval, but differs in its trigger and target. It is triggered by discourse incompleteness in the current window, and its queries specify non-hypothetical evidence needs for missing prior dialogue context. This distinction matters because streaming summaries must recover referents, prior states, and rationales from earlier turns rather than infer plausible answers. 3 Streaming Dialogue Summarization: Formulation and Evaluation In the absence of a formal task definition and dedicated benchmark for streaming dialogue summarization, we present the problem formulation (Section 3.1), benchmark construction (Section 3.2), and evaluation metrics (Section 3.3). 3.1 Problem Formulation We formulate streaming dialogue summarization as a sequential task over an utterance stream. At each step t, the model observes a current window tW_t of recent utterances, while all preceding utterances form the accumulated history ℋtH_t. The goal is to generate a self-contained summary of tW_t by leveraging history ℋtH_t. The summary reflects the salient utterances within tW_t. A subset of these salient utterances is independently comprehensible. The interpretation of the remaining salient utterances strictly depends on prior context in ℋtH_t. This dependence introduces contextual gaps. Resolving such gaps necessitates retrieving missing evidence from ℋtH_t. The history ℋtH_t grows unboundedly over time, rendering exhaustive access computationally impractical. Therefore, the model must construct and maintain a memory module ℳtM_t. Instead of storing all past interactions, ℳtM_t extracts selectively and preserves the critical evidence necessary to resolve contextual gaps. The success of the task is determined by how effectively ℳtM_t provides the missing context needed to construct summary StS_t. 3.2 Benchmark Construction Streaming dialogue summarization requires utterance-level grounding over long-term dialogue histories, which existing dialogue summarization benchmarks generally lack. Without links between history-dependent utterances in tW_t and resolving evidence in ℋtH_t, we cannot assess whether memory is adequate or whether the summary is self-contained. We therefore construct a benchmark with explicit utterance–evidence links. Streaming Dialogue Data. We source 35 long dialogues from chit-chat and workplace domains across three datasets (20 chit-chat from LoCoMo (Maharana et al., 2024) and REALTALK (Lee et al., 2025a); 15 workplace collaborative dialogues from EverMemBench (Hu et al., 2026)). The two domains are selected because workplace dialogues sustain a single topic across sequential agendas, concentrating evidence contiguously in ℋtH_t, whereas chit-chat dialogues shift topics frequently, dispersing it discontinuously. Each dialogue is segmented into 1,024-token windows, each approximating five minutes of conversation, where ℋtH_t comprises all preceding utterances. Windows with |ℋt|<|H_t|< 7K tokens or entirely self-contained salient utterances are excluded. The resulting 1,079 candidates span ℋtH_t lengths of 7K to 160K tokens, ensuring diversity in history length. From these, 900 instances are sampled with domain stratification, reflecting that workplace dialogues are on average ten times longer. Detailed statistics are provided in Appendix A.1. Gap Annotation. Evaluating whether a generated summary is contextually self-contained requires two references. Salient utterances define the current-window content to preserve, and contextual gaps specify the missing historical information needed to make history-dependent utterances self-contained. Together, they serve as ground truth for memory adequacy and summary quality. A contextual gap is annotated only when incompleteness stems from missing prior context. Following completeness-related error types in prior dialogue summarization studies (Liu et al., 2021; Tang et al., 2022; Zhu et al., 2023; Kirstein et al., 2024), we define three history-resolvable gap types. (i) Referential gaps denote missing antecedents of pronouns, mentions, or discourse references. (i) Attribute gaps refer to missing states, preferences, or entity properties. (i) Relational gaps encompass missing causal, logical, or discourse-level relations. Each history-dependent salient utterance receives one representative gap, resolved by one or more evidence utterances from ℋH. Appendix A.2 provides definitions and examples. Salient utterances and contextual gaps are constructed through a five-stage LLM-assisted annotation pipeline, detailed in Appendix A.3. Each stage employs three independent LLMs from distinct model families. Outputs are retained only by majority agreement (Kim et al., 2024b; Lee et al., 2024; Thakur et al., 2025). This design reduces single-family dependence and yields a reproducible reference standard for comparing memory construction methods. Each retained gap records the target salient utterance, gap type, resolving evidence utterances from history, and resolution statement. The final benchmark instance pairs the current window and accumulated history with the reference salient utterances and contextual gaps. 3.3 Evaluation Metrics Summary quality alone is insufficient to evaluate streaming summarization, as it cannot distinguish memory-grounded gap resolution from confabulated context. We therefore evaluate two axes, memory quality via memory recall, and summary quality measured by faithfulness, conciseness, and completeness (Song et al., 2024; Min et al., 2025). To isolate the effect of memory on summarization, completeness is decomposed into window completeness and gap-resolution completeness. All metrics are detailed in Appendix B. Memory Recall. Memory quality is assessed independently of the generated summary, as evidence recovery and summary generation are distinct failure modes. For each annotated contextual gap, we assign a binary label indicating whether the memory satisfies the corresponding resolution statement. Memory recall is the proportion of positively labeled gaps, measuring how completely the memory module preserves the historical basis for self-contained summarization. Window Completeness. Independent of memory, a summary must also cover the salient content observable in the current window. For each salient utterance, we check whether its content appears in the summary. Window completeness is the fraction of salient utterances covered, measuring how well the summary reflects the current window, regardless of memory-related failures. Gap-Resolution Completeness. Recovered evidence is only meaningful if subsequently reflected in the summary. Among gaps resolved by memory, we check whether the resolution is expressed in the summary. Gap-resolution completeness is the fraction of memory-resolved gaps reflected in the summary, measuring how well the model utilizes recovered evidence in generation. 4 Methodology: ReMEMBER The quality of ℳtM_t constrains whether the summarizer receives gap-resolving evidence. Summarization-based memory can dilute such evidence through global compression, while retrieval with window-level queries preserves detail but favors window-overlapping history over gap-resolving evidence. ReMEMBER addresses this mismatch by constructing memory around contextual gaps, retrieving missing evidence with gap-specific queries, and refining retrieved chunks into a compact ℳtM_t under the memory budget. 4.1 Gap-Conditioned Evidence Retrieval Retrieval in streaming dialogue summarization suffers from a history-window mismatch. A query derived from tW_t surfaces visible window content and retrieves history that repeats or paraphrases it. Yet the needed evidence is the presupposed referent, state, rationale, or causal link. ReMEMBER addresses this mismatch by conditioning retrieval on detected contextual gaps rather than the full tW_t. Gap Detection and Query Construction. Gap-conditioned retrieval proceeds in two stages. The first identifies which utterances are both summary-worthy and gap-bearing. The second constructs an evidence query for each identified gap without hypothesizing its resolution. An utterance is summary-worthy when it conveys information that should be preserved in a self-contained summary, such as an action, decision, plan, or status update. It is gap-bearing when its interpretation depends on prior dialogue, such as an absent referent, rationale, prior state, or causal dependency. These criteria define the retrieval trigger at inference time. They are applied only to tW_t, without benchmark annotations, resolving evidence, or gap-type labels. Detecting such utterances requires discourse-level reasoning beyond lexical overlap, since the missing evidence may not share surface form with any token in tW_t (Elgohary et al., 2019; Du et al., 2026). ReMEMBER implements this detection with a compact LLM to keep per-window inference cost tractable111We use Qwen3.5-4B (Qwen Team, 2026a) as the default for gap detection; ablations with Qwen3.5-9B and Gemma-4-E2B-it (DeepMind, 2026) show no consistent gain over the 4B scale (Appendix C.1).. For each gap-bearing utterance, ReMEMBER converts the unresolved dependency into an evidence-seeking query. The query identifies the gap-bearing utterance, states why the utterance is not self-contained, specifies the type of evidence required for resolution, and supplies lexical anchors drawn from tW_t. This avoids anchoring retrieval to a hypothetical answer that may not exist in ℋtH_t, reducing retrieval drift. The prompt used for gap detection is shown in Figure 3. Candidate Chunk Construction. Candidate construction follows three design choices. First, ℋtH_t is segmented into 128-token chunks with 32-token overlap. This granularity keeps each chunk small enough to isolate specific evidence while preserving sufficient turn context for retrieval. Second, each gap query is issued to both a sparse and a dense retriever, targeting complementary aspects of relevance. Sparse retrieval uses BM25 (Robertson and Zaragoza, 2009) to enforce lexical overlap with the query anchors. Dense retrieval uses Qwen3-Embedding-0.6B (Zhang et al., 2025), a model that supports instruction-aware embeddings and is therefore well-suited to the structured, multi-part gap queries222Each retriever returns the top 30 chunks per gap, providing a bounded candidate pool that is broad enough for evidence recall without approximating full-history access.. Third, the two ranked lists are fused with reciprocal rank fusion, which aggregates ranks without cross-system score calibration. For each gap query g, the fused score for a chunk c is computed as sg(c)=160+rsparse(c)+160+rdense(c),s_g(c)= 160+r^sparse(c)+ 160+r^dense(c), where rsparse(c)r^sparse(c) and rdense(c)r^dense(c) denote the ranks of c under the respective retrievers, following the standard setting for reciprocal rank fusion (Cormack et al., 2009). The top-K chunks per gap are retained as gC_g, where K is determined by the token budget divided by the chunk size. 4.2 Gap-Conditioned Chunk Refinement Retrieved chunks introduce a second failure mode, chunk-evidence mismatch. A 128-token chunk provides sufficient context for retrieval. Yet it inevitably carries gap-irrelevant content that occupies memory space without contributing to gap resolution (Pan et al., 2025; Song et al., 2026). ReMEMBER therefore refines gC_g through two steps, gap-conditioned turn extraction and gap-balanced evidence accumulation. Gap-Conditioned Turn Extraction. Scoring at the chunk level dilutes the gap-resolution signal, since the required clue is often concentrated in a single utterance. ReMEMBER decomposes each chunk ci∈gc_i _g into constituent utterances. Each utterance and the gap query g are embedded with the same Qwen3-Embedding-0.6B encoder used in the retrieval step. ReMEMBER then scores each utterance as cos(e(u),e(g)) (e(u),\,e(g)). Since g already encodes the specific evidence need that triggered retrieval, this cosine score serves as a sufficient gap-conditioned relevance signal without additional supervision. The utterances within each cic_i are thus re-ranked per gap, pushing gap-irrelevant content down. The complete turn containing each high-scoring utterance is then extracted, including its speaker information, as a turn-level evidence unit. Thus, gC_g is converted into gT_g, a set of turn-level evidence units ordered by gap relevance. Gap-Balanced Evidence Accumulation. Turns are accumulated into ℳtM_t in rounds, where round d appends the d-th highest-scoring turn from each gT_g if not already present, until the prespecified memory budget B is reached. This yields ℳt=τg,d∣g∈t,d=1,…,DM_t=\ _g,d g _t,\ d=1,…,D\, where D is the largest round completed before ℳtM_t exceeds the token budget B. This round-robin allocation ensures that no single gap monopolizes ℳtM_t, so each unresolved dependency in tW_t retains representation. The resulting ℳtM_t is thus not a general compression of ℋtH_t but a gap-aligned collection of turn-level evidence, enabling the summary generator to produce a contextually self-contained summary of tW_t without access to the full ℋtH_t. 4.3 Integration with Summary Generation ReMEMBER is designed as a gap-resolving memory module. The constructed memory ℳtM_t can be integrated with any standard summary generator. In our experiments, generation is held fixed across memory strategies. The generator receives only ℳtM_t and the current window tW_t as input. The prompt for summary generation can be found in Figure 4. 5 Evaluation In this section, we evaluate whether ReMEMBER constructs gap-resolving memory and improves streaming dialogue summaries under a fixed memory budget. Section 5.1 introduces metrics and baselines. Sections 5.2–5.3 evaluate memory recall and summary quality against memory construction baselines. Sections 5.4–5.5 further analyze recall breakdowns by gap type, component-level contributions and computational cost. 5.1 Experimental Setup The experiment isolates the effect of memory construction by holding the summarizer fixed across all methods. Each method receives the same current window W and constructs ℳM from prior dialogue. Metrics. Memory quality is measured by memory recall and summary quality along four dimensions (window completeness, gap-resolution completeness, faithfulness, and conciseness), as defined in Section 3.3. We additionally report composite score, the arithmetic mean across all four dimensions, as an overall measure of summary quality. All metrics are scored by Qwen3.6-27B (temperature 0.0) with rubric-guided prompting. Rubric-guided LLM evaluation has been shown to achieve human-level correlation across NLG tasks (Zheng et al., 2023; Kim et al., 2024b), with stronger models further improving agreement with human annotators (Thakur et al., 2025) and consistently strong alignment on faithfulness and completeness (Song et al., 2024; Lee et al., 2024). Scoring criteria and prompts are provided in Figures 5-10. Baselines. We compare ReMEMBER against two groups. The first group consists of diagnostic references that control memory availability and quality. The second group consists of memory construction baselines that build memory under the same capacity constraint. (i) Diagnostic references isolate how summary quality changes as a function of memory availability and organization, independently of any construction method. Ideal Memory supplies the reference gap-resolving evidence as memory, serving as an upper-bound diagnostic for evidence availability. No Memory summarizes tW_t alone, measuring the summary quality achievable without any historical context. Full Memory supplies the entire ℋtH_t as memory, revealing whether the bottleneck lies in evidence availability or in how evidence is organized for generation. When ℋH exceeds the model context limit, the oldest turns are truncated first. (i) Memory construction baselines represent three representative strategies for converting ℋtH_t into a bounded memory. Recency-based memory (Recent Memory) retains the most recent turns immediately preceding tW_t, under the rationale that temporally proximate turns are most likely to resolve current gaps. Summarization-based Memory (Inc. Summary, Hier. Summary) instead compresses the entire ℋtH_t into a fixed-length memory, covering the full history at the cost of abstractive compression. Inc. Summary updates a running summary at each window, while Hier. Summary aggregates segment-level summaries bottom-up (prompt in Figure 11). The compression operates over 4,096-token segments with a 1,024-token overlap, applied recursively. Retrieval-based Memory (Sparse, Dense, Hybrid) retrieves chunks from ℋtH_t using tW_t as a single composite query via lexical, semantic, and hybrid matching, respectively, as window-aware retrieval better captures the evidence signal than compression. Sparse retrieval uses BM25 (Robertson and Zaragoza, 2009); dense retrieval uses Qwen3-Embedding-0.6B (Zhang et al., 2025) and packs the top-8 chunks to ensure under the memory budget; hybrid retrieval packs the top-4 chunks from each ranking. Implementation Details. Both the memory capacity and window size are fixed at 1,024 tokens. Under this setting, ReMEMBER retains top-8 retrieved chunks, giving a retrieval budget of 8 chunks per query. This ensures that memory does not dominate the generation context while providing sufficient capacity for historical evidence. All memory-based methods use the same summary-generation instruction (Figure 4). No Memory, which requires no memory context, uses a separate prompt (Figure 12). Summary evaluation results are averaged across three summarizers (Qwen3.5-4B, Qwen3.5-9B, and Gemma-4-E2B-it at temperature 0.7). Further details are in Appendix D. Memory Type Memory Recall Referential Gap Attribute Gap Relational Gap Ideal Memory 1.0000 0.3251 0.5421 0.1328 Full Memory 0.8445 0.2410 0.4252 0.0935 Recent Memory 0.4126 0.1756 0.2130 0.0441 Inc. Summary 0.3581 0.1355 0.1983 0.0340 Hier. Summary 0.3212 0.1095 0.2196 0.0214 Sparse 0.5130 0.2029 0.2617 0.0621 Dense 0.4897 0.1969 0.2490 0.0561 Hybrid 0.5412 0.2183 0.2777 0.0614 ReMEMBER 0.6984 0.2457 0.3558 0.1008 Table 1: Memory recall and its breakdown by gap type, where each type-level score is the fraction of gaps included in ℳtM_t out of all annotated gaps of that type. Domain-wise results are in Appendix C.2. 5.2 Gap-Resolving Evidence Recovery Table 1 reveals memory recall depends on how evidence is selected, not on how much history is accessed. ReMEMBER achieves a memory recall of 0.6984, outperforming the best memory construction baseline, Hybrid, by 0.157. Inc. Summary and Hier. Summary access the full history yet fall below even the Recent Memory. This indicates that indiscriminate compression actively discards task-relevant evidence. Sparse, Dense, and Hybrid recover more evidence but remain bounded by surface similarity to the current window, leaving implicitly connected evidence unrecovered regardless of retrieval budget. Memory Type Win-Comp Gap-Comp Conc Faith Composite -32K 32K-64K 64K- -32K 32K-64K 64K- -32K 32K-64K 64K- -32K 32K-64K 64K- -32K 32K-64K 64K- Ideal Memory 0.73 0.71 0.70 0.73 0.76 0.77 0.65 0.71 0.73 0.88 0.88 0.90 0.75 0.77 0.77 No Memory 0.70 0.65 0.65 N/A N/A N/A 0.61 0.66 0.68 0.92 0.91 0.91 0.55 0.56 0.56 Full Memory 0.39 0.21 0.13 0.45 0.42 0.24 0.31 0.22 0.16 0.76 0.80 0.80 0.48 0.41 0.33 Recent Memory 0.68 0.68 0.67 0.21 0.24 0.40 0.52 0.60 0.63 0.88 0.89 0.90 0.57 0.60 0.65 Inc. Summary 0.72 0.73 0.72 0.27 0.17 0.17 0.54 0.63 0.65 0.74 0.74 0.75 0.57 0.57 0.57 Hier. Summary 0.74 0.73 0.71 0.30 0.17 0.05 0.55 0.61 0.62 0.73 0.71 0.72 0.58 0.56 0.52 Sparse 0.69 0.69 0.70 0.28 0.31 0.43 0.54 0.63 0.67 0.87 0.88 0.89 0.60 0.63 0.67 Dense 0.70 0.66 0.67 0.32 0.32 0.36 0.56 0.62 0.67 0.87 0.87 0.88 0.62 0.62 0.64 Hybrid 0.70 0.68 0.69 0.31 0.31 0.45 0.55 0.63 0.67 0.88 0.90 0.90 0.61 0.63 0.68 ReMEMBER 0.73 0.72 0.72 0.41 0.48 0.47 0.58 0.66 0.68 0.88 0.88 0.89 0.65 0.68 0.69 Table 2: Summary quality across dialogue length bins (-32K, 32K–64K, 64K-). Win-Comp, Gap-Comp, Conc, and Faith denote window completeness, gap-resolution completeness, conciseness, and faithfulness, respectively. For No Memory, the unavailable Gap-Comp is counted as 0 as no historical evidence is supplied. Scores are averaged over three summarizers, and higher scores indicate better performance. Model-wise results are in Appendix C.3 5.3 Impact on Streaming Summaries Table 2 reports summary quality across dialogue length bins. ReMEMBER achieves the best composite score among memory construction baselines in every length bin. This advantage is driven mainly by gap-resolution completeness, where ReMEMBER improves over Hybrid by up to 0.17, while maintaining strong window completeness, conciseness, and faithfulness. This pattern indicates that the summary gains come from resolving missing contextual dependencies without sacrificing current window coverage or reliability. In contrast, Full Memory exposes substantially more history, but achieves lower window completeness and conciseness than Retrieval-based Memories. The diagnostic references show that the central challenge is not evidence availability alone, but organizing historical evidence into a form that the summarizer can reliably use. Memory Type Referential Gap Attribute Gap Relational Gap Memory Summary Memory Summary Memory Summary Ideal Memory 100.0 80.34 100.0 73.73 100.0 72.96 Full Memory 78.80 35.73 83.79 37.11 74.03 21.45 Recent Memory 51.15 37.31 39.10 26.90 33.79 22.71 Inc. Summary 42.24 26.96 35.98 21.01 25.14 12.89 Hier. Summary 33.24 21.21 36.38 19.34 16.02 7.00 Sparse 60.33 42.77 48.2 31.96 45.95 28.58 Dense 58.61 43.82 44.99 30.30 42.17 26.00 Hybrid 64.32 46.34 51.29 34.46 46.13 25.68 ReMEMBER 75.26 57.15 66.15 46.78 76.89 52.21 Table 3: Percentage of annotated gaps per type whose resolving evidence is included in memory and reflected in the generated summary. Variations Memory Recall Gap-Comp Win-Comp Conc Faith (i) w/o Gap Conditioned Retrieval 0.60 0.43 0.63 0.62 0.82 (i) w/o Chunk Refinement 0.66 0.46 0.64 0.66 0.82 ReMEMBER 0.70 0.50 0.68 0.66 0.81 Table 4: Ablation results using Qwen3.5-4B as gap detection model and summarizer. 5.4 Gap-Level Evidence Use Table 3 separates evidence inclusion in memory from evidence reflection in the summary. ReMEMBER improves most in this regime by reasoning beyond lexical overlap, raising memory inclusion and summary coverage for relational gaps over memory construction baselines. Full Memory nonetheless buries gap-resolving evidence among irrelevant context across all gap types, producing a needle-in-a-haystack failure (Lee et al., 2025b). Even Ideal Memory does not guarantee full evidence reflection, showing that generation imposes a separate ceiling. The persistent gap between memory inclusion and summary use suggests that full resolution requires co-design of memory construction and summary generation. 5.5 Ablation Study Table 4 isolates the contribution of each component in ReMEMBER. (i) w/o Gap-Conditioned Retrieval retrieves with the current window as a single query and keeps the same memory budget; (i) w/o Chunk Refinement stores retrieved chunks without refinement. Removing gap-conditioned retrieval causes the larger drop. Window-level retrieval tends to recover history overlapping with tW_t, rather than evidence that resolves its implicit dependencies. Removing chunk refinement also degrades performance, indicating that raw chunks contain gap-irrelevant context that consumes the fixed memory budget. These results show that ReMEMBER improves memory construction by targeting missing evidence needs and densifying retrieved evidence. 5.6 Latency–Memory Recall Trade-off Figure 2 compares memory recall and memory-construction runtime across three dialogue-length bins.333Single H200 GPU; one CPU thread. Gap-conditioned construction achieves a favorable balance between recall and runtime as dialogue length grows. ReMEMBER incurs a construction latency of approximately four seconds across all tested dialogue-length bins, yet consistently achieves the highest memory recall. Retrieval-based methods (Sparse, Dense, Hybrid) run in under one second but recover less gap-resolving evidence, whereas Hier. Summary (Hier) incurs the highest runtime while yielding the lowest recall, indicating that repeated compression is both costly and lossy under a fixed memory budget. Figure 2: Memory recall versus memory build runtime (log scale, in seconds) across three dialogue length bins. 6 Conclusion We present streaming dialogue summarization as a new task with a benchmark and evaluation metrics. Our analysis shows that existing memory paradigms retrieve evidence aligned with what the current window states, not what it leaves implicit. To address this mismatch, ReMEMBER constructs memory around detected contextual gaps rather than surface similarity. Under the same budget, ReMEMBER improves memory recall and gap-resolution completeness across histories up to 160K tokens. Even with reference gap-resolving evidence, a persistent gap remains between memory recall and summary use, indicating that summary generation independently limits gap resolution. References Y. Bai, S. Tu, J. Zhang, H. Peng, X. Wang, X. Lv, S. Cao, J. Xu, L. Hou, Y. Dong, et al. (2025) Longbench v2: towards deeper understanding and reasoning on realistic long-context multitasks. In ACL, External Links: Document Cited by: §2. S. Bird, E. Klein, and E. Loper (2009) Natural language processing with python. O’Reilly Media. Cited by: Table 10, Appendix D. Y. Chen, N. Nishida, H. Nakayama, and Y. Matsumoto (2025) Post persona alignment for multi-session dialogue generation. In EMNLP, External Links: Document Cited by: §2. G. V. Cormack, C. L. Clarke, and S. Buettcher (2009) Reciprocal rank fusion outperforms condorcet and individual rank learning methods. In SIGIR, External Links: Document Cited by: §4.1. G. DeepMind (2026) Gemma 4. Note: https://huggingface.co/google/gemma-4-31b-it Cited by: §A.3, §C.3, Appendix D, footnote 1. K. Deshpande, V. Sirdeshmukh, J. B. Mols, L. Jin, E. Hernandez-Cardona, D. Lee, J. Kritz, W. E. Primack, S. Yue, and C. Xing (2025) Multichallenge: a realistic multi-turn conversation evaluation benchmark challenging to frontier llms. In ACL, External Links: Document Cited by: §1. Y. Du, B. Wang, Y. He, B. Liang, B. Wang, Z. Li, L. Gui, J. Z. Pan, R. Xu, and K. Wong (2026) MemGuide: intent-driven memory selection for goal-oriented multi-session llm agents. In AAAI, External Links: Document Cited by: §2, §4.1. A. Elgohary, D. Peskov, and J. Boyd-Graber (2019) Can you unpack that? learning to rewrite questions-in-context. In EMNLP-IJCNLP, External Links: Document Cited by: §2, §4.1. L. Gao, X. Ma, J. Lin, and J. Callan (2023a) Precise zero-shot dense retrieval without relevance labels. In ACL, External Links: Document Cited by: §2. S. Gao, X. Cheng, M. Li, X. Chen, J. Li, D. Zhao, and R. Yan (2023b) Dialogue summarization with static-dynamic structure fusion graph. In ACL, External Links: Document Cited by: §2. M. I. E. Ghebriout, G. Guibon, I. Lerner, and E. Vincent (2025) QUARTZ: qa-based unsupervised abstractive refinement for task-oriented dialogue summarization. In EMNLP, External Links: Document Cited by: §1. C. Hu, T. Li, X. Gao, H. Chen, D. Xu, Y. Bai, T. Lin, X. Zhao, X. Li, J. An, et al. (2026) EverMemBench: benchmarking long-term interactive memory in large language modelsevermembench: benchmarking long-term interactive memory in large language models. arXiv preprint arXiv:2602.01313. External Links: 2602.01313, Link Cited by: §A.1, §3.2. E. Hwang, Y. Zhou, J. B. Wendt, B. Gunel, N. Vo, J. Xie, and S. Tata (2024) Enhancing incremental summarization with structured representations. In EMNLP, External Links: Document Cited by: §2. Q. Jia, Y. Liu, S. Ren, and K. Q. Zhu (2023) Taxonomy of abstractive dialogue summarization: scenarios, approaches, and future directions. ACM Computing Surveys 56 (3), p. 1–38. External Links: Document Cited by: §2. K. Jin, Y. Wang, L. Santos, T. Fang, X. Yang, S. K. Im, and H. G. Oliveira (2025) Reasoning or not? a comprehensive evaluation of reasoning llms for dialogue summarization. Expert Systems with Applications, p. 129831. External Links: Document Cited by: §1. H. Kim and B. Kim (2025) Nexussum: hierarchical llm agents for long-form narrative summarization. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), External Links: Document Cited by: §1. J. Kim, W. Chay, H. Hwang, D. Kyung, H. Chung, E. Cho, Y. Kwon, Y. Jo, and E. Choi (2024a) DialSim: a dialogue simulator for evaluating long-term multi-party dialogue understanding of conversational agents. arXiv preprint arXiv:2406.13144. External Links: 2406.13144, Link Cited by: §2. S. Kim, J. Suk, S. Longpre, B. Y. Lin, J. Shin, S. Welleck, G. Neubig, M. Lee, K. Lee, and M. Seo (2024b) Prometheus 2: an open source language model specialized in evaluating other language models. In EMNLP, External Links: Document Cited by: §3.2, §5.1. F. Kirstein, J. P. Wahle, B. Gipp, and T. Ruas (2025) CADS: a systematic literature review on the challenges of abstractive dialogue summarization (abstract reprint). In IJCAI, External Links: Document Cited by: §1. F. Kirstein, J. P. Wahle, T. Ruas, and B. Gipp (2024) What’s under the hood: investigating automatic metrics on meeting summarization. In EMNLP, External Links: Document Cited by: §A.2, §3.2. D. Lee, A. Maharana, J. Pujara, X. Ren, and F. Barbieri (2025a) Realtalk: a 21-day real-world dataset for long-term conversation. arXiv preprint arXiv:2502.13270. External Links: 2502.13270, Link Cited by: §A.1, §1, §2, §3.2. Y. Lee, J. Deng, N. H. Kim, H. Min, T. Yun, M. Ban, K. Yul, and H. Song (2025b) Towards a holistic and automated evaluation framework for multi-level comprehension of llms in book-length contexts. In EMNLP, External Links: Document Cited by: §1, §5.4. Y. Lee, T. Yun, J. Cai, H. Su, and H. Song (2024) UniSumEval: towards unified, fine-grained, multi-dimensional summarization evaluation for llms. In EMNLP, External Links: Document Cited by: §3.2, §5.1. D. Li, T. Chen, A. Tung, and L. B. Chilton (2021) Hierarchical summarization for longform spoken dialog. In UIST, p. 582–597. External Links: Document Cited by: §2. H. Li, C. Yang, A. Zhang, Y. Deng, X. Wang, and T. Chua (2025a) Hello again! llm-powered personalized agent for long-term dialogue. In NAACL, External Links: Document Cited by: §2. R. Li, C. Li, G. Murray, and G. Carenini (2025b) Hierarchical attention adapter for abstractive dialogue summarization. In NewSum, External Links: Document Cited by: §1, §1. H. Lin, J. Zhu, L. Xiang, F. Zhai, Y. Zhou, J. Zhang, and C. Zong (2023) Topic-oriented dialogue summarization. TASLP 31, p. 1797–1810. External Links: Document Cited by: §2. D. Liu, Z. Wu, D. Song, and H. Huang (2025) A persona-aware llm-enhanced framework for multi-session personalized dialogue generation. In ACL, External Links: Document Cited by: §2. N. F. Liu, K. Lin, J. Hewitt, A. Paranjape, M. Bevilacqua, F. Petroni, and P. Liang (2024a) Lost in the middle: how language models use long contexts. TACL 12, p. 157–173. External Links: Document Cited by: §1. S. Liu, J. Wu, J. Bao, W. Wang, N. Hovakimyan, and C. G. Healey (2024b) Towards a robust retrieval-based summarization system. arXiv preprint arXiv:2403.19889. External Links: 2403.19889, Link Cited by: §1. Z. Liu, K. Shi, and N. Chen (2021) Coreference-aware dialogue summarization. In SIGDIAL, External Links: Document Cited by: §A.2, §3.2. A. Maharana, D. Lee, S. Tulyakov, M. Bansal, F. Barbieri, and Y. Fang (2024) Evaluating very long-term conversational memory of llm agents. In ACL, External Links: Document Cited by: §A.1, §2, §3.2. Y. Mao, P. He, X. Liu, Y. Shen, J. Gao, J. Han, and W. Chen (2021) Generation-augmented retrieval for open-domain question answering. In ACL-IJCNLP, External Links: Document Cited by: §2. H. Min, Y. Lee, M. Ban, J. Deng, N. H. Kim, T. Yun, H. Su, J. Cai, and H. Song (2025) Towards multi-dimensional evaluation of llm summarization across domains and languages. In ACL, External Links: Document Cited by: §3.3. S. Min, K. Krishna, X. Lyu, M. Lewis, W. Yih, P. Koh, M. Iyyer, L. Zettlemoyer, and H. Hajishirzi (2023) Factscore: fine-grained atomic evaluation of factual precision in long form text generation. In EMNLP, External Links: Document Cited by: Appendix B. K. T. Ong, N. Kim, M. Gwak, H. Chae, T. Kwon, Y. Jo, S. Hwang, D. Lee, and J. Yeo (2025) Towards lifelong dialogue agents via timeline-based memory management. In NAACL, External Links: Document Cited by: §2. OpenAI (2022) Tiktoken. Note: https://github.com/openai/tiktoken Cited by: Appendix D. L. Ou and M. Lapata (2025) Context-aware hierarchical merging for long document summarization. In ACL, External Links: Document Cited by: §1. Z. Pan, Q. Wu, H. Jiang, X. Luo, H. Cheng, D. Li, Y. Yang, C. Lin, H. V. Zhao, L. Qiu, et al. (2025) SeCom: on memory construction and retrieval for personalized conversational agents. In ICLR, External Links: Link Cited by: §2, §4.2. Qwen Team (2026a) Qwen3.5: towards native multimodal agents. External Links: Link Cited by: §C.3, Appendix D, footnote 1. Qwen Team (2026b) Qwen3.6-27B: flagship-level coding in a 27B dense model. External Links: Link Cited by: §A.3, Appendix D. M. Ravaut, A. Sun, N. Chen, and S. Joty (2024) On context utilization in summarization with large language models. In ACL, External Links: Document Cited by: §2. S. Robertson and H. Zaragoza (2009) The probabilistic relevance framework: bm25 and beyond. Now Publishers Inc. Cited by: Appendix B, §4.1, §5.1. H. Song, J. Choi, and M. Kim (2026) Aligning extraction and generation for robust retrieval-augmented generation. In WSDM, External Links: Document Cited by: §1, §4.2. H. Song, H. Su, I. Shalyminov, J. Cai, and S. Mansour (2024) FineSurE: fine-grained summarization evaluation using llms. In ACL, External Links: Document Cited by: Appendix B, §3.3, §5.1. L. Sun, L. He, S. Jia, Y. He, and C. You (2025) Docagent: an agentic framework for multi-modal long-context document understanding. In EMNLP, External Links: Document Cited by: §1. Z. Tan, J. Yan, I. Hsu, R. Han, Z. Wang, L. Le, Y. Song, Y. Chen, H. Palangi, G. Lee, et al. (2025) In prospect and retrospect: reflective memory management for long-term personalized dialogue agents. In ACL, External Links: Document Cited by: §2. X. Tang, A. Nair, B. Wang, B. Wang, J. Desai, A. Wade, H. Li, A. Celikyilmaz, Y. Mehdad, and D. Radev (2022) CONFIT: toward faithful dialogue summarization with linguistically-informed contrastive fine-tuning. In NAACL, External Links: Document Cited by: §A.2, §2, §3.2. G. Team, A. Zeng, X. Lv, Q. Zheng, Z. Hou, B. Chen, C. Xie, C. Wang, D. Yin, H. Zeng, J. Zhang, K. Wang, L. Zhong, M. Liu, R. Lu, S. Cao, X. Zhang, X. Huang, Y. Wei, Y. Cheng, Y. An, Y. Niu, Y. Wen, Y. Bai, Z. Du, Z. Wang, Z. Zhu, B. Zhang, B. Wen, B. Wu, B. Xu, C. Huang, C. Zhao, C. Cai, C. Yu, C. Li, C. Ge, C. Huang, C. Zhang, C. Xu, C. Zhu, C. Li, C. Yin, D. Lin, D. Yang, D. Jiang, D. Ai, E. Zhu, F. Wang, G. Pan, G. Wang, H. Sun, H. Li, H. Li, H. Hu, H. Zhang, H. Peng, H. Tai, H. Zhang, H. Wang, H. Yang, H. Liu, H. Zhao, H. Liu, H. Yan, H. Liu, H. Chen, J. Li, J. Zhao, J. Ren, J. Jiao, J. Zhao, J. Yan, J. Wang, J. Gui, J. Zhao, J. Liu, J. Li, J. Li, J. Lu, J. Wang, J. Yuan, J. Li, J. Du, J. Du, J. Liu, J. Zhi, J. Gao, K. Wang, L. Yang, L. Xu, L. Fan, L. Wu, L. Ding, L. Wang, M. Zhang, M. Li, M. Xu, M. Zhao, M. Zhai, P. Du, Q. Dong, S. Lei, S. Tu, S. Yang, S. Lu, S. Li, S. Li, Shuang-Li, S. Yang, S. Yi, T. Yu, W. Tian, W. Wang, W. Yu, W. L. Tam, W. Liang, W. Liu, X. Wang, X. Jia, X. Gu, X. Ling, X. Wang, X. Fan, X. Pan, X. Zhang, X. Zhang, X. Fu, X. Zhang, Y. Xu, Y. Wu, Y. Lu, Y. Wang, Y. Zhou, Y. Pan, Y. Zhang, Y. Wang, Y. Li, Y. Su, Y. Geng, Y. Zhu, Y. Yang, Y. Li, Y. Wu, Y. Li, Y. Liu, Y. Wang, Y. Li, Y. Zhang, Z. Liu, Z. Yang, Z. Zhou, Z. Qiao, Z. Feng, Z. Liu, Z. Zhang, Z. Wang, Z. Yao, Z. Wang, Z. Liu, Z. Chai, Z. Li, Z. Zhao, W. Chen, J. Zhai, B. Xu, M. Huang, H. Wang, J. Li, Y. Dong, and J. Tang (2025) GLM-4.5: agentic, reasoning, and coding (arc) foundation models. External Links: 2508.06471, Link Cited by: §A.3, Appendix D. A. S. Thakur, K. Choudhary, V. S. Ramayapally, S. Vaidyanathan, and D. Hupkes (2025) Judging the judges: evaluating alignment and vulnerabilities in llms-as-judges. In GEM, External Links: Link Cited by: §3.2, §5.1. B. Wang, Z. Liu, and N. Chen (2023a) Instructive dialogue summarization with query aggregations. In EMNLP, External Links: Document Cited by: §2. B. Wang, J. Li, and R. Xu (2026) Bounded state in an infinite horizon: proactive hierarchical memory for ad-hoc recall over streaming dialogues. arXiv preprint arXiv:2603.04885. External Links: 2603.04885, Link Cited by: §2. L. Wang, N. Yang, and F. Wei (2023b) Query2doc: query expansion with large language models. In EMNLP, External Links: Document Cited by: §2. L. Wang, M. Zhao, H. Ji, Z. Jiang, R. Li, Z. Hu, and X. Lu (2024) Dialogue summarization enhanced response generation for multi-domain task-oriented dialogue systems. Information Processing & Management 61 (3), p. 103668. External Links: Document Cited by: §1. Q. Wang, Y. Fu, Y. Cao, S. Wang, Z. Tian, and L. Ding (2025) Recursively summarizing enables long-term dialogue memory in large language models. Neurocomputing 639, p. 130–193. External Links: Document Cited by: §1, §2. J. Wei, C. Yang, X. Song, Y. Lu, N. Hu, J. Huang, D. Tran, D. Peng, R. Liu, D. Huang, et al. (2024) Long-form factuality in large language models. In NIPS, External Links: Link Cited by: Appendix B. Y. Wu, C. Zhao, Y. Cao, X. Xu, Y. Mehdad, M. Ji, and C. N. Cheng (2025) Incremental summarization for customer support via progressive note-taking and agent feedback. In EMNLP, External Links: Document Cited by: §1, §1, §1. J. Xiao, Y. Chen, Y. Ou, H. Yu, K. Shu, and Y. Xiao (2024) Baichuan2-sum: instruction finetune baichuan2-7b model for dialogue summarization. In IJCNN, External Links: Document Cited by: §2. J. Xu, A. Szlam, and J. Weston (2022) Beyond goldfish memory: long-term open-domain conversation. In ACL, External Links: Document Cited by: §2. S. Yan, J. Ni, L. Zheng, J. Zhang, P. Wu, D. Yin, J. Lyu, C. Yuan, and F. Rao (2026) AdaMem: adaptive user-centric memory for long-horizon dialogue agents. arXiv preprint arXiv:2603.16496. External Links: 2603.16496, Link Cited by: §2. C. Yang, Z. Sun, W. Wei, and W. Hu (2026) Beyond static summarization: proactive memory extraction for llm agents. arXiv preprint arXiv:2601.04463. External Links: 2601.04463, Link Cited by: §2. Z. Yi, J. Ouyang, Z. Xu, Y. Liu, T. Liao, H. Luo, and Y. Shen (2025) A survey on recent advances in llm-based multi-turn dialogue systems. ACM Computing Surveys 58 (6), p. 1–38. External Links: Document Cited by: §1, §2. C. Yoon, G. Kim, B. Jeon, S. Kim, Y. Jo, and J. Kang (2025) Ask optimal questions: aligning large language models with retriever’s preference in conversation. In Findings of the Association for Computational Linguistics: NAACL 2025, p. 5899–5921. External Links: Document Cited by: §2, §2. Y. Zhang, M. Li, D. Long, X. Zhang, H. Lin, B. Yang, P. Xie, A. Yang, D. Liu, J. Lin, et al. (2025) Qwen3 embedding: advancing text embedding and reranking through foundation models. arXiv:2506.05176. External Links: 2506.05176, Link Cited by: §4.1, §5.1. Y. Zhang, A. Ni, T. Yu, R. Zhang, C. Zhu, B. Deb, A. Celikyilmaz, A. Hassan, and D. Radev (2021) An exploratory study on long dialogue summarization: what works and what’s next. In EMNLP, External Links: Document Cited by: §2. L. Zheng, W. Chiang, Y. Sheng, S. Zhuang, Z. Wu, Y. Zhuang, Z. Lin, Z. Li, D. Li, E. Xing, et al. (2023) Judging llm-as-a-judge with mt-bench and chatbot arena. In NIPS, External Links: Link Cited by: §5.1. M. Zhong, D. Yin, T. Yu, A. Zaidi, M. Mutuma, R. Jha, A. Hassan, A. Celikyilmaz, Y. Liu, X. Qiu, et al. (2021) QMSum: a new benchmark for query-based multi-domain meeting summarization. In NAACL, External Links: Document Cited by: §2. W. Zhong, L. Guo, Q. Gao, H. Ye, and Y. Wang (2024) Memorybank: enhancing large language models with long-term memory. In AAAI, External Links: Document Cited by: §2. C. Zhu, S. Wang, R. Feng, K. Song, and X. Qiu (2025a) Convsearch-r1: enhancing query reformulation for conversational search with reasoning via reinforcement learning. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, External Links: Document Cited by: §2, §2. C. Zhu, R. Xu, M. Zeng, and X. Huang (2020) A hierarchical network for abstractive meeting summarization with cross-domain pretraining. In EMNLP, External Links: Document Cited by: §2. R. Zhu, J. H. Lau, and J. Qi (2025b) Factual dialogue summarization via learning from large language models. In COLING, External Links: Link Cited by: §1. R. Zhu, J. Qi, and J. H. Lau (2023) Annotating and detecting fine-grained factual errors for dialogue summarization. In ACL, External Links: Document Cited by: §A.2, §3.2. Domain Source # Samples Avg. Dialogue Length Ref. Gap Att. Gap Rel. Gap Avg. Sal. Avg. Gap Chit-Chat LoCoMo, RealTalk21 300 20,446 (8,024-43608) 205 188 71 4.70 1.55 Workplace EverMemBench 600 80,574 (8,024-159,576) 282 624 128 9.49 1.73 All – 900 60,532 (8,024-159,576) 487 812 199 7.90 1.67 Table 5: Benchmark statistics by domain. Dialogue length reports the average number of tokens in each benchmark instance, including both the accumulated history and the current window, with the minimum–maximum range in parentheses. Referential, Attribute, and Relational gaps denote the number of annotated contextual gaps by type. Ref. Gap, Att.Gap, Rel. Gap, Avg. Sal. and Avg. Gap denote Referential Gap, Attribute Gap, Relational Gap, the average number of salient utterances and contextual gaps per instance, respectively. Appendix A Benchmark Construction Detail A.1 Benchmark Statistics This section provides additional details on the benchmark dataset described in Section 3.2. Table 5 reports the source datasets and benchmark statistics by domain. The benchmark contains 900 window-level instances sampled from 35 source dialogues (10 LoCoMo (Maharana et al., 2024), 10 RealTalk21 (Lee et al., 2025a), and 15 EverMemBench (Hu et al., 2026)). Chit-chat instances are drawn from LoCoMo and RealTalk21, while workplace instances are drawn from EverMemBench. Dialogue length is measured at the benchmark-instance level as |ℋt|+|t||H_t|+|W_t|, with the current window fixed to 1,024 tokens, rather than as the length of the source dialogue. Table 10 lists the original dataset repositories used to obtain the raw data before preprocessing. A.2 Gap Taxonomy This section provides detailed definitions and examples for the contextual gap types introduced in Section 3.2. Building on prior work on faithfulness error types in dialogue summarization (Liu et al., 2021; Tang et al., 2022; Zhu et al., 2023; Kirstein et al., 2024), we reinterpret the underlying discourse phenomena as pre-generation contextual losses in streaming dialogue summarization. Prior work analyzes faithfulness failures after generation, including missing information, incorrect entity or circumstance details, and unsupported links in generated summaries. Our setting instead focuses on the corresponding omissions before generation. The current window may omit the antecedent needed to resolve a reference, the attribute needed to specify an entity or event, or the relation needed to understand why an utterance follows. We therefore annotate history-dependent incompleteness as a contextual gap that can be resolved by evidence from ℋtH_t, rather than as an error introduced by the summarizer. We organize contextual gaps into three history-resolvable dependency types according to what is omitted from the current window. Prior context may supply a missing referent, a missing attribute, or a missing relation. These roles correspond to referential, attribute, and relational gaps, respectively. Table 6 provides annotated examples across all three types. ∙ Referential gaps arise when an utterance contains an expression whose antecedent or referent is absent from tW_t. Such expressions include pronouns, shorthand references, vague noun phrases, demonstratives, and discourse references. These gaps ask which entity, event, decision, request, or prior statement the utterance refers to. ∙ Attribute gaps arise when the relevant entity or event is identifiable, but a necessary property, parameter, state, preference, constraint, scope, role, assignment, or specification is absent from tW_t. These gaps ask what attribute or specification is needed to make the utterance self-contained. ∙ Relational gaps arise when the current utterance depends on an omitted causal, temporal, logical, or discourse relation. The missing relation may involve prior reasoning, motivation, agreement, comparison, condition, or constraint. These gaps ask why the utterance follows, how it is justified, or how it connects to prior dialogue. If a salient utterance contains multiple distinct missing dependencies, they are identified separately during annotation. For evaluation, each history-dependent salient utterance is associated with one representative gap and one or more pieces of evidence from ℋtH_t that explicitly resolve the missing referent, attribute, or relation. Gap Type Gap Utterance Evidence Gap Reason Resolution Referential Gap During testing, be sure to have the other party simulate a few requests with incorrect signatures and non-standard data formats. We are officially starting a new development task today to implement a Webhook interface to receive order notifications generated by external partner channels. The phrase “the other party” cannot be stably resolved from the current utterance alone. The evidence identifies the relevant counterpart as the external partner channels that generate order notifications. Attribute Gap I plan to reuse the distributed lock solution used when creating orders previously to ensure the idempotency of callback processing. I’m focusing on testing the idempotency logic for payment callbacks, especially the solution you emphasized, which uses Redis distributed locks combined with a unique index for the database payment transaction number. The target mentions a prior distributed lock solution, but omits its technical specification. The evidence specifies that the solution combines Redis distributed locks with a unique database index. Relational Gap @All members Synchronizing the final decision on the selection logic of emission factors. Technically, @Ruiqing Jiang, when designing the algorithm, you need to reserve an interface to prioritize user-defined factors, and if none exist, then fall back to our built-in database. The target announces a final decision, but the decision logic itself is not stated. The evidence supplies the relation that defines the decision, namely prioritizing user-defined factors before falling back to the built-in database. Table 6: Examples of contextual gap types. The gap utterance is from the current window tW_t, while the evidence is from the prior history ℋtH_t. A.3 Gap Annotation Pipeline Details We provide full implementation details for the five-stage annotation pipeline introduced in Section 3.2. In all stages, a candidate is retained only when at least two of the three LLMs agree; disagreements are resolved by the majority label without further adjudication. (i) Salient Utterance Identification. We select utterances from tW_t that contain a concrete decision, request, action item, or status update. Simple acknowledgments, greetings, praise, and emotional reactions are excluded. When consecutive utterances form a single coherent update or decision, they are merged into one entry. (i) Contextual Dependence Judgment. For each salient utterance, we assess whether it meets the standard of self-contained summarizability, defined as the ability to be summarized clearly and stably from tW_t alone without recourse to earlier dialogue. Each utterance is examined for unresolvable pronouns, vague noun phrases, underspecified attributes, and unstated reasoning that would prevent independent summarization. A gap is assigned only when the missing information is not recoverable from nearby utterances within tW_t; additional detail that would merely enrich the summary does not qualify. Each gap is recorded under one of three types following the taxonomy in Appendix A.2: referential, attribute, or relational. An utterance is marked as history-dependent only when at least two LLMs agree on the same gap type. Each history-dependent utterance is assigned at most one representative gap, selected as the dependency whose absence most severely impairs summarizability. Stages (i) and (i) are implemented jointly in a single prompt across three diverse LLMs, Qwen3.6-27B (Qwen Team, 2026b), Gemma-4-31B-it (DeepMind, 2026), and GLM-4.7-Flash (Team et al., 2025), each run at temperature 0.0; the prompt is provided in Figure 13. (i) Candidate History Filtering. We screen all chunks in ℋtH_t for relevance to tW_t and retain only those warranting further examination in Stage (iv). Each chunk receives a binary label independently. A chunk is labeled relevant when it contains prior content that is necessary or directly useful for understanding or summarizing tW_t, such as a decision or plan explicitly continued in the window, information needed to resolve references, or earlier steps of an ongoing task. Topical similarity alone does not qualify; a chunk is discarded when it is only loosely related or when connecting it to the window requires inference beyond what the dialogue supports. The three LLMs are drawn from distinct model families, Qwen3.6-27B, Gemma-4-31B-it, and GLM-4.7-Flash, and each is run at temperature 0.0. The prompt is provided in Figure 14. (iv) Evidence and Resolution Annotation. For each history-dependent utterance, we audit every sentence within the retained candidate chunks to identify those that explicitly supply the missing information. Each sentence is evaluated independently through a two-step protocol. The judge first writes a reasoning trace specifying what missing content the sentence provides or fails to provide with respect to the identified gap, then assigns a binary label of resolve or not_resolve based solely on that trace. Topical overlap, shared entities, discourse proximity, and broad background context do not constitute resolution; a sentence qualifies only when it explicitly provides the exact referent, attribute, prior decision, or commitment that the target utterance presupposes. The reasoning traces of all positively labeled sentences are subsequently aggregated into a single resolution statement for the gap. Given the fine-grained reasoning demands of this stage, we run inference with extended thinking enabled on Gemma-4-31B-it; the prompt is provided in Figures 15 and 16. (v) Annotation Validation. We apply four joint acceptance criteria to remove annotations that passed earlier stages but fail closer scrutiny. The evidence must be sufficient, in that the resolving sentence supplies the exact missing information defined by the gap type. It must be non-inferential, in that no additional guessing or assumption is required to close the gap. It must support independence, in that the target utterance becomes unambiguously self-contained once the resolving information is incorporated. It must be non-redundant, in that the resolving content is meaningfully distinct from what is already present in tW_t. This step is specifically designed to catch two recurring failure modes, namely cases in which resolving evidence is in fact present in tW_t but was overlooked in Stage (i), and cases in which the resolution is too vague or indirect to constitute a verifiable resolution. The prompt is provided in Figure 17; we run all three LLMs, Qwen3.6-27B, Gemma-4-31B-it, and GLM-4.7-Flash, at temperature 0.0. Appendix B Evaluation Metric Formulations Memory Recall. Let t=g1,…,g|t|G_t=\g_1,…,g_|G_t|\ denote the set of annotated contextual gaps for step t, and let t+⊆tG^+_t _t denote the subset for which ℳtM_t explicitly contains the resolving information, verified either verbatim or as a close semantic paraphrase of the supporting evidence. Memory recall is defined as MemRecall(ℳt,t)=|t+||t|.MemRecall(M_t,G_t)= |G^+_t||G_t|. This metric measures how completely the memory module preserves the historical evidence required for self-contained summarization, independently of the generated summary. All labels are produced by Qwen3.6-27B at temperature 0.0; the prompt is provided in Figure 5. Window Completeness. Let tsal=u1,…,u|tsal|U^sal_t=\u_1,…,u_|U^sal_t|\ denote the set of salient utterances in tW_t, and let t+⊆tsalU^+_t ^sal_t denote the subset whose primary claim, comprising both the core referent and the essential relation, is recoverable from StS_t. Window completeness is defined as WinComp(tsal,St)=|t+||tsal|.WinComp(U^sal_t,S_t)= |U^+_t||U^sal_t|. Narrative coverage of the same topic without recovering the specific referent and relation does not qualify. We use Qwen3.6-27B (temperature 0.0) for this stage; see Figure 6 for the prompt. Gap-Resolution Completeness. Let t++⊆t+G^++_t ^+_t denote the subset of memory-resolved gaps whose minimal gap-resolving fact, including both the specific referent and the essential relation, is explicitly expressed in StS_t. Gap-resolution completeness is defined as GapComp(t+,St)=|t++||t+|.GapComp(G^+_t,S_t)= |G^++_t||G^+_t|. This metric measures how well the model utilizes recovered evidence in generation, conditioned on successful memory retrieval. The prompt is provided in Figures 7 and 8; we run Qwen3.6-27B at temperature 0.0. Conciseness. Let twin⊆StS^win_t S_t denote the set of summary sentences that cover at least one salient utterance, as determined by t+U^+_t, and let tgap⊆StS^gap_t S_t denote the set of summary sentences that explicitly recover at least one gap-resolving fact, as determined by t++G^++_t. Conciseness is defined as Conciseness(St)=|twin∪tgap||St|.Conciseness(S_t)= |S^win_t ^gap_t||S_t|. This metric measures the proportion of summary sentences that serve a demonstrable communicative function, penalizing content that neither reflects salient window utterances nor expresses resolved contextual gaps. Conciseness shares the evaluation outputs of window completeness and gap-resolution completeness and requires no additional model call. Faithfulness. Let St=s1,…,sNS_t=\s_1,…,s_N\ be the generated summary of N sentences. Unlike completeness and conciseness, which are measured at the sentence level, faithfulness is evaluated at the atomic fact level. Summaries of tW_t that incorporate resolved contextual gaps tend to produce long sentences that conflate multiple verifiable claims; sentence-level verification is therefore too coarse to detect partial hallucinations within a single sentence. Following Min et al. (2023) and Wei et al. (2024), each sentence sns_n is first decomposed into a set of atomic facts ℱn=fn,1,…,fn,|ℱn|F_n=\f_n,1,…,f_n,|F_n|\, each expressing a single self-contained verifiable claim. Each atomic fact is then verified following the fact-checking protocol of Song et al. (2024), extended to support multi-section dialogue transcripts. ℱn∗⊆ℱnF^*_n _n denotes the subset verified as factually grounded, and faithfulness is defined as Faithfulness(St)=∑n=1N|ℱn∗|∑n=1N|ℱn|.Faithfulness(S_t)= _n=1^N|F^*_n| _n=1^N|F_n|. The verification source differs by method type. For memory-based methods, each atomic fact is verified against ℳt∪tM_t _t. For full-context methods, ℋtH_t is too long to serve directly as a grounding document; we therefore apply sparse retrieval (Robertson and Zaragoza, 2009) over ℋtH_t to select the top-50 chunks most relevant to each atomic fact, and verify against this retrieved set using the same prompt. Both steps are implemented with Qwen3.6-27B at temperature 0.0; the decomposition and verification prompts are provided in Figures 9 and 10. Summ. Model Memory Type Chit-Chat Workplace Win-Comp Gap-Comp Conc Faith Composite Win-Comp Gap-Comp Conc Faith Composite Qwen3.5-4B Ideal Memory 0.7185 0.8141 0.7032 0.7857 0.7554 0.6514 0.8375 0.7576 0.8350 0.7712 No Memory 0.7186 N/A 0.6433 0.8707 0.5582 0.6517 N/A 0.6900 0.8819 0.5559 Full Memory 0.3135 0.4566 0.2691 0.6607 0.4250 0.1811 0.3378 0.2124 0.8076 0.3843 Recent Memory 0.6280 0.1989 0.5076 0.7895 0.4134 0.6334 0.3526 0.6093 0.8460 0.6103 Inc. Summary 0.6551 0.2681 0.5084 0.6568 0.5221 0.6789 0.2093 0.6391 0.6721 0.5499 Hier. Summary 0.6989 0.3321 0.5307 0.6381 0.5499 0.6599 0.1367 0.6168 0.6124 0.5064 Sparse 0.6482 0.2500 0.5374 0.7734 0.5518 0.6464 0.4201 0.6606 0.8189 0.6363 Dense 0.6527 0.3033 0.5471 0.7790 0.5705 0.6182 0.3634 0.6604 0.8002 0.6106 Hybrid 0.6404 0.2884 0.5494 0.8099 0.5720 0.6331 0.4163 0.6629 0.8569 0.6423 ReMEMBER 0.6913 0.4559 0.6038 0.7853 0.6341 0.6684 0.5165 0.6900 0.8255 0.6751 Qwen3.5-9B Ideal Memory 0.7521 0.7773 0.7322 0.8685 0.7825 0.7004 0.7877 0.8066 0.8830 0.7946 No Memory 0.7033 N/A 0.6889 0.9043 0.5741 0.6408 N/A 0.7306 0.8963 0.5669 Full Memory 0.4421 0.4429 0.4063 0.7071 0.4996 0.2176 0.3259 0.2968 0.7674 0.4019 Recent Memory 0.7147 0.1937 0.6013 0.8668 0.5941 0.6784 0.3382 0.7252 0.8831 0.6562 Inc. Summary 0.7451 0.3076 0.6436 0.7072 0.6009 0.7085 0.1939 0.7378 0.6969 0.5843 Hier. Summary 0.7810 0.3092 0.6461 0.6968 0.6083 0.7016 0.1229 0.7125 0.6674 0.5511 Sparse 0.7373 0.2695 0.6358 0.8621 0.6262 0.6892 0.4086 0.7571 0.8774 0.6831 Dense 0.7508 0.3401 0.6678 0.8812 0.6600 0.6777 0.3583 0.7399 0.8750 0.6627 Hybrid 0.7439 0.3192 0.6277 0.8600 0.6377 0.6944 0.3986 0.7614 0.8890 0.6859 ReMEMBER 0.7501 0.4122 0.6757 0.8624 0.6751 0.7030 0.4762 0.7717 0.8857 0.7091 Gemma-4-E2B-it Ideal Memory 0.7845 0.6078 0.4653 0.9419 0.6999 0.7381 0.6654 0.5891 0.9682 0.7402 No Memory 0.7265 N/A 0.4813 0.9521 0.5400 0.6413 N/A 0.5752 0.9741 0.5476 Full Memory 0.5029 0.4002 0.2322 0.8215 0.4892 0.1178 0.2918 0.0872 0.8492 0.3365 Recent Memory 0.7179 0.1609 0.3615 0.9387 0.5445 0.6858 0.3278 0.5235 0.9673 0.6261 Inc. Summary 0.8031 0.2236 0.3870 0.8238 0.5593 0.7704 0.1569 0.5400 0.8810 0.4636 Hier. Summary 0.8103 0.2286 0.3908 0.8313 0.5194 0.7584 0.1012 0.5266 0.8847 0.5871 Sparse 0.7478 0.1998 0.3846 0.9419 0.5689 0.7094 0.3676 0.5536 0.9707 0.6503 Dense 0.7555 0.2806 0.3992 0.9415 0.5942 0.6887 0.3360 0.5506 0.9657 0.6353 Hybrid 0.7566 0.2394 0.4076 0.9381 0.5854 0.7079 0.3986 0.5512 0.9689 0.6566 ReMEMBER 0.7854 0.3133 0.4089 0.9401 0.6119 0.7529 0.4230 0.5632 0.9681 0.6768 Table 7: Summary quality by domain and summarization model across memory construction methods. Win-Comp, Gap-Comp, Conc, Faith, and Composite denote window completeness, gap-resolution completeness, conciseness, faithfulness and their mean, respectively. Memory Type Chit-Chat Workplace Recent Memory 0.3019 0.4679 Inc. Summary 0.4859 0.2942 Hier. Summary 0.5519 0.2059 Sparse 0.4057 0.5666 Dense 0.4983 0.4854 Hybrid 0.4798 0.5719 ReMEMBER 0.6918 0.7018 Table 8: Domain-wise Memory Recall scores across memory construction methods, reported separately for Chit-Chat and Workplace domains. Model Chit-Chat Workplace Memory Recall Gap-Comp Memory Recall Gap-Comp Qwen3.5-9B 0.6810 0.4006 0.6322 0.4581 Gemma-4-E2B-it 0.6509 0.4041 0.6361 0.4652 Qwen3.5-4B 0.6918 0.3938 0.7018 0.4719 Table 9: Gap detection model variation. Domain-wise memory recall and Gap-Comp scores are reported. Summaries are generated with Qwen3.5-4B across all configurations. Gap-Comp denotes Gap-Resolution Completeness. Appendix C Additional Analysis of ReMEMBER This appendix provides additional analyses of ReMEMBER beyond the main results. We examine whether the gains are consistent across different summarization models and dialogue domains, whether memory recall improvements hold separately in chit-chat and workplace settings, and whether gap detection depends on the choice of compact LLM. Together, these analyses test whether the benefits of gap-conditioned memory construction are robust to generator choice, domain characteristics, and the model used for detecting unresolved contextual gaps. C.1 Gap Detection Model Ablation Table 9 reports the effect of varying the gap detection model across two domains. All three compact models yield comparable performance, indicating that gap detection does not require a large model. Performance variation across domains is more pronounced than across models, suggesting that domain characteristics drive recall differences more than model capacity. C.2 Memory Recall Across Domains Table 8 reports Memory Recall separately for the chit-chat and workplace domains. Across both domains, ReMEMBER achieves the highest recall among memory construction baselines, reaching 0.6918 in chit-chat and 0.7018 in workplace. This indicates that gap-conditioned memory construction improves evidence recovery across both dialogue settings. The domain-wise results show different baseline behavior. In chit-chat, summarization-based memory is relatively strong, with Hier. Summary reaching 0.5519 recall and Inc. Summary reaching 0.4859. This is likely because chit-chat dialogues are shorter on average, making compression less lossy than in longer workplace histories. In workplace dialogues, summarization-based memory degrades sharply, while retrieval-based memory is stronger, with Hybrid reaching 0.5719 recall. This suggests that as dialogue histories become longer, repeated compression loses fine-grained evidence, whereas retrieval better preserves localized historical evidence. Despite these domain differences, ReMEMBER consistently improves over the strongest baseline in each domain. It improves over Hier. Summary by 0.1399 in chit-chat and over Hybrid by 0.1299 in workplace. These results show that explicitly querying unresolved contextual gaps recovers evidence that both compression-based and window-level retrieval baselines miss. Type Name / Usage Source / ID Params VRAM GPU h / call Sec. / call LLM Qwen3.5-4B Qwen/Qwen3.5-4B 4B 30GB 0.000436 1.57 Qwen3.5-9B Qwen/Qwen3.5-9B 9B 60GB 0.000392 1.41 Qwen3.6-27B Qwen/Qwen3.6-27B 27B 90GB 0.001060 3.81 Gemma-4-E2B-it google/gemma-4-E2B-it 5B 30GB 0.000387 1.39 Gemma-4-31B-it google/gemma-4-31B-it 31B 90GB 0.000458 1.65 + thinking mode 31B 90GB 0.020000 72.00 GLM-4.7-Flash zai-org/GLM-4.7-Flash 30B 90GB 0.000162 0.58 Embed. Qwen3-Embedding-0.6B Qwen/Qwen3-Embedding-0.6B 0.6B 3GB – – Preproc. Sentence segmentation NLTK punkt Bird et al. (2009) – – – – Token counting tiktoken cl100k_base – – – – Datasets EverMemBench EverMind-AI/EverMemBench-Dynamic – – – – LoCoMo snap-research/locomo – – – – RealTalk21 danny911kr/REALTALK – – – – Table 10: Model, embedding, preprocessing, and dataset implementation details. All model runs used a single NVIDIA H200 GPU at FP16 precision. VRAM denotes the approximate peak allocated GPU memory. GPU hours and seconds report the average cost per model call, computed over all calls made with each model. C.3 Performance Across Summarizers and Domains Table 7 reports summary quality across three summarization models and two dialogue domains. Across all summarizers, ReMEMBER outperforms the memory construction baselines in both domains, achieving the highest composite score in every setting, indicating the best overall balance among window completeness, gap-resolution completeness, conciseness, and faithfulness. The gains are mainly driven by gap-resolution completeness. ReMEMBER consistently improves Gap-Comp over recency-, summarization-, and retrieval-based memory, showing that the recovered evidence is not only present in memory but also usable by different downstream summarizers. The results also show that the benefit of ReMEMBER is not tied to a particular generator. With Qwen3.5-4B (Qwen Team, 2026a), Qwen3.5-9B, and Gemma-4-E2B-it (DeepMind, 2026), ReMEMBER yields the strongest overall performance across both domains while maintaining competitive window completeness and faithfulness. Retrieval-based methods (Sparse, Dense, Hybrid) often preserve faithfulness, but their Gap-Comp remains lower because window-level retrieval misses evidence required to resolve underspecified current-window utterances. Summarization-based memory (Inc. Summary, Hier. Summary) sometimes improves window completeness, but its Gap-Comp remains limited, indicating that repeated compression discards fine-grained historical evidence. The diagnostic references further clarify the bottleneck. No Memory preserves high faithfulness but cannot resolve history-dependent gaps, while Full Memory often lowers window completeness and conciseness, especially in the workplace domain. Ideal Memory provides a reference-evidence upper bound. Its gap-resolution scores remain below perfect, indicating that even when relevant evidence is supplied, summary generation can still fail to fully express the resolved information. Overall, these results suggest that gap-conditioned memory construction improves overall summary quality consistently across summarization models and dialogue domains. Appendix D Model and Hardware Details Table 10 summarizes the implementation resources used in our experiments, including model and embedding identifiers, dataset sources, hardware, precision, peak allocated VRAM, and measured average runtime cost. We use Qwen3.5-4B (Qwen Team, 2026a), Qwen3.5-9B (Qwen Team, 2026a), and Gemma-4-E2B-it (DeepMind, 2026) for gap detection and summary generation. We use Qwen3.6-27B (Qwen Team, 2026b), Gemma-4-31B-it (DeepMind, 2026), and GLM-4.7-Flash (Team et al., 2025) for benchmark construction and evaluation. For Gemma-4-31B-it, we report non-thinking mode by default, with thinking-mode costs shown in parentheses. We use NLTK (Bird et al., 2009) punkt for sentence segmentation and tiktoken (OpenAI, 2022) with the cl100k_base encoding for approximate token counting when constructing windows, chunks, and memory budgets. All model runs use a single NVIDIA H200 GPU. All results are reported from a single experimental run. Appendix E Scientific Artifacts All experiments use existing research datasets and open-weight language models. The model checkpoints are publicly accessible through Hugging Face. Benchmark statistics and implementation details are provided in Appendix A.1 and Appendix D. Appendix F Use of Generative AI We used AI assistants for coding assistance (Codex) and for grammar checking (Claude) during the preparation of this paper. Prompt: Gap Detection in ReMEMBER You are building retrieval queries for long-dialogue memory. Input is ONLY the current conversation window. Earlier history is hidden. Task: Find current-window utterances that a concise summary would mention, but that cannot be stated faithfully without earlier dialogue. Do not answer the missing context. Convert each missing slot into a retrieval need for earlier dialogue. Select an utterance when: ∙ it is a concrete action, plan, decision, result, request, question, issue, artifact, task, review, test, fix, status update, owner assignment, or personal update; ∙ it would likely appear in a summary of the current window; ∙ a specific referent, artifact, owner, project, scope, version, rationale, requirement, decision, result, deadline, or prior state is missing from the current window; ∙ the missing context is likely stated in earlier dialogue. Do not select greetings, thanks, small talk, generic reactions, self-contained utterances, image-only references, or merely nice-to-know details. For each gap: ∙ quote the exact current-window utterance or the shortest complete span; ∙ gap_reason must name the missing slot and why the quote is not self-contained; ∙ evidence_need_query starts with ”retrieve earlier dialogue …” and uses only visible words from the current window plus the missing-slot type; ∙ keywords are stable anchor terms copied from the quote or surrounding topic; ∙ never guess the answer. Prefer recall for real summary-worthy gaps. If several related utterances refer to the same missing context, select the most informative one. Output up to max_gaps gaps. Return compact JSON only: "gaps": [ "utterance_index": 0, "quote": "exact quote, <= 220 chars", "gap_reason": "missing slot and why earlier context is needed, <= 220 chars", "evidence_need_query": "retrieve earlier dialogue identifying/stating/explaining ...", "keywords": ["up", "to", "8", "anchors"] ] Positive examples: Utterance: ”Please help review it again to see if the logic is sound.” Output gap_reason: ”The artifact referred to by ’it’ and the logic being reviewed are not identified in the current window.” Output evidence_need_query: ”retrieve earlier dialogue identifying the artifact to review and the logic that should be checked” Utterance: ”Received, I will immediately arrange test cases, and formal testing will begin tomorrow.” Output gap_reason: ”The feature or task being tested is not identified in the current window.” Output evidence_need_query: ”retrieve earlier dialogue identifying the feature or task for the test cases and formal testing” Utterance: ”This confirms we should not change the current allocation.” Output gap_reason: ”The allocation and confirming rationale are not stated in the current window.” Output evidence_need_query: ”retrieve earlier dialogue stating the current allocation and why it should remain unchanged” Negative examples: Utterance: ”Thanks, that sounds great!” Do not output: not summary-worthy and no required earlier evidence. Utterance: ”The API documentation was updated today.” Do not output if the current window already identifies which API or the summary can faithfully state the update without earlier context. Current window: window Figure 3: Prompt template for gap detection in ReMEMBER. Prompt: Memory-Augmented Dialogue Summary Generation Your task is to generate a ’Reinforced Dialogue Summary’ by synthesizing current [Window] with [Memory] in a fact-centered manner. Instructions: 1. Fully understand [Window] then carefully read [Memory]. 2. Map all entities in [Window] to their specific Identity, Role, or Context defined in [Memory]. Replace all vague terms with these precise identifiers. 3. Enrich the content of [Window] by integrating missing context such as coreference, causality, logical continuity, and technical details from [Memory] where applicable. 4. Generate a concise, high-density, and contextually reinforced summary centered on the content in [Window]. The result should be a cohesive narrative that reflects the core insights and the logical evolution of the situation. Provide your output as JSON. No additional explanation. "summary": "Your high-density, contextually reinforced summary here." [Window] window [Memory] memory Figure 4: Prompt template for memory-augmented dialogue summary generation. Prompt: Memory Recall Evaluation You are a strict memory coverage evaluator. Your task is to judge whether MEMORY explicitly contains the information needed to resolve each GAP. For this task, the information needed to resolve a GAP is already defined in the GAP ITEM. You must not redefine it. ∙ supporting_sentences provide the information that resolves the GAP. ∙ supporting_reasoning explains why that information resolves the GAP. Do NOT decide that the GAP needs additional information beyond the provided supporting_sentences and supporting_reasoning. Your job is not to redesign the gap resolution. Your job is only to check whether MEMORY contains that key information explicitly, either verbatim or as a close semantic paraphrase. For each GAP: 1. Identify the key information expressed by supporting_sentences, using supporting_reasoning only to understand why that information resolves the GAP. 2. Check whether that same key information is present in MEMORY. 3. Decide 1 if MEMORY contains that information explicitly, either verbatim or as a close semantic paraphrase. 4. Decide 0 only if MEMORY does not contain the key information from the supporting_sentences, contains only broad topical overlap, or contradicts it. Important: ∙ The coverage criterion is fixed by supporting_sentences and supporting_reasoning, not by your own idea of what else might be useful to resolve the salient_utterance. ∙ Do NOT introduce new required information. ∙ Do NOT mark 0 because some additional background, definition, detail, or rationale would be helpful if it is not part of supporting_sentences or supporting_reasoning. ∙ Use DIALOGUE only to understand the salient_utterance context. Do NOT derive additional required information from DIALOGUE. ∙ The final decision must be based only on MEMORY, but the target information to look for is defined by supporting_sentences and supporting_reasoning. ∙ MEMORY does not need to quote supporting_sentences verbatim. A close semantic paraphrase is enough, but broad topical similarity is not enough. ∙ Do not use outside knowledge or common sense. ∙ If MEMORY contains the key information from supporting_sentences, choose 1. Gap-type guide: ∙ Coreference (C): MEMORY must contain the information that identifies the referent. ∙ Attribute (A): MEMORY must contain the information for the missing attribute, state, role, scope, constraint, or specification. ∙ Logic (L): MEMORY must contain the information for the rationale, causal link, motivation, dependency, or justification. Return JSONL only: "gap_id": "...", "gap_type": "C/A/L", "target_information": [ "Atomic key information from supporting_sentences, interpreted with supporting_reasoning" ], "evidence_from_memory": [ "target_item": "...", "memory_index": "M# or null", "text": "Exact or semantically equivalent supporting span from MEMORY" ], "missing_target_information": [ "Key target information not found in MEMORY" ], "decision": "1 or 0", "reasoning": "One concise sentence explaining whether MEMORY contains the target information." [DIALOGUE] window [MEMORY] memory [GAP ITEMS] gaps Figure 5: Prompt template for memory recall evaluation. Prompt: Window Completeness Evaluation For each salient utterance (U#), follow these steps: 1. Identify the single most important claim in the utterance. Decompose it into two parts: (a) the core referent — the specific entity, event, decision, or quantity at the center of the claim; (b) the essential relation — the role this referent plays (who did what, when, why, or to whom) that makes the utterance salient. 2. Decide whether a reader who sees only the summary could recover the claim with both (a) the correct referent and (b) the correct relation. ∙ Paraphrase is acceptable for the referent (synonyms, role-based references, alternate phrasings) as long as it uniquely identifies the same thing in (a). ∙ Narrative coverage of the same topic, project, or domain — without naming the specific referent or stating the specific relation — does NOT count. Score 0.0 in that case. ∙ A summary that mentions the referent but only in a different context (different action, different time, different participants) does NOT count for that relation. ∙ Do not use outside knowledge or commonsense inference. The claim must be directly recoverable from the summary text. Scores (binary): ∙ 1.0: The summary states both (a) the specific referent and (b) the specific relation. A reader recovers the complete claim from the summary alone. ∙ 0.0: Anything else — the referent is missing or only described by a generic role; the relation is generalized, vague, or missing; the summary only mentions the broader topic/narrative; the summary contradicts the claim; or the claim is only implied through commonsense. Partial coverage does NOT earn credit. Output JSON only. No explanation. [ "utterance_num": "U0", "score": 1.0, "line_number": ["S1", "S3"] , ... ] N Summary Sentences (S#): summary M Salient Utterances (U#): salient_utterances Figure 6: Prompt template for window completeness evaluation. Prompt: Gap-Resolution Completeness Evaluation, Part I For each gap case (G#), evaluate whether the summary recovers the missing context. Goal: Reward the summary only if it contains the specific missing context from relevant_chunk that is absent from salient_utterance. Do NOT reward the summary for merely covering the same event, topic, relationship, preference, plan, project, document, task, or broad narrative. For each gap case (G#), follow these steps: 1. Identify the exact gap in the salient_utterance. Write one concrete question Q that asks for the missing antecedent, referent, source, target, object, decision, time, quantity, or relation. Q must be answerable only by using relevant_chunk, not by using salient_utterance alone. 2. Select exactly one gap-resolving fact F from relevant_chunk. F must be the minimal fact that directly answers Q. F must satisfy ALL of the following: ∙ (a) Directness: F resolves the exact missing information in salient_utterance. Do not choose a related fact just because it appears in the summary. ∙ (b) Core referent: F includes the specific entity, event, decision, document, person, date, quantity, or object that answers Q. ∙ (c) Essential relation: F includes the role this referent plays (who did what, when, why, to whom, about what, or based on what). ∙ (d) Novelty: F is not already lexically or semantically present in salient_utterance. If the summary could be written using only salient_utterance without reading relevant_chunk, score 0.0. ∙ (e) Minimality: F should not be a broad summary of relevant_chunk. It should be the smallest fact needed to fill the gap. If relevant_chunk contains multiple possible facts, choose the one that most directly fills the missing slot in salient_utterance. Do not choose an alternative fact merely because the summary mentions it. Do not use ”OR” facts. Pick one F. 3. Decide whether the summary alone contains F. The reader sees only the summary, not relevant_chunk and not salient_utterance. Apply ALL tests. Any single failure -> score 0.0. T1. Exact gap coverage: Does the summary answer Q with the same F selected from relevant_chunk? T2. Referent + relation: Does at least one cited summary sentence explicitly contain both the core referent and the essential relation? If the summary mentions only the referent, or only a related action, score 0.0. T3. Fidelity: The summary’s answer to Q must match relevant_chunk. If it gives a different plausible answer, different participant, different object, different time, or different relation, score 0.0. T4. Anti-echo: If the summary only restates the salient_utterance’s topic, category, or already-known referent without adding F from relevant_chunk, score 0.0. T5. Anti-narrative: If the summary only states that an event, conversation, relationship, preference, routine, trip, health issue, project, task, meeting, document, decision, or implementation happened, but does not recover the missing concrete context required by Q, score 0.0. T6. Specificity: Generic role mentions such as ”they”, ”someone”, ”the friend”, ”the family member”, ”the place”, ”the thing”, ”the plan”, ”the issue”, ”the team”, ”the project”, ”the document”, ”the solution”, or ”the requirements” do not count unless they uniquely identify the same concrete referent and relation as F. T7. No outside knowledge: Do not use commonsense, world knowledge, or assumptions to bridge missing information. F must be directly recoverable from summary text. Scores (binary): ∙ 1.0: The summary explicitly recovers the selected F, including both the specific referent and essential relation, and the cited summary sentence(s) support it. ∙ 0.0: Any test fails, no valid F exists, the summary is silent on Q, the summary only covers the broad narrative, the summary only echoes salient_utterance, or the summary contradicts F. Figure 7: Prompt template for gap-resolution completeness evaluation, Part I. Prompt: Gap-Resolution Completeness Evaluation, Part I Examples (illustrative, do NOT copy verbatim): Example A — score 1.0 (personal plan) salient_utterance: ”I finally booked it for next Friday.” relevant_chunk: ”Maya said she wanted to celebrate her birthday at the small Thai place near the river because it has vegan options.” Q: What was booked for next Friday? F: ”Maya’s birthday celebration at the small Thai place near the river” summary contains: ”the speaker booked Maya’s birthday dinner at the riverside Thai restaurant for next Friday” score: 1.0 Example B — score 0.0 (wrong answer) salient_utterance: ”He said that was the reason he stopped going.” relevant_chunk: ”Daniel stopped going to the climbing gym after he hurt his wrist during a bouldering class.” Q: Why did Daniel stop going? F: ”Daniel stopped going to the climbing gym because he hurt his wrist during a bouldering class” summary contains: ”Daniel stopped going because the membership became too expensive” score: 0.0 Example C — score 0.0 (salient echo) salient_utterance: ”I made sure to avoid it when I cooked for her.” relevant_chunk: ”Nina is allergic to walnuts, but almonds and cashews are fine.” Q: What did the speaker avoid when cooking for Nina? F: ”walnuts, because Nina is allergic to them” summary contains: ”the speaker cooked carefully for Nina and avoided an ingredient” score: 0.0 Example D — score 0.0 (broad narrative) salient_utterance: ”That place is why I want to go back in June.” relevant_chunk: ”When we visited Kyoto last spring, the quiet garden behind Nanzen-ji was Elena’s favorite stop.” Q: Which place made the speaker want to go back in June? F: ”the quiet garden behind Nanzen-ji in Kyoto” summary contains: ”the conversation described a memorable previous trip and a desire to return” score: 0.0 Example E — score 1.0 (work/domain case) salient_utterance: ”This task can be closed today.” relevant_chunk: ”Today is the last day for the platform’s microservice architecture diagram review.” Q: Which task can be closed today? F: ”the platform’s microservice architecture diagram review can be closed today” summary contains: ”the platform’s microservice architecture diagram review was completed and closed today” score: 1.0 Output JSON only. No explanation. [ "gap_num": "G0", "utterance_num": "U0", "question": "What concrete missing information is required?", "selected_F": "The minimal fact from relevant_chunk that directly answers the question.", "score": 1.0, "line_number": ["S1", "S4"] , ... ] N Summary Sentences (S#): summary M Gap Cases (G#): gap_cases Figure 8: Prompt template for gap-resolution completeness evaluation, Part I. Prompt: Summary Fact Decomposition for Faitfulness You are decomposing a generated summary into self-contained evaluable facts for factuality evaluation. For each summary sentence (S#), follow these steps: 1. Identify all verifiable claims in the sentence, not only the main claim. A claim is verifiable if it can be checked against the dialogue context as true or false. 2. Decompose each claim into a self-contained evaluable fact. For each fact, preserve: (a) the core referent — the specific entity, event, decision, state, quantity, or issue at the center of the claim; (b) the essential relation — what happened to the referent, who did what, when, why, how, or to whom; (c) support-relevant details — details that affect verification, such as time, location, quantity, frequency, negation, comparison, condition, cause, or consequence. 3. Split coordinated or compressed claims when they express different verifiable information. ∙ Split claims connected by ”and”, ”but”, ”while”, ”because”, ”so”, ”after”, ”before”, or similar relations when each part can be verified separately. ∙ If a causal, temporal, contrastive, or decision relation is itself asserted, preserve it as a separate evaluable fact. ∙ Do not drop details that change the truth condition of the claim. 4. Make each fact self-contained. ∙ Resolve pronouns and vague references using only the generated summary. ∙ You may use surrounding summary sentences only to resolve references. ∙ Do not use the source dialogue, retrieved memory, external knowledge, or commonsense inference. ∙ Do not add information that is not explicitly stated in the generated summary. 5. Exclude non-verifiable or subjective statements. ∙ Do not extract vague judgments such as ”the discussion was productive” unless the summary explicitly states verifiable evidence for them. ∙ Do not create trivial facts such as ”the team existed”, ”the issue existed”, or ”the box existed.” ∙ Each fact must be traceable to a specific source span in the generated summary. Output JSON only. No explanation. Return a compact JSON array. Each object must contain exactly these keys: ∙ ”sentence_num”: the source sentence id such as ”S0” ∙ ”fact_id”: a stable id such as ”S0-F0” ∙ ”fact”: one self-contained evaluable fact Return [] if there are no verifiable facts. After the closing ] stop immediately. [ "sentence_num": "S0", "fact_id": "S0-F0", "fact": "A self-contained evaluable fact." ] N Summary Sentences (S#): summary Figure 9: Prompt template for decomposing summary sentences into atomic facts. Prompt: Faitfulness Evaluation You will receive a transcript followed by a corresponding summary. Your task is to assess the factuality of each summary sentence across nine categories: ∙ no error: the statement is factually consistent with the transcript. This includes paraphrase, generalization, aggregation, and reasonable inference that is entailed by or follows naturally from the transcript, even if it is not stated verbatim. Do not penalize a sentence merely because the wording differs or because it synthesizes information across multiple turns. ∙ out-of-context error: the statement asserts a specific fact that is neither stated in nor reasonably inferable from the transcript (genuine fabrication). Do NOT use this category for legitimate paraphrase, summary-level abstraction, or inference that the transcript supports. ∙ entity error: the primary arguments (or their attributes) of the predicate are wrong. ∙ predicate error: the predicate in the summary statement is inconsistent with the transcript. ∙ circumstantial error: the additional information (like location or time) specifying the circumstance around a predicate is wrong. ∙ grammatical error: the grammar of the sentence is so wrong that it becomes meaningless. ∙ coreference error: a pronoun or reference with wrong or non-existing antecedent. ∙ linking error: error in how multiple statements are linked together in the discourse (for example temporal ordering or causal link). ∙ other error: the statement contains any factuality error which is not defined here. The transcript may be split into several labeled sections (for example prior context / memory and the current dialogue window, or retrieved passages). Treat all sections together as a single body of ground-truth evidence: a summary sentence is supported as long as ANY section supports it. Never flag a sentence merely because its supporting evidence sits in the prior-context/memory portion rather than the current window. Instruction: First, compare each summary sentence with the transcript. Judge whether the claim is contradicted by or unsupportable from the transcript — not whether it is restated word-for-word. Reasonable inference, paraphrase, and synthesis across turns are acceptable and should be labeled ”no error”. Only assign an error category when the sentence states something that conflicts with the transcript or asserts a specific fact the transcript does not support. Second, provide a single sentence explaining which factuality error the sentence has. Third, answer the classified error category for each sentence in the summary. Provide your answer in JSON format. The answer should be a list of dictionaries whose keys are ”sentence”, ”reason”, and ”category”. No additional information: [ "sentence": "first sentence", "reason": "your reason", "category": "no error", "sentence": "second sentence", "reason": "your reason", "category": "out-of-context error", "sentence": "third sentence", "reason": "your reason", "category": "entity error", ] Transcript: transcript Summary with N sentences: summary Figure 10: Prompt template for faithfulness evaluation. Prompt (a): Incremental Summarization — Initial Segment Summary Generate a fact-centered summary for the following dialogue segment. [Instructions] 1. Introduce all participants and entities with their exact names and roles as stated. 2. Preserve all proper nouns, technical terms, and numerical data verbatim. 3. Record specific content — not that a topic was raised, but exactly what was said. [Input] Dialogue Segment: chunk Prompt (b): Incremental Summarization — Running Summary Update (Incremental) Update the running summary by integrating Segment i. [Instructions] 1. Preserve all proper nouns, technical terms, and numerical data from both sources verbatim. 2. Record specific content — not that a topic was raised, but exactly what was said. 3. Integrate new information seamlessly into the existing summary. [Input] Running Summary: running_summary New Segment: chunk Prompt (c): Hierarchical Summarization — Level 0 Segment Summarization Summarize Segment i with full factual fidelity. Preserve all proper nouns, technical terms, numerical data, and speaker attributions. Do not generalize. [Input] Dialogue Segment: chunk Prompt (d): Hierarchical Summarization — Intermediate Merge Merge these summaries into one cohesive summary. Preserve all proper nouns, technical terms, and factual details. [Input] merged_input Prompt (e): Hierarchical Summarization — Final Merge Merge the following summaries into a single cohesive summary. Strict limit: under max_new_tokens tokens. Preserve all proper nouns, technical terms, and factual details. [Input] merged_input Figure 11: Prompt templates for summarization-based memory construction. Incremental summarization: (a) initialization generates the first summary from a new segment; (b) update integrates a new segment into an existing running summary. Hierarchical summarization: (c) level-0 summarizes each segment individually; (d) intermediate merge combines groups of segment summaries; (e) final merge produces the top-level summary under a strict token budget. Prompt: Memory-Free Dialogue Summary Generation Your task is to generate a ’Dialogue Summary’ of current [Window] in a fact-centered manner. Instructions: 1. Fully understand [Window]. 2. Generate a concise, high-density summary of [Window]. The result should be a cohesive narrative that reflects the core insights and the logical evolution of the situation. Provide your output as JSON. No additional explanation. "summary": "Your high-density summary here." [Window] window Figure 12: Prompt template for dialogue summary generation. Prompt: (i) Salient Utterance Identification and (i) Contextual Dependence Judgment You are a Linguistic and Dialogue Context Analyst specializing in discourse coherence and pragmatics. Your task is to analyze the provided dialogue excerpt to identify Salient Utterances and categorize their Contextual Gaps based ONLY on the provided text. # Instructions 1. Select sentences that contain a concrete decision, request, action item, or status update. ∙ Merge Rule: If consecutive sentences form one coherent update/decision, merge them into a single entry. ∙ Exclude: Simple acknowledgments (”Okay”), greetings, praise (”Great job”), or emotional reactions. 2. For each salient utterance, judge whether it is contextually self-contained for summarization: ∙ Identify pronouns, vague entities, underspecified concepts, missing attributes, and unstated reasoning that may prevent the utterance from being summarized independently. ∙ Check whether the information needed to interpret the utterance in a stable and unambiguous way is explicitly available in the excerpt. ∙ Assign a gap if the utterance is not sufficiently self-contained to support a contextually self-contained summary based on the current window alone. 3. For each salient utterance, assign a gap type: ∙ Coreference Resolution (C): a pronoun, shorthand reference, or vague noun phrase cannot be stably resolved from the excerpt. ∙ Attribute/State Supply (A): a key concept, entity property, parameter, state, scope, or specification is missing, making the utterance insufficiently self-contained for summary writing. ∙ Logic/Causal Connection (L): the utterance depends on prior reasoning, motivation, agreement, comparison, or constraint that is not given in the excerpt, so the conclusion or action is not fully supported within the window. ∙ No Gap (N): the utterance is sufficiently self-contained to be summarized clearly and stably from the excerpt alone. 4. Rules: ∙ Use the standard of self-contained summarizability, not mere rough interpretability. ∙ Mark N only when the utterance can be summarized from the current window without needing earlier dialogue to resolve its main meaning, reference, or rationale. ∙ If nearby sentences fully resolve the missing information, do not mark a gap. ∙ Do not mark a gap just because additional detail could make the utterance richer. ∙ Commonly understood domain terms are not gaps by themselves, but project-specific concepts may be gaps if they remain underspecified for summary writing. ∙ Clarification questions or examples can still have gaps if they rely on missing prior context. Provide your answer in JSONL format. No additional explanation. ’sentence_numbers’: [number, number], ’sentences’: [’text’, ’text’], ’reason’: ’concise gap analysis’, ’gap_type’: ’N | C | A | L’ ’sentence_numbers’: [number], ’sentences’: [’text’], ’reason’: ’concise gap analysis’, ’gap_type’: ’N | C | A | L’ --- # [Input Dialogue] window Figure 13: Prompt template for salient utterance identification and contextual dependence judgment. Prompt: (i) Candidate History Filtering You are a Context Retriever specializing in conversation threading. Your task is to determine, for EACH chunk in [Dialogue Context], whether the chunk is relevant to the [Dialogue Window]. [Dialogue Context] contains multiple past-dialogue chunks. You must evaluate each chunk independently and output one binary label per chunk. A label should be: ∙ 1: The chunk contains prior dialogue that is necessary or directly useful for understanding, continuing, or summarizing the current [Dialogue Window]. ∙ 0: The chunk is unrelated, only loosely topically similar, or not needed to maintain the conversational thread. A chunk is relevant if it contains at least one of the following: 1. A topic, entity, event, plan, task, or decision that is explicitly continued in the Dialogue Window. 2. Prior information needed to resolve references in the Dialogue Window, such as “this,” “that,” “it,” “the previous one,” “the method,” or similar expressions. 3. User preferences, constraints, assumptions, or prior decisions that directly affect the current window. 4. Earlier steps of the same ongoing task, project, or discussion. A chunk is NOT relevant if: 1. It discusses a different topic or a separate session. 2. It is only generally similar but not needed for the current window. 3. It contains background information that does not change the interpretation of the current window. 4. It requires guessing or inferring a connection that is not clearly supported. Important: ∙ Evaluate each chunk separately. ∙ Process chunks in 0-based index order, from the first chunk to the last chunk. ∙ Do NOT skip any chunk, including the final chunk. ∙ Before final output, verify that the list contains one label for every chunk index from 0 to N-1. ∙ Do NOT assign one label to the entire Dialogue Context. ∙ Do NOT rank the chunks. ∙ Do NOT explain your reasoning. ∙ Output only a Python-style list of 0s and 1s. ∙ If there are N chunks in [Dialogue Context], your output must contain exactly N labels. Any output other than a single list of binary labels is invalid. --- # [Dialogue Window] Dialogue_Window_Content # [Dialogue Context, 0-based index] Dialogue_Context_Content --- # Output Format, [0,1,0,...] Figure 14: Prompt template for candidate history filtering. Prompt: (iv) Evidence and Resolution Annotation, Part I You are a Contextual Gap Resolver. Your task is to audit EACH sentence in the [CURRENT SEARCH CHUNK] and decide whether the sentence provides explicit evidence that fills a concrete missing information slot in the [TARGET]. Gap Type ∙ Coreference Resolution (C): a pronoun, shorthand reference, or vague noun phrase cannot be stably resolved from the excerpt. ∙ Attribute/State Supply (A): a key concept, entity property, parameter, state, scope, or specification is missing, making the utterance insufficiently self-contained for summary writing. ∙ Logic/Causal Connection (L): the utterance depends on prior reasoning, motivation, agreement, comparison, logic, cause, or constraint that is not given in the excerpt, so the conclusion or action is not fully supported within the window. You must act as a strict logic gate. ∙ Use only explicit evidence in the [CURRENT SEARCH CHUNK]. ∙ Do not use outside knowledge. ∙ Do not infer unstated links. ∙ Do not mark a sentence as resolving the gap merely because it shares the same topic, entity, meeting, or general context. ∙ A sentence resolves the gap only if it explicitly provides information that the target depends on for independent understanding, such as: A valid resolving sentence must explicitly provide at least one of the following: ∙ the exact referent of a vague or ambiguous expression ∙ a missing attribute, definition, state, scope, role, parameter, or specification ∙ a necessary prior decision, rationale, agreement, comparison, condition, or event ∙ an earlier action, request, or commitment that the target continues, refers back to, or presupposes Do not accept a sentence just because: ∙ it is about the same topic ∙ it mentions the same people, team, or project ∙ it appears nearby in the discourse or event flow ∙ it provides only broad background or loosely related context Figure 15: Prompt template for evidence and resolution annotation, Part I. Prompt: (iv) Evidence and Resolution Annotation, Part I # Strict Audit Protocol 1. Read the [REFERENCE WINDOW], [TARGET], [Gap Type], and [Gap Reason], and determine the exact missing content needed to resolve the gap. ∙ The missing content must be specific and concrete. ∙ Do not define it as a broad topic, general context, or abstract category. 2. Audit every sentence in the [CURRENT SEARCH CHUNK], from the first sentence. 3. For each sentence, think step-by-step: ∙ Judge the sentence only with respect to the missing content implied by the [Gap Type] and [Gap Reason]. ∙ State whether the sentence provides explicit content that fills a concrete target gap. ∙ Focus on what exact content the sentence provides or fails to provide, not on whether it is generally related. 4. Write your judgment in resolution_reasoning. ∙ resolution_reasoning must explain the sentence strictly in terms of its gap-resolution role. ∙ If the sentence resolves the gap, briefly and concretely state what missing content it provides and how that helps make the target independently understandable. ∙ If the sentence does not resolve the gap, state what the sentence does contain, then explain why that is still insufficient to resolve the gap. ∙ Make clear whether the sentence is only topically related, background-only, or missing the actual dependency needed by the target. 5. Only after writing resolution_reasoning, decide the final status. ∙ Mark the sentence as “resolve” only if it explicitly provides the missing content needed by the target. ∙ Otherwise mark it as “not_resolve”. Additional constraints for resolution_reasoning ∙ Do not say only that the sentence is “related,” “relevant,” “same context,” or “helpful.” ∙ Do not justify using topic overlap, shared entities, or discourse proximity alone. ∙ Do not restate the sentence without explaining its gap-resolution role. ∙ Do not use vague phrases such as “this helps understand the context” unless you specify exactly what missing content it provides. ∙ Keep it brief, but include the exact reason for resolve vs. not_resolve. Provide your answer in JSONL format. No additional explanation. "source_id":"T0-S0","sentence":"...","reasoning":"...","status":"resolve" "source_id":"T0-S1","sentence":"...","reasoning":"...","status":"not_resolve" [REFERENCE WINDOW] (Contextual Background) NOTE: This data is for contextual background only. Do NOT attempt to resolve the gap using this section, as it has been pre-verified that the required information is NOT present here. window [TARGET] [Sentence]: target_sentence [Gap Type]: gap_type [Gap Reason]: gap_reason [CURRENT SEARCH CHUNK] search_chunk Figure 16: Prompt template for evidence and resolution annotation, Part I. Prompt: Critical Logic Audit for Contextual Gap Resolution You are a Critical Logic Auditor. Your task is to perform a final validation of a ”Contextual Gap Resolution” result. You must determine if the provided [RESOLVING SENTENCE] truly and sufficiently fills the [GAP] in the [TARGET SENTENCE] as claimed in the [REASONING]. # Validation Criteria: 1. Sufficiency: Does the resolving sentence provide the exact missing information (referent, attribute, or logic) defined in the Gap Reason? 2. Non-Inference: Is the resolution explicit? If you still need to ”guess” or ”assume” anything to make the target clear, the resolution is INVALID. 3. Independence: After incorporating the information from the resolving sentence, can the target sentence now be summarized as a standalone, unambiguous fact? 4. Redundancy: Is the information in the resolving sentence meaningfully distinct from what is already present in the [REFERENCE WINDOW]? If the resolving sentence merely restates or duplicates content already available in the window, the resolution is INVALID — it provides no new contextual value beyond what was already accessible. # Evaluation Rules: ∙ 1: The evidence is explicit, directly addresses the gap, and makes the target self-contained. ∙ 0: The reasoning is based on topical overlap, the evidence is too vague, or the resolution requires additional unstated context. # Instructions: ∙ Audit each entry in the [CANDIDATE LIST] independently. ∙ Identify the ”source_id” for every candidate that receives a score of 1. ∙ Return the results strictly as a JSON list of strings containing only the successful ”source_id”s. ∙ No preamble, no explanation, no additional text. # Output format: ["Tn-Sm", "Tn-Sm", ...] [REFERENCE WINDOW] (Contextual Background) NOTE: This data is for contextual background only. Do NOT attempt to resolve the gap using this section, as it has been pre-verified that the required information is NOT present here. window [TARGET] [SENTENCE] target_sentence [GAP TYPE] gap_type [GAP REASON] gap_reason [CANDIDATE LIST] candidate Figure 17: Prompt template for final validation of contextual gap resolution annotations.