PaperlayerView exact revision on arXiv

Source-linked AI summary

MemFuse: Multi-Source Memory Fusion from Fragmented Observations

Chao Li, Yuanfa Li, Wenhao Wu, Xule Liu, Zhi Wang, Kun Shao

arXiv:2608.18704v1cs.CLcs.AI

TL;DR

Existing memory benchmarks do not specifically test linking fragmented, source-tagged events into traceable evidence for fusion-oriented questions. This paper introduces MemFuseBench and MemFuse, and reports the best Overall score among evaluated systems under all three LLM settings.

  • Problem

    Existing benchmarks do not specifically test whether systems can link fragmented, source-tagged events into traceable evidence for fusion-oriented questions.

  • Method

    The paper introduces MemFuseBench for source-tagged, evidence-grounded multi-source evaluation and MemFuse, which preserves event provenance while fusing related events in a causal graph.

  • Results

    MemFuse achieves the best Overall score among the evaluated retrieval and memory systems under all three LLM settings.

  • Takeaways & Limitations

    MemFuseBench establishes a fusion-centric setting for evaluating temporal reasoning, cross-source evidence fusion, and robustness to noise.

  • Takeaways & Limitations

    Evidence events required by a question are not always perfectly aligned with member events surfaced through fused-memory retrieval.

Abstract

from arXiv · show

Long-term memory is essential for agents that operate across extended interactions, yet existing memory systems and benchmarks predominantly focus on single-source textual histories. In realistic settings, however, relevant information is often fragmented across applications and devices, as well as across users and time, requiring agents to integrate dispersed observations into coherent episodic memories while preserving their source provenance. To address these gaps, we introduce **MemFuseBench**, a benchmark for *multi-source memory fusion*. MemFuseBench is built with a Scene-to-Sensor pipeline that synthesizes controllable scenarios into source-tagged observations, evidence-grounded questions, and adversarial distractors. It enables systematic evaluation of temporal reasoning, cross-source evidence fusion, and robustness to noise. We further propose **MemFuse**, a structured memory system that preserves source-level evidence in event-layer atomic memory and organizes related atomic events into cluster-layer fused memory within a causal fusion graph. During retrieval, MemFuse retrieves and organizes related evidence fragments while maintaining traceability to original source events. Experiments on MemFuseBench show that MemFuse achieves the best overall performance among the evaluated memory systems under all three LLM settings and consistently improves performance on questions requiring cross-source evidence fusion.

Introduction

The paper frames multi-source memory fusion as integrating fragmented, source-tagged events into traceable episodic memories, addressing gaps in existing memory benchmarks. It introduces MemFuseBench and MemFuse to evaluate and support this capability through controlled evidence synthesis and graph-structured retrieval.

  • Problem: Multi-source memory fusion integrates distributed semantic events while preserving event-layer provenance across different origins.Existing memory systems work well when relevant context forms a coherent history, but realistic information may be fragmented across origins.
  • Problem: Existing benchmarks test conversational recall, temporal updates, or long-context reasoning, but not traceable fusion of fragmented, source-tagged events.Some recent benchmarks include heterogeneous digital traces and multimodal evidence, yet they do not specifically evaluate fusion-oriented questions.
  • MemFuseBench: MemFuseBench uses a Scene-to-Sensor pipeline to generate source-tagged observations, evidence-grounded questions, and adversarial distractors across 357 questions and 7,823 events.The benchmark covers six diagnostic categories and includes questions requiring evidence from multiple origins while rejecting plausible distractors.
  • MemFuse: MemFuse preserves atomic event-layer evidence and organizes related events into cluster-layer memory within a causal fusion graph.During retrieval, agentic search recovers compact cluster memories together with their traceable source events.
  • Results: MemFuse achieves the best Overall score among the evaluated retrieval and memory systems under all three LLM settings.The introduction also reports consistent gains on questions requiring cross-source evidence fusion.

Related Work

