Sync from GitHub c06d2c6

app.py

@@ -266,6 +266,7 @@ def api_find(
     k: int = DEFAULT_TOP_K,
     page: int = 0,
     section: str = "",
+    pages: list = None,
     history: list = None,
 ) -> dict:  # the per-yield type: Server.api infers outputs from this annotation
     """One agent turn (one ZeroGPU call), streamed as events (see
@@ -291,7 +292,13 @@ def api_find(
         }
         return
     start = time.monotonic()
-    viewer = {"page": int(page or 0), "section": str(section or "")}
+    # `pages` = every page currently on the viewer (the two-page spread shows
+    # two); the agent reads them all and may circle on any. Falls back to the
+    # single `page` for older clients.
+    shown = [int(p) for p in (pages or []) if str(p).strip().isdigit()] or (
+        [int(page)] if page else []
+    )
+    viewer = {"page": int(page or 0), "section": str(section or ""), "pages": shown}
     options = _router_options(manual, request)
     log.info(
         "find: manual=%s k=%s viewer=%s hist=%d opts=%d q=%r",

frontend/index.html

@@ -243,38 +243,49 @@
           p. <span x-text="viewPage"></span><span class="text-brand-400 font-medium"> / <span x-text="docPages"></span></span>
         </div>
         <div class="flex-1 min-w-0 text-[12px] text-brand-500/90 truncate text-right pr-1" x-text="sectionTitle(viewPage)"></div>
+        <button @click="spread=!spread" :aria-pressed="spread" aria-label="Two-page view" title="Two-page view"
+          class="grid place-items-center w-11 h-11 rounded-xl transition"
+          :class="spread ? 'text-brand-700 bg-brand-100' : 'text-brand-600 hover:bg-brand-100'">
+          <i data-lucide="book-open" class="w-5 h-5"></i>
+        </button>
         <button x-show="navStack.length" @click="goBack()" aria-label="Back" title="Back to previous spot"
           class="grid place-items-center w-11 h-11 rounded-xl text-brand-600 hover:bg-brand-100 transition">
           <i data-lucide="undo-2" class="w-5 h-5"></i>
         </button>
       </div>
 
-      <!-- the page -->
-      <div class="flex-1 min-h-0 overflow-auto scroll-thin bg-brand-50/40 flex justify-center items-start p-4">
-        <template x-if="viewDoc">
-          <!-- fit the whole page to the available HEIGHT so it isn't blown up
-               past the viewport (the pane width is fine; portrait pages were
-               overflowing vertically). aspect-ratio keeps this box exactly the
-               image's shape, so the SVG circle overlay stays aligned 1:1 -->
-          <div class="relative h-full max-w-full shrink-0" :style="`aspect-ratio:${imgW}/${imgH}`">
-            <img :src="pageUrl" @load="imgW=$event.target.naturalWidth; imgH=$event.target.naturalHeight"
-                 class="block h-full w-full select-none rounded-lg shadow-sm ring-1 ring-navy/10" draggable="false" alt="manual page">
-            <!-- circle overlay: bbox coordinates are in the rendered page's
-                 pixel space, identical to the image's natural size. NB: no
-                 <template x-if> in here — HTML templates aren't valid SVG
-                 children, so the ellipse always exists and every binding
-                 guards against circle being null -->
-            <svg id="circle-overlay" x-show="circle && circle.page===viewPage" :viewBox="`0 0 ${imgW} ${imgH}`"
-                 class="absolute inset-0 w-full h-full pointer-events-none">
-              <ellipse :cx="circle ? (circle.bbox[0]+circle.bbox[2])/2 : 0"
-                       :cy="circle ? (circle.bbox[1]+circle.bbox[3])/2 : 0"
-                       :rx="circle ? (circle.bbox[2]-circle.bbox[0])/2+16 : 0"
-                       :ry="circle ? (circle.bbox[3]-circle.bbox[1])/2+16 : 0"
-                       fill="none" stroke="#f59e0b" stroke-width="9" opacity="0.85"/>
+      <!-- the page(s): a book-style spread — the active page plus the next one
+           for context (toggle to single with the book button). Each slot is a
+           full-height flex column; the image fits the slot's HEIGHT and (in
+           spread) at most half the width, so both facing pages stay fully
+           visible without blowing up. img + svg are stacked in one grid cell
+           and both carry the page's aspect-ratio + max constraints, so they
+           compute the SAME box and the circle overlay stays aligned 1:1. -->
+      <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}`"
+                 @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">
+            <!-- box overlay: a rounded rectangle hugging the grounded region,
+                 padded slightly and CLAMPED to the page so it never runs off
+                 (an ellipse circumscribing the box ballooned wide boxes into a
+                 page-spanning arc). bbox coords are in this page's rendered
+                 pixel space (= its natural size); only the page the box is FOR
+                 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}`"
+                 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"
+                    stroke="#f59e0b" stroke-width="8" opacity="0.95"/>
             </svg>
           </div>
         </template>
-        <div x-show="!viewDoc" class="chat-grid h-full grid place-items-center text-center px-8">
+        <div x-show="!viewDoc" class="h-full w-full grid place-items-center text-center px-8">
           <div>
             <i data-lucide="file-text" class="inline-block w-11 h-11 text-brand-300 mb-3"></i>
             <p class="text-brand-500/80 text-sm max-w-xs">Pick a manual and it opens here — then say things like <em>go to the brakes section</em> or <em>next page</em>.</p>
@@ -359,9 +370,25 @@ function repairGuy() {
     // viewer state machine: which page is open, the manual's chapter index,
     // a jump history for "back", and the active circle overlay.
     viewDoc:'', viewPage:1, docPages:1, sections:[], navStack:[], circle:null,
-    imgW:1240, imgH:1754,  // replaced by the real natural size on image load
+    imgW:1240, imgH:1754,  // the ACTIVE (left) page's natural size; fallback for the overlay
+    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}` : ''; },
+    // 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 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 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};
+    },
 
     async init(){
       window.lucide?.createIcons();  // swap static <i data-lucide> -> clean SVG icons
@@ -392,7 +419,7 @@ function repairGuy() {
     async newChat(){
       this.lastRequest=''; this.activity=null; this.history=[];
       this.trace=[]; this.traceSeen=0; this.tab='toc';
-      this.viewDoc=''; this.viewPage=1; this.navStack=[]; this.circle=null; this.sections=[];
+      this.viewDoc=''; this.viewPage=1; this.navStack=[]; this.circle=null; this.sections=[]; this.nat={};
       const m = this.manuals.find(x=>x.value===this.manual);
       if(!m) return;
       this.docPages = m.pages || 1;
@@ -553,6 +580,7 @@ function repairGuy() {
         const job = this.client.submit('/find', {
           request:q, manual:this.manual, k:this.k,
           page: this.viewDoc ? this.viewPage : 0, section: this.sectionTitle(this.viewPage),
+          pages: this.spreadPages,  // every page currently on screen — the agent may circle on any
           history: this.history,
         });
         // the client re-delivers the generator's last yield in the completion

models/minicpm.py

@@ -64,6 +64,10 @@ GROUND_PROMPT = (
     "part in the drawing and box THAT part (not the legend text).\n"
     "- Otherwise it may be a row in a table, a specification value, or a "
     "heading — box that.\n"
+    "Box ONLY that one part, as TIGHTLY as possible — just the part itself. Do "
+    "NOT box the whole figure, the whole diagram, a group of parts, or the page; "
+    "if the part is small, the box must be small. A box wider than about half "
+    "the page is almost always wrong.\n"
     "Reply with ONLY the box, as <box>x1 y1 x2 y2</box>: four integers "
     "normalized to 0-1000 (x left→right, y top→bottom) over the whole page, "
     "and nothing else. If it is not on this page, reply exactly: NOT FOUND"

models/minicpm_agent.py

@@ -59,8 +59,10 @@ SYSTEM_PROMPT = (
     '  {"tool": "go_to_section", "section": <number>}\n'
     "- Jump straight to a known PHYSICAL page number:\n"
     '  {"tool": "go_to_page", "page": <number>}\n'
-    "- Circle something on the CURRENT page (its full text is given to you):\n"
-    '  {"tool": "circle", "target": "<short name of the thing to circle>"}\n'
+    "- Circle something on a page CURRENTLY ON SCREEN (their full text is given "
+    "to you). When two pages are shown, set page to the one whose text has it:\n"
+    '  {"tool": "circle", "target": "<short name of the thing to circle>", '
+    '"page": <the on-screen page number it is on>}\n'
     "- Finish — nothing more to do, or it isn't in the manual:\n"
     '  {"tool": "done", "message": "<one short line for the mechanic>"}\n\n'
     "How to choose:\n"
@@ -69,11 +71,12 @@ SYSTEM_PROMPT = (
     'contents that lists the part with a page number ("Actuators .... 855"), or '
     "history gave one → go_to_page that number. Do NOT circle the index line; "
     "go to the page it points to.\n"
-    "- The thing they want is on the CURRENT page → circle it. The target MUST "
-    "be what the mechanic asked for — match it to the page's exact wording if it "
-    "appears there; NEVER circle a different component.\n"
-    "- Otherwise → search. After a search shows a page, that page becomes the "
-    "CURRENT page, so circle on it or search again.\n"
+    "- The thing they want is on a page ON SCREEN → circle it, and set page to "
+    "the one it is on. The target MUST be what the mechanic asked for — match it "
+    "to that page's exact wording if it appears there; NEVER circle a different "
+    "component.\n"
+    "- Otherwise → search. After a search shows a page, that page is on screen, "
+    "so circle on it or search again.\n"
     "- Use the conversation history only to resolve what they mean (e.g. "
     '"circle the other one"); never restate earlier answers.\n\n'
     "Examples (copy the FORMAT, not the values):\n"
@@ -82,8 +85,8 @@ SYSTEM_PROMPT = (
     '{"tool": "search", "query": "fuel filter replacement"}\n'
     'Mechanic: "the wastegate actuator" (current page is an index reading '
     '"Actuators .... 855") → {"tool": "go_to_page", "page": 855}\n'
-    'Mechanic: "circle the bleeder screw" (it is on this page) → '
-    '{"tool": "circle", "target": "bleeder screw"}'
+    'Mechanic: "circle the bleeder screw" (it is on p.412, which is on screen) → '
+    '{"tool": "circle", "target": "bleeder screw", "page": 412}'
 )
 
 
@@ -94,24 +97,38 @@ def system_message() -> dict:
 def state_message(
     request: str,
     toc: list[dict],
-    page: int | None,
+    shown: list[dict],
     section: str,
-    page_text: str,
 ) -> dict:
     """The user message for the current step: what the mechanic just said, the
     table of contents (numbered, the go_to_section index), and the whole text of
