localagentbrowser 1.57__tar.gz → 1.61__tar.gz

{localagentbrowser-1.57 → localagentbrowser-1.61}/CHANGELOG.md

@@ -1,11 +1,50 @@
 # Changelog
 
-Every version of `agent_browser.py`, newest first. Each released version is also a tagged commit (`v1.11` … `v1.57`); 1.54 to 1.56 were internal steps
-measured on the regression suite and released as part of 1.57 (see
+Every version of `agent_browser.py`, newest first. Each released version is also a tagged commit (`v1.11` … `v1.61`); 1.54 to 1.56 and 1.58 to 1.60 were internal steps
+measured on the regression suite and released as part of 1.57 and 1.61 (see
 [docs/regression-history.md](docs/regression-history.md)).
 Timings are from live runs on the development machine (Intel i5-9500, 6 cores, no GPU, Qwen2.5-7B-Instruct
 Q4_K_M in LM Studio), where reading the prompt takes about 90% of every model call.
 
+## [1.61] - 2026-10-21
+Released together with the internal steps 1.58, 1.59 and 1.60, each measured on the regression suite
+([docs/regression-history.md](docs/regression-history.md) has every step's results, task by task).
+### Added
+- An outline pointer for long pages. On a page long enough to have an outline, the read-on check looks for an unread
+  part whose label names a word of an item with nothing recorded yet ("Administration" for "setup and
+  administration"), and a plain READ_MORE then reads that part instead of the next one. Told only to use the
+  outline, the model went on to the next part 6 times out of 6 on a 10-part comparison page; with the code making
+  the jump, it reaches the part every time. Words that say what the whole page is about are ignored (the page title's
+  words, words every item shares), as are item verbs and parts that start inside code; hyphenated words stay whole.
+  On 1.61 the comparison finished for the first time since 1.56, from that page's Administration part.
+- "Every item has the discoveries it asks for: choose FINISH now" in the note after a discovery, when each item has
+  at least what it asks for. When that holds, the read-on check also asks for FINISH instead of offering to read on
+  (replayed: read on 6 of 6 before, FINISH 9 of 9 after).
+### Changed
+- The agent is sent back before finishing only for gaps the code verifies: an item nothing was copied for, fewer
+  things than the item asks for, or nothing recorded. The model's other verdicts are logged "(not sent back)" and
+  only shape the final result. About half of the send-backs for those verdicts had been wrong, costing finishes.
+- Every item that asks for a number is counted, not only items with a condition: an owl task finished with two
+  tribes for "at least three cultures". Amounts of time or measure ("the first two weeks") are not counts.
+- A thing not shown to meet a condition stays in the result, marked where it is first named ("**OnlyOffice** (not
+  shown in the pages read to be free and open-source)"), instead of being left out: leaving such things out dropped
+  correct answers along with wrong ones.
+- A description named by the coverage check as one of a list's things is ignored (it had made two office suites
+  count as three).
+- Smaller fresh prompts: refusal reasons in the journal are cut to 120 characters, pages list 8 links instead of 15
+  (those with a few words of text first; in four suites the agent opened 39 pages, none from page links), and links
+  whose text is HTML are skipped. Fresh prompts are about 2,500 tokens instead of 3,500-4,900.
+- Regression suite: the scorer accepts a forbidden item when the result marks it with the caveat.
+### Fixed
+- When several things shared a caveat, only the first was marked: the identical note next to it counted for all.
+
+Regression runs, finished out of 7 (model minutes): 1.58 5 (214), 1.59 5 (209.5), 1.60 6 (170.6), 1.61 6 (222.1).
+What is still open: a fresh prompt (when a conversation reaches its token budget) does not carry the advice to
+finish, and on 1.61 the documentation task read on after one with all four items found; nothing checks that a
+recipe's steps reach their end (on 1.60 cold brew stopped after step 2). Measured and not used: checking a
+discovery's link to its item by shared words (most links without a shared word are right), and a 16,384-token
+context, which would halve the fresh prompts but needs more memory than the default aims for.
+
 ## [1.57] - 2026-10-19
 Released together with the internal steps 1.54, 1.55 and 1.56, each of which was measured on the regression suite
 but not released on its own. [docs/regression-history.md](docs/regression-history.md) has every step's results,

{localagentbrowser-1.57/localagentbrowser.egg-info → localagentbrowser-1.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localagentbrowser
-Version: 1.57
+Version: 1.61
 Summary: An autonomous web agent driven by a local LLM (LM Studio) and Playwright. Runs entirely on your own machine.
 Author: SnowFX
 License-Expression: MIT
@@ -199,19 +199,19 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 
 Since 1.53, every change is measured on the same seven objectives, one of each kind above, run one after the other
 with a time limit each (`tools/regression.py`, see [Testing](#testing)). Single runs vary with the pages a search
-turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 were internal steps measured this way
-and released together as 1.57; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
+turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 and 1.58 to 1.60 were internal steps
+measured this way and released with 1.57 and 1.61; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
 has every step's results and what each one showed.
 
-| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) |
-|---|---|---|---|
-| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min |
-| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" |
-| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for |
-| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time |
-| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited |
-| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for |
-| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one |
+| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) | 1.61 (verified send-backs, outline pointer) |
+|---|---|---|---|---|
+| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min | Finished, 17 min |
+| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" | Finished, 21 min: LibreOffice, WPS Office and OnlyOffice, each marked "not shown in the pages read to be free and open-source" |
+| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for | Finished, 26 min, setup and administration from the part of a long page the outline pointer chose |
+| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time | Finished, 33 min: every step, the 16-hour steep and the shelf life, cited |
+| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited | Finished, 39 min |
+| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for | Finished, 42 min: four cultures, cited, with a view |
+| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one | Time limit: all four items found from python.org, then it read on |
 
 ## How it works
 
@@ -323,9 +323,9 @@ Measured on an Intel i5-9500 (6 cores, no GPU) with Qwen2.5-7B-Instruct Q4_K_M a
 | Coverage check before finishing (all checklist items) | about 1–3 min |
 | Writing the final result (once, at the end) | 50–190 s, depending on how much was found |
 
-Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 13 to
-19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 21 to 44 when they finished;
-and the explanation 13 to 59. A GPU or a smaller model will be much faster.
+Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 9 to
+19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 17 to 44 when they finished;
+and the explanation 13 to 59. A whole suite of seven tasks took 171 to 272 minutes. A GPU or a smaller model will be much faster.
 
 ## FAQ
 
@@ -363,15 +363,17 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **Judging whether a finding covers an item is the weakest area.** The model's verdict is unreliable both ways:
   on 1.53 the explanation finished from one overview paragraph without oxygen or water, and in the regression runs
   since 1.54 about half of the coverage check's send-backs were for gaps that were not real ("missing official
-  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). The code now verifies what
-  it can (an item nothing answers, a count, word-for-word proof of a condition), but each wrong send-back still
-  costs a finish on this hardware, since a send-back costs 8–10 minutes.
+  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). Since 1.58 the agent is sent
+  back only for what the code verifies (an item nothing answers, fewer things than asked for); the model's other
+  verdicts only shape the final result, so a thin answer can still pass (on 1.61 the comparison's "many
+  simultaneous users" part is short).
 - **Conditions in the objective.** A small model tends to drop conditions such as "open source" or "using the
   official documentation": a list of open-source office suites once included FreeOffice (free but not open
   source), and a task that asked for the official Python documentation used a tutorial site. The objective
   checklist keeps the conditions in view (the documentation task uses python.org since 1.55), and a thing not
-  shown in the findings to meet a condition is left out of the result and listed after it. The check is strict:
-  on 1.57 it sent back three correct open-source suites because no words showed them to be "free". Check the
+  shown in the findings to meet a condition is marked where it is named ("not shown in the pages read to be free
+  and open-source"). The mark says what the pages read did not show, not that the thing fails the condition: on
+  1.61 it marked LibreOffice and OnlyOffice, which are open source, as well as WPS Office, which is not. Check the
   result against any conditions you set.
 - **A small model's judgement is the ceiling.** It sometimes drifts to loosely related pages, prefers
   secondary sources or stays with one source too long, and results vary with the first pages a search turns
@@ -402,8 +404,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Keep a fixed checklist of the objective's parts instead of re-splitting it at every check (1.53)
 - [ ] Check that a finding really covers its checklist item, including conditions like "open source" (partly, since
   1.57: a coverage check before finishing, with what the code can verify)
-- [ ] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
-  result (the next step after 1.57)
+- [x] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
+  result (1.58, released in 1.61)
+- [x] Point the agent to the part of a long page whose outline names an item it still needs (1.61)
+- [ ] Keep the advice to finish when a conversation starts over from a fresh prompt (the next step after 1.61)
 - [ ] Rewind dead ends: save the conversation before an expensive step such as reading a long page, and if it
   leads nowhere, return to that point with a short note instead of carrying the unused page text in every later
   prompt (LM Studio reuses its cache up to the saved point)
@@ -456,8 +460,8 @@ the [Code of Conduct](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CO
 ## Project history
 
 Every released version is a tagged commit, and [CHANGELOG.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CHANGELOG.md) describes what changed in each one and
-why, with the measurements behind the decisions. Versions 1.54 to 1.56 were internal steps, each measured on the
-regression suite and released together as 1.57; their results are in
+why, with the measurements behind the decisions. Versions 1.54 to 1.56 and 1.58 to 1.60 were internal steps, each
+measured on the regression suite and released with 1.57 and 1.61; their results are in
 [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md).
 
 ## Acknowledgements

{localagentbrowser-1.57 → localagentbrowser-1.61}/README.md

@@ -167,19 +167,19 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 
 Since 1.53, every change is measured on the same seven objectives, one of each kind above, run one after the other
 with a time limit each (`tools/regression.py`, see [Testing](#testing)). Single runs vary with the pages a search
-turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 were internal steps measured this way
-and released together as 1.57; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
+turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 and 1.58 to 1.60 were internal steps
+measured this way and released with 1.57 and 1.61; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
 has every step's results and what each one showed.
 
-| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) |
-|---|---|---|---|
-| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min |
-| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" |
-| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for |
-| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time |
-| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited |
-| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for |
-| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one |
+| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) | 1.61 (verified send-backs, outline pointer) |
+|---|---|---|---|---|
+| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min | Finished, 17 min |
+| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" | Finished, 21 min: LibreOffice, WPS Office and OnlyOffice, each marked "not shown in the pages read to be free and open-source" |
+| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for | Finished, 26 min, setup and administration from the part of a long page the outline pointer chose |
+| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time | Finished, 33 min: every step, the 16-hour steep and the shelf life, cited |
+| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited | Finished, 39 min |
+| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for | Finished, 42 min: four cultures, cited, with a view |
+| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one | Time limit: all four items found from python.org, then it read on |
 
 ## How it works
 
@@ -291,9 +291,9 @@ Measured on an Intel i5-9500 (6 cores, no GPU) with Qwen2.5-7B-Instruct Q4_K_M a
 | Coverage check before finishing (all checklist items) | about 1–3 min |
 | Writing the final result (once, at the end) | 50–190 s, depending on how much was found |
 
-Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 13 to
-19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 21 to 44 when they finished;
-and the explanation 13 to 59. A GPU or a smaller model will be much faster.
+Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 9 to
+19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 17 to 44 when they finished;
+and the explanation 13 to 59. A whole suite of seven tasks took 171 to 272 minutes. A GPU or a smaller model will be much faster.
 
 ## FAQ
 
@@ -331,15 +331,17 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **Judging whether a finding covers an item is the weakest area.** The model's verdict is unreliable both ways:
   on 1.53 the explanation finished from one overview paragraph without oxygen or water, and in the regression runs
   since 1.54 about half of the coverage check's send-backs were for gaps that were not real ("missing official
-  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). The code now verifies what
-  it can (an item nothing answers, a count, word-for-word proof of a condition), but each wrong send-back still
-  costs a finish on this hardware, since a send-back costs 8–10 minutes.
+  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). Since 1.58 the agent is sent
+  back only for what the code verifies (an item nothing answers, fewer things than asked for); the model's other
+  verdicts only shape the final result, so a thin answer can still pass (on 1.61 the comparison's "many
+  simultaneous users" part is short).
 - **Conditions in the objective.** A small model tends to drop conditions such as "open source" or "using the
   official documentation": a list of open-source office suites once included FreeOffice (free but not open
   source), and a task that asked for the official Python documentation used a tutorial site. The objective
   checklist keeps the conditions in view (the documentation task uses python.org since 1.55), and a thing not
-  shown in the findings to meet a condition is left out of the result and listed after it. The check is strict:
-  on 1.57 it sent back three correct open-source suites because no words showed them to be "free". Check the
+  shown in the findings to meet a condition is marked where it is named ("not shown in the pages read to be free
+  and open-source"). The mark says what the pages read did not show, not that the thing fails the condition: on
+  1.61 it marked LibreOffice and OnlyOffice, which are open source, as well as WPS Office, which is not. Check the
   result against any conditions you set.
 - **A small model's judgement is the ceiling.** It sometimes drifts to loosely related pages, prefers
   secondary sources or stays with one source too long, and results vary with the first pages a search turns
@@ -370,8 +372,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Keep a fixed checklist of the objective's parts instead of re-splitting it at every check (1.53)
 - [ ] Check that a finding really covers its checklist item, including conditions like "open source" (partly, since
   1.57: a coverage check before finishing, with what the code can verify)
-- [ ] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
-  result (the next step after 1.57)
+- [x] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
+  result (1.58, released in 1.61)
+- [x] Point the agent to the part of a long page whose outline names an item it still needs (1.61)
+- [ ] Keep the advice to finish when a conversation starts over from a fresh prompt (the next step after 1.61)
 - [ ] Rewind dead ends: save the conversation before an expensive step such as reading a long page, and if it
   leads nowhere, return to that point with a short note instead of carrying the unused page text in every later
   prompt (LM Studio reuses its cache up to the saved point)
@@ -424,8 +428,8 @@ the [Code of Conduct](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CO
 ## Project history
 
 Every released version is a tagged commit, and [CHANGELOG.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CHANGELOG.md) describes what changed in each one and
-why, with the measurements behind the decisions. Versions 1.54 to 1.56 were internal steps, each measured on the
-regression suite and released together as 1.57; their results are in
+why, with the measurements behind the decisions. Versions 1.54 to 1.56 and 1.58 to 1.60 were internal steps, each
+measured on the regression suite and released with 1.57 and 1.61; their results are in
 [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md).
 
 ## Acknowledgements

{localagentbrowser-1.57 → localagentbrowser-1.61}/agent_browser.py

@@ -30,11 +30,13 @@ SEARCH_URL = "https://html.duckduckgo.com/html/?q="
 REPORT_FILE = "research_report.md"
 JOURNAL_BATCH = 6        # The prompt shows 6-11 recent journal entries; old ones are dropped 6 at a time
 MAX_JOURNAL_DETAIL_CHARS = 120  # Longest query/URL/request text shown per journal line
+MAX_JOURNAL_REASON_CHARS = 120  # Longest refusal reason shown per journal line (the full text is in research_log.txt)
 MAX_THOUGHT_CHARS = 120 # Old reasoning is trimmed in the prompt; the full text stays in research_log.txt
 MAX_SEARCH_RESULTS = 8
 MAX_SNIPPET_CHARS = 200
 PAGE_PART_CHARS = 2500   # Pages are shown in parts of about this size; READ_MORE shows the next part
-MAX_LINKS = 15
+MAX_LINKS = 8           # Links listed per page; most pages are reached from search results
+CONTENT_LINK_WORDS = 3   # Links with at least this many words of text are listed before shorter (menu) links
 OUTLINE_MIN_PARTS = 5    # Pages with at least this many parts get an outline of what each part covers
 MAX_OUTLINE_LINES = 40
 MAX_OUTLINE_LABEL = 90
@@ -75,6 +77,8 @@ MAX_CHECKLIST_ITEM_CHARS = 200
 SPLIT_MAX_TOKENS = 300
 COVERAGE_MAX_TOKENS = 400  # Length limit for the check of one checklist item before finishing
 MAX_CONDITION_WORDS = 2    # Longer "conditions" are descriptions of the item, not properties a thing must have
+MAX_THING_NAME_WORDS = 6   # Longer "things" named by the coverage check are descriptions, not names
+UNANSWERED_GAP = "nothing in DISCOVERIES SO FAR answers it"
 MAX_MISSING_CLAIM_WORDS = 4  # Short "missing" claims are checked against the discoveries' words; longer ones are kept
 COVERAGE_ITEM_CHECK = (
     "Check the one CHECKLIST item named at the end against the DISCOVERIES. Give:\n"
@@ -86,9 +90,10 @@ COVERAGE_ITEM_CHECK = (
     "Do not repeat what the evidence already says; '' if the evidence fully answers it;\n"
     "- conditions: the conditions the item sets on the things it asks for, in its own words (for example \"free\", "
     "\"open-source\", \"official\"); [] if it sets none;\n"
-    "- things: if the item has conditions, one entry for each thing the evidence names for it, with \"proof\": the exact "
-    "words from the DISCOVERIES that show that thing meets the conditions ('' if the DISCOVERIES do not say it); [] if "
-    "the item has no conditions.")
+    "- things: if the item asks for a number of things or has conditions, one entry for each different thing the "
+    "evidence names for it, with \"proof\": the exact words from the DISCOVERIES that show that thing meets the "
+    "conditions, or that name it if there are no conditions ('' if the DISCOVERIES do not say it); [] if the item asks "
+    "for neither.")
 COVERAGE_FORMAT = {"type": "json_schema", "json_schema": {"name": "coverage", "strict": True, "schema": {
     "type": "object", "properties": {
         "evidence": {"type": "string"}, "missing": {"type": "string"},
@@ -364,10 +369,19 @@ async def extract_page_links(page, shown_links=None):
     seen = set()
     link_lines = []
     omitted = 0
+    # Links with a few words of text (article titles, "Next: ...") before short ones (menu items such as "GUIDES"),
+    # each group in page order: the list is capped, and menus come first on most pages. In 4 regression suites the
+    # agent opened 39 pages, all from search results and none from page links, while the links were more than half
+    # of every new page it was shown
+    links = sorted(links, key=lambda link: len(link["text"].split()) < CONTENT_LINK_WORDS)
     for link in links:
         if link["href"] in seen or normalize_url(link["href"]) == normalize_url(page.url):
             continue
         seen.add(link["href"])
+        # Image links whose text is the image's HTML ('<img src="...') say nothing and took about a third of a
+        # site's link list (shop links, mostly)
+        if link["text"].startswith("<"):
+            continue
         if shown_links is not None and link["href"] in shown_links:
             omitted += 1
             continue
@@ -559,6 +573,11 @@ def read_more_target(parameter, page_state):
     # The model sometimes writes "2 of 2" or "part 3"; the first number is the part it means
     number = re.search(r'\d+', parameter)
     target = int(number.group()) - 1 if number else page_state["index"] + 1
+    # Told by the read-on check to read the outline part that names an open item, the model repeated a plain
+    # READ_MORE for the next part in 2 to 3 of 6 replays; a plain READ_MORE after that advice reads the named part
+    pointed = page_state.get("pointed")
+    if not number and pointed and pointed[0] == (page_state.get("url"), page_state["index"]):
+        target = pointed[1]
     # Asking for the part already shown nearly always meant the next one ("READ_MORE 9" while on part 9 came up
     # in most long-page runs, and refusing it cost a retry each time), so it is read as that, except on the last part
     if target == page_state["index"] and target < len(page_state["parts"]) - 1:
@@ -611,15 +630,81 @@ def read_on_check(page_state, current_url, target, checklist=None):
     confirmed.add(index)
     # Naming the items still open: on an explanation task the model answered 'none' for every part of an overview
     # that gave the inputs and outputs it still needed, while it was thinking about the Calvin cycle
+    # With every item holding what it asks for, a documentation task got "choose FINISH now" after a discovery and
+    # read four more parts anyway, answering each of these checks 'none' and repeating READ_MORE: then this check
+    # asks for FINISH first and no longer offers reading on
+    if every_item_has_discoveries(checklist):
+        return "CONFIRM_READ_ON", (f"Before reading on: every item of the OBJECTIVE CHECKLIST already has the discoveries "
+                                   f"it asks for. Choose FINISH now with the complete final result. Only if part "
+                                   f"{index + 1}, which is shown now, gives something an item still clearly lacks, "
+                                   "DISCOVER that instead.")
     still_open = open_items(checklist)
     serves = f"the OBJECTIVE (above all the checklist items with nothing recorded yet: {still_open})" if still_open else "the OBJECTIVE"
+    pointer = outline_pointer(page_state, checklist)
+    if pointer and pointer[0] != index + 2:
+        page_state["pointed"] = ((page_state.get("url"), index), pointer[0] - 1)
+    read_on = (f"repeat your READ_MORE: it will show part {pointer[0]}, not the next part, because the Page Outline "
+               f"names '{pointer[1]}' there, from an item with nothing recorded yet" if pointer and pointer[0] != index + 2
+               else "repeat your READ_MORE")
     return "CONFIRM_READ_ON", (f"Before reading on: you have recorded nothing from part {index + 1}, which is shown now. "
                                f"In thought_process, list each fact in it that serves {serves}, or write 'none'. If any "
-                               "of them are not in DISCOVERIES SO FAR, DISCOVER them now. If there are none, repeat your "
-                               "READ_MORE. But if DISCOVERIES SO FAR already cover every item of the OBJECTIVE CHECKLIST, choose "
+                               f"of them are not in DISCOVERIES SO FAR, DISCOVER them now. If there are none, {read_on}. "
+                               "But if DISCOVERIES SO FAR already cover every item of the OBJECTIVE CHECKLIST, choose "
                                "FINISH instead of reading on, and if this page is not about the OBJECTIVE at all, leave "
                                "it with SEARCH or NAVIGATE.")
 
+# Words that say what to do with an item, not what it is about ("Compare ... features" matched "How do they compare")
+ITEM_VERBS = {"compare", "find", "explain", "describe", "detail", "list", "give", "name", "say", "what", "which", "each",
+              "about", "into", "does", "make"}
+
+def outline_words(text):
+    # Hyphenated words stay whole: "open-source" split into "open" matched "Can I open and edit ..." in an FAQ
+    return re.findall(r"[a-z0-9]+(?:-[a-z0-9]+)*", str(text).lower())
+
+def outline_word_parts(outline):
+    """For each word in the outline labels, the part numbers (1-based) whose label has it."""
+    parts = {}
+    for number, label in enumerate(outline, 1):
+        for word in set(outline_words(label)):
+            parts.setdefault(word.rstrip("s"), set()).add(number)
+    return parts
+
+def outline_pointer(page_state, checklist):
+    """The first unread part whose outline label names a word of an open checklist item, as (part, word), or None.
+
+    Told to use the outline to reach an open item, the model still read the next part 6 of 6 times on a 10-part
+    comparison page whose outline named "Administration" and "Features" in parts 5 and 6. Words in many labels
+    ("SQLite", "PostgreSQL" in every heading of that page) say nothing about where an item is, so only words in
+    at most a third of the labels count.
+    """
+    outline = page_state.get("outline") or []
+    if len(outline) < OUTLINE_MIN_PARTS:
+        return None
+    seen = page_state.get("seen_parts") or set()
+    parts = page_state.get("parts") or []
+    where = outline_word_parts(outline)
+    # Topic words point anywhere: the page's own title (its first label: "photosynthesis" on the Photosynthesis
+    # article, "free" on a page of free office suites) and words every item shares ("SQLite" in each item of a
+    # comparison) say what the whole page is about, not where one item is
+    to_find = [item for item in checklist or [] if not OPINION_REQUEST.search(item["text"])]
+    topic = {w.rstrip("s") for w in outline_words(outline[0])}
+    if len(to_find) > 1:
+        topic |= set.intersection(*({w.rstrip("s") for w in outline_words(item["text"])} for item in to_find))
+    for item in to_find:
+        if item["discoveries"]:
+            continue
+        for word in outline_words(item["text"]):
+            key = word.rstrip("s")
+            if len(key) < 4 or word in MISSING_STOPWORDS or word in ITEM_VERBS or key in topic:
+                continue
+            # A part that starts inside code is labelled by its first code line, not a heading: on the venv docs,
+            # "Install pip in the virtual environment." was a docstring in the module's source
+            numbers = sorted(n for n in where.get(key, ()) if n - 1 not in seen
+                             and not str(parts[n - 1] if n <= len(parts) else "").lstrip().startswith("```"))
+            if numbers and len(where[key]) <= len(outline) / 3:
+                return numbers[0], word
+    return None
+
 def gap_check(thought, tried):
     # The model is asked to write 'not covered' for missing parts; on a comparison it wrote "Available Libraries:
     # Not covered" and finished anyway. A FINISH whose own reasoning says that is sent back to work on the gap,
@@ -776,6 +861,29 @@ def checklist_lines(checklist):
         lines.append(f"{number}. {item['text']} (discoveries for it: {found or 'none yet'})")
     return "\n".join(lines)
 
+def every_item_has_discoveries(checklist):
+    """Whether each item to find has at least the discoveries it asks for: one, or the number it names."""
+    items = [item for item in checklist or [] if not OPINION_REQUEST.search(item["text"])]
+    needed = [asked_count(item["text"]) or 1 for item in items]
+    # As many different discoveries as the items ask for in all: on 1.53 one overview paragraph was linked to all four
+    # items of an explanation, and finishing from it gave a thin result
+    distinct = {n for item in items for n in item["discoveries"]}
+    return (bool(items) and all(len(item["discoveries"]) >= k for item, k in zip(items, needed, strict=True))
+            and len(distinct) >= sum(needed))
+
+def after_discovery_advice(checklist):
+    # With Western, European and Native American views recorded for "at least three cultures", an owl task kept
+    # searching for more until its time ran out (twice); told only "if DISCOVERIES SO FAR now cover every item", the
+    # model kept judging that they did not. When the code can see each item has what it asks for, it says so; the
+    # coverage check before FINISH still looks at what the discoveries say
+    if every_item_has_discoveries(checklist):
+        return ("Every item of the OBJECTIVE CHECKLIST now has the discoveries it asks for (an item asking for three "
+                "things has three). Choose FINISH now with the complete final result, unless one of these discoveries "
+                "clearly does not answer its item; do not read further for extra or merely interesting details.")
+    return ("If DISCOVERIES SO FAR now cover every item of the OBJECTIVE CHECKLIST, choose FINISH now; do not read further "
+            "for extra or merely interesting details. If some items are still not covered, work on those next instead of "
+            "adding more detail to items already covered.")
+
 def open_items(checklist):
     """The checklist items nothing has been recorded for yet (opinions are written at FINISH), as one line for prompts."""
     return "; ".join(f"{n}. {item['text']}" for n, item in enumerate(checklist or [], 1)
@@ -806,10 +914,17 @@ def check_parts(tried):
             f"OBJECTIVE CHECKLIST:\n{checklist_lines(checklist)}\n")
 
 NUMBER_WORDS = {"two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9, "ten": 10}
+MEASURE_WORDS = {"second", "seconds", "minute", "minutes", "hour", "hours", "day", "days", "week", "weeks", "month",
+                 "months", "year", "years", "cup", "cups", "times", "percent"}
 
 def asked_count(text):
-    """The number of things an item asks for ("three ...", "5 ..."), or None. "At least three" counts as three."""
-    for word in plain_words(text):
+    """The number of things an item asks for ("three ...", "5 ..."), or None. "At least three" counts as three.
+
+    A number of time units or amounts ("the first two weeks", "2 cups") is not a number of things to find."""
+    words = plain_words(text)
+    for word, after in zip(words, words[1:] + [""], strict=True):
+        if after in MEASURE_WORDS:
+            continue
         if word in NUMBER_WORDS:
             return NUMBER_WORDS[word]
         if word.isdigit() and 2 <= int(word) <= 20:
@@ -892,7 +1007,10 @@ async def coverage_gaps(client, objective, checklist, journal, only=None):
             conditions = [c for c in verdict.get("conditions") or [] if isinstance(c, str) and states(item["text"], c)
                           and len([w for w in plain_words(c) if len(w) > 2]) <= MAX_CONDITION_WORDS
                           and asked_count(item["text"])]
-            things = [t for t in verdict.get("things") or [] if isinstance(t, dict) and str(t.get("name", "")).strip()]
+            # A thing is a name ("OnlyOffice"), not a sentence: the model also listed ".docx/.xlsx/.pptx compatibility
+            # is genuinely excellent ..." as one, which got a caveat of its own and made two suites count as three
+            things = [t for t in verdict.get("things") or [] if isinstance(t, dict) and str(t.get("name", "")).strip()
+                      and "\n" not in str(t["name"]).strip() and len(str(t["name"]).split()) <= MAX_THING_NAME_WORDS]
         except Exception as err:
             print(f"⚠️ Coverage check of item {n} failed ({err}); treating it as covered.")
             continue
@@ -901,15 +1019,16 @@ async def coverage_gaps(client, objective, checklist, journal, only=None):
         # that item to "the best time to repot is spring and summer", and the final result invented a care routine
         if not re.search(r"\w", str(verdict.get("evidence", ""))):
             unanswered.append(n)
-            gaps.append(f"Item {n} ({item['text']}): nothing in DISCOVERIES SO FAR answers it")
+            gaps.append(f"Item {n} ({item['text']}): {UNANSWERED_GAP}")
         elif missing:
             gaps.append(f"Item {n} ({item['text']}): missing {missing}")
         # A number the item asks for is counted, not judged: a list run recorded only LibreOffice, twice, and the
         # check found nothing missing from "three free, open-source alternatives"
         wanted = asked_count(item["text"])
         names = list(dict.fromkeys(str(t["name"]).strip() for t in things))
-        # Only with a real condition: the model lists every thing it names only for those
-        if wanted and conditions and names and len(names) < wanted:
+        # Also without a condition: an owl task finished from one discovery naming two tribes for "at least three
+        # cultures", with the two named as things and nothing missing, because the count ran only with conditions
+        if wanted and names and len(names) < wanted:
             gaps.append(f"Item {n} ({item['text']}): only {len(names)} of {wanted} found ({', '.join(names)})")
         for thing in things:
             proof = str(thing.get("proof", ""))
@@ -921,7 +1040,7 @@ async def coverage_gaps(client, objective, checklist, journal, only=None):
             unmet = [c for c in conditions if not (copied and states(proof, c))]
             if unmet:
                 condition = " and ".join(unmet)
-                unproven.append(f"{thing['name']} (not shown to be {condition})")
+                unproven.append((str(thing["name"]).strip(), condition))
                 gaps.append(f"Item {n}: {thing['name']}: no words in DISCOVERIES SO FAR show it is {condition}. SEARCH "
                             f"for '{thing['name']} {condition}' to check it, or replace it with one that is")
     return gaps, unanswered, unproven
@@ -943,9 +1062,17 @@ async def coverage_refusal(client, objective, tried, journal):
         # final result said nothing was found
         gaps = ["Nothing has been recorded for any checklist item yet"]
         tried["unanswered"] = [n for n, item in enumerate(checklist, 1) if not OPINION_REQUEST.search(item["text"])]
+    # Only gaps the code can confirm send the agent back: an item nothing was copied for, fewer things than the item
+    # asks for, or nothing recorded at all. About half of the send-backs for the model's other verdicts were wrong in
+    # four suite runs ("missing official documentation" on a comparison, "H2O, O2" already recorded, "free" on a
+    # correct list of open-source suites) and cost a finish each; those verdicts now only shape the final result
+    hard = [g for g in gaps if g.endswith(UNANSWERED_GAP) or re.search(r"\): only \d+ of \d+ found", g)
+            or g.startswith("Nothing has been recorded")]
+    if gaps:
+        print("⚠️ Gaps found:\n" + "\n".join(f"   - {g}{'' if g in hard else ' (not sent back)'}" for g in gaps))
+    gaps = hard
     if not gaps:
         return None
-    print("⚠️ Gaps found:\n" + "\n".join(f"   - {g}" for g in gaps))
     return "BLOCKED_COVERAGE", ("Before finishing, each checklist item was checked against DISCOVERIES SO FAR, and these "
                                 "gaps were found:\n" + "\n".join(f"- {g}" for g in gaps) + "\nWork on them first: DISCOVER "
                                 "the missing information, or words that show a condition is met, from the current page if "
@@ -1058,7 +1185,10 @@ def journal_line(e):
         detail += f" (landed on {destination})"
     line = f"T{e.get('turn')} {action} {detail}".rstrip()
     if e.get("reason") or e.get("error"):
-        line += f" -> {e.get('reason') or e.get('error')}"
+        # Shortened like the details: the model saw the full refusal when it happened, and repeating it in every
+        # fresh prompt made the journal the largest part of one (up to 7,000 characters, mostly read-on checks
+        # and the finish and coverage checks with their lists), at about 8 tokens a second
+        line += f" -> {shorten(e.get('reason') or e.get('error'), MAX_JOURNAL_REASON_CHARS)}"
     thought = e.get("thought", "")
     if thought:
         line += f" | thought: {thought[:MAX_THOUGHT_CHARS] + '...' if len(thought) > MAX_THOUGHT_CHARS else thought}"
@@ -1335,8 +1465,9 @@ async def compose_final_result(client, objective, journal, checklist=None, not_f
         parts += ("### NOT FOUND (no discovery answers these; they are reported after your result)\n"
                   + "\n".join(f"- {text}" for text in unfound) + "\n\n")
     if unproven:
-        parts += ("### NOT SHOWN TO MEET THE CONDITIONS (do not list these; they are reported after your result)\n"
-                  + "\n".join(f"- {text}" for text in unproven) + "\n\n")
+        parts += ("### NOT SHOWN TO MEET THE CONDITIONS (the discoveries do not show these meet them; if you list one, "
+                  "say so right after it)\n" + "\n".join(f"- {name}: not shown to be {cond}" for name, cond in unproven)
+                  + "\n\n")
     request = (f"### OBJECTIVE\n{objective}\n\n{parts}### DISCOVERIES\n{listing}\n\n"
                "Write the complete final result the OBJECTIVE asks for: do exactly what it asks (for example answer "
                "the question, write the summary or the plan, or give the opinion). Rules:\n"
@@ -1385,8 +1516,27 @@ async def compose_final_result(client, objective, journal, checklist=None, not_f
             text += "\n\n" + (paragraph if paragraph.lower().startswith("my view:") else f"My view: {paragraph}")
     if unfound:
         text += "\n\nNot found in the pages read:\n" + "\n".join(f"- {t}" for t in unfound)
-    if unproven:
-        text += "\n\nLeft out, not shown to meet the conditions in the pages read:\n" + "\n".join(f"- {t}" for t in unproven)
+    return with_caveats(text, unproven)
+
+def with_caveats(text, unproven):
+    """The final result with each thing not shown to meet a condition marked where it is first named.
+
+    Leaving such things out dropped correct answers along with wrong ones: a page said "open-source" of
+    LibreOffice, ONLYOFFICE and Apache OpenOffice, but not "free". So they stay, marked by the code, which does not
+    rely on the final result to say it; things the result does not name are listed after it.
+    """
+    unnamed = []
+    for name, condition in unproven:
+        note = f"(not shown in the pages read to be {condition})"
+        match = re.search(re.escape(name) + r"(\*\*)?", text, re.I)
+        if not match:
+            unnamed.append(f"- {name}: {note[1:-1]}")
+        # Only a note right after this name counts as already there: checked against the whole text, the note added
+        # to OnlyOffice left WPS Office, with the same condition, unmarked in a list run's result
+        elif not text[match.end():].lstrip().lower().startswith(note.lower()):
+            text = text[:match.end()] + f" {note}" + text[match.end():]
+    if unnamed:
+        text += "\n\nNot shown in the pages read to meet the conditions:\n" + "\n".join(unnamed)
     return text
 
 async def load_page(page, url=None):
@@ -1582,10 +1732,7 @@ async def main():
                     set_note(conversation, f"RESULT: Your DISCOVER was recorded as discovery [{number}]{linked_note}. "
                                            f"{where_you_are(page_state, current_url)} The page is unchanged.\n"
                                            f"OBJECTIVE CHECKLIST now:\n{checklist_lines(tried['checklist'])}\n"
-                                           "Do not record the same information again. If DISCOVERIES SO FAR now cover "
-                                           "every item of the OBJECTIVE CHECKLIST, choose FINISH now; do not read further "
-                                           "for extra or merely interesting details. If some items are still not covered, "
-                                           "work on those next instead of adding more detail to items already covered.",
+                                           f"Do not record the same information again. {after_discovery_advice(tried['checklist'])}",
                              current_url)
 
                 # A single refusal gets a short warning; repeated refusals get an explicit list of other options

{localagentbrowser-1.57 → localagentbrowser-1.61/localagentbrowser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localagentbrowser
-Version: 1.57
+Version: 1.61
 Summary: An autonomous web agent driven by a local LLM (LM Studio) and Playwright. Runs entirely on your own machine.
 Author: SnowFX
 License-Expression: MIT
@@ -199,19 +199,19 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 
 Since 1.53, every change is measured on the same seven objectives, one of each kind above, run one after the other
 with a time limit each (`tools/regression.py`, see [Testing](#testing)). Single runs vary with the pages a search
-turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 were internal steps measured this way
-and released together as 1.57; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
+turns up, so the suite compares versions on all seven at once. 1.54 to 1.56 and 1.58 to 1.60 were internal steps
+measured this way and released with 1.57 and 1.61; [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md)
 has every step's results and what each one showed.
 
-| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) |
-|---|---|---|---|
-| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min |
-| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" |
-| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for |
-| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time |
-| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited |
-| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for |
-| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one |
+| Task | 1.52 | 1.53 (objective checklist) | 1.57 (coverage check) | 1.61 (verified send-backs, outline pointer) |
+|---|---|---|---|---|
+| Factual question | Finished, 12 min | Finished, 14 min | Finished, 13 min | Finished, 17 min |
+| List of three office suites | Time limit | Finished, 30 min; but WPS Office is not open source | Time limit: three correct open-source suites by turn 7, sent back because no words showed them to be "free" | Finished, 21 min: LibreOffice, WPS Office and OnlyOffice, each marked "not shown in the pages read to be free and open-source" |
+| Comparison and recommendation | Time limit | Finished, 39 min | Time limit, after a send-back for "official documentation", which the objective does not ask for | Finished, 26 min, setup and administration from the part of a long page the outline pointer chose |
+| How-to (cold brew from 1.55; repotting before) | Time limit | Time limit | Finished, 36 min; but "how long it keeps" answered with the steeping time | Finished, 33 min: every step, the 16-hour steep and the shelf life, cited |
+| Explanation (photosynthesis) | Time limit | Finished, 13 min, but thin: no oxygen or water | Finished, 59 min: inputs, outputs and both stages, cited | Finished, 39 min |
+| Opinion (owls) | Time limit | Finished, 38 min | Time limit: its first page covered two of the three cultures asked for | Finished, 42 min: four cultures, cited, with a view |
+| Documentation (venv, official docs) | Finished, 15 min, from a tutorial site | Time limit (30 min) | Finished, 37 min, all from python.org; but the Windows line repeats the create command instead of the activate one | Time limit: all four items found from python.org, then it read on |
 
 ## How it works
 
@@ -323,9 +323,9 @@ Measured on an Intel i5-9500 (6 cores, no GPU) with Qwen2.5-7B-Instruct Q4_K_M a
 | Coverage check before finishing (all checklist items) | about 1–3 min |
 | Writing the final result (once, at the end) | 50–190 s, depending on how much was found |
 
-Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 13 to
-19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 21 to 44 when they finished;
-and the explanation 13 to 59. A GPU or a smaller model will be much faster.
+Whole runs vary with the pages a search turns up. In the regression runs since 1.53, a factual question took 9 to
+19 minutes of model time; the list, comparison, how-to, opinion and documentation tasks 17 to 44 when they finished;
+and the explanation 13 to 59. A whole suite of seven tasks took 171 to 272 minutes. A GPU or a smaller model will be much faster.
 
 ## FAQ
 
@@ -363,15 +363,17 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **Judging whether a finding covers an item is the weakest area.** The model's verdict is unreliable both ways:
   on 1.53 the explanation finished from one overview paragraph without oxygen or water, and in the regression runs
   since 1.54 about half of the coverage check's send-backs were for gaps that were not real ("missing official
-  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). The code now verifies what
-  it can (an item nothing answers, a count, word-for-word proof of a condition), but each wrong send-back still
-  costs a finish on this hardware, since a send-back costs 8–10 minutes.
+  documentation" on a comparison that did not ask for it, "H2O, O2" already recorded). Since 1.58 the agent is sent
+  back only for what the code verifies (an item nothing answers, fewer things than asked for); the model's other
+  verdicts only shape the final result, so a thin answer can still pass (on 1.61 the comparison's "many
+  simultaneous users" part is short).
 - **Conditions in the objective.** A small model tends to drop conditions such as "open source" or "using the
   official documentation": a list of open-source office suites once included FreeOffice (free but not open
   source), and a task that asked for the official Python documentation used a tutorial site. The objective
   checklist keeps the conditions in view (the documentation task uses python.org since 1.55), and a thing not
-  shown in the findings to meet a condition is left out of the result and listed after it. The check is strict:
-  on 1.57 it sent back three correct open-source suites because no words showed them to be "free". Check the
+  shown in the findings to meet a condition is marked where it is named ("not shown in the pages read to be free
+  and open-source"). The mark says what the pages read did not show, not that the thing fails the condition: on
+  1.61 it marked LibreOffice and OnlyOffice, which are open source, as well as WPS Office, which is not. Check the
   result against any conditions you set.
 - **A small model's judgement is the ceiling.** It sometimes drifts to loosely related pages, prefers
   secondary sources or stays with one source too long, and results vary with the first pages a search turns
@@ -402,8 +404,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Keep a fixed checklist of the objective's parts instead of re-splitting it at every check (1.53)
 - [ ] Check that a finding really covers its checklist item, including conditions like "open source" (partly, since
   1.57: a coverage check before finishing, with what the code can verify)
-- [ ] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
-  result (the next step after 1.57)
+- [x] Send the agent back only for gaps the code verifies, and let the model's other verdicts only shape the final
+  result (1.58, released in 1.61)
+- [x] Point the agent to the part of a long page whose outline names an item it still needs (1.61)
+- [ ] Keep the advice to finish when a conversation starts over from a fresh prompt (the next step after 1.61)
 - [ ] Rewind dead ends: save the conversation before an expensive step such as reading a long page, and if it
   leads nowhere, return to that point with a short note instead of carrying the unused page text in every later
   prompt (LM Studio reuses its cache up to the saved point)
@@ -456,8 +460,8 @@ the [Code of Conduct](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CO
 ## Project history
 
 Every released version is a tagged commit, and [CHANGELOG.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/CHANGELOG.md) describes what changed in each one and
-why, with the measurements behind the decisions. Versions 1.54 to 1.56 were internal steps, each measured on the
-regression suite and released together as 1.57; their results are in
+why, with the measurements behind the decisions. Versions 1.54 to 1.56 and 1.58 to 1.60 were internal steps, each
+measured on the regression suite and released with 1.57 and 1.61; their results are in
 [docs/regression-history.md](https://github.com/SnowFXXX/LocalAgentBrowser/blob/main/docs/regression-history.md).
 
 ## Acknowledgements

{localagentbrowser-1.57 → localagentbrowser-1.61}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localagentbrowser"
-version = "1.57"
+version = "1.61"
 description = "An autonomous web agent driven by a local LLM (LM Studio) and Playwright. Runs entirely on your own machine."
 readme = "README.md"
 license = "MIT"

{localagentbrowser-1.57 → localagentbrowser-1.61}/tests/test_checklist.py

@@ -72,6 +72,34 @@ class TestChecksUseTheChecklist:
         assert "serves the OBJECTIVE (above all the checklist items with nothing recorded yet: 1. What goes in), or write 'none'" in reason
         assert "Where it happens" not in reason
 
+    def test_read_on_check_points_to_the_outline_part_naming_an_open_item(self):
+        tried = {"queries": [], "urls": [], "checklist": checklist("Compare SQLite and PostgreSQL setup and administration",
+                                                                   "Compare SQLite and PostgreSQL features")}
+        outline = ["SQLite vs PostgreSQL / Why", "What is SQLite? / What is PostgreSQL?", "SQLite vs PostgreSQL: Similarities",
+                   "SQLite vs PostgreSQL: Data types", "SQLite / PostgreSQL / Licenses / Administration",
+                   "Performance / Features", "Scalability"]
+        page = {"url": DOCS, "parts": ["x"] * 7, "outline": outline, "index": 0, "seen_parts": {0}}
+        reason = ab.check_decision("READ_MORE", "", discoveries("x"), tried, page, DOCS)[1]
+        assert ("If there are none, repeat your READ_MORE: it will show part 5, not the next part, because the Page "
+                "Outline names 'administration' there") in reason
+        # Repeated plainly, the READ_MORE reads the part named; a part number the model gives is kept
+        assert ab.read_more_target("", page) == 4 and ab.read_more_target("2", page) == 1
+        assert ab.read_more_target("", dict(page, index=1)) == 2
+        # Words in many labels ("sqlite") and item verbs ("compare") point nowhere
+        assert ab.outline_pointer(dict(page, seen_parts={0, 4, 5}), tried["checklist"]) is None
+        # A label taken from the first line of code is not a heading
+        code = dict(page, parts=["x"] * 4 + ["```\n    Administration of the pool\n"] + ["x"] * 2)
+        assert ab.outline_pointer(code, tried["checklist"]) == (6, "features")
+
+    def test_read_on_check_asks_for_finish_once_every_item_has_its_discoveries(self):
+        tried = {"queries": [], "urls": [], "checklist": checklist("What goes in", "Where it happens")}
+        ab.link_discovery(tried["checklist"], [1], 1)
+        ab.link_discovery(tried["checklist"], [2], 2)
+        page = {"url": DOCS, "parts": ["a", "b"], "index": 0, "seen_parts": {0}}
+        reason = ab.check_decision("READ_MORE", "", discoveries("x", "y"), tried, page, DOCS)[1]
+        assert "already has the discoveries it asks for. Choose FINISH now" in reason
+        assert "repeat your READ_MORE" not in reason
+
 
 class TestFinalResult:
     def test_checklist_is_given_with_a_rule_to_cover_it(self):
@@ -119,9 +147,16 @@ class TestCoverageGaps:
                           "'OnlyOffice free and open-source' to check it, or replace it with one that is"]
 
     def test_long_descriptions_are_not_conditions(self):
-        reply = verdict(conditions=["in different cultures or religions"], things=[("Western cultures", "")])
+        reply = verdict(conditions=["in different cultures or religions"],
+                        things=[("Western cultures", ""), ("Hopi", ""), ("Greece", "")])
         assert gaps(["How at least three different cultures or religions viewed owls"], [reply])[0] == []
 
+    def test_a_short_count_is_found_without_a_condition(self):
+        reply = verdict(things=[("Dakota Hidatsa Indians", "the Dakota Hidatsa"), ("Hopis Indians", "the Hopis")])
+        assert gaps(["How at least three different cultures viewed owls"], [reply])[0] == [
+            "Item 1 (How at least three different cultures viewed owls): only 2 of 3 found (Dakota Hidatsa Indians, "
+            "Hopis Indians)"]
+
     def test_conditions_the_item_does_not_state_are_ignored(self):
         reply = verdict(conditions=["open-source"], things=[("WPS Office", "")])
         assert gaps(["What each one is best at"], [reply])[0] == []
@@ -132,13 +167,22 @@ class TestCoverageGaps:
 
 
 class TestCoverageRefusal:
-    def test_sent_back_once_with_the_gaps(self):
-        client, _ = fake_client([verdict(missing="oxygen")])
+    def test_sent_back_once_for_an_item_nothing_answers(self):
+        client, _ = fake_client([verdict(evidence="", missing="oxygen")])
         tried = {"checklist": checklist("What comes out")}
         refusal = asyncio.run(ab.coverage_refusal(client, "objective", tried, discoveries("x")))
-        assert refusal[0] == "BLOCKED_COVERAGE" and "- Item 1 (What comes out): missing oxygen" in refusal[1]
+        assert refusal[0] == "BLOCKED_COVERAGE"
+        assert "- Item 1 (What comes out): nothing in DISCOVERIES SO FAR answers it" in refusal[1]
         assert asyncio.run(ab.coverage_refusal(client, "objective", tried, discoveries("x"))) is None
 
+    def test_the_model_s_other_verdicts_do_not_send_back(self):
+        reply = verdict(missing="official documentation", conditions=["free"],
+                        things=[("ONLYOFFICE", ""), ("LibreOffice", ""), ("OpenOffice", "")])
+        client, _ = fake_client([reply])
+        tried = {"checklist": checklist("Name three free suites")}
+        assert asyncio.run(ab.coverage_refusal(client, "objective", tried, discoveries("ONLYOFFICE is open source."))) is None
+        assert tried["unproven_items"] == [1], "the unmet condition still counts for the final result"
+
     def test_skipped_after_an_exhausted_search(self):
         client, model = fake_client([])
         assert asyncio.run(ab.coverage_refusal(client, "o", {"checklist": checklist("a"), "search_exhausted": True},
@@ -158,6 +202,8 @@ class TestCountedItems:
         assert ab.asked_count("Name three free, open-source alternatives") == 3
         assert ab.asked_count("Find at least 4 examples") == 4
         assert ab.asked_count("How tall is it in meters?") is None
+        assert ab.asked_count("Say how to care for the plant during the first two weeks") is None
+        assert ab.asked_count("Name two drinks made with 2 cups of water") == 2
 
     def test_fewer_different_things_than_asked_is_a_gap(self):
         reply = verdict(conditions=["open-source"], things=[("LibreOffice", "LibreOffice is free and open source"),
@@ -220,12 +266,25 @@ class TestUnprovenThings:
         tried = {"checklist": items, "unproven_items": [1]}
         found = discoveries("LibreOffice is free and open source. WPS Office has a familiar interface.")
         missing, unproven = asyncio.run(ab.not_found_items(client, "o", tried, found))
-        assert missing == [] and unproven == ["WPS Office (not shown to be open-source)"]
+        assert missing == [] and unproven == [("WPS Office", "open-source")]
 
-        client, model = fake_client(["1. LibreOffice [1]"])
+        client, model = fake_client(["1. **LibreOffice** [1]\n2. **WPS Office**"])
         text = asyncio.run(ab.compose_final_result(client, "o", found, items, [], unproven))
-        assert "### NOT SHOWN TO MEET THE CONDITIONS (do not list these" in model.calls[0][-1]["content"]
-        assert text.endswith("Left out, not shown to meet the conditions in the pages read:\n- WPS Office (not shown to be open-source)")
+        assert "- WPS Office: not shown to be open-source" in model.calls[0][-1]["content"]
+        assert text == "1. **LibreOffice** [1]\n2. **WPS Office** (not shown in the pages read to be open-source)"
+
+    def test_unnamed_things_are_listed_after_the_result_and_notes_are_not_doubled(self):
+        text = ab.with_caveats("LibreOffice [1]. ONLYOFFICE (not shown in the pages read to be free).",
+                               [("ONLYOFFICE", "free"), ("WPS Office", "open-source")])
+        assert text == ("LibreOffice [1]. ONLYOFFICE (not shown in the pages read to be free).\n\n"
+                        "Not shown in the pages read to meet the conditions:\n- WPS Office: not shown in the pages read "
+                        "to be open-source")
+
+    def test_things_with_the_same_condition_are_each_marked(self):
+        note = "(not shown in the pages read to be free and open-source)"
+        text = ab.with_caveats("1. **OnlyOffice** [1]\n2. **WPS Office** [2]",
+                               [("OnlyOffice", "free and open-source"), ("WPS Office", "free and open-source")])
+        assert text == f"1. **OnlyOffice** {note} [1]\n2. **WPS Office** {note} [2]"
 
 
 def test_opinion_items_are_shown_as_written_at_finish():
@@ -249,3 +308,39 @@ class TestReallyMissing:
 
     def test_co2_does_not_count_as_o2(self):
         assert ab.really_missing("O2", discoveries("Plants take in CO2.")) == "O2"
+
+
+def test_descriptions_are_not_things():
+    reply = verdict(conditions=["open-source"], things=[
+        ("LibreOffice", "LibreOffice is free and open source"),
+        ("OnlyOffice", ""),
+        (".docx/.xlsx/.pptx compatibility is genuinely excellent\nBuilt-in real-time collaboration", "")])
+    client, _ = fake_client([reply])
+    result, _, unproven = asyncio.run(ab.coverage_gaps(client, "o", checklist("Name three free, open-source suites"),
+                                                       discoveries("LibreOffice is free and open source.")))
+    assert "Item 1 (Name three free, open-source suites): only 2 of 3 found (LibreOffice, OnlyOffice)" in result
+    assert unproven == [("OnlyOffice", "open-source")]
+
+
+class TestAfterDiscoveryAdvice:
+    def test_says_finish_when_every_item_has_what_it_asks_for(self):
+        items = checklist("Find how at least three cultures viewed owls", "Give your own opinion on why")
+        for n in (1, 2):
+            ab.link_discovery(items, [1], n)
+        assert "If DISCOVERIES SO FAR now cover" in ab.after_discovery_advice(items), "two of three is not enough"
+        ab.link_discovery(items, [1], 3)
+        assert ab.after_discovery_advice(items).startswith("Every item of the OBJECTIVE CHECKLIST now has the discoveries")
+
+    def test_an_item_without_discoveries_keeps_the_usual_advice(self):
+        items = checklist("Setup", "Features")
+        ab.link_discovery(items, [1], 1)
+        assert not ab.every_item_has_discoveries(items)
+
+
+def test_one_discovery_linked_to_every_item_is_not_enough():
+    items = checklist("What goes in", "What comes out", "Light reactions", "Calvin cycle")
+    ab.link_discovery(items, [1, 2, 3, 4], 1)
+    assert not ab.every_item_has_discoveries(items)
+    for n in (2, 3, 4):
+        ab.link_discovery(items, [n], n)
+    assert ab.every_item_has_discoveries(items)

{localagentbrowser-1.57 → localagentbrowser-1.61}/tests/test_journal.py

@@ -72,3 +72,10 @@ def test_restore_path_escapes():
     row = "Medium plants\t4-5 inches\tChoose a pot just 1-2 inches wider"
     assert ab.restore_path_escapes(row) == row, "tabs from a page table stay"
     assert ab.restore_path_escapes("C:" + "\t" + "emp") == r"C:\temp"
+
+
+def test_long_refusal_reasons_are_shortened_in_the_journal():
+    reason = "Before reading on: you have recorded nothing from part 3. " + "List each fact. " * 40
+    line = ab.journal_line({"turn": 8, "action": "REFUSED_IN_TURN", "requested": "READ_MORE", "reason": reason})
+    assert line.startswith("T8 REFUSED_IN_TURN READ_MORE -> Before reading on: you have recorded nothing from part 3.")
+    assert len(line) < 200 and line.endswith("...")

{localagentbrowser-1.57 → localagentbrowser-1.61}/tests/test_main_loop.py

@@ -144,10 +144,10 @@ def test_discoveries_are_linked_to_checklist_items(monkeypatch, tmp_path):
 
 
 def test_a_coverage_send_back_starts_the_next_turn_fresh(monkeypatch, tmp_path):
-    gap = json.dumps({"evidence": "[1] fact from a", "missing": "the second fact", "conditions": [], "things": []})
+    gap = json.dumps({"evidence": "", "missing": "the second fact", "conditions": [], "things": []})
     script = [reply("SEARCH", "docs a"), reply("NAVIGATE", A), reply("DISCOVER", "fact from a"),
               reply("FINISH", "done"), reply("FINISH", "done"),  # finish check, then repeated
-              gap, COVERED,                                       # coverage check: a gap in item 1 -> sent back
+              gap, COVERED,                                       # coverage check: nothing answers item 1 -> sent back
               reply("FINISH", "done"), reply("FINISH", "done"),   # next turn, fresh prompt
               COVERED, COVERED,                                   # nothing linked: both items checked once more
               "Final [1]."]

{localagentbrowser-1.57 → localagentbrowser-1.61}/tests/test_page_text.py

@@ -51,7 +51,7 @@ def test_render_part_footer():
     assert "[End of page]" in ab.render_part(page)
 
 
-MENU = [{"text": f"Menu item {i}", "href": f"https://site.example/menu{i}"} for i in range(15)]
+MENU = [{"text": f"Menu item {i}", "href": f"https://site.example/menu{i}"} for i in range(ab.MAX_LINKS)]
 CONTENT = [{"text": f"Content link {i}", "href": f"https://site.example/content{i}"} for i in range(5)]
 
 
@@ -66,9 +66,23 @@ def test_next_page_on_the_same_site_lists_new_links_instead_of_the_menu():
     asyncio.run(ab.extract_page_links(FakeLinksPage("https://site.example/a", MENU + CONTENT), shown))
     links = asyncio.run(ab.extract_page_links(FakeLinksPage("https://site.example/b", MENU + CONTENT), shown))
     assert links.count("->") == 5 and "Content link 0" in links and "Menu item" not in links
-    assert "(15 links already listed" in links
+    assert f"({ab.MAX_LINKS} links already listed" in links
 
 
 def test_without_a_running_conversation_the_full_list_is_shown():
     links = asyncio.run(ab.extract_page_links(FakeLinksPage("https://site.example/b", MENU + CONTENT)))
     assert links.count("->") == ab.MAX_LINKS and "not repeated" not in links
+
+
+def test_links_whose_text_is_html_are_skipped():
+    images = [{"text": '<img src="https://site.example/x.jpg">', "href": f"https://shop.example/{i}"} for i in range(5)]
+    links = asyncio.run(ab.extract_page_links(FakeLinksPage("https://site.example/a", images + CONTENT)))
+    assert "<img" not in links and links.count("->") == 5
+
+
+def test_links_with_a_few_words_come_before_menu_items():
+    menu = [{"text": f"Menu{i}", "href": f"https://site.example/m{i}"} for i in range(10)]
+    article = [{"text": "How to repot a houseplant", "href": "https://site.example/repot"}]
+    links = asyncio.run(ab.extract_page_links(FakeLinksPage("https://site.example/a", menu + article)))
+    assert links.splitlines()[0] == "- How to repot a houseplant -> https://site.example/repot"
+    assert links.count("->") == ab.MAX_LINKS

{localagentbrowser-1.57 → localagentbrowser-1.61}/tests/test_regression.py

@@ -110,3 +110,9 @@ def test_task_ids_are_unique_and_every_kind_has_a_core_task():
     ids = [t["id"] for t in rg.TASKS]
     assert len(ids) == len(set(ids))
     assert {t["kind"] for t in rg.TASKS} == {t["kind"] for t in rg.TASKS if t["core"]}
+
+
+def test_a_caveated_forbidden_item_is_not_a_missed_condition():
+    result = "1. LibreOffice [1]\n2. OnlyOffice [1]\n3. **FreeOffice** (not shown in the pages read to be free and open-source)"
+    assert rg.score_run(TASK, journal(result, "LibreOffice and OnlyOffice ..."))["forbidden"] == []
+    assert rg.score_run(TASK, journal("3. FreeOffice [1]", "x"))["forbidden"] == ["freeoffice"]

{localagentbrowser-1.57 → localagentbrowser-1.61}/tools/regression.py

@@ -210,7 +210,10 @@ def score_run(task, journal, console="", checklist=None):
         "unverified_numbers": ab.unverified_numbers(result, found) if finish else [],
         "gap_statements": [m.group(0) for m in GAP_STATEMENT.finditer(result)],
         "missing": ["/".join(group[:3]) for group in task.get("expect", []) if not any(word in low for word in group)],
-        "forbidden": [word for word in task.get("forbid", []) if word in low],
+        # A forbidden item marked by the agent's own caveat ("FreeOffice (not shown in the pages read to be ...") is
+        # flagged to the reader, so it does not count as a missed condition
+        "forbidden": [word for word in task.get("forbid", []) if word in low
+                      and not re.search(re.escape(word) + r"\W{0,3}\(not shown in the pages read", low)],
         # How far a run got, so one that was about to finish is not read the same as one that was stuck
         "finish_attempts": sum(1 for e in journal if e.get("action") in ("FINISH", "BLOCKED_FINISH", "CONFIRM_FINISH")
                                or str(e.get("requested", "")).startswith("FINISH")),