Prior work develops long-term agent memory, memory benchmarks, event-centric lifelogging, and multisensor fusion, but existing benchmarks do not center linking, fusing, and tracing distributed event fragments for agent memory. MemFuseBench addresses this gap by focusing on multi-source evidence fusion with provenance.

  • Long-Term Agent Memory: Long-term agent-memory systems store past interactions as records, summaries, linked notes, or hierarchical memory units for later retrieval.Recent work also introduces structured or graph-based memory to connect related experiences and support multi-step retrieval.
  • Memory Benchmarks: LoCoMo, LongMemEval, and MemBench evaluate conversational recall, temporal updates, abstention, and long-context reasoning.EverMemBench and GroupMemBench extend evaluation to long-term interactive memory and multi-party conversations.
  • Memory Benchmarks: LifeBench and SMMBench use heterogeneous digital traces or independently originated multimodal evidence, broadening input sources for memory evaluation.However, they do not center task design on linking, fusing, and tracing distributed event fragments.
  • Multi-Source Memory Fusion: Event-centric resources and lifelogging systems organize heterogeneous records into event structures, while multisensor fusion combines signals or decisions from multiple sensors.These directions relate to multi-source evidence but are not concerned with agent memory.

MemFuseBench

MemFuseBench targets multi-source memory fusion by requiring provenance-aware reasoning over evidence fragmented across devices, applications, users, and time. Its Scene-to-Sensor pipeline produces validated, distractor-containing instances whose questions require stitching evidence from multiple events.

  • Motivation: Existing memory benchmarks do not isolate reasoning over fragmented evidence when no single record suffices, nor provide source-level provenance annotations.MemFuseBench addresses these missing properties with evidence-grounded questions that depend on stitching fragments across sources.
  • Construction Pipeline: MemFuseBench generates source-specific event streams from controllable personas and causally linked scenario timelines, then derives evidence-grounded questions.The top-down Scene-to-Sensor process projects latent activities into timestamped observations, preserving alignment between world events and source views.
  • Noise and Validation: The benchmark interleaves routine, periodic, noise, and conflict events, filters unsupported or shortcut-solvable questions, and injects plausible distractors while preserving auditable gold evidence.Reviewer-corrector validation checks intermediate artifacts for coherence, evidence support, and answer preservation under noise.
  • Validation: At least one revision was made for approximately 20% of the 357 QA instances after independent model-guided verification and manual inspection of disagreements.GPT-5.5, Claude Opus 4.6, and Gemini 3.1 Pro independently answered and evaluated every question.
  • Benchmark Scale: 357 questions span six scenario datasets and six diagnostic categories, with each question requiring 9.4 distinct events on average.Each scenario contains 1,303.8 atomic events and 110.6k tokens on average under the Gemini 3.1 Flash Lite tokenizer.

MemFuse

MemFuse separates provenance preservation from memory aggregation through event-layer atomic memory, cluster-layer fused memory, and a causal fusion graph. Its online fusion and fusion-aware retrieval jointly organize fragmented evidence while retaining traceability to source events.

  • Dual-layer memory: Event-layer atomic memory stores immutable, indexed events with provenance, while cluster-layer fused memory groups related events into retrieval units with source back-pointers.Each FusedNode contains a member set, fused summary, and links to its source events.
  • Agentic memory fusion: MemFuse builds dual-layer memory online through candidate retrieval, fusion planning, rule validation, and graph commitment.The fusion agent gathers related evidence, proposes operations, and commits only plans that pass validation.
  • Causal fusion graph: The causal fusion graph connects atomic events and fused memories through Belong, Causal, and Semantic relations that support cross-source reasoning.Belong edges ground fused summaries in member events, Causal edges encode event order, and Semantic edges connect related nodes.
  • Fusion-aware retrieval: Fusion-aware retrieval combines query planning, dense and sparse retrieval, temporal retrieval when needed, graph expansion, ranking, and evidence assembly.The retrieval agent accumulates candidates through graph relations and returns final top-k events as the context for answering.

Experiments