-    the page being viewed. page_text is the parsed page rendered to text (figures
-    and tables as their descriptions) — empty when no page is open or the manual
-    has no parse."""
+    the page(s) currently on the viewer. The viewer shows a two-page spread, so
+    `shown` is [{page, text}] for each page on screen (one or two). Each page's
+    text is the parsed page rendered to text (figures/tables as descriptions) —
+    empty when the manual has no parse. When the agent circles, it names which of
+    these pages the target is on."""
     toc_lines = "\n".join(
         f"{i + 1}. {s['title']} (p.{s['page']})" for i, s in enumerate(toc)
     ) or "(none)"
-    where = f"p.{page}" + (f', section "{section}"' if section else "") if page else "(no page open)"
-    page_block = (
-        f"CURRENT PAGE ({where}) — full text:\n{page_text}"
-        if page_text
-        else f"CURRENT PAGE: {where} (no text available)"
-    )
+    if shown:
+        where = " and ".join(f"p.{s['page']}" for s in shown) + (
+            f' (section "{section}")' if section else ""
+        )
+        blocks = "\n\n".join(
+            f"PAGE {s['page']} — full text:\n{s['text'] or '(no text available)'}"
+            for s in shown
+        )
+        page_block = (
+            f"CURRENTLY ON SCREEN — {where}. You can circle on "
+            + (
+                "either of these pages (say which in the circle call):\n"
+                if len(shown) > 1
+                else "this page:\n"
+            )
+            + blocks
+        )
+    else:
+        page_block = "CURRENTLY ON SCREEN: (no page open)"
     # The request goes LAST (after the long page text) so it stays freshest —
     # otherwise the page block dominates and the agent acts on the page instead
     # of what was asked.
