Sync from GitHub 80886c2

app.py

@@ -63,6 +63,7 @@ from core.constants import (
     MOCK_PDF_DIR,
     PARSED_SUBDIR,
     PREINDEXED_DIR,
+    RENDER_DPI,
     VISUAL_SUBDIR,
 )
 from core.pdf import pdf_outline, render_page_png
@@ -345,8 +346,14 @@ def index():
     frontend needs (default/max k) so it needs no extra round-trip on load."""
     with open(os.path.join(_FRONTEND_DIR, "index.html")) as f:
         html = f.read()
-    html = html.replace("__DEFAULT_K__", str(DEFAULT_TOP_K)).replace(
-        "__MAX_K__", str(MAX_TOP_K)
+    html = (
+        html.replace("__DEFAULT_K__", str(DEFAULT_TOP_K))
+        .replace("__MAX_K__", str(MAX_TOP_K))
+        # Cache-bust key for /page images: changing the render DPI changes the
+        # served page size, so it must change the URL too — otherwise a browser
+        # could keep an old-resolution page (cached up to a day) under the same
+        # URL while the grounding render uses the new size.
+        .replace("__PAGE_V__", str(RENDER_DPI))
     )
     return HTMLResponse(html)
 
@@ -375,9 +382,11 @@ def serve_pdf(doc_id: str):
 @app.get("/page/{doc_id}/{page}")
 def serve_page(doc_id: str, page: int):
     """One manual page rendered to PNG at RENDER_DPI — the viewer pane's <img>
-    source. Grounding boxes from the find turn are in this image's pixel
-    coordinates, so the SVG circle overlay maps 1:1. Immutable content → long
-    browser cache, which is what makes page flips instant."""
+    source. Cached long (immutable content → instant page flips); the URL
+    carries a ?v=RENDER_DPI cache key so a render-size change can't leave a
+    stale-resolution page under the same URL. The circle overlay sizes its
+    viewBox from the grounding render's dimensions (sent with the bbox), not
+    this image, so it stays aligned even if a cached page is a different size."""
     path = _pdf_path(doc_id)
     if not path or not os.path.isfile(path):
         return Response(status_code=404)

frontend/index.html

@@ -264,7 +264,7 @@
       <div class="flex-1 min-h-0 overflow-auto scroll-thin bg-brand-50/40 flex justify-center items-stretch gap-3 p-4">
         <template x-for="p in spreadPages" :key="p">
           <div class="relative flex-1 min-w-0 grid place-items-center">
-            <img :src="`/page/${encodeURIComponent(viewDoc)}/${p}`"
+            <img :src="`/page/${encodeURIComponent(viewDoc)}/${p}?v=__PAGE_V__`"
                  @load="nat[p]={w:$event.target.naturalWidth,h:$event.target.naturalHeight}; if(p===viewPage){imgW=$event.target.naturalWidth; imgH=$event.target.naturalHeight;}"
                  class="col-start-1 row-start-1 block max-h-full max-w-full w-auto h-auto select-none rounded-lg shadow-sm ring-1 ring-navy/10"
                  draggable="false" alt="manual page">
@@ -276,8 +276,8 @@
                  shows it. No <template x-if> inside <svg> (HTML templates aren't
                  valid SVG children) — the rect always exists, bindings null-guard. -->
             <svg x-show="circle && circle.page===p"
-                 :style="`aspect-ratio:${natOf(p).w}/${natOf(p).h}`"
-                 :viewBox="`0 0 ${natOf(p).w} ${natOf(p).h}`"
+                 :style="`aspect-ratio:${boxDims(p).w}/${boxDims(p).h}`"
+                 :viewBox="`0 0 ${boxDims(p).w} ${boxDims(p).h}`"
                  class="col-start-1 row-start-1 max-h-full max-w-full w-auto h-auto pointer-events-none">
               <rect :x="boxRect(p).x" :y="boxRect(p).y" :width="boxRect(p).w" :height="boxRect(p).h"
                     rx="14" ry="14" fill="#f59e0b" fill-opacity="0.10"