Experiments evaluate MemFuseBench performance across three LLM settings, comparing MemFuse with long-context, retrieval, and memory baselines under a shared top-k framework. MemFuse achieves the strongest overall top-k results, particularly on cross-source Fusion, while ablations show retrieval-time components drive most gains.

  • Experimental setup: Evaluations use the same event streams and questions across Qwen3-30B-A3B, GPT-4.1 Mini, and Gemini 3.1 Flash Lite, with GPT-4.1 Mini judging checklist coverage.Long context uses the full stream, naive RAG retrieves embedding neighbors, and memory systems use native interfaces; top-k systems share a 20-item budget.
  • Overall performance: Existing memory systems remain 0.0673–0.2060 below Long context across settings, reflecting information loss in top-k retrieval and sensitivity to the underlying LLM.The strongest memory baseline beats naive RAG under Qwen3-30B-A3B and GPT-4.1 Mini but trails it under Gemini 3.1 Flash Lite.
  • Overall performance: MemFuse achieves Overall scores of 0.4659, 0.4574, and 0.4698 across the three LLM settings, exceeding naive RAG by 0.1285–0.1481.It also exceeds the strongest competing retrieval or memory system by 0.0024–0.1461 and uses fewer inference tokens than EverMemOS in every setting.
  • Diagnostic categories: Fusion is the primary bottleneck, with naive RAG 0.2047–0.2706 below Long context; MemFuse closes 62%–78% of this gap and leads Conflict in every setting.MemFuse also scores substantially higher than naive RAG on User Query and Perspective.
  • Ablation study: Removing agentic retrieval reduces Overall by 0.1036 (22.1%), while removing retrieval constraints reduces it by 0.0513, showing retrieval-time components drive most gains.Ablations use MemFuse @k = 20 with Gemini 3.1 Flash Lite as the main LLM and GPT-4.1 Mini as judge.
  • Ablation study: Graph and cluster-level fused memory provide smaller Overall gains but category-specific benefits of 0.0609 on User Query and 0.0938 on Perspective.These components retain causal organization and cluster-layer fused memories, respectively, depending on the ablation variant.

Conclusion

The paper concludes by framing MemFuseBench and MemFuse as contributions to multi-source memory fusion for long-term agent-memory reasoning. It also identifies imperfect alignment between question-required evidence and retrieved member events as a limitation motivating future optimization.

  • Contributions: MemFuseBench supports research on multi-source memory fusion through controllable Scene-to-Sensor generation, source-level evidence, adversarial noise, and reviewer-corrector validation.These components are presented as the benchmark’s construction features.
  • Contributions: MemFuse combines event-layer atomic memory, cluster-layer fused memory, and a causal fusion graph for retrieval and expansion.The framework is introduced as a structured memory system for long-term agent-memory reasoning.
  • Limitations: A limitation is that evidence events required by questions may not perfectly align with member events surfaced through fused-memory retrieval.Future work could optimize the fusion process and graph structure to improve retrieval and answer quality.

A. Ethics and Intended Use · B. MemFuseBench Synthesis Pipeline

