Intake: never re-ask for deal-breakers once given

core/intake.py

@@ -148,8 +148,9 @@ terms.other as a short phrase (e.g. "MRR of at least $30k", "must be profitable"
    - Warm, natural and short: at most two sentences, then ONE question. Use the member's language (English or \
 Arabic); if they write in Arabic, reply in Modern Standard Arabic.
    - After a document arrives, show you read it by mentioning one specific detail.
-   - The missing list was made BEFORE the member's latest message. Ask about the first item still unknown after you \
-apply that message. Phrase it conversationally, never like a form.
+   - The missing list was made BEFORE the member's latest message. Of the items still unknown after you apply that \
+message, ask about the one that fits the conversation most naturally (usually the first). Never ask about anything \
+the member already said in ANY earlier message or the document. Phrase it conversationally, never like a form.
    - Clarify when it matters: if an answer is vague in a way that changes who you'd recommend, ask one short \
 clarifying question before moving on. Examples: "early stage" -> pre-seed, seed, or both? "software" -> what kind \
 (B2B SaaS, fintech, AI, marketplaces)? "in Qatar" -> based in Qatar, or selling into Qatar? Never ask about details that \
@@ -424,6 +425,20 @@ def dealbreaker_lines(s: Session) -> list[str]:
     return lines + add
 
 
+_MUST_WORK = re.compile(r"\b(only|must|have to|need to be|won'?t|will not|can'?t|cannot|not willing|refuse|no)\b[^.]{0,40}"
+                        r"\b(remote|on.?site|in.?office|hybrid|relocat\w*|office)\b|\b(remote|on.?site|hybrid)\s+only\b"
+                        r"|non.?negotiable|deal.?breaker", re.I)
+
+
+def _work_only_if_required(s: Session, said: str) -> None:
+    """A work mode filters people out only if the member said it's a requirement. "Hybrid is fine" is a preference:
+    it stays in their public terms as text, but it doesn't remove on-site or remote roles."""
+    if s.terms and s.terms.work and not _MUST_WORK.search(said):
+        s.terms.work = []
+        if s.raw_terms:
+            s.raw_terms.work = []
+
+
 def _all_private(t):
     """A member's own numbers are never explained to anyone else: mark every bound private.
 
@@ -469,6 +484,11 @@ def _messages(s: Session, need: list[str]) -> list[dict]:
     if _arabic_share(last) > 0.3:
         doc += "\n\nThe member is writing in Arabic: reply in Modern Standard Arabic."
     system = SYSTEM
+    if _has_rules(s):
+        context["dealbreakers_already_given"] = dealbreaker_lines(s)
+        system += ("\nDEAL-BREAKERS ARE ALREADY GIVEN (see dealbreakers_already_given). Do not ask for deal-breakers "
+                   "again in any form: no 'any other deal-breakers?', no examples of deal-breakers. If the member adds "
+                   "one on their own, record it.")
     if delta_mode():
         context["terms_so_far"] = s.raw_terms.model_dump(exclude_none=True) if s.raw_terms else {}
         context["empty_fields"] = [k for k in ("display_name", "headline", "public_bio", "looking_for", "location",
@@ -566,25 +586,32 @@ def _turn(session_id: str, text: str, file, stream: bool):
     s.raw_terms = fix_units(mark_private(_merge_terms(s.raw_terms, turn.terms), s.draft.private_limits), said,
                             s.draft.location)
     s.terms = _all_private(to_terms(s.raw_terms))
+    _work_only_if_required(s, said)
     # A "yes" only confirms the profile if it answers the summary.
     s.confirmed = turn.confirmed and s.summary_shown and ready(s)
     s.summary_shown = turn.asks == "summary"
     if turn.asks in ("dealbreakers", "summary"):
         s.dealbreakers_asked = True  # asked once ("none" is fine); never ask again after a summary
-    asks_more = re.search(r"deal.?breaker|rule (?:someone|anyone|people) out|anything else|any other|other requirement",
-                          turn.reply, re.I) and "?" in turn.reply
-    # Once they've just given deal-breakers and nothing required is missing, the next step is the summary: any other
-    # question here (more deal-breakers, equity, timeline...) would make their next "yes" ambiguous.
-    if _rules(s) != rules_before and _has_rules(s) and not _required(s) and (asks_more or turn.asks != "summary"):
-        # They just gave their deal-breakers; asking "any others?" makes the next "yes" ambiguous (and the
-        # model's own asks label can't be trusted here). Ask once more with a direct instruction.
-        note = [{"role": "user", "content": "(Note from Handshake: the member has just given their deal-breakers. "
-                                            "Write the summary now and ask only whether it is correct.)"}]
+    asks_more = re.search(r"deal.?breaker|rule (?:someone|anyone|people) out|anything else|any other|other requirement"
+                          r"|non.?negotiable|must.?have|would make you say no", turn.reply, re.I) and "?" in turn.reply
+    todo = _required(s)
+    # Deal-breakers are known, so asking for more makes the member repeat themselves (and makes their next "yes"
+    # ambiguous). And once they've just given them with nothing else missing, the next step is the summary.
+    redo = None
+    if _has_rules(s) and asks_more:
+        redo = ("Write the summary now and ask only whether it is correct." if not todo else
+                f"Do not ask about deal-breakers. Ask only about: {todo[0]}.")
+    elif _rules(s) != rules_before and _has_rules(s) and not todo and turn.asks != "summary":
+        redo = "Write the summary now and ask only whether it is correct."
+    if redo:
+        # The model's own asks label can't be trusted here, so code decides and asks once more, directly.
+        note = [{"role": "user", "content": "(Note from Handshake: the member has already given their deal-breakers. "
+                                            + redo + ")"}]
         try:
             again, _ = llm.chat_json(_messages(s, missing(s)) + note, _Turn, max_tokens=1500, timeout=TURN_TIMEOUT)
             if again.reply.strip():
                 turn = again
-                s.summary_shown = True
+                s.summary_shown = not todo
                 s.dealbreakers_asked = True
         except llm.LLMError:
             pass

tests/test_intake.py

@@ -13,11 +13,13 @@ def script(monkeypatch, turns):
 
     def fake(messages, schema, max_tokens=0, timeout=0):
         sent.append(messages)
-        nxt = queue.pop(0)
+        nxt = queue.pop(0) if len(queue) > 1 or not sent[:-1] else (queue[0] if queue else fake.last)
+        fake.last = nxt
         if isinstance(nxt, Exception):
             raise nxt
         return schema.model_validate(nxt), "fake"
 
+    fake.last = turns[-1] if turns else None
     monkeypatch.setattr(llm, "chat_json", fake)
     return sent
 
@@ -65,7 +67,7 @@ def test_monthly_qar_salary_becomes_annual_usd(monkeypatch):
 
 
 def test_terms_survive_a_turn_that_omits_them(monkeypatch):
-    script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "terms": {"valuation": {"low": 9e6}}, "asks": "summary", "reply": "a"},
+    script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "terms": {"valuation": {"low": 9e6}}, "reply": "a"},
                          {"role": "founder", "profile": FOUNDER, "reply": "b"}])
     sid = ob.start()["session_id"]
     ob.send(sid, "x")
@@ -93,7 +95,7 @@ def test_private_number_is_stripped_from_public_fields(monkeypatch):
     leaky = {**FOUNDER, "public_bio": "Won't go below a $9M valuation.",
              "public_terms": {"raising": "$2M", "valuation": "at least $9M"},
              "private_limits": ["Valuation floor $9M"]}
-    script(monkeypatch, [{"role": "founder", "profile": leaky, "asks": "summary", "reply": "ok"}])
+    script(monkeypatch, [{"role": "founder", "profile": leaky, "reply": "ok"}])
     sid = ob.start()["session_id"]
     p = ob.send(sid, "x")["profile"]
     assert p["public_bio"] == "" and "valuation" not in p["public_terms"]
@@ -207,7 +209,7 @@ def test_bad_files_get_friendly_errors(tmp_path):
 
 
 def test_dealbreaker_card_includes_numbers_the_model_did_not_word(monkeypatch):
-    script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "terms": {"valuation": {"low": 5000000}}, "asks": "summary", "reply": "ok"}])
+    script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "terms": {"valuation": {"low": 5000000}}, "reply": "ok"}])
     sid = ob.start()["session_id"]
     st = ob.send(sid, "floor is $5M")
     assert st["profile"]["dealbreakers"] == ["Valuation of at least $5M"]
@@ -225,3 +227,76 @@ def test_vision_outage_is_explained(tmp_path, monkeypatch):
     monkeypatch.setattr(llm, "read_image", lambda *a, **k: (_ for _ in ()).throw(llm.LLMError("down")))
     with pytest.raises(documents.DocumentError, match="mostly images"):
         documents.read(tmp_path / "deck.pdf")
+
+
+def test_delta_mode_merges_only_what_changed(monkeypatch):
+    monkeypatch.setenv("INTAKE_MODE", "delta")
+    script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "reply": "a"},
+                         {"profile": {"public_terms": {"timeline": "Q1 2027"}, "stage": "series a"}, "reply": "b"}])
+    sid = ob.start()["session_id"]
+    ob.send(sid, "x")
+    p = ob.send(sid, "we're series A, closing Q1 2027")["profile"]
+    assert p["public_terms"] == {"raising": "$2M", "timeline": "Q1 2027"}      # old keys kept, new key added
+    assert p["stage"] == "series a" and p["display_name"] == "Mariam" and p["role"] == "founder"
+
+
+def test_full_mode_is_the_original_prompt(monkeypatch):
+    monkeypatch.setenv("INTAKE_MODE", "full")
+    sent = script(monkeypatch, [{"role": "founder", "profile": FOUNDER, "reply": "a"}])
+    ob.send(ob.start()["session_id"], "x")
+    assert "WRITE ONLY CHANGES" not in sent[0][0]["content"] and "terms_so_far" not in sent[0][1]["content"]
+
+
+def test_looking_for_is_written_from_terms_when_the_model_skips_it(monkeypatch):
+    prof = {**FOUNDER, "looking_for": "", "public_terms": {"raising": "$1.5M", "roles": "backend engineer"}}
+    script(monkeypatch, [{"role": "founder", "profile": prof, "reply": "ok"}])
+    sid = ob.start()["session_id"]
+    p = ob.send(sid, "raising 1.5M, hiring a backend engineer")["profile"]
+    assert p["looking_for"] == "Looking for a lead or investor for a $1.5M round and to hire: backend engineer."
+    assert not any(m.startswith("who or what") for m in ob.missing(ob.get_session(sid)))
+
+
+def test_raise_and_wanted_roles_come_from_the_members_words(monkeypatch):
+    prof = {**FOUNDER, "public_terms": {}, "seeking": [], "looking_for": "A lead investor who knows fintech, and a backend engineer."}
+    script(monkeypatch, [{"role": "founder", "profile": prof, "reply": "ok"}])
+    sid = ob.start()["session_id"]
+    p = ob.send(sid, "im raising 1.5 million dollars and need a lead investor, also hiring a backend engineer")["profile"]
+    assert p["public_terms"]["raising"] == "$1.5M"
+    assert p["seeking"] == ["investor", "engineer"]
+    assert not ob._required(ob.get_session(sid))
+
+
+def test_rewritten_hire_keeps_its_known_salary(monkeypatch):
+    script(monkeypatch, [
+        {"role": "founder", "profile": FOUNDER, "terms": {"hires": [{"kind": "engineer", "salary": {"high": 105000}}]},
+         "reply": "a"},
+        {"profile": {}, "terms": {"hires": [{"kind": "engineer", "title": "Senior backend engineer", "work": ["hybrid"]}]},
+         "reply": "b"}])
+    sid = ob.start()["session_id"]
+    ob.send(sid, "x")
+    ob.send(sid, "y")
+    h = ob.get_session(sid).terms.hires[0]
+    assert h.salary.high == 105000 and h.work == ["hybrid"] and h.title == "Senior backend engineer"
+
+
+def test_investor_stage_cheque_and_focus_come_from_their_words(monkeypatch):
+    script(monkeypatch, [{"role": "investor", "profile": {"display_name": "Khalifa", "location": "Doha, Qatar",
+                                                          "tags": ["healthtech", "GCC"]}, "reply": "ok"}])
+    sid = ob.start()["session_id"]
+    p = ob.send(sid, "Seed stage only. Cheques of 500k to 1 million dollars.")["profile"]
+    assert p["public_terms"]["stages"] == "seed" and p["public_terms"]["cheque_size"] == "$500k–$1M"
+    assert p["looking_for"] == "Founders at seed stage in healthtech, GCC."
+
+
+def test_work_preference_is_not_a_dealbreaker(monkeypatch):
+    script(monkeypatch, [{"role": "engineer", "profile": {"display_name": "Khalid"}, "terms": {"work": ["hybrid"]}, "reply": "ok"}])
+    sid = ob.start()["session_id"]
+    ob.send(sid, "hybrid is fine")
+    assert ob.get_session(sid).terms.work == []
+
+
+def test_work_requirement_is_a_dealbreaker(monkeypatch):
+    script(monkeypatch, [{"role": "engineer", "profile": {"display_name": "Sara"}, "terms": {"work": ["remote"]}, "reply": "ok"}])
+    sid = ob.start()["session_id"]
+    ob.send(sid, "remote only, I won't relocate")
+    assert ob.get_session(sid).terms.work == ["remote"]