Expand Only When the User Pushes Back: Friction-Gated Query Expansion for Conversational Search

Search systems often fail because people and documents use different words for the same thing. A shopper types "broken pipe" while the catalog says "conduit fracture". Two families of fixes exist. One rewrites or expands the query with extra words. The other leaves the query alone and trusts the user's phrasing. Each fix is right some of the time and harmful the rest of the time. Generative expansion beats human rewrites on conversational benchmarks (ConvGQR), yet on a technical catalog, LLM rewriting removed the domain constraints that made the query precise and did worse than the raw query (ECLASS-Augmented Semantic Product Search). Users already tell us which case they are in. They do not click rating buttons, but they rephrase, skip results, page deeper, or say "no, not that one." This is implicit feedback: supervision that can be read off normal user behavior.

We propose a small recurrent controller, a gated recurrent unit (GRU) that carries a running summary of the session from turn to turn. It reads only these friction signals and decides, at each turn, how far the retriever should move away from the user's literal words toward a learned "catalog vocabulary" expansion. Training needs no annotation. When a later turn in the session succeeds, the document it found is projected backwards as the target for the earlier failed turn. The claim to test is specific: conditioning expansion on accumulated user friction beats both "always expand" and "never expand." It should help most on post-failure turns and cost nothing on turns where the user was satisfied.

Core Claim

The open problem is control, not representation. Dense encoders already bridge much of the lexical gap. The Contextualized Query Embeddings (CQE) model encodes the conversation history into one query vector in about 11ms, and expansion methods add vocabulary the user never typed. What no existing system does is use the user's behavioral reaction to decide when the added vocabulary is warranted.

The literature points to three reasons this matters:

  1. Uncontrolled expansion drifts. Gains peak at two rounds of LLM–retriever interplay in InteR.
  2. Rewriting can strip the user's own constraints (ECLASS).
  3. Models that always consult context degrade on simple standalone requests by inventing links that are not there (Tulsiani et al.).

A gate driven by friction addresses all three. On a satisfied session it stays near zero and leaves the query intact. It opens only after evidence of a mismatch.

Mechanism

At turn $t$ the retriever forms its query vector as

$$q_t = (1-g_t)\,q^{\text{raw}}_t + g_t\,q^{\text{exp}}_t, \qquad g_t = \sigma(w^\top h_t), \quad h_t = \text{GRU}(h_{t-1}, f_t).$$

The terms are:

  • $q^{\text{raw}}_t$ is the contextualized embedding of the user's words, from a CQE-style encoder.
  • $q^{\text{exp}}_t$ is the same encoder applied to the query plus a learned expansion.
  • $g_t \in [0,1]$ is a vector gate, applied per dimension, so the model can retain some aspects of the raw query while expanding others.
  • $\sigma$ is the logistic function, and $w$ is a learned weight vector.
  • $h_t$ is the GRU hidden state, the running summary of the session.
  • $f_t$ is a short vector of friction features for the transition into turn $t$.

The friction features are:

  • lexical and embedding similarity between the current and previous query, which signals a rephrase;
  • the output of a small negative-cue classifier trained on FEDI's feedback taxonomy (Petrak et al.);
  • an explicit "neutral/polite" indicator, such as for "thanks";
  • clicks, skips, and dwell where logs provide them;
  • result-page depth.

The GRU never reads full text. That keeps its per-turn cost negligible next to the encoder. It also confines the recurrent memory to the one thing gated recurrence is known to do well: learning when to keep and when to discard accumulated evidence.

Training uses backwards labeling, adapted from spoken dialogue (Park et al.; Tulsiani et al.). Take a session in which turn $k$ fails and a later reformulated turn $k'$ yields an accepted document (a click or purchase in logs, or a positively rated passage under simulated feedback). That document becomes a silver positive for turn $k$.

These pairs train two things:

  1. The expansion branch, to cross the lexical gap. It is an expansion head on the shared encoder trained with a contrastive loss, so that the failed phrasing retrieves the successful document.
  2. The gate, to decide when crossing is needed. It is trained end-to-end through the ranking loss, using backpropagation across the turns of the session.

Following the asymmetric teacher–student idea of Tulsiani et al., one optional teacher sees the whole session, future turns included. The deployed student is strictly causal and uses only past friction.

Relation to Prior Work

Three groups of work motivate the proposal.

The first group models session feedback without order. Bi et al.'s SCEM re-ranks deeper result pages using the average of embeddings for items clicked in the session. AVLEM adds negative feedback on aspect values but treats feedback as a set. We reuse their logged-session setting but model feedback as an ordered sequence of signals. The aim is not to describe intent better. It is to control how far the query is allowed to drift.

The second group uses feedback text directly. Mo et al. feed simulated user feedback into query rewriting and into MonoT5 re-ranking. They report that the feedback processors break on neutral phrases like "Thanks." Our gate consumes coarse friction features rather than raw feedback text, so it should be harder to fool with neutral phrasing; Proposed Experiments includes a direct test.

The third group supplies the method. Backwards labeling and teacher–student distillation come from ASR self-learning (Tulsiani et al.). Chen et al. observe that detecting whether an interaction went well is easier than solving the underlying task. That observation is the reason we expect friction features to be a reliable control signal, even when the retrieval itself is hard.

Two papers constrain the design.

Shi and Sen find that vocabulary alignment in dialogue has a priming distance of 1. If lexical effects are that local, a memoryless gate on the last transition might suffice, which would make recurrence unnecessary. We test this directly rather than assume otherwise.