MemFuseBench is a fully synthetic benchmark intended for memory organization and evidence-grounded retrieval, not sensitive-attribute inference about real individuals. Its six-stage Scene-to-Sensor pipeline constructs personas and causal scenarios, renders source-tagged event streams, generates and filters evidence-supported questions, injects auditable distractors, and freezes a reviewed artifact for experiments.

  • A. Ethics and Intended Use: MemFuseBench contains no real user records but simulates multi-source personal traces, including routines, locations, device states, and cross-user interactions.Its intended use is evaluating memory organization and evidence-grounded retrieval rather than inferring sensitive attributes about real individuals.
  • A. Ethics and Intended Use: Practical deployment would require explicit user consent, cross-user and cross-source access control, audit logs, and user-governed controls.
  • B. MemFuseBench Synthesis Pipeline: The pipeline begins by sampling stable personas, shared schedules, relationships, and multi-device inventories into a persona-source graph constraining later stages.Generation uses one pass for identities and shared weekday/weekend schedules, then expands the scaffold into individual routines and device assignments.
  • B. MemFuseBench Synthesis Pipeline: Scenario construction organizes daily activities into causally linked storyline events grouped by episode, producing the latent ground-truth timeline.The timeline includes episode themes, date windows, dates, observable devices, and causal relations.
  • B. MemFuseBench Synthesis Pipeline: Event-stream synthesis projects storyline events into source-specific streams while interleaving routine, periodic, noise, and conflict events, leaving each source with only a partial view.The combined stream is timestamped, source-tagged, ordered, deduplicated by device and timestamp, and assigned scenario- and episode-qualified identifiers; generation constraints and deterministic post-processing handle different properties.
  • B. MemFuseBench Synthesis Pipeline: Category-spanning question generation produces questions, reference answers, and answer checklists across six diagnostic categories, conditioned on personas, devices, and causal relations.
  • B. MemFuseBench Synthesis Pipeline: QA filtering removes semantic duplicates, commonsense shortcuts, and items lacking answerable, evidence-supported reference answers.The implementation applies semantic deduplication, context-free answerability testing, and evidence-sufficiency checks.
  • B. MemFuseBench Synthesis Pipeline: Adversarial noise injection adds semantically similar, topically plausible distractors while keeping the gold evidence set auditable and unchanged.Finalized samples therefore contain both gold evidence and plausible non-evidence distractors.

C. MemFuse Implementation Details · Storage and Indexing

This section specifies the concrete implementation choices and fixed budgets used in the experiments, including storage and indexing backends. Atomic and fused memories preserve identifiers and links to member events for traceability.

  • C. MemFuse Implementation Details: The section records concrete implementation choices used in the reported experiments.It focuses on implementation rather than redefining the system’s conceptual procedures.
  • C. MemFuse Implementation Details: It also records the fixed budgets used in the reported experiments.These budgets are presented as fixed implementation settings.
  • C. MemFuse Implementation Details: The main paper defines MemFuse’s memory layers and agentic fusion procedure.These definitions provide the system-level context for the implementation details recorded here.
  • C. MemFuse Implementation Details: The main paper also defines typed graph relations and a fusion-aware retrieval algorithm.The implementation section records the concrete choices associated with these system components.
  • Storage and Indexing: Table 3 records the storage and indexing backends used by the system.The table is the stated source for the backend choices.
  • Storage and Indexing: Atomic events retain their benchmark identifiers.This preserves the identifiers assigned to the underlying benchmark events.
  • Storage and Indexing: Cluster-layer fused memories retain back-pointers to their member events.The back-pointers connect each fused memory to the atomic events it contains.

Retrieval Scoring and Context Assembly · Key Fixed Parameters

MemFuse retrieval combines multiple search signals, scores atomic and fused candidates with fusion-aware factors, and assembles traceable context under explicit node and length budgets. The fixed-parameter table identifies the settings most directly affecting fusion and retrieval.

  • Retrieval Scoring and Context Assembly: Each search-tool call combines dense retrieval over the original and up to three rewritten queries, BM25L lexical retrieval, and confident-window temporal retrieval.Dense retrieval considers at most 10 candidates per rewrite, and retrieval constraints apply only when planner confidence reaches 0.6.
  • Retrieval Scoring and Context Assembly: Reciprocal rank fusion combines ranked lists, and the 30 highest positive-score candidates form the seed pool.This seed pool feeds the subsequent fusion-aware retrieval scoring stage.
  • Retrieval Scoring and Context Assembly: Atomic-event scoring combines semantic similarity, graph-distance discounting, reciprocal-rank-fusion score, path priors, and date matching.The graph-expansion factor is β = 0.7; path priors are 0.08 for direct seeds, 0.06 for time-window hits, 0.04 for causal paths, 0.03 for membership paths, and 0.01 for semantic paths.
  • Retrieval Scoring and Context Assembly: Fused-node ranking combines the summary-candidate score, member-event scores, graph distance, and a mean-top-three member-score term.Fused nodes and atomic candidates are compared in a shared ranking pool using their respective scores.
  • Retrieval Scoring and Context Assembly: Context assembly adds selected atomic candidates directly, while selected fused nodes contribute summaries followed by member events within top-k and length budgets.At most three fused nodes contribute to reader context, with at most 10 member events from each.
  • Key Fixed Parameters: The fixed-parameter table focuses on settings that most directly affect fusion and retrieval, while omitting query-specific planning outputs and secondary limits.This table defines the scope of the reported fixed retrieval configuration.