@@ -223,7 +240,17 @@ def _parse_tool(raw: str) -> dict | None:
             return None
     if tool == "circle":
         target = str(obj.get("target") or "").strip()
-        return {"tool": "circle", "target": target} if _real(target) else None
+        if not _real(target):
+            return None
+        out = {"tool": "circle", "target": target}
+        # Optional: which on-screen page the target is on (the pipeline validates
+        # it against the pages actually shown and defaults to the active page).
+        try:
+            if obj.get("page") is not None:
+                out["page"] = int(obj.get("page"))
+        except (TypeError, ValueError):
+            pass
+        return out
     if tool == "done":
         return {"tool": "done", "message": str(obj.get("message") or "").strip()}
     return None

pipelines/agent_ask.py

@@ -99,13 +99,21 @@ def agent_events(
     def page_text(p: int) -> str:
         return page_to_text(page_elements.get(p, []))
 
+    # The page(s) on the viewer — a two-page spread shows the active page plus
+    # the next. The agent sees the text of all of them and may circle on any;
+    # the active page stays first. Falls back to the single current page.
+    shown_pages = [int(p) for p in (viewer.get("pages") or []) if int(p) >= 1] or [cur]
+    if cur in shown_pages:
+        shown_pages = [cur] + [p for p in shown_pages if p != cur]
+    shown_pages = shown_pages[:2]
+    shown = [{"page": p, "text": page_text(p)} for p in shown_pages]
+
     messages = [minicpm_agent.system_message()]
     messages += _history_messages(history)
-    messages.append(
-        minicpm_agent.state_message(request, sections, cur, section, page_text(cur))
-    )
+    messages.append(minicpm_agent.state_message(request, sections, shown, section))
 
-    current_page = cur  # the page circle acts on; moves when search shows one
+    current_page = shown_pages[0]  # the active page circle defaults to
+    circleable = set(shown_pages)  # pages the agent may circle on right now
     yield {"type": "status", "text": "Thinking…"}
 
     for step in range(AGENT_MAX_STEPS):
@@ -194,6 +202,7 @@ def agent_events(
             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
             messages.append(
                 minicpm_agent.tool_result_message(
                     f"Search showed p.{best_page}. It is now the CURRENT page.\n"
@@ -209,18 +218,25 @@ def agent_events(
 
         if tool["tool"] == "circle":
             target = tool["target"]
-            yield {"type": "step", "tool": "circle", "target": target}
+            # The agent says which shown page the target is on (it has both pages'
+            # text). Default to the active page when it's unspecified or not one of
+            # the pages on screen — so the box is grounded on, and drawn over, the
+            # RIGHT page.
+            page = tool.get("page")
+            if page not in circleable:
+                page = current_page
+            yield {"type": "step", "tool": "circle", "target": target, "page": page}
             yield {"type": "status", "text": "Pinning it down…"}
-            img = render_page(visual_store.pdf_path(doc_id), current_page)
+            img = render_page(visual_store.pdf_path(doc_id), page)
             box, braw = minicpm.ground_box(img, target)
             log.info("ground_box(%r) on p.%d → %s | raw=%r",
-                     target, current_page, box, braw[:200])
+                     target, page, box, braw[:200])
             yield {
                 "type": "done",
                 "kind": "point",
                 "found": True,
                 "target": target,
-                "page": current_page,
+                "page": page,
                 "bbox": [round(v) for v in box] if box is not None else None,
                 # the VLM's raw grounding reply — diagnostic only (helps explain
                 # where/why a box landed); shown in the trace view.

pipelines/mock_ask.py

@@ -158,7 +158,8 @@ class MockAskPipeline:
     def _find_events(self, store, request, doc_id, info, top_k, sections, viewer):
         delay = float(os.environ.get("MOCK_DELAY", "0"))
         cur = max(1, int(viewer.get("page") or 1))
-        prompt = self._mock_prompt(request, sections, cur)
+        shown = [int(p) for p in (viewer.get("pages") or []) if str(p).isdigit()][:2] or [cur]
+        prompt = self._mock_prompt(request, sections, shown)
         yield {"type": "status", "text": "Thinking…"}
         time.sleep(delay)
 
@@ -216,7 +217,7 @@ class MockAskPipeline:
 
     def _circle(self, store, doc_id, page, target, delay):
         """Emit the circle step + terminal point event for a target on a page."""
-        yield {"type": "step", "tool": "circle", "target": target}
+        yield {"type": "step", "tool": "circle", "target": target, "page": page}
         yield {"type": "status", "text": "Pinning it down…"}
         time.sleep(delay)
         box = self._mock_box(store, doc_id, page, target)
@@ -233,18 +234,20 @@ class MockAskPipeline:
                 "raw": json.dumps(tool, separators=(",", ":")), "prompt": prompt}
 
     @staticmethod
-    def _mock_prompt(request: str, sections: list[dict], page: int) -> str:
+    def _mock_prompt(request: str, sections: list[dict], shown: list[int]) -> str:
         """A representative stand-in for the rendered chat prompt, so the
         Diagnostics 'prompt' view is exercisable in MOCK_MODELS=1. Not the real
-        template — just the same shape (system rules + TOC + request)."""
+        template — just the same shape (system rules + the on-screen pages +
+        TOC + request)."""
         toc = "\n".join(
             f"{i + 1}. {s['title']} (p.{s.get('page') or s.get('page_start')})"
             for i, s in enumerate(sections)
         ) or "(none)"
+        where = " and ".join(f"p.{p}" for p in shown) or "(no page open)"
         return (
             "<|im_start|>system\n(mock) You FIND the right page and POINT at "
             "things — reply with ONE tool JSON, no prose.<|im_end|>\n"
-            f"<|im_start|>user\nCURRENT PAGE: p.{page} (mock text omitted)\n\n"
+            f"<|im_start|>user\nCURRENTLY ON SCREEN — {where} (mock text omitted)\n\n"
             f"TABLE OF CONTENTS:\n{toc}\n\n"
             f"The mechanic said: {request!r}\n"
             "Choose ONE tool and reply with ONLY its JSON object."