localagentbrowser 1.47__tar.gz → 1.52__tar.gz

{localagentbrowser-1.47 → localagentbrowser-1.52}/CHANGELOG.md

@@ -4,6 +4,97 @@ Every version of `agent_browser.py`, newest first. Each version is also a tagged
 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.52] - 2026-10-16
+### Changed
+- The note after each DISCOVER also says to work on parts of the objective that are not covered yet before
+  adding detail to parts that are. On the explanation task (how photosynthesis works), 1.51 recorded the
+  Calvin cycle enzyme by enzyme while the light reactions and the inputs and outputs were still missing.
+
+Rerun: after two Calvin cycle discoveries the agent left for a page on the light reactions and recorded where
+each stage happens and what the light reactions do. It still did not finish within 65 minutes: it lost about
+20 minutes reading the history and evolution sections of a long encyclopedia article twice, answering "none"
+to each read-on check, and never recorded the inputs and outputs that article's first part gives.
+
+Regression runs on 1.51 for the other kinds of task: the list task (three free, open-source alternatives to
+Microsoft Office) finished in 7 turns and 15.5 minutes of model time (49.3 on 1.46), naming LibreOffice,
+OnlyOffice and Apache OpenOffice, all open source; its final result wrongly says FreeOffice was "not
+mentioned" in the discoveries while leaving it out.
+
+## [1.51] - 2026-10-16
+### Fixed
+- On the repotting how-to, 1.50 sent back the model's invented steps once (part 2 still only said "follow
+  these 6 easy steps"), the model sent nearly the same steps again, and they went through as a confirmed
+  repeat. A DISCOVER far below anything real is now refused outright, and repeating it does not help: below
+  40% of its word pairs on the page text shown, or with a sentence below 25%. Real discoveries in the
+  earlier runs scored at least 50% overall and 40% per sentence; these invented steps scored 32%, one of
+  them 9%. Between those levels and 70% / 35%, the one-time confirmation stays.
+
+Rerun: the invented steps were refused, the agent read on and recorded the guide's real materials and steps,
+and FINISH came on turn 7 after 28.5 minutes of model time (67.5 on 1.44). The final result has every step,
+including putting the plant in the new pot, and says that no care instructions beyond the first watering
+were found. Regression on the comparison task with 1.50: 8 turns and 24.9 minutes of model time (38.2 on
+1.42), all parts covered and cited, with a recommendation.
+
+## [1.50] - 2026-10-16
+Three runs of the strict documentation objective (Playwright test agents, "do not FINISH until ... fully
+validated", including "parameter schemas" the documentation does not have).
+### Changed
+- `READ_MORE` with the number of the part already shown reads the next part. The model did this in most
+  long-page runs, meaning the next part, and refusing it cost a retry each time. On the last part it is still
+  refused.
+- The read-on check also says to leave a page that is not about the objective: shown an unrelated "agent"
+  project's command reference, the model read on part after part.
+### Fixed
+- After being told twice that a search was exhausted and that it could finish with the gap named, the model
+  tried FINISH, the finish check sent it to work on the uncovered part, and it repeated the search again (five
+  times in one run). Once a search is exhausted, FINISH goes through without the finish and gap checks.
+
+Third run: FINISH on turn 10 (25.2 minutes of model time), the first time this objective has finished; earlier
+versions searched for over an hour. The result has the official `npx playwright init-agents --loop=vscode`
+command and the file layout from the official docs, but it is thin: the finish check was answered with
+"covered by [1] covered by [2] covered by [3]" without naming the parts, one discovery was off topic, and the
+result does not say that no parameter schemas were found.
+
+## [1.49] - 2026-10-16
+A documentation task on 1.48 (create a Python virtual environment with venv, activate it on Windows and on
+macOS or Linux, and install packages) garbled commands in two places.
+### Fixed
+- Recording the Windows command `python -m venv C:\path\to\new\virtual\environment`, the model wrote single
+  backslashes in its JSON reply: `\t`, `\n` and `\r` became a tab, a newline and a carriage return, and since
+  the response format does not allow `\v`, the model turned `\virtual\environment` into `\real\name`. The
+  system prompt now asks for every backslash to be written twice, and a tab, carriage return, backspace or
+  form feed right before a letter is turned back into its backslash sequence when the text also has a
+  backslash or a drive letter (page tables keep their real tabs).
+- The final result turned the recorded `.\venv\Scripts\activate` and `source venv/bin/activate` into
+  `.venv\Scripts\activate` and `source .venv/bin/activate`, which do not match the `python -m venv venv` it
+  gave first. Rule 1 of the final result now says to copy commands, code, file paths and names exactly.
+  Replaying that step three times on 1.48 changed the commands twice; with the rule, all three were exact.
+
+Rerun with the backslash changes: FINISH on turn 6 (15.1 minutes of model time) with the create, activate
+and install commands, the Windows path intact. It used a tutorial site rather than the official
+documentation the objective named; checking conditions like that is still a weakness.
+
+## [1.48] - 2026-10-16
+An opinion task on 1.47 (how at least three cultures or religions have viewed owls, then an opinion on why
+they attract such different meanings) showed three problems.
+### Fixed
+- A discovery copied two sentences from the page and added a third the page never said ("...depicted
+  alongside other wise figures like the prophet Samuel"); copied text lifted the whole discovery to 75%, past
+  the page-match check. Each sentence of 8 or more word pairs is now also scored, and one below 35% gets the
+  same cheap retry. Measured on the earlier runs' real discoveries, sentences scored 40-100%; invented ones
+  0-41%.
+- With three cultures recorded where three were asked for, the read-on check pushed the agent to keep
+  collecting. It now also says to choose FINISH if the discoveries already cover every part of the objective.
+- The final result listed many traditions but gave no opinion, although the objective asked for one. When the
+  objective asks for an opinion, view or recommendation and the result has no "My view:" paragraph, a short
+  second call writes only that paragraph from the result.
+- The report's number check treated citation ranges like "[1-4]" as numbers.
+
+Rerun with the sentence and finish changes: FINISH on turn 11 (37.9 minutes of model time) with the views of
+Greek, English and many Native American peoples from a detailed source, all discoveries matching the page. Its
+three page-match checks were condensed summaries of real sentences; the model repeated each and it went
+through, at 37-61 s per check. Replaying the final-result step on that run added a "My view:" paragraph.
+
 ## [1.47] - 2026-10-16
 A list task on 1.46 (three free, open-source alternatives to Microsoft Office and what each is best at)
 finished on its own in 18 turns and 49 minutes of model time. LibreOffice and OnlyOffice were right, but the

{localagentbrowser-1.47/localagentbrowser.egg-info → localagentbrowser-1.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localagentbrowser
-Version: 1.47
+Version: 1.52
 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
@@ -56,7 +56,7 @@ and tuned to work well with a **small 7B model on a CPU, no GPU required**.
 - ⚡ **Built for slow hardware.** It reuses LM Studio's prompt cache, so most turns process only what changed.
 - 📝 **A readable report every time.** `research_report.md` holds the final result and every finding with its
   source, written however the run ends; `research_log.txt` keeps every action and reason.
-- ✅ **Tested.** 107 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
+- ✅ **Tested.** 112 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
   plus live runs on seven different kinds of task (see [results](#results-on-different-kinds-of-tasks)).
 
 📖 **The story behind it:** [Teaching a 7B model on a CPU to finish what it starts](https://dev.to/snowfxxx/teaching-a-7b-model-on-a-cpu-to-finish-what-it-starts-1amc),
@@ -184,14 +184,15 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 | Kind of task | Objective (abridged) | Version | Outcome |
 |---|---|---|---|
 | Documentation research | Setup commands and file layout for Playwright's test agents | 1.27 | Finished on its own in 13 turns (~36 min) with commands, roles and file layout |
-| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40 | Its most detailed findings (per-client setup, seed test, agent definition files), but it keeps searching for schemas the docs do not contain and has not finished within an hour |
+| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40, 1.50 | 1.38–1.40: its most detailed findings (per-client setup, seed test, agent definition files), but it kept searching for schemas the docs do not contain and did not finish within an hour. 1.50: finished in 10 turns (25 min) with the official init command and file layout, but with thin findings and without saying the schemas were not found |
 | Opinion from several sources | How spiritual traditions view cats, then form an opinion | 1.30 | Six traditions from two sources and a stated opinion, in 18 turns (37 min of model time) |
+| Opinion from several sources | How at least three cultures or religions have viewed owls, then an opinion on why | 1.47–1.48 | Greek, English and many Native American views from one detailed source in 11 turns (38 min); 1.48 adds the opinion the result had left out and catches an invented sentence in a discovery |
 | Factual question | Tallest mountain in Africa, height in meters and feet | 1.35, 1.40, 1.46 | Correct, cited answer in 4 turns (about 12 min of model time) in all three versions; before 1.35 it kept reading after finding it |
-| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min) |
+| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42, 1.50 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min); on 1.50 in 8 turns (25 min) |
 | List of items | Three free, open-source Photoshop alternatives and the strengths of each | 1.37–1.38 | GIMP, Krita and Darktable with their strengths, all cited, in 9 turns (24 min); 1.37 listed a fourth and added an unrequested opinion, which 1.38 fixes |
-| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words |
+| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46, 1.51 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words; on 1.51: LibreOffice, OnlyOffice and Apache OpenOffice, all open source, in 7 turns (16 min) |
 | Step-by-step how-to | Make a sourdough starter, with quantities and what to do each day | 1.36–1.37 | A clear plan in 7 turns (19 min), but it invented the first water amount; 1.37 stops guessing and flags unsupported numbers, and the agent then went looking for the missing details |
-| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 checks findings against the page and recorded the guide's real materials, steps and aftercare, finishing in 24 turns (68 min), though the final result left out one step |
+| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44, 1.51 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 recorded the guide's real steps but took 68 min and its result left one out. 1.51: every step from the page, in 7 turns (29 min), and it says that no care instructions beyond the first watering were found |
 | Explanation of a topic | How photosynthesis works: inputs and outputs, both stages and where each takes place | 1.41–1.42 | A complete, cited explanation in 18 turns (45 min); 1.41 read four parts of a relevant page without recording them and had not finished after 49 min |
 
 ## How it works
@@ -229,8 +230,9 @@ flowchart LR
   check: record something, or repeat the action to leave. Moving on to the next part of a page works the same
   way, and the model must first list what the part it is on says about the objective (or "none").
 - **Findings must match the page.** A finding that shares too few word pairs with the page text shown so far
-  is sent back once, asking for only what the page says in its own words: a small model will otherwise
-  "complete" a list from its own knowledge when a page says "follow these 6 steps" and the steps come later.
+  (or has a sentence that does) is sent back once, asking for only what the page says in its own words, and
+  one far from anything on the page is refused outright. A small model will otherwise "complete" a list from
+  its own knowledge when a page says "follow these 6 steps" and the steps come later.
 - **Numbered findings.** Findings are numbered in the prompt and listed with every check, and the model names
   the finding that covers each part of the objective ("covered by [2]") instead of just saying "covered".
 - **Knowing when it's done.** After every new finding the model is asked whether the objective is now fully
@@ -325,10 +327,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **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
   up; every finding is in `research_report.md` regardless.
-- **Very strict objectives can keep it searching.** An objective that forbids finishing until everything is
-  "fully validated" can keep the agent looking for something the web may not contain. It is told to finish
-  and name what it could not find after looking in several places, but a 7B model does not always judge
-  when that point has come; the turn limit (100) and Ctrl+C still apply, and the report is always current.
+- **Very strict objectives.** An objective that forbids finishing until everything is "fully validated" used
+  to keep the agent looking for something the web may not contain. On 1.50 it finished such an objective in 25
+  minutes, but with thin findings and without naming what it could not find, so check the result against the
+  objective.
 - **Check the citations.** The final result is told to use only recorded findings, but a 7B model sometimes
   puts the wrong number on a citation, adds a line no finding supports or leaves out a step, so verify a
   claim against the listed findings before relying on it.
@@ -345,7 +347,7 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Write the final result in a separate, rule-bound step and flag unsupported numbers (1.32–1.38)
 - [x] Finish as soon as the objective is covered (1.35)
 - [x] Get the model to weigh each part of a long page before reading on (1.42)
-- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely
+- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely (they finish since 1.50; naming the gaps is still open)
 - [ ] Try more kinds of objectives (seven so far) and adjust the rules that don't generalise
 - [ ] Make fresh prompts (the slowest kind of turn) cheaper still (31% cheaper since 1.34)
 - [ ] Interacting with pages (clicking, forms) for tasks beyond reading

{localagentbrowser-1.47 → localagentbrowser-1.52}/README.md

@@ -24,7 +24,7 @@ and tuned to work well with a **small 7B model on a CPU, no GPU required**.
 - ⚡ **Built for slow hardware.** It reuses LM Studio's prompt cache, so most turns process only what changed.
 - 📝 **A readable report every time.** `research_report.md` holds the final result and every finding with its
   source, written however the run ends; `research_log.txt` keeps every action and reason.
-- ✅ **Tested.** 107 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
+- ✅ **Tested.** 112 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
   plus live runs on seven different kinds of task (see [results](#results-on-different-kinds-of-tasks)).
 
 📖 **The story behind it:** [Teaching a 7B model on a CPU to finish what it starts](https://dev.to/snowfxxx/teaching-a-7b-model-on-a-cpu-to-finish-what-it-starts-1amc),
@@ -152,14 +152,15 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 | Kind of task | Objective (abridged) | Version | Outcome |
 |---|---|---|---|
 | Documentation research | Setup commands and file layout for Playwright's test agents | 1.27 | Finished on its own in 13 turns (~36 min) with commands, roles and file layout |
-| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40 | Its most detailed findings (per-client setup, seed test, agent definition files), but it keeps searching for schemas the docs do not contain and has not finished within an hour |
+| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40, 1.50 | 1.38–1.40: its most detailed findings (per-client setup, seed test, agent definition files), but it kept searching for schemas the docs do not contain and did not finish within an hour. 1.50: finished in 10 turns (25 min) with the official init command and file layout, but with thin findings and without saying the schemas were not found |
 | Opinion from several sources | How spiritual traditions view cats, then form an opinion | 1.30 | Six traditions from two sources and a stated opinion, in 18 turns (37 min of model time) |
+| Opinion from several sources | How at least three cultures or religions have viewed owls, then an opinion on why | 1.47–1.48 | Greek, English and many Native American views from one detailed source in 11 turns (38 min); 1.48 adds the opinion the result had left out and catches an invented sentence in a discovery |
 | Factual question | Tallest mountain in Africa, height in meters and feet | 1.35, 1.40, 1.46 | Correct, cited answer in 4 turns (about 12 min of model time) in all three versions; before 1.35 it kept reading after finding it |
-| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min) |
+| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42, 1.50 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min); on 1.50 in 8 turns (25 min) |
 | List of items | Three free, open-source Photoshop alternatives and the strengths of each | 1.37–1.38 | GIMP, Krita and Darktable with their strengths, all cited, in 9 turns (24 min); 1.37 listed a fourth and added an unrequested opinion, which 1.38 fixes |
-| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words |
+| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46, 1.51 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words; on 1.51: LibreOffice, OnlyOffice and Apache OpenOffice, all open source, in 7 turns (16 min) |
 | Step-by-step how-to | Make a sourdough starter, with quantities and what to do each day | 1.36–1.37 | A clear plan in 7 turns (19 min), but it invented the first water amount; 1.37 stops guessing and flags unsupported numbers, and the agent then went looking for the missing details |
-| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 checks findings against the page and recorded the guide's real materials, steps and aftercare, finishing in 24 turns (68 min), though the final result left out one step |
+| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44, 1.51 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 recorded the guide's real steps but took 68 min and its result left one out. 1.51: every step from the page, in 7 turns (29 min), and it says that no care instructions beyond the first watering were found |
 | Explanation of a topic | How photosynthesis works: inputs and outputs, both stages and where each takes place | 1.41–1.42 | A complete, cited explanation in 18 turns (45 min); 1.41 read four parts of a relevant page without recording them and had not finished after 49 min |
 
 ## How it works
@@ -197,8 +198,9 @@ flowchart LR
   check: record something, or repeat the action to leave. Moving on to the next part of a page works the same
   way, and the model must first list what the part it is on says about the objective (or "none").
 - **Findings must match the page.** A finding that shares too few word pairs with the page text shown so far
-  is sent back once, asking for only what the page says in its own words: a small model will otherwise
-  "complete" a list from its own knowledge when a page says "follow these 6 steps" and the steps come later.
+  (or has a sentence that does) is sent back once, asking for only what the page says in its own words, and
+  one far from anything on the page is refused outright. A small model will otherwise "complete" a list from
+  its own knowledge when a page says "follow these 6 steps" and the steps come later.
 - **Numbered findings.** Findings are numbered in the prompt and listed with every check, and the model names
   the finding that covers each part of the objective ("covered by [2]") instead of just saying "covered".
 - **Knowing when it's done.** After every new finding the model is asked whether the objective is now fully
@@ -293,10 +295,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **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
   up; every finding is in `research_report.md` regardless.
-- **Very strict objectives can keep it searching.** An objective that forbids finishing until everything is
-  "fully validated" can keep the agent looking for something the web may not contain. It is told to finish
-  and name what it could not find after looking in several places, but a 7B model does not always judge
-  when that point has come; the turn limit (100) and Ctrl+C still apply, and the report is always current.
+- **Very strict objectives.** An objective that forbids finishing until everything is "fully validated" used
+  to keep the agent looking for something the web may not contain. On 1.50 it finished such an objective in 25
+  minutes, but with thin findings and without naming what it could not find, so check the result against the
+  objective.
 - **Check the citations.** The final result is told to use only recorded findings, but a 7B model sometimes
   puts the wrong number on a citation, adds a line no finding supports or leaves out a step, so verify a
   claim against the listed findings before relying on it.
@@ -313,7 +315,7 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Write the final result in a separate, rule-bound step and flag unsupported numbers (1.32–1.38)
 - [x] Finish as soon as the objective is covered (1.35)
 - [x] Get the model to weigh each part of a long page before reading on (1.42)
-- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely
+- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely (they finish since 1.50; naming the gaps is still open)
 - [ ] Try more kinds of objectives (seven so far) and adjust the rules that don't generalise
 - [ ] Make fresh prompts (the slowest kind of turn) cheaper still (31% cheaper since 1.34)
 - [ ] Interacting with pages (clicking, forms) for tasks beyond reading

{localagentbrowser-1.47 → localagentbrowser-1.52}/agent_browser.py

@@ -49,9 +49,15 @@ MAX_DISCOVERY_PROMPT_CHARS = 250  # Discoveries are shortened to this in fresh p
 MAX_CHECK_DISCOVERY_CHARS = 150   # Shorter still in the numbered list that comes with the finish and progress checks
 GROUNDED_PAIR_SHARE = 0.7  # A DISCOVER sharing fewer of its word pairs with the page text shown is confirmed first
 MIN_GROUNDING_PAIRS = 20   # Shorter discoveries are not checked: a few connecting words sink their score
+GROUNDED_SENTENCE_SHARE = 0.35  # Any one sentence matching the page text shown less than this is confirmed too
+MIN_SENTENCE_PAIRS = 8     # Shorter sentences are not scored on their own
+UNGROUNDED_PAIR_SHARE = 0.4       # Below this (whole) or the next (any sentence) a DISCOVER is refused outright
+UNGROUNDED_SENTENCE_SHARE = 0.25
 TURN_PAUSE_SECONDS = 1
 STALL_TURNS = 4          # Turns without a new discovery before the model is asked to check its progress
 COMPOSE_MAX_TOKENS = 900  # Length limit for the separately written final result
+VIEW_MAX_TOKENS = 250     # Length limit for a 'My view:' paragraph added when the result left it out
+OPINION_REQUEST = re.compile(r"\b(opinion|your (own )?view|recommend\w*|what do you think)\b", re.I)
 OBJECTIVE_CHECK_EVERY = 8 # Turns between scheduled objective checks, which happen even while discoveries continue
 READ_FIRST = ("First, if the CURRENT ENVIRONMENT (or an unread part of this page, via READ_MORE) contains information "
               "relevant to the objective that is not yet in DISCOVERIES SO FAR, DISCOVER it now.")
@@ -88,7 +94,7 @@ Strictly follow these rules:
 2. Never repeat a search query, and never NAVIGATE to the page you are already on. You may return to a previously visited URL when it still has information you need, at most 3 visits per URL. These limits are enforced automatically.
 3. Prefer primary, authoritative sources over copies and summaries of them.
 4. Gather only what the objective asks for. As soon as your discoveries cover every part of it, FINISH; do not keep reading for extra or merely interesting details.
-5. Output ONLY raw JSON. No markdown wrappers, no backticks, no conversational filler."""
+5. Output ONLY raw JSON. No markdown wrappers, no backticks, no conversational filler. Inside JSON strings, write every backslash twice (a Windows path C:\\Users\\me is written "C:\\\\Users\\\\me")."""
 
 RESPONSE_FORMAT = {
     "type": "json_schema",
@@ -416,13 +422,25 @@ def grounding_check(parameter, page_state, current_url, objective=""):
     parts = page_state.get("parts") or []
     if not (current_url and page_state.get("url") == normalize_url(current_url) and parts):
         return None
-    if len(word_pairs(parameter)) < MIN_GROUNDING_PAIRS:
-        return None
     # The objective's wording counts as well: "Mount Kilimanjaro is the tallest mountain in Africa..." echoed the
     # question's "tallest" where the page says "highest", and was sent back although it was accurate
     shown = [parts[i] for i in sorted(page_state.get("seen_parts", {0})) if i < len(parts)] + [objective]
-    if grounded_share(parameter, shown) >= GROUNDED_PAIR_SHARE:
+    long_enough = len(word_pairs(parameter)) >= MIN_GROUNDING_PAIRS
+    whole = grounded_share(parameter, shown) if long_enough else 1.0
+    # An invented sentence can hide behind copied ones: an opinion task's discovery was 75% copied, but its last
+    # sentence ("...depicted alongside other wise figures like the prophet Samuel") was not on the page (31%).
+    # Real sentences scored 40-100% against their page, invented ones 0-41%.
+    sentences = [s for s in re.split(r"(?<=[.!?])\s+|\n+", parameter) if len(word_pairs(s)) >= MIN_SENTENCE_PAIRS]
+    lowest = min((grounded_share(s, shown) for s in sentences), default=1.0)
+    if whole >= GROUNDED_PAIR_SHARE and lowest >= GROUNDED_SENTENCE_SHARE:
         return None
+    # Far below anything real (whole discoveries 50%+, sentences 40%+), repeating does not confirm it: asked once,
+    # the model sent its invented repotting steps again (32% overall, one step 9%) and they went through
+    if whole < UNGROUNDED_PAIR_SHARE or lowest < UNGROUNDED_SENTENCE_SHARE:
+        return "BLOCKED_DISCOVER", ("That DISCOVER is mostly not in the page text you have been shown, so it comes from "
+                                    "your own knowledge. DISCOVER only what the parts shown actually say, in the page's own "
+                                    "wording. If what you need is not there, READ_MORE (a later part may have it) or look "
+                                    "elsewhere.")
     # Only repeating the same DISCOVER confirms it: asked again, the model once sent a different text that was
     # still invented ("water sparingly", which the page never said), and a per-part pass let it through
     asked = page_state.setdefault("grounding_asked", [])
@@ -431,7 +449,7 @@ def grounding_check(parameter, page_state, current_url, objective=""):
         return None
     asked.append(mine)
     # Pointed to READ_MORE as well, the model left a part holding the real materials list and steps unrecorded
-    return "CONFIRM_GROUNDED", (f"Much of that DISCOVER does not match the page text you have been shown, so part of it "
+    return "CONFIRM_GROUNDED", (f"Some of that DISCOVER does not match the page text you have been shown, so part of it "
                                 "seems to come from your own knowledge. DISCOVER again with only what the page actually "
                                 f"says in part {page_state['index'] + 1} (shown now) or the parts before it, using the "
                                 "page's own wording, for example its lists and steps. Do not add steps, amounts or "
@@ -470,7 +488,12 @@ def is_known_discovery(parameter, journal):
 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)
-    return int(number.group()) - 1 if number else page_state["index"] + 1
+    target = int(number.group()) - 1 if number else page_state["index"] + 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:
+        target += 1
+    return target
 
 def leave_check(action, page_state, current_url, journal=()):
     # The model often left content pages without recording what it needed from them. The first attempt to
@@ -505,7 +528,9 @@ def read_on_check(page_state, current_url, target):
     # asking it to DISCOVER relevant information first: on an explanation task it read four parts of a page that
     # had the inputs, outputs and cell locations it needed and recorded them only when a progress check fired.
     # Moving on from a part nothing was recorded from gets one cheap retry that makes the model name what the
-    # part says about the objective; repeating the READ_MORE then goes through.
+    # part says about the objective; repeating the READ_MORE then goes through. It also offers FINISH: with three
+    # cultures recorded where three were asked for, the check pushed an opinion task to keep collecting more, and
+    # it offers leaving: shown an unrelated "agent" project page, the model read on part after part.
     index = page_state["index"]
     # Only moving forward counts: going back to an earlier part is covered by the re-read check
     if target <= index or index in page_state.get("recorded_parts", set()):
@@ -517,13 +542,16 @@ def read_on_check(page_state, current_url, target):
     return "CONFIRM_READ_ON", (f"Before reading on: you have recorded nothing from part {index + 1}, which is shown now. "
                                "In thought_process, list each fact in it that serves the OBJECTIVE, or write 'none'. If any "
                                "of them are not in DISCOVERIES SO FAR, DISCOVER them now. If there are none, repeat your "
-                               "READ_MORE.")
+                               "READ_MORE. But if DISCOVERIES SO FAR already cover every part of the OBJECTIVE, choose "
+                               "FINISH instead of reading on, and if this page is not about the OBJECTIVE at all, leave "
+                               "it with SEARCH or NAVIGATE.")
 
 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,
     # at most GAP_REFUSAL_LIMIT times per run so a part that cannot be found does not block finishing for good
-    if "not covered" not in str(thought).lower() or tried.get("gap_refusals", 0) >= GAP_REFUSAL_LIMIT:
+    if ("not covered" not in str(thought).lower() or tried.get("gap_refusals", 0) >= GAP_REFUSAL_LIMIT
+            or tried.get("search_exhausted")):
         return None
     tried["gap_refusals"] = tried.get("gap_refusals", 0) + 1
     return ("BLOCKED_FINISH", "Your own check marks a part of the objective as 'not covered'. Do not finish yet: work on "
@@ -543,6 +571,10 @@ def check_decision(action, parameter, journal, tried, page_state, current_url, t
             repeats = tried.setdefault("repeated_searches", {})
             repeats[normalize_query(query)] = repeats.get(normalize_query(query), 0) + 1
             if repeats[normalize_query(query)] >= 2:
+                # Told to finish with the gap, the model tried FINISH, was asked by the finish check to work on the
+                # uncovered part, and repeated the search again (five times on a strict objective); from here a
+                # FINISH goes straight through
+                tried["search_exhausted"] = True
                 return "BLOCKED_SEARCH", (f"You have now tried to repeat the search '{query}' "
                                           f"{repeats[normalize_query(query)]} times. It was already done and did not find "
                                           "what you need. Either SEARCH with clearly different words, or accept that it "
@@ -616,7 +648,7 @@ def finish_check(tried, journal, page_state=None, current_url=None):
     # Asked to judge whether its discoveries "satisfy" the objective, a small model says yes too easily: on an
     # opinion task it finished after one source and gave a summary instead of the opinion asked for. The first
     # FINISH of each turn gets a cheap retry asking for a part-by-part check; repeating FINISH then goes through.
-    if tried.get("finish_confirmed"):
+    if tried.get("finish_confirmed") or tried.get("search_exhausted"):
         return None
     tried["finish_confirmed"] = True  # Reset at the start of every turn
     return "CONFIRM_FINISH", (f"{source_note(journal)}{unread_note(page_state or {}, current_url)}"
@@ -817,6 +849,19 @@ Active URL: {current_url if current_url else "None (Loop Initializing)"}
         {"role": "user", "content": user_payload}
     ]
 
+PATH_ESCAPES = {"\t": "\\t", "\r": "\\r", "\b": "\\b", "\f": "\\f"}
+
+def restore_path_escapes(text):
+    """Undoes JSON escapes the model did not mean: recording the Windows command "python -m venv
+    C:\\path\\to\\new\\virtual\\environment", it wrote single backslashes, and its \\t, \\n and \\r became a tab, a
+    newline and a carriage return. A tab, carriage return, backspace or form feed right before a letter is
+    treated as such a path; a newline is only restored where it sits between word characters (as in "to\\new").
+    Only text that also has a backslash or a drive letter is touched: page tables are read with real tabs."""
+    if not re.search(r"[\t\r\b\f][A-Za-z]", text) or not re.search(r"\\|\b[A-Za-z]:[\\\"\t\r\b\f\n]", text):
+        return text
+    text = re.sub(r"(?<=\w)\n(?=[a-z])", r"\\n", text)
+    return re.sub(r"[\t\r\b\f](?=[A-Za-z])", lambda m: PATH_ESCAPES[m.group()], text)
+
 async def request_decision(client, messages, journal, tried, page_state, current_url):
     # Cheap retries: a reply that is invalid or would be refused is answered with a short correction
     # appended to the same conversation. Everything before the correction is identical to what LM Studio
@@ -842,6 +887,9 @@ async def request_decision(client, messages, journal, tried, page_state, current
             action_decision = json.loads(raw_content)
             if not isinstance(action_decision, dict):
                 raise ValueError("the reply was JSON but not an object")
+            for key in ("parameter", "thought_process"):
+                if isinstance(action_decision.get(key), str):
+                    action_decision[key] = restore_path_escapes(action_decision[key])
         except (json.JSONDecodeError, ValueError) as parse_err:
             json_failures += 1
             print(f"⚠️ Model returned invalid JSON (attempt {json_failures}/{MAX_JSON_RETRIES}): {raw_content[:200]}")
@@ -883,7 +931,7 @@ def unverified_numbers(text, discoveries):
     A small model writing a how-to filled a gap with an invented quantity ("45 grams of lukewarm water (about
     1/4 cup)"); numbers are where such errors do the most harm and the easiest place to check them.
     """
-    text = re.sub(r"\[\d+(?:\s*[,;]\s*\d+)*\]", " ", str(text))  # Citation markers like [2] or [4, 5]
+    text = re.sub(r"\[\d+(?:\s*[-–,;]\s*\d+)*\]", " ", str(text))  # Citation markers: [2], [4, 5], [1-4]
     text = re.sub(r"(?m)^\s*\d+[.)]\s", " ", text)      # Numbered list items
     known = {n.replace(",", "") for e in discoveries for n in NUMBER_PATTERN.findall(e["extracted_data"])}
     unverified = []
@@ -937,7 +985,8 @@ async def compose_final_result(client, objective, journal):
                "the question, write the summary or the plan, or give the opinion). Rules:\n"
                "1. Use only the information in the DISCOVERIES. Do not fill gaps from your own knowledge or with "
                "guesses: no amounts, numbers, steps or advice that the discoveries do not contain. Where a detail the "
-               "objective asks for is missing, say that it was not found.\n"
+               "objective asks for is missing, say that it was not found. Copy commands, code, file paths and "
+               "names exactly as the discoveries give them.\n"
                "2. A discovery about one source's own situation (for example a company's workload in a case study) "
                "describes that situation, not the one in the OBJECTIVE: say whose situation it is, and do not assume "
                "details of the OBJECTIVE's situation that it does not state.\n"
@@ -959,7 +1008,21 @@ async def compose_final_result(client, objective, journal):
             text = str(reply.get("parameter") or reply.get("thought_process") or text)
         except (json.JSONDecodeError, AttributeError):
             pass
-    return text.strip()
+    text = text.strip()
+    # Asked to "give your own opinion" about owls, the result listed the traditions and ended without one,
+    # although rule 6 asks for a 'My view:' paragraph whenever the objective wants a view. A short second call
+    # writes only that paragraph, from the result just written
+    if OPINION_REQUEST.search(objective) and "my view:" not in text.lower():
+        view = await client.chat.completions.create(model=MODEL, temperature=0.3, max_tokens=VIEW_MAX_TOKENS, messages=[
+            {"role": "system", "content": COMPOSE_SYSTEM},
+            {"role": "user", "content": f"### OBJECTIVE\n{objective}\n\n### RESULT\n{text}\n\nThe OBJECTIVE asks for your "
+                                        "own view, opinion or recommendation, and the RESULT does not give it yet. Write "
+                                        "only that, as one short paragraph that starts with 'My view:', based on the "
+                                        "RESULT. Plain text."}])
+        paragraph = extract_message_content(view).strip()
+        if paragraph:
+            text += "\n\n" + (paragraph if paragraph.lower().startswith("my view:") else f"My view: {paragraph}")
+    return text
 
 async def load_page(page, url=None):
     """Loads a URL (or reloads the page) and returns Playwright's response, which may be None."""
@@ -1130,13 +1193,16 @@ async def main():
                     page_state.setdefault("recorded_parts", set()).add(page_state["index"])
                     # A discovery is when the objective can become complete; on a one-answer question the model
                     # recorded the full answer, said "the objective has been met", then kept reading for
-                    # "interesting" details, so completion is checked right here
+                    # "interesting" details, so completion is checked right here. On an explanation task it recorded
+                    # the Calvin cycle step by step while the light reactions were still missing, so the note also
+                    # points to the parts not yet covered
                     number = sum(1 for e in journal if e.get("action") == "DISCOVER")
                     set_note(conversation, f"RESULT: Your DISCOVER was recorded as discovery [{number}] in DISCOVERIES SO FAR. "
                                            f"{where_you_are(page_state, current_url)} The page is unchanged. "
                                            "Do not record the same information again. If DISCOVERIES SO FAR now cover "
                                            "every part of the OBJECTIVE, choose FINISH now; do not read further for extra "
-                                           "or merely interesting details.", current_url)
+                                           "or merely interesting details. If some parts are still not covered, work on "
+                                           "those next instead of adding more detail to parts already covered.", current_url)
 
                 # A single refusal gets a short warning; repeated refusals get an explicit list of other options
                 last_entry = journal[-1]["action"] if journal else ""

{localagentbrowser-1.47 → localagentbrowser-1.52/localagentbrowser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localagentbrowser
-Version: 1.47
+Version: 1.52
 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
@@ -56,7 +56,7 @@ and tuned to work well with a **small 7B model on a CPU, no GPU required**.
 - ⚡ **Built for slow hardware.** It reuses LM Studio's prompt cache, so most turns process only what changed.
 - 📝 **A readable report every time.** `research_report.md` holds the final result and every finding with its
   source, written however the run ends; `research_log.txt` keeps every action and reason.
-- ✅ **Tested.** 107 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
+- ✅ **Tested.** 112 tests on Linux and Windows, Python 3.10–3.13, run in about a second with no model or browser,
   plus live runs on seven different kinds of task (see [results](#results-on-different-kinds-of-tasks)).
 
 📖 **The story behind it:** [Teaching a 7B model on a CPU to finish what it starts](https://dev.to/snowfxxx/teaching-a-7b-model-on-a-cpu-to-finish-what-it-starts-1amc),
@@ -184,14 +184,15 @@ does not generalise; the [changelog](https://github.com/SnowFXXX/LocalAgentBrows
 | Kind of task | Objective (abridged) | Version | Outcome |
 |---|---|---|---|
 | Documentation research | Setup commands and file layout for Playwright's test agents | 1.27 | Finished on its own in 13 turns (~36 min) with commands, roles and file layout |
-| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40 | Its most detailed findings (per-client setup, seed test, agent definition files), but it keeps searching for schemas the docs do not contain and has not finished within an hour |
+| Documentation research, strict | The same, but "do not FINISH until fully validated", including "parameter schemas" | 1.38–1.40, 1.50 | 1.38–1.40: its most detailed findings (per-client setup, seed test, agent definition files), but it kept searching for schemas the docs do not contain and did not finish within an hour. 1.50: finished in 10 turns (25 min) with the official init command and file layout, but with thin findings and without saying the schemas were not found |
 | Opinion from several sources | How spiritual traditions view cats, then form an opinion | 1.30 | Six traditions from two sources and a stated opinion, in 18 turns (37 min of model time) |
+| Opinion from several sources | How at least three cultures or religions have viewed owls, then an opinion on why | 1.47–1.48 | Greek, English and many Native American views from one detailed source in 11 turns (38 min); 1.48 adds the opinion the result had left out and catches an invented sentence in a discovery |
 | Factual question | Tallest mountain in Africa, height in meters and feet | 1.35, 1.40, 1.46 | Correct, cited answer in 4 turns (about 12 min of model time) in all three versions; before 1.35 it kept reading after finding it |
-| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min) |
+| Comparison and recommendation | Python vs Rust for command-line tools; recommend one for a beginner. Later: SQLite vs PostgreSQL for a small web app, then a recommendation for a hobby project | 1.36, 1.42, 1.50 | Python vs Rust: cited comparison recommending Python in 16 turns (33 min), Rust's libraries not covered. SQLite vs PostgreSQL: all three parts covered and cited, with a recommendation, in 13 turns (38 min); on 1.50 in 8 turns (25 min) |
 | List of items | Three free, open-source Photoshop alternatives and the strengths of each | 1.37–1.38 | GIMP, Krita and Darktable with their strengths, all cited, in 9 turns (24 min); 1.37 listed a fourth and added an unrequested opinion, which 1.38 fixes |
-| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words |
+| List of items | Three free, open-source alternatives to Microsoft Office and what each is best at | 1.46, 1.51 | LibreOffice and OnlyOffice with their strengths, cited, in 18 turns (49 min); the third, FreeOffice, is free but not open source, and LibreOffice was recorded four times in different words; on 1.51: LibreOffice, OnlyOffice and Apache OpenOffice, all open source, in 7 turns (16 min) |
 | Step-by-step how-to | Make a sourdough starter, with quantities and what to do each day | 1.36–1.37 | A clear plan in 7 turns (19 min), but it invented the first water amount; 1.37 stops guessing and flags unsupported numbers, and the agent then went looking for the missing details |
-| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 checks findings against the page and recorded the guide's real materials, steps and aftercare, finishing in 24 turns (68 min), though the final result left out one step |
+| Step-by-step how-to | Repot a houseplant: what you need, the steps, and care for the first two weeks | 1.43–1.44, 1.51 | 1.43 recorded six steps it wrote itself before reading the part that had them; 1.44 recorded the guide's real steps but took 68 min and its result left one out. 1.51: every step from the page, in 7 turns (29 min), and it says that no care instructions beyond the first watering were found |
 | Explanation of a topic | How photosynthesis works: inputs and outputs, both stages and where each takes place | 1.41–1.42 | A complete, cited explanation in 18 turns (45 min); 1.41 read four parts of a relevant page without recording them and had not finished after 49 min |
 
 ## How it works
@@ -229,8 +230,9 @@ flowchart LR
   check: record something, or repeat the action to leave. Moving on to the next part of a page works the same
   way, and the model must first list what the part it is on says about the objective (or "none").
 - **Findings must match the page.** A finding that shares too few word pairs with the page text shown so far
-  is sent back once, asking for only what the page says in its own words: a small model will otherwise
-  "complete" a list from its own knowledge when a page says "follow these 6 steps" and the steps come later.
+  (or has a sentence that does) is sent back once, asking for only what the page says in its own words, and
+  one far from anything on the page is refused outright. A small model will otherwise "complete" a list from
+  its own knowledge when a page says "follow these 6 steps" and the steps come later.
 - **Numbered findings.** Findings are numbered in the prompt and listed with every check, and the model names
   the finding that covers each part of the objective ("covered by [2]") instead of just saying "covered".
 - **Knowing when it's done.** After every new finding the model is asked whether the objective is now fully
@@ -325,10 +327,10 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - **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
   up; every finding is in `research_report.md` regardless.
-- **Very strict objectives can keep it searching.** An objective that forbids finishing until everything is
-  "fully validated" can keep the agent looking for something the web may not contain. It is told to finish
-  and name what it could not find after looking in several places, but a 7B model does not always judge
-  when that point has come; the turn limit (100) and Ctrl+C still apply, and the report is always current.
+- **Very strict objectives.** An objective that forbids finishing until everything is "fully validated" used
+  to keep the agent looking for something the web may not contain. On 1.50 it finished such an objective in 25
+  minutes, but with thin findings and without naming what it could not find, so check the result against the
+  objective.
 - **Check the citations.** The final result is told to use only recorded findings, but a 7B model sometimes
   puts the wrong number on a citation, adds a line no finding supports or leaves out a step, so verify a
   claim against the listed findings before relying on it.
@@ -345,7 +347,7 @@ turn that brings in a new page takes a few minutes. See [Performance](#performan
 - [x] Write the final result in a separate, rule-bound step and flag unsupported numbers (1.32–1.38)
 - [x] Finish as soon as the objective is covered (1.35)
 - [x] Get the model to weigh each part of a long page before reading on (1.42)
-- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely
+- [ ] Let very strict objectives end with the gaps named instead of searching indefinitely (they finish since 1.50; naming the gaps is still open)
 - [ ] Try more kinds of objectives (seven so far) and adjust the rules that don't generalise
 - [ ] Make fresh prompts (the slowest kind of turn) cheaper still (31% cheaper since 1.34)
 - [ ] Interacting with pages (clicking, forms) for tasks beyond reading

{localagentbrowser-1.47 → localagentbrowser-1.52}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localagentbrowser"
-version = "1.47"
+version = "1.52"
 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.47 → localagentbrowser-1.52}/tests/test_decisions.py

@@ -132,7 +132,8 @@ class TestReadOnCheck:
         page = unrecorded_page(DOCS)
         first = decide("READ_MORE", "", page, DOCS)
         assert first[0] == "CONFIRM_READ_ON" and "recorded nothing from part 1" in first[1]
-        assert "write 'none'" in first[1]
+        assert "write 'none'" in first[1] and "choose FINISH instead of reading on" in first[1]
+        assert "not about the OBJECTIVE at all, leave it" in first[1]
         assert decide("READ_MORE", "", page, DOCS) is None, "repeating it goes through"
 
     def test_no_check_after_recording_from_the_shown_part(self):
@@ -156,10 +157,11 @@ class TestReadOnCheck:
         page.update(index=4, seen_parts={0, 1, 2, 3, 4}, reread_confirmed={2})
         assert decide("READ_MORE", "3", page, DOCS) is None
 
-    def test_asking_for_the_part_already_shown_is_refused(self):
-        result = decide("READ_MORE", "1", unrecorded_page(DOCS), DOCS)
-        assert result[0] == "BLOCKED_READ_MORE" and "already shown" in result[1] and "For part 2" in result[1]
+    def test_asking_for_the_part_already_shown_means_the_next_one(self):
+        assert ab.read_more_target("1", unrecorded_page(DOCS)) == 1
+        assert decide("READ_MORE", "1", recorded_page(DOCS, parts=("a", "b")), DOCS) is None
         last = recorded_page(DOCS, parts=("a", "b"), index=1)
+        assert ab.read_more_target("2", last) == 1, "on the last part it stays a request for that part"
         assert "last part" in decide("READ_MORE", "2", last, DOCS)[1]
 
 
@@ -248,14 +250,13 @@ class TestGroundingCheck:
         page = unrecorded_page(GUIDE, parts=(self.PAGE, "Step 1: Water the plant the day before."))
         return page
 
-    def test_a_discover_the_page_does_not_say_is_confirmed_once(self):
+    def test_a_discover_the_page_does_not_say_is_refused_even_when_repeated(self):
         page = self.page()
         invented = ("1. Gently remove the plant from its pot. 2. Loosen any tangled roots and trim dead ones. "
                     "3. Place fresh potting mix in the bottom of the new pot.")
-        first = decide("DISCOVER", invented, page, GUIDE)
-        assert first[0] == "CONFIRM_GROUNDED" and "does not match the page text" in first[1]
-        assert "DISCOVER again with only what the page actually says in part 1" in first[1]
-        assert decide("DISCOVER", invented, page, GUIDE) is None, "repeating it goes through"
+        for _ in range(2):
+            result = decide("DISCOVER", invented, page, GUIDE)
+            assert result[0] == "BLOCKED_DISCOVER" and "comes from your own knowledge" in result[1]
 
     def test_a_discover_copied_from_the_page_passes(self):
         copied = "Choose a pot one to two inches wider than the current one, with drainage holes."
@@ -264,10 +265,10 @@ class TestGroundingCheck:
     def test_short_discoveries_are_not_checked(self):
         assert decide("DISCOVER", "Use a bigger pot.", self.page(), GUIDE) is None
 
-    def test_real_advice_mixed_with_invented_steps_is_confirmed(self):
+    def test_real_advice_mixed_with_invented_steps_is_refused(self):
         mixed = ("Choose a pot one to two inches wider than the current one, with drainage holes. The steps are: "
                  "loosen and inspect the roots, prune any dead roots, then fill with fresh potting mix.")
-        assert decide("DISCOVER", mixed, self.page(), GUIDE)[0] == "CONFIRM_GROUNDED"
+        assert decide("DISCOVER", mixed, self.page(), GUIDE)[0] == "BLOCKED_DISCOVER"
 
 
 def test_recorded_parts_are_remembered_across_visits(monkeypatch):
@@ -290,15 +291,14 @@ def test_recorded_parts_are_remembered_across_visits(monkeypatch):
     assert decide("READ_MORE", "", state, GUIDE) is None, "part 1 was recorded on the earlier visit"
 
 
-def test_a_different_ungrounded_discover_is_checked_again():
+def test_a_different_ungrounded_discover_is_refused_again():
     page = TestGroundingCheck().page()
     first = ("1. Gently remove the plant from its pot. 2. Loosen any tangled roots and trim dead ones before you "
              "start. 3. Place fresh potting mix in the bottom of the new pot.")
     second = ("During the first two weeks water your plant sparingly and avoid fertilizing it until it settles in. "
               "Keep it out of direct sun and check the soil every few days.")
-    assert decide("DISCOVER", first, page, GUIDE)[0] == "CONFIRM_GROUNDED"
-    assert decide("DISCOVER", second, page, GUIDE)[0] == "CONFIRM_GROUNDED"
-    assert decide("DISCOVER", second, page, GUIDE) is None, "repeating the same one goes through"
+    assert decide("DISCOVER", first, page, GUIDE)[0] == "BLOCKED_DISCOVER"
+    assert decide("DISCOVER", second, page, GUIDE)[0] == "BLOCKED_DISCOVER"
 
 
 def test_the_objectives_wording_counts_as_grounded():
@@ -311,3 +311,24 @@ def test_the_objectives_wording_counts_as_grounded():
     page["grounding_asked"] = []
     tried["objective"] = "What is the tallest mountain in Africa, and how tall is it in meters and in feet?"
     assert ab.check_decision("DISCOVER", finding, [], tried, page, DOCS) is None
+
+
+def test_an_invented_sentence_behind_copied_ones_is_confirmed():
+    page = unrecorded_page(GUIDE, parts=(
+        "Owls have played a crucial role in Native American cultures since time immemorial, with sightings often "
+        "associated with shapeshifters, spiritual messages and supernatural signs. In Christianity, owls symbolize "
+        "wisdom and appear in several places.",))
+    finding = ("Owls have played a crucial role in Native American cultures since time immemorial, with sightings often "
+               "associated with shapeshifters, spiritual messages and supernatural signs. In Christianity, owls symbolize "
+               "wisdom and are often depicted alongside other wise figures like the prophet Samuel.")
+    first = decide("DISCOVER", finding, page, GUIDE)
+    assert first[0] == "CONFIRM_GROUNDED" and "DISCOVER again with only what the page actually says in part 1" in first[1]
+    assert decide("DISCOVER", finding, page, GUIDE) is None, "repeating a borderline one goes through"
+
+
+def test_finish_goes_through_once_a_search_is_exhausted():
+    tried = {"queries": ["schemas"], "urls": []}
+    page = recorded_page(DOCS)
+    for _ in range(2):
+        assert ab.check_decision("SEARCH", "schemas", [], tried, page, DOCS)[0] == "BLOCKED_SEARCH"
+    assert ab.check_decision("FINISH", "result", [], tried, page, DOCS, "Schemas: not covered") is None

{localagentbrowser-1.47 → localagentbrowser-1.52}/tests/test_journal.py

@@ -55,4 +55,14 @@ def test_old_entries_are_dropped_in_batches():
 
 def test_unverified_numbers_ignores_grouped_citations():
     found = [{"extracted_data": "LibreOffice offers good compatibility."}]
-    assert ab.unverified_numbers("LibreOffice has good compatibility [4, 5] and more [2;3].", found) == []
+    assert ab.unverified_numbers("LibreOffice has good compatibility [4, 5] and more [2;3] [1-4].", found) == []
+
+
+def test_restore_path_escapes():
+    # What json.loads makes of "C:\path\to\new\real" written with single backslashes
+    mangled = "python -m venv C:\\path" + "\t" + "o" + "\n" + "ew" + "\r" + "eal"
+    assert ab.restore_path_escapes(mangled) == r"python -m venv C:\path\to\new\real"
+    assert ab.restore_path_escapes("First line.\nSecond line.") == "First line.\nSecond line.", "real newlines stay"
+    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"

{localagentbrowser-1.47 → localagentbrowser-1.52}/tests/test_model_turns.py

@@ -93,12 +93,25 @@ class TestComposeFinalResult:
         assert "unless the objective explicitly asks for your view" in user["content"] and "Do not fill gaps" in user["content"]
         assert "give exactly that many" in user["content"]
         assert "describes that situation, not the one in the OBJECTIVE" in user["content"]
+        assert "Copy commands, code, file paths and names exactly" in user["content"]
         assert "DRAFT" not in user["content"], "the agent's unverified draft is not shown"
 
     def test_unwraps_a_json_reply(self):
         client, _ = fake_client([reply("FINISH", "My view: supported by [1].")])
         assert asyncio.run(ab.compose_final_result(client, "objective", discoveries("x"))) == "My view: supported by [1]."
 
+    def test_adds_a_missing_view_when_the_objective_asks_for_one(self):
+        client, model = fake_client(["Owls mean wisdom in Greece [1].", "Their night habits invite mystery."])
+        text = asyncio.run(ab.compose_final_result(client, "Find views on owls, then give your own opinion.",
+                                                   discoveries("Greece: wisdom")))
+        assert text == "Owls mean wisdom in Greece [1].\n\nMy view: Their night habits invite mystery."
+        assert "does not give it yet" in model.calls[1][-1]["content"]
+
+    def test_no_extra_call_when_no_view_is_asked_for(self):
+        client, model = fake_client(["Three items [1]."])
+        asyncio.run(ab.compose_final_result(client, "Name three items.", discoveries("x")))
+        assert len(model.calls) == 1
+
 
 class TestConversation:
     def test_turns_continue_one_conversation(self, scrapes):