D. Experimental Reproducibility · Common Evaluation Protocol

The common evaluation protocol standardizes model access, generation settings, memory construction, query planning, judging, event ordering, and reader inputs. It also ensures retrieved contexts are evaluated with consistent question metadata and reader prompts.

  • Common Evaluation Protocol: GPT-4.1 Mini and Gemini 3.1 Flash Lite are accessed through provider-hosted APIs.
  • Common Evaluation Protocol: Qwen3-30B-A3B is served locally with vLLM on one NVIDIA A100 GPU.
  • Common Evaluation Protocol: Answer generation uses temperature 1 and a 2,048-token output limit, while memory construction and query planning use temperature 1 and a 4,096-token limit.
  • Common Evaluation Protocol: The GPT-4.1 Mini judge uses temperature zero and a 4,096-token limit.
  • Common Evaluation Protocol: Events are serialized in timestamp order for every system, with Naive RAG’s selected events restored to chronological order.
  • Common Evaluation Protocol: Retrieved contexts are passed to the same reader model with the questioner identity, question time, and question.
  • Common Evaluation Protocol: Full-context and retrieved-context readers use the same user message and differ only in their system descriptions.

Answer Checklist Metric and Judge … Dimension A & B: Evidence Leakage

The paper defines checklist-based answer scoring and uses staged reviewer–corrector validation to enforce coherence, schema consistency, answer preservation, and non-leaking adversarial distractors. Adversarial events are examined for target- and cross-question evidence leakage alongside internal validity and discrimination quality.

  • Answer Checklist Metric and Judge: Each question receives a checklist-based score according to whether its checklist items are covered.Overall is the question-macro average across all questions, while category scores average questions within each category.
  • Answer Checklist Metric and Judge: GPT-4.1 Mini judges answers using the question, system answer, and checklist, with retries and reevaluation for provider or formatting failures.Unscorable questions are marked as errors, and official aggregates are withheld until resolution.
  • Reviewer–Corrector Validation Prompts: Reviewer–corrector stages validate coherence across personas, devices, timelines, events, and questions, then filter duplicate, ambiguous, shortcut-answerable, or unsupported items.Stage 6 preserves gold evidence and reference answers while allowing adversarial distractors to be revised for clarity or topicality.
  • Review Dimensions: Stage 1 checks routine alignment, conflicts, realism, device consistency, modality compliance, character consistency, field completeness, ownership, locations, device support, interests, names, identifiers, and child-device appropriateness.The checks include shared-event timing, non-overlapping activities, exact device-set equality, standard modalities, age-appropriate devices, and required-field presence.
  • Fix Workflow: The corrector independently verifies reported issues before applying prioritized fixes, treating HIGH issues as mandatory, MEDIUM issues as recommended, and LOW issues as optional.Fixes use shared_schedule as the timing ground truth and preserve consistency across device references, owners, modalities, names, and routines.
  • Step 4: Backup & Write Back: Before writing corrections, the workflow backs up the original file, writes valid JSON to the original path, validates loading, and produces a fix report.Fixes are minimal and targeted, with post-fix checks for internal consistency and JSON validity.
  • Stage 6 Reviewer Prompt: Stage 6 reviews only adversarial events linked to target questions and checks their device, modality, description, timestamp, location, and source-linked structure.Adversarial events intentionally omit a characters field and must remain semantically similar distractors without becoming evidence for the target or any other question.
  • Dimension A & B: Evidence Leakage: Evidence leakage fails review when an event directly answers, matches the quality of target evidence, completes its causal chain, contradicts evidence, or supports a different question.Cross-question checking compares each adversarial event against all questions in the same scenario, not only its assigned target.