@@ -347,6 +347,7 @@ const ICONS = {
   'undo-2': '<path d="M9 14 4 9l5-5"/><path d="M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5 5.5 5.5 0 0 1-5.5 5.5H11"/>',
   'circle-slash': '<circle cx="12" cy="12" r="10"/><path d="m4.9 4.9 14.2 14.2"/>',
   info: '<circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/>',
+  'help-circle': '<circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><path d="M12 17h.01"/>',
 };
 
 function repairGuy() {
@@ -374,17 +375,23 @@ function repairGuy() {
     spread:true,           // book-style two-page view (active page + the next)
     nat:{},                // page number -> {w,h} natural size, set on each image load
 
-    get pageUrl(){ return this.viewDoc ? `/page/${encodeURIComponent(this.viewDoc)}/${this.viewPage}` : ''; },
+    get pageUrl(){ return this.viewDoc ? `/page/${encodeURIComponent(this.viewDoc)}/${this.viewPage}?v=__PAGE_V__` : ''; },
     // the page(s) on screen: the active page, plus the next one as context in
     // spread mode (none past the last page). The active page is always LEFT, so
     // the agent's target/circle page stays the first element.
     get spreadPages(){ if(!this.viewDoc) return []; const p=this.viewPage; return (this.spread && p<this.docPages) ? [p, p+1] : [p]; },
     natOf(p){ return this.nat[p] || {w:this.imgW, h:this.imgH}; },
+    // The coordinate space the active circle's bbox lives in: the size of the
+    // image the VLM GROUNDED on (sent by the backend), NOT the browser-loaded
+    // page <img>. Using this for the SVG viewBox keeps the circle aligned even
+    // if the served page PNG is a different/stale resolution. Falls back to the
+    // loaded image's natural size (older events without dims).
+    boxDims(p){ const c=this.circle; return (c && c.page===p && c.dims) ? {w:c.dims[0], h:c.dims[1]} : this.natOf(p); },
     // the overlay rectangle for the active circle on page p: bbox + a small pad,
     // normalized (x1<x2,y1<y2) and clamped to the page so it never runs off.
     boxRect(p){
       if(!this.circle || !this.circle.bbox) return {x:0,y:0,w:0,h:0};
-      const b=this.circle.bbox, n=this.natOf(p), pad=14;
+      const b=this.circle.bbox, n=this.boxDims(p), pad=14;
       const x1=Math.min(b[0],b[2]), y1=Math.min(b[1],b[3]), x2=Math.max(b[0],b[2]), y2=Math.max(b[1],b[3]);
       const x=Math.max(0,x1-pad), y=Math.max(0,y1-pad);
       return {x, y, w:Math.min(n.w,x2+pad)-x, h:Math.min(n.h,y2+pad)-y};
@@ -508,6 +515,7 @@ function repairGuy() {
         case 'step':{  // the chosen tool, with its args
           let label='';
           if(ev.tool==='search') label=`search · “${ev.query}”`;
+          else if(ev.tool==='find_answer') label=`find_answer · “${ev.query}”`;
           else if(ev.tool==='circle') label=`circle · “${ev.target}”`;
           else if(ev.tool==='go_to_section') label=`go_to_section · ${ev.title} (p.${ev.page})`;
           else if(ev.tool==='go_to_page') label=`go_to_page · p.${ev.page}`;
@@ -629,6 +637,7 @@ function repairGuy() {
           else if(ev.tool==='go_to_page'){ find.icon='file-text'; find.label=`Going to page ${ev.page}`; find.detail=''; this.status=`Opening page ${ev.page}…`; }
           else if(ev.tool==='circle'){ find.icon='target'; find.label=`Circling “${ev.target}”`; find.detail=''; this.status=`Looking for “${ev.target}”…`; }
           else if(ev.tool==='search'){ find.icon='search'; find.label=`Searching: “${ev.query}”`; find.detail=''; this.status=`Searching the manual for “${ev.query}”…`; }
+          else if(ev.tool==='find_answer'){ find.icon='help-circle'; find.label=`Looking up: “${ev.query}”`; find.detail=''; this.status=`Looking up “${ev.query}” in the manual…`; }
           break;
 
         case 'tool_result':  // search candidates (no longer shown — keep status only)
@@ -659,7 +668,7 @@ function repairGuy() {
             this.recordHistory(ev.message||'done');
           }else if(ev.found){  // point
             this.setPage(ev.page);
-            if(ev.bbox){ this.circle={page:ev.page, bbox:ev.bbox}; find.icon='target'; find.label=`Circled “${ev.target}”`; this.recordHistory(`circled “${ev.target}” on p.${ev.page}`); }
+            if(ev.bbox){ this.circle={page:ev.page, bbox:ev.bbox, dims:ev.dims}; find.icon='target'; find.label=`Circled “${ev.target}”`; this.recordHistory(`circled “${ev.target}” on p.${ev.page}`); }
             else { find.icon='file-text'; find.label=`Showed “${ev.target}”`; this.recordHistory(`showed “${ev.target}” on p.${ev.page}`); }  // page found, not pinpointed
             find.detail=`p.${ev.page}${meta}`;
           }else{

models/minicpm_agent.py

@@ -8,6 +8,9 @@ tool:
 
     search(query)            semantic-search the manual; the best page is shown
                              and its text added to the conversation
+    find_answer(query)       dense TEXT search of the parsed chunks for a
+                             spec/value/fact; the page that states it is shown,
+                             its text added so the agent can circle the answer
     go_to_section(section)   jump to a numbered table-of-contents section
     circle(target)           circle something on the CURRENT page (its text is
                              in context); the VLM grounds the box
@@ -43,7 +46,7 @@ from core.constants import (
 
 # The tools the agent may emit, and the JSON shape of each. Kept here so the
 # prompt and the parser can't drift apart.
-TOOLS = ("search", "go_to_section", "go_to_page", "circle", "done")
+TOOLS = ("search", "find_answer", "go_to_section", "go_to_page", "circle", "done")
 
 SYSTEM_PROMPT = (
     "You are the assistant for a hands-busy mechanic reading a repair manual on "
@@ -55,6 +58,11 @@ SYSTEM_PROMPT = (
     "Tools:\n"
     '- Search the manual for a part/topic/procedure:\n'
     '  {"tool": "search", "query": "<focused search phrase>"}\n'
+    "- Look up the ANSWER to a question — a spec, value, or fact (fuel type, a "
+    "torque, an oil/coolant capacity). This searches the manual TEXT, so it "
+    "finds the page that STATES the answer when a topic search would miss the "
+    "plain specs page:\n"
+    '  {"tool": "find_answer", "query": "<the spec or fact being asked for>"}\n'
     "- Jump to a section — use its number from the TABLE OF CONTENTS:\n"
     '  {"tool": "go_to_section", "section": <number>}\n'
     "- Jump straight to a known PHYSICAL page number:\n"
@@ -81,6 +89,11 @@ SYSTEM_PROMPT = (
     'a value, or a line (e.g. "what fuel does it take" answered by "Engine fuel '
     '- Gasoline") → circle that spot, using the printed words as the target. '
     "Point at the answer; do NOT keep searching for a better page.\n"
+    "- They ask a QUESTION for a spec/value/fact that is NOT on screen yet "
+    '("what fuel does it take", "engine oil capacity", "drain-plug torque") → '
+    "find_answer with the fact as the query; it searches the manual text and "
+    "shows the page that states it, which you then circle. Use find_answer for "
+    "fact questions; use search to find a part, diagram, or procedure.\n"
     "- Otherwise → search. After a search shows a page, that page is on screen, "
     "so circle on it or search again — but NEVER repeat a search that did not "
     "move you; act on the page instead.\n"
@@ -95,7 +108,9 @@ SYSTEM_PROMPT = (
     'Mechanic: "circle the bleeder screw" (it is on p.412, which is on screen) → '
     '{"tool": "circle", "target": "bleeder screw", "page": 412}\n'
     'Mechanic: "what fuel does it take" (p.5 on screen shows "Engine fuel - '
-    'Gasoline") → {"tool": "circle", "target": "Engine fuel - Gasoline", "page": 5}'
+    'Gasoline") → {"tool": "circle", "target": "Engine fuel - Gasoline", "page": 5}\n'
+    'Mechanic: "what\'s the engine oil capacity" (not on this page) → '
+    '{"tool": "find_answer", "query": "engine oil capacity"}'
 )
 
 
@@ -286,6 +301,9 @@ def _parse_tool(raw: str) -> dict | None:
     if tool == "search":
         query = str(obj.get("query") or "").strip()
         return {"tool": "search", "query": query} if _real(query) else None
+    if tool == "find_answer":
+        query = str(obj.get("query") or "").strip()
+        return {"tool": "find_answer", "query": query} if _real(query) else None
     if tool == "go_to_section":
         try:
             return {"tool": "go_to_section", "section": int(obj.get("section"))}

pipelines/agent_ask.py

@@ -13,6 +13,10 @@ Flow (one @spaces.GPU call, streamed as events):
       search(query)      ColEmbed top-N → 1B rerank by page text → show
                          the best page; its text is fed back so the agent
                          can then circle on it                            (continues)
+      find_answer(query) dense TEXT retrieval over the parsed chunks → show
+                         the page that STATES the answer (where a visual
+                         search would miss the plain specs page); its text
+                         is fed back so the agent can circle it           (continues)
       circle(target)     ground the target on the CURRENT page (VLM) and
                          circle it                                        (terminal)
       done(message)      nothing to do / not in the manual                (terminal)
@@ -52,6 +56,7 @@ from core.page_context import index_pages, page_to_text
 from core.pdf import page_count, render_page
 from models import minicpm, minicpm_agent
 from models.colembed import maxsim_search
+from pipelines.parsed_ask import retrieve_pages
 
 log = logging.getLogger("repairguy.agent")
 
@@ -119,6 +124,41 @@ def agent_events(
     ground_failed = set()  # (page, normalized target) the VLM already missed
     yield {"type": "status", "text": "Thinking…"}
 
+    def present_hits(hits, qkey):
+        """Shared tail for the two retrieval tools (search / find_answer): show
+        the shortlist, land on the top page, and feed its text back — FORCING a
+        decision when the landing is a no-op (the same query again, or a page
+        already shown this turn), so a greedy 1B can't loop the identical lookup
+        forever. The only thing that differs between the tools is the retriever
+        that produced `hits`; everything downstream is identical."""
+        nonlocal current_page, circleable
+        rendered = [
+            (p, render_page(visual_store.pdf_path(doc_id), p)) for _, p, _ in hits
+        ]
+        yield {
+            "type": "tool_result",
+            "tool": "search_docs",
+            "gallery": [
+                (img, f"{manual} — p.{p} (score {s:.3g})")
+                for (p, img), (_, _, s) in zip(rendered, hits)
+            ],
+            "page_refs": [(doc_id, p) for _, p, _ in hits],
+        }
+        best_page = hits[0][1]
+        yield {"type": "found", "page": best_page}
+        current_page = best_page
+        circleable = {best_page}  # the lookup landed here — circle on this page
+        stuck = qkey in tried_queries or best_page in seen_pages
+        tried_queries.add(qkey)
+        seen_pages.add(best_page)
+        messages.append(
+            minicpm_agent.tool_result_message(
+                minicpm_agent.search_result_message(
+                    request, best_page, page_text(best_page), stuck
+                )
+            )
+        )
+
     for step in range(AGENT_MAX_STEPS):
         # Render the exact prompt BEFORE deciding so the trace can show what the
         # brain was asked, not just what it answered.
@@ -194,35 +234,27 @@ def agent_events(
                     minicpm_agent.tool_result_message(f"Search for {query!r} found nothing.")
                 )
                 continue
-            pages = [(p, render_page(visual_store.pdf_path(doc_id), p)) for _, p, _ in hits]
-            yield {
-                "type": "tool_result",
-                "tool": "search_docs",
-                "gallery": [
-                    (img, f"{manual} — p.{p} (score {s:.3g})")
-                    for (p, img), (_, _, s) in zip(pages, hits)
-                ],
-                "page_refs": [(doc_id, p) for _, p, _ in hits],
-            }
-            best_page = hits[0][1]
-            yield {"type": "found", "page": best_page}
-            current_page = best_page
-            circleable = {best_page}  # search landed here — circle on this page
-            # A no-op search — the same query again, or it lands on a page already
-            # shown this turn — means the agent is stuck. Feed back a FORCING
-            # message (no "search again") so a greedy 1B can't loop the identical
-            # search forever; otherwise the normal "circle or search again" prompt.
-            qkey = " ".join(query.lower().split())
-            stuck = qkey in tried_queries or best_page in seen_pages
-            tried_queries.add(qkey)
-            seen_pages.add(best_page)
-            messages.append(
-                minicpm_agent.tool_result_message(
-                    minicpm_agent.search_result_message(
-                        request, best_page, page_text(best_page), stuck
-                    )
+            yield from present_hits(hits, "search:" + " ".join(query.lower().split()))
+            continue
+
+        if tool["tool"] == "find_answer":
+            query = tool["query"]
+            yield {"type": "step", "tool": "find_answer", "query": query}
+            yield {"type": "status", "text": f"Looking up “{query}”…"}
+            # Dense retrieval over the PARSED chunks (text/semantic) — the index
+            # the parsed store was built for. A fact lookup ("what fuel does it
+            # take") is a TEXT match: ColEmbed ranks pages by VISUAL similarity
+            # and misses the plain specs page, so fact questions route here. Same
+            # (doc_id, page, score) shape as maxsim_search; the agent then circles
+            # the answering line on the page shown.
+            hits = retrieve_pages(query, parsed_store, doc_ids, top_k)
+            log.info("find_answer(%r) → %s", query, [(p, round(s, 3)) for _, p, s in hits])
+            if not hits:
+                messages.append(
+                    minicpm_agent.tool_result_message(f"Looking up {query!r} found nothing.")
                 )
-            )
+                continue
+            yield from present_hits(hits, "answer:" + " ".join(query.lower().split()))
             continue
 
         if tool["tool"] == "circle":
@@ -262,6 +294,12 @@ def agent_events(
                 "target": target,
                 "page": page,
                 "bbox": [round(v) for v in box] if box is not None else None,
+                # The pixel size of the image the box was GROUNDED on — the bbox
+                # is in this coordinate space. The frontend sizes its SVG viewBox
+                # from this (not the browser-loaded <img>), so the circle lands
+                # correctly even if the displayed page PNG is served at a
+                # different/stale resolution than this grounding render.
+                "dims": [img.width, img.height],
                 # the VLM's raw grounding reply — diagnostic only (helps explain
                 # where/why a box landed); shown in the trace view.
                 "ground_raw": braw[:300],