RaFe trains rewriters from reranker scores. Its rewriter inherits any blind spots of the reranker that scores it. Our silver labels come from user success instead, so they avoid that dependence but carry their own noise, which an analysis in Proposed Experiments measures.

Research Program

The work proceeds in four steps:

  1. Build the silver-label miner. It runs over Amazon product search sessions where page 1 fails and a purchase happens on page 2 or 3, as in Bi et al., and over TREC CAsT, QReCC and TopiOCQA sessions augmented with ConvSim-style simulated feedback following Mo et al.
  2. Train the expansion head and the friction GRU on a shared dense encoder initialized from a CQE-style model.
  3. Analyze what the gate learns. We will plot gate value against turn type: first turn, post-rephrase, post-"no", post-"thanks", and standalone commands. We will also check whether the per-dimension gate preserves catalog constraint terms that ECLASS found rewriting destroys.
  4. Measure the effect of label noise. We inject false "success" events and track degradation. This addresses the data-poisoning risk Chen et al. flag for self-training on decoded interactions.

Baselines

Unconditioned dense contextual encoder. The do-nothing reference is the CQE-style encoder with $g_t=0$: no expansion, no friction. On CAsT-19/20, CQE reports CQE-hybrid nDCG@3 of 0.515. We use the same encoder checkpoint and the same index, so the only change is the gate.

Always-on generative expansion. This is the strongest existing method for conversational lexical gaps: ConvGQR, which combines rewriting with generated pseudo-answer expansion. It reports 46.5 MRR in zero-shot CAsT-20 and 42.0 MRR on QReCC with dense retrieval. We will rerun it on our retriever with the same training data and an equal tuning budget. Beating it means three things together: higher MRR and nDCG@3 overall, no loss on first and standalone turns, and lower per-query latency.

Text-feedback re-ranking. FeedbackMonoT5 represents feedback-aware systems that read the feedback text itself. Mo et al. report about a 6% average nDCG@3 gain for it and a 16% gain overall from simulated feedback. These are relative figures; the file gives no absolute nDCG for these systems, so we will report our own reruns with the same simulated feedback.

Product-search session models. On Amazon logs we compare against SCEM and AVLEM. For SCEM the file gives only relative gains over a production system: 85% MAP and 93% NDCG@10 on page 3, Cell Phones. AVLEM's reported gain is likewise relative, about 10–20% MRR over its own initial retrieval model. No absolute numbers were found on Lacuna for either, so both will be reimplemented on identical splits.

Ablations. Two ablations isolate the key ingredients:

  1. Memoryless gate. The GRU is replaced by a feedforward gate on $f_t$ alone. This tests whether recurrence matters.
  2. Ungated expansion. The expansion head is trained on the same silver pairs, but $g_t$ is fixed to a tuned constant. This tests whether friction-conditioning, rather than the silver data, carries the gain.

Why not just…?

Why not just fine-tune the dense retriever on the mined reformulation pairs and skip the gate? This is the most serious competitor, because the silver pairs may carry most of the benefit. It is exactly the ungated-expansion ablation above. The gate's justification is the turn-type breakdown. If constant expansion matches the gate on first and standalone turns, the context over-reliance and nuance stripping reported by Tulsiani et al. and ECLASS did not materialize here. In that case we will report that the contribution is the backwards-labeling miner, not the controller.

Why not just concatenate the whole history into a transformer and let attention sort it out? Full-history transformers cost about 314ms for BERT re-ranking and over 500ms for T5 reformulation, versus about 11ms for a bi-encoder (CQE). Neither these systems nor ConvGQR consumes behavioral friction signals at all. We give a CQE-style model the friction features as extra input tokens. That isolates whether a separate recurrent gate helps beyond simply exposing the signals.

Why not just use a click centroid or Rocchio feedback? Centroids average in vectors for items the user rejected and cannot represent "not that." Negative-aware AVLEM outperforms its positive-only initial model (AVLEM). Mo et al. also note that Rocchio-style feedback is polluted by conversational tokens. SCEM is nevertheless strong on deep pages, so it stays as a full baseline rather than a strawman.

Why not just a rule on the last turn, given that entrainment has priming distance 1? Shi and Sen give a real reason to expect a last-turn rule to work. The memoryless-gate ablation settles it. Recurrence is justified only if it wins on sessions with two or more failed turns, where accumulated frustration should push the gate higher than any single transition would. If it does not win there, we adopt the simpler gate.

Proposed Experiments

The main evaluation reports MRR and nDCG@3 on CAsT-19/20, QReCC and TopiOCQA, and MAP and NDCG@10 on the Amazon pagination sessions. Every result is broken down by turn type: first, standalone, post-rephrase, post-negation, and post-neutral.

Three checks decide the outcome:

  1. Satisfied turns. On turns with no preceding friction, the gated model must be statistically indistinguishable from the no-expansion encoder. An always-expand model is expected to drop on these turns.
  2. Post-friction turns. The gated model must exceed ConvGQR-style expansion.
  3. Neutral feedback. Inserting "thanks"-type feedback, which degrades the processors in Mo et al., must leave the gate value and the ranking essentially unchanged.

We also report added latency over the base encoder, which we expect to be under a millisecond. Finally, we report retrieval quality as silver-label noise increases, to bound the poisoning risk.

If the first and third checks fail, friction is not a usable control signal, and the proposal reduces to its data-mining component.