Dimension C: Content/Logic Validity · 19. Character-Action Age/Role Inconsistency: The event

Dimension C defines content and logic validity checks for device modality, existence, observability, readings, location, timing, identity, and event atomicity. It also flags character actions inconsistent with persona attributes and duplicate device-timestamp pairs as adversarial inconsistencies.

  • Dimension C: Content/Logic Validity: Events must use devices that exist in the persona and whose modality supports the stated event.A device’s modality is cross-referenced against all_devices; nonexistent device IDs are invalid.
  • Dimension C: Content/Logic Validity: Descriptions must match the information perceivable by the stated modality rather than assert unsupported observations.For example, a health modality cannot report camera-detected movement.
  • Dimension C: Content/Logic Validity: Physiological and environmental readings are invalid when they fall outside specified plausible ranges, including heart rate, SpO2, temperature, humidity, PM2.5, and hourly steps.The listed ranges include heart rate 40-180 bpm normally, SpO2 88-100%, body temperature 35-40 deg C, room temperature 15-35 deg C, humidity 20-80%, PM2.5 0-500 ug/m^3, and 0-10000 steps per hour.
  • Dimension C: Content/Logic Validity: Events must be consistent with device location, timestamp plausibility, weekday activity, ownership, language, and single-observation atomicity.Fixed devices remain at installation locations, wearables follow their person, timestamps must fit the activity and date, personal devices must report their owner’s data, and one event must describe one instantaneous observation.
  • Dimension C: Content/Logic Validity: Descriptions must use the device’s sensing perspective and named characters, not omniscient claims or generic references such as “the user.”Devices can report only physically sensed information, while multi-person scenarios require explicit character names.
  • 19. Character-Action Age/Role Inconsistency: The event: Character actions are invalid when impossible given the character’s persona-defined age, role, or health status.The check cross-references those persona fields; examples include children driving or attending work meetings, while age-appropriate tablet gaming passes.
  • 19. Character-Action Age/Role Inconsistency: The event: An adversarial event is invalid when it duplicates both the device and timestamp of another event in the same episode.This creates an ambiguous data point across adversarial and non-adversarial events.

Dimension D: Adversarial Quality (Distractor Effectiveness) … 4. Modality-Description Match

The benchmark designs adversarial events as specific, topically related non-evidence distractors that test retrieval discrimination without leaking answers. Reviews and corrections validate cross-question safety, logical consistency, device/modality alignment, and event-description quality.

  • Dimension D: Adversarial Quality (Distractor Effectiveness); Review Passing Criteria: Adversarial events should share topical overlap with the target while remaining irrelevant to its answer; completely unrelated topics are trivially excluded and fail discrimination testing.Examples distinguish unrelated thermostat data from health-related distractors that use a different context.
  • Dimension D: Adversarial Quality (Distractor Effectiveness): Specific concrete details, such as readings, named people, or activities, are required because vague generic descriptions would not confuse retrieval systems.Generic failures include “Normal readings detected” and “Activity observed”; specificity is classified as medium severity guidance.
  • Review Passing Criteria; Stage 6 Corrector Prompt: A passing distractor is internally consistent, realistic, logically sound, and incapable of serving as evidence for the target or any other question.It may describe similar activities or readings at irrelevant times or for irrelevant purposes, while device, modality, and description remain mutually consistent.
  • Review Process: Reviewers validate each adversarial event against its target question, all scenario questions, persona devices, and content-logic constraints before documenting failures.Checks include device existence, modality compatibility, reading plausibility, location-device match, timestamp plausibility, and character-device ownership.
  • Input Files; Review Process: The review process uses scenario data, question-answer-evidence mappings, all scenario questions, persona device inventories, modality references, and dated input information.Reference information defines modalities such as health, motion, vision, audio, environment, location, app_usage, and dialogue, alongside compatible device types.
  • Severity Guide: The severity guide covers leakage, evidence equivalence, device or modality incompatibility, timestamp and reading errors, contradictions, location inconsistencies, and topic irrelevance.It also identifies structural and narrative defects such as non-atomic events, omniscient narration, generic names, and duplicate device-timestamp pairs.
  • Important Notes; Stage 6 Corrector Prompt: Reviewers should flag only genuine evidence or leakage problems, check every adversarial event thoroughly, and read complete answer text before correction.The correction prompt repairs failed events while preserving their usefulness as distractors.
  • Event Description Quality Rules (must follow when writing/rewriting descriptions); 1. Atomic Event Principle; 2. Device Perspective; 3. Name Usage; 4. Modality-Description Match: Rewritten descriptions must remain single-timepoint observations, use the device’s sensing perspective and character names, and match the stated modality’s perceptual capabilities.For example, health reports physiological metrics, motion reports activity, vision reports visual observations, and environment reports physical measurements.

5. Realistic Readings … Judge User Prompt

The section specifies realistic, specific, English observations and a conservative correction workflow for adversarial events. It also defines fusion and retrieval prompts that preserve evidence structure, enforce concrete-event criteria, and adapt queries, time windows, and coverage to the question.

  • 5. Realistic Readings: Physiological readings must stay within HR 40–200 bpm, SpO2 88–100%, temperature 35–40 deg C, and respiration 10–30/min.Environmental values must also remain plausible: room temperature 15–35 deg C, humidity 20–80%, and PM2.5 0–500 ug/m^3.
  • 6. Specificity / 7. Language: Descriptions must use concrete details such as exact readings, named activities, and particular observations, while all dataset text must be proper English.Vague descriptions such as “normal readings” or “everything fine,” Chinese text, and garbled or incomplete text are disallowed.
  • Correction Process: Correction begins with a backup, review-report inspection, issue verification against the actual event and target answer, targeted fixing, and mandatory post-fix verification.Reviewers’ findings may be rejected when verification shows a false positive.
  • Correction Process: Only flagged events with source == "adversarial" may be modified; event_id, source, target_question, answers, and evidence_event_ids remain unchanged.Descriptions are the preferred fix target, while metadata changes are restricted to field-specific validity problems and require checking device existence, modality compatibility, and location consistency.
  • Fix Strategy by Issue Type / Evidence Leakage Fixes (Dimension A & B) / Content/Logic Fixes (Dimension C) / Adversarial Quality Fixes (Dimension D): Issue-specific fixes remove direct-answer leakage, make evidence-equivalent distractors non-evidential, repair device/modality and location inconsistencies, replace impossible readings, and correct ownership, language, timestamps, and weekday activities.Adversarial descriptions must remain topically related, realistic, specific, and useful for discrimination without becoming valid evidence.
  • Post-Fix Global Verification / Output: After any evidence-leakage fix, all questions in the scenario must be checked for newly introduced leakage, with iterative revision until no question is helped by the repaired description.The fix report records verified, rejected, and applied issues by loop, including reasoning and global-verification status.
  • MemFuse Method Prompts / Fusion Agent / Fusion Agent System Prompt: The fusion agent chooses among search_memory, get_pack_members, and fusion-plan actions, using English JSON and concrete event-segment criteria rather than broad topical similarity.Fusion is reserved for the same activity instance, short scene, event segment, or mutually supportive evidence chain; causal events from different instances should use create_edge.
  • Fusion-Aware Retrieval / Round Retrieval Planning Prompt: Retrieval planning preserves the question’s answer shape, creates complementary evidence queries, normalizes dates and narrow time ranges, and enables coverage or timeline retrieval only when the question requires it.Broad multi-day questions disable time windows, while bounded episodes use explicit start and end times; confidence must be reduced below 0.6 when weekday/date resolution is uncertain.
Loading 2608.18704v1…