Briglia CLI 0.2.44

Briglia CLI 0.2.44 (sequence 104)

This release tightens the time limit on web page reading, moves OpenCode page reading to GPT-6 Luna, and adds GPT-6.1 Sol to the ChatGPT subscription.

Page reading: a 2-minute limit on every backend

• Every page-reading and web_fetch compression call now has a 2-minute total limit on every backend: OpenRouter, your OpenAI API key, OpenCode Go and the ChatGPT subscription. It used to be 5 minutes, and only when OpenRouter was your main provider. Since 0.2.43 the model only picks passage numbers instead of rewriting text, so a healthy call finishes well inside that.
• The limit applies to each attempt. A cut call is retried, up to 3 attempts, and the pauses between retries count inside the limit. Keep-alive bytes don't reset the clock. No temperature and no output token cap are sent, as before.
• OpenAI API key: a call cut at the limit is recorded as an unknown charge in /spend, the same way as on OpenRouter. OpenAI doesn't report the cost of a cut call later, so it stays unknown until you run /spend accept-unknown. With a daily or monthly cap set, an unknown charge pauses paid work until then; with no cap (the default) it only shows in /spend.
• /websearch openrouter while OpenRouter isn't your main provider now gets the same limit and unknown-charge tracking. Before, those calls weren't tracked at all.
• ChatGPT subscription and OpenCode Go get the limit only. They are flat plans, so no per-call charge is recorded. On the subscription, a login refresh sits outside the timer so it is never cut halfway.
• Every backend logs a cut the same way in the web log, and briglia doctor shows the page-reading model and the limit.

OpenCode page reading on GPT-6 Luna

• On OpenCode Go, page reading and web_fetch compression now use GPT-6 Luna at medium effort over OpenCode's Responses API, with strict JSON, instead of MiMo 2.6 Flash. In tests on 16 pages it took a median 6.0 seconds a page against 11.7 seconds for MiMo, with the same facts found and about 30% less text passed to the researcher.
• The researcher itself still runs on your main model.

GPT-6.1 Sol on the ChatGPT subscription

• GPT-6.1 Sol is added to the subscription catalog, listed first, and is the default for new ChatGPT setups at high effort. Existing installs keep the model they have.
• It supports low, medium, high, xhigh and max effort; none and minimal are not accepted.
• /model now adapts the effort. Switching to a subscription model that can't take your saved effort changes it to the nearest one it accepts and tells you: none or minimal becomes low, and max becomes xhigh on a model without max. Before, switching to GPT-6.1 Sol with none saved would have failed on the next message.
• The Telegram /model buttons, the setup and settings pages, the menu recommendation (English and Italian) and briglia doctor are updated. Doctor warns if the saved effort isn't accepted by the subscription model.

Unchanged

• The main agent's prompts and requests are byte-identical to 0.2.43.

Accepted by Codex before release. Evidence: Web selftest 290/290, subscription 188/188, Responses 163/163, summary 32/32, affinity 93/93, a real-binary 2-minute cut against a local fixture (cut at 121 s, retried, completed), wire 91/91 main-agent bodies identical, full CI on macOS and Linux.

Update with /upgrade or briglia upgrade. Phones unchanged.

Briglia CLI 0.2.43

Briglia CLI 0.2.43 (sequence 103)

This release changes how web research reads pages. Page reading is faster, quotes are always exact copies of the page, and on OpenRouter it now runs on GPT-6 Luna instead of DeepSeek V4 Flash.

How pages are read now

• One call per page. There is no longer a separate call for links and images.
• The model picks, Briglia copies. Briglia splits each page into numbered passages of up to about 1,500 characters (paragraphs, headings, list items, table rows, images, code) and numbers every link and image inside them. The model answers only with the numbers of the passages, links and images that matter. Briglia then copies those passages word for word from the page, with their links in place. Quotes can no longer be misquoted or cut short.
• Nothing is filtered out by category. Menus, footers, contact and legal links stay available, so a question like "where are the dealers?" or "how do returns work?" can still find its link, even on a site in another language. Only duplicates, links to the page itself, # anchors, javascript: links and ad trackers get no number.
• Small pages skip the model. A page of 8,000 characters or less goes to the researcher whole.
• No temperature on any web request. A low temperature made some models repeat themselves until the time limit.
• Multi-line links and captions stay whole. A link or image caption that runs onto a second line is kept in one passage, so choosing it brings back the full caption and its URL.

In tests on the same model, a research run was about 20% faster and slightly cheaper, with answers of the same quality. The researcher receives somewhat more page text than before (complete passages instead of fragments).

OpenRouter

• Page reading uses GPT-6 Luna (openai/gpt-6-luna, medium effort), the same model as the OpenAI and ChatGPT lanes, on OpenAI's and Azure's standard endpoints. On 16 test pages it took a median 5.5 seconds a page, against 23 seconds for DeepSeek on Reka and DigitalOcean, with no stuck calls. It costs slightly more per page (about $0.0027 against $0.0021). The Reka/DigitalOcean pin is gone.
• Clearer failure logs. After a failed or cut call, Briglia asks OpenRouter which host served it and what it cost, and writes that to the web log.
• Own OpenAI key on OpenRouter (BYOK). When OpenRouter bills through your own OpenAI key, a cut call is settled at the provider's charge plus OpenRouter's fee, as OpenRouter reports them. If the provider's charge isn't reported, the call stays an unknown charge in /spend.
• The 5-minute limit per page-reading call and the unknown-charge rules from 0.2.42 are unchanged. No output token cap is sent.

Unchanged

• OpenCode page reading stays on MiMo 2.6 Flash.
• The main agent's prompts and requests are byte-identical to 0.2.42.

Accepted by Codex before release. Evidence: Web selftest 280/280, legacy web loop, summary 32/32, mid-turn 450/450, round delivery 143/143, stage markers 46/46, wire 91/91 main-agent bodies identical, full CI on macOS and Linux.

Update with /upgrade or briglia upgrade. Phones unchanged.

Briglia CLI 0.2.42

Briglia CLI 0.2.42 (sequence 102)

This release does two things. It makes web research on OpenRouter more reliable, by letting the page-reading model think as long as it needs to. And it helps find out why a tool call can stop making progress in the middle of a long task (seen so far with write_file: Briglia stays alive but the task never moves on), with a diagnostic log of every tool call's internal steps and a fix for one proven way the Git checkpoint could wait far longer than its timeout.

Web research and output limits

• No output token caps. Briglia no longer sends an output limit (max_tokens or similar) on any request. The page extractor used to be capped at 8,000 tokens, and DeepSeek often spent all of it thinking and returned nothing. Web research, web_fetch compression, compaction and prune summaries, and the connection checks in setup and doctor now let the model finish. Summaries are still checked when they come back (at most 65,536 bytes, never empty or cut off, one retry).
• Page extractor on OpenRouter uses Reka and DigitalOcean. Makora is no longer used: it looped and often refused with "capacity" errors. A retry after a failure goes to a host that has not failed yet.
• 5-minute limit per extraction call. When OpenRouter is your main provider, each page-reading call (excerpts, assets and web_fetch compression) has a total time limit of 5 minutes, counted from the start. It limits time, not thinking. A call that runs out is cancelled, logged as "deadline" and retried, up to 3 attempts.
• Cut or dropped calls count as unknown charges. OpenRouter may still bill a call Briglia stopped waiting for, or one whose connection dropped. Such a call is recorded as an unknown charge and shown in /spend; if OpenRouter later reports the real cost, Briglia records it once. If you have set a daily or monthly spend cap, an unknown charge pauses paid work until you send /spend accept-unknown. With no cap (the default), nothing pauses.
• Clearer failure logging. Every failed extraction attempt logs its host, reason, token counts and generation id in the web log.

Tool stall diagnostics

• Tool stage markers. Every tool call now records each internal step as it starts and finishes: the Git checkpoint (repository lookup, snapshot, launch, wait for exit, reading its output), the file write, file tracking, code diagnostics, project instructions, MCP server start-up, and the end of each round. One JSON line per step, with the call id, times, duration and outcome. No file contents, command text or secrets are logged; paths appear as file names only. Cost is about 0.1 ms per write_file call, and a slow or frozen disk never holds up a tool.
• Stall report. If a step stays open for more than 120 seconds, Briglia writes one "stall suspected" report listing every open step (and, on Linux, what each thread is waiting on) to the log and to stderr. It only reports: nothing is cancelled, failed or retried.
• Git checkpoint fix. After Git exited, Briglia waited for Git's output with no time limit. If a process started by Git kept that output open, write_file could hang well past the 15-second Git timeout. Briglia now stops reading about 2 seconds after Git exits (the caller waits at most 3 seconds). When this happens, the log records the step git.drain_stdout_barrier with outcome error and the note "stdout still held open by a descendant; stopped reading".
• Unchanged: the main agent's prompts and requests (byte-identical to 0.2.41), and mid-turn round delivery from 0.2.41.

If you have seen tool calls stall

1. Upgrade with /upgrade (or briglia upgrade).
2. Docker users: if Briglia's data folder is a volume mounted from the host (for example a Mac folder), point the log at storage inside the container, for example BRIGLIA_STAGE_MARKERS_PATH=/var/tmp/briglia/stage-markers.log, so the log does not depend on the mounted volume.
3. For the test run, turn off any external supervisor or watchdog that automatically restarts Briglia or resubmits the task. Restarting destroys the evidence of which step was open.
4. When a task stalls, before stopping anything, collect:
   • briglia __stage-markers --unclosed (steps that started and never finished),
   • the [StageMarkers] STALL REPORT lines from stderr,
   • any thread capture you normally take.
5. Reading the result: if the open step is git.drain_stdout_barrier, or you see that step end with "stdout still held open by a descendant; stopped reading" and the stall no longer happens, the Git output wait was the cause and this release fixes it. If stalls continue, the open step names where to look next.

The log lives at ~/.local/share/briglia/logs/stage-markers.log (rotated at 8 MB, owner-only, removed by /deleteuserdata). briglia doctor shows its path and any damage. Set BRIGLIA_STAGE_MARKERS=0 to turn the markers off. Details: documentation/stage-markers.md.

Accepted by Codex before release. Evidence: stage-marker selftest 46/46, Web selftest 250/250, summary-bounds selftest 32/32, round-delivery selftest 143/143, mid-turn selftest 450/450, wire 91/91 main-agent bodies identical, lifecycle r3–r12 differential passes, full CI on macOS and Linux.

Phones unchanged.

Briglia CLI 0.2.41

Briglia CLI 0.2.41 (sequence 101)

Background work now reaches Bree while she is still working. Until now, a background command or subagent that finished during a long task waited until Bree's whole turn ended, and then woke her for a separate turn. Now she can use the result in the task she is already doing.

• Results arrive in the running task. When a background Bash command, or a background (or moved-to-background) subagent, finishes while Bree is still working, its result is added to the output of the tool call she is running, clearly labelled as background work. Her next step can use it straight away. It never interrupts a model reply already being generated, and it carries no user authority.
• It is ordinary tool output. The result keeps the limits it has today (subagent report caps, Bash output tails and spill files). If it makes the context too large, the normal compaction and summaries handle it, exactly as for any other tool result. There are no new size limits and no prompt changes; ordinary requests are byte-identical to 0.2.40.
• Idle behaviour is unchanged. When Bree is not working, a finished job wakes her as before.
• Unchanged: emails, reminders, watchers and watch matches still arrive only when Bree is idle.
• /stop wins. Results from jobs stopped with /stop never arrive mid-turn, and cleaning up a stopped turn cannot affect a newer one.
• Delivered once. A result is marked delivered only after the conversation that contains it has been saved. If the save fails, it is delivered normally when Bree is idle. A result already delivered inside a task is never delivered a second time later.
• Off switch. Set the environment variable BRIGLIA_MIDTURN_BACKGROUND_RESULTS=0 to go back to idle-only delivery.
• Downgrade-safe. 0.2.40 loads everything 0.2.41 saves.

Accepted by Codex before release. Evidence: round-delivery selftest 143/143 (five consecutive runs), earlier mid-turn selftest 450/450, wire 91/91 bodies identical, lifecycle differential passes, full CI on macOS and Linux.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.40

Briglia CLI 0.2.40 (sequence 100)

A focused fix for the compaction error some long tasks hit: "Compaction summary missing or larger than the bounded output policy". What the model is asked to write is unchanged (same prompt, same length instruction, same output limit), and the main agent's requests are byte-identical to 0.2.39.

• Longer summaries are accepted. A compaction summary may now be up to 65,536 bytes (was 36,000). The old check rejected summaries that followed the requested length, especially in Italian or code. The room Briglia reserves for the summary when it plans a compaction grows to match, so a long, valid summary can't leave the next request larger than planned.
• Cut-off replies are never accepted. A reply the provider stopped early (for example finish_reason: length, or an incomplete Responses round) is rejected on both Chat Completions and Responses, even when it looks complete.
• One plain retry. An empty, cut-off or too-long summary is requested once more, identically. If the second attempt also fails during a task, the task stops as before, with nothing replaced, and the error now names the reason, for example "Compaction summary rejected after 2 attempts: the reply was cut off by the provider". Send another message to continue.
• Older turns. When an earlier turn is pruned, an empty or cut-off summary also gets one retry; after a second failure Briglia uses the plain list of the tools that ran, as before (previously an empty reply left no summary at all).
• Spend. Summaries of earlier turns, including retries, are now counted in /spend totals and limits. They were not before.
• Downgrade-safe. An older Briglia that finds a summary over 36,000 bytes still loads the conversation; only that summary leaves the live context, and its snapshot link (with the full work) stays.

Accepted by Codex before release. Evidence: summary-bounds selftest 29/29; active-compaction owner test 284/284 on both transports; wire 91/91 bodies identical; lifecycle differential passes; full CI on macOS and Linux.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.39

Briglia CLI 0.2.39 (sequence 99)

A small reliability fix for web research when OpenRouter is your main provider. Nothing else changes: the main agent's requests, the Web researcher and every other provider are byte-identical to 0.2.38.

• Faster, steadier page reading on OpenRouter. Page extraction and web_fetch compression (DeepSeek V4 Flash, deepseek/deepseek-v4-flash-0731) are now limited to three OpenRouter hosts that passed repeated live extraction tests with Briglia's exact request (strict JSON, low effort, on a large and a small real page): Reka, Makora and DigitalOcean. OpenRouter still picks the fastest of them. Before, the unrestricted "fastest host" routing mostly landed on a host that often stalled for about 90 seconds and returned an empty reply, costing several minutes per stall in long research runs.
• Applies only while /provider is openrouter. An /orprovider pin still governs only the main model (and the researcher, which runs it).

Accepted by Codex before release. Evidence: Web selftests 190/190 and the legacy web-loop tests pass; wire 91/91 bodies identical; lifecycle differential passes; full CI on macOS and Linux.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.38

Briglia CLI 0.2.38 (sequence 98)

You no longer have to wait for a long job to finish before Briglia listens. The main agent's ordinary requests are byte-identical to 0.2.37 apart from the image-tool wording below.

• Your message is read within about 3 seconds. If Briglia is waiting on a long Bash command, or on a general-purpose, custom or Web research subagent, and you write, that work moves to the background and keeps running while Briglia reads your message. The window is fixed at about 3 seconds from your first message and does not extend when more messages follow. Tool calls it had planned before it could see your message are not run; it re-reads and decides again (at most three times in a row).
• Background results arrive exactly once. A moved command or subagent reports when Briglia is idle, once, even across a restart or crash. Work that died in a crash is reported once as lost. A Web research call made inside a subagent keeps running with it and is charged once with it.
• No "got it" text. On Telegram a silent 👀 reaction shows the message arrived while Briglia was busy.
• /status lists background jobs. /stop stops everything the agent started, including background commands, subagents and results still waiting; stopped work does not restart later, also after a restart.
• Not yet in the background: Browse (browser) agents, custom agents that can drive the browser, and image generation still finish before Briglia replies.
• Generated images are sent explicitly. Briglia sees each image it generates and shares it with send_document_to_chat when it chooses, instead of every image being attached automatically after the reply.
• Spend limits stay complete. Every tool and subagent charge is recorded exactly once, across failed saves and restarts; when two records of one charge disagree, the larger amount counts. If a daily or monthly limit is set and some cost cannot be known (a subagent lost in a crash, an unreadable spend file), paid work pauses and says why. /spend accept-unknown accepts only the unknown amounts open at that moment, as $0, and keeps every known charge; /more cannot lift this pause. Without a limit the gap is only reported. Mind import and /deleteuserdata settle pending charges first or stop without changing anything.
• Storage failures never look like "empty". If the conversation file or the held-message file exists but cannot be read, Briglia holds new work, keeps the files untouched for repair, and shows the problem in /status and a maintenance alert; after repair and /restart, the earlier request runs first and held messages follow, each once.

Implemented by Claude on the owner's request and accepted by Codex at bb84de4 after six rounds for the Bash part and four for the subagent part. Release-only follow-up: the permission-based "unreadable file" test rows now run only as a non-root user, because the Linux CI container runs as root and root can read a mode-000 file; the decode-failure rows cover the same paths there (test-only, no product change). Evidence: mid-turn wake selftest 450/450 on macOS (five consecutive runs) and 426/426 as root on Linux, every review reproduction kept as a permanent test, dozens of mutation controls each caught by its own rows; all CI guards and both scans pass; wire 91/91 bodies identical outside the reviewed image-tool migration; the lifecycle differential passes; browser and headless tests pass.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.37

Briglia CLI 0.2.37 (sequence 97)

Web research now runs on your own main model, OpenRouter works without an OpenAI key, and briglia menu is organised around your AI lanes, including your own named servers. The main agent's requests are byte-identical to 0.2.36.

• The Web researcher follows your main model. It uses the same provider, model and thinking level as the main agent (ChatGPT subscription, OpenAI, OpenCode Go, OpenRouter including an /orprovider pin, or your own server). The settings are fixed when a research run starts; a /model change applies from the next run. The legacy web_search loop (/websubagent off) does the same. A request for a cheap subagent lane is ignored for research, and the result says so. /websearch now chooses only the page-reading backend.
• OpenRouter on its own. With OpenRouter as your provider and no OpenAI key, everything goes through your OpenRouter key: voice messages (gpt-transcribe), images (Gemini 3 Pro Image by default, Gemini 3.1 Flash Image as the quick engine, with editing and aspect ratios up to 21:9), OCR of scanned documents, and page reading (DeepSeek V4 Flash at low effort, routed to the fastest host). If you do add an OpenAI key, it is used for these exactly as before.
• Named servers. Add any OpenAI-compatible server by name, local (LM Studio, Ollama, vLLM) or online, with an optional API key. You can have several. Existing local-server and custom-endpoint setups move over automatically, unchanged. A saved key is only ever sent to the address it was saved with.
• A menu built around lanes. The menu opens on "Your AI lanes", with a Briglia is using selector at the top to switch between them. Adding a lane saves it without switching to it (except the very first lane of a new setup). OpenCode Go and server lanes need a saved OpenAI key, because they read web pages with OpenAI; the lane's screen asks for it only when it is missing.
• /provider in Telegram shows one button per lane, including each named server (/provider <name> works too). Switching to a lane that needs the OpenAI key when none is saved still switches, with a warning that web page reading will fail until you add it.
• Installer: the last line now says to open a new Terminal window and run briglia menu.
• Fix: paid OpenAI research in the legacy web loop is counted in your spend again.

Implemented by Claude on the owner's request and accepted by Codex at 6888bfd after three review rounds. Evidence: menu selftest 329/329 with every review reproduction kept as a permanent test, Web 190/190, media routing 53/53, subscription 188/188, Responses 163/163, mutation controls in each round; all CI guards and both scans pass; wire is 91/91 bodies identical; the lifecycle differential passes; browser and headless tests pass.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.36

Briglia CLI 0.2.36 (sequence 96)

briglia menu becomes the way to set up and manage Briglia: a simple page in your browser, in English or Italian. The main agent's requests are byte-identical to 0.2.35.

• briglia menu: setup and settings in one page. The first time, it walks you through each step. First the language, then how Briglia thinks: ChatGPT subscription (the default and the easiest), OpenCode Go, OpenRouter (new setups start on DeepSeek V4.1 Flash) or a local model. Then Telegram, the Serper and Jina keys, optional email and OpenAI key, this computer's permissions and keep-awake, and the document/media tools. On every lane except ChatGPT, an OpenAI API key is required, because web research runs on OpenAI models. On ChatGPT it's optional and needed only for voice messages and image generation.
• Telegram without looking up a chat ID. Paste the BotFather token and send your new bot a message. The page finds you and asks "Is this you?".
• Keys are checked as you paste them. There is no verify button: each key is checked and saved on its own, and a refused key gets a plain-language reason. Browser Quick Setup (briglia quicksetup, kept as a fallback) now works the same way.
• The hub afterwards. Reopening the menu shows an overview. You can change model or thinking level, replace keys, sign in to ChatGPT again or sign out, switch or add a provider, turn email on or off, and install tools. Thinking levels show friendly names with the real level underneath, and high is the default on every provider. A Start/Stop switch sits in the top-right corner once setup is done.
• Works while Briglia is running. Changes apply between messages; if Briglia is answering, the page asks you to try again. A change made elsewhere in the meantime (for example /model in Telegram) is never overwritten. ChatGPT sign-in, email on/off and AgentMail account changes take effect live. On Linux, the page reports "running" only after the service really answers.
• 6-minute stall limit. On the ChatGPT subscription and the OpenAI API, six minutes without any data (before or during a response) ends that attempt, and the usual retries follow. Healthy streams, which send data every few seconds, are unaffected.
• Email polling fixes. AgentMail catch-up positions are tied to the account, so changing accounts never reuses the old one. Positions saved before 0.2.36 are not reused: emails that arrive during the upgrade restart get no "new email" notice, but they still show in the unread list. Stopped or switched Google email checks now finish with no side effects.

Implemented by Claude on the owner's request and accepted by Codex at 698bc39 after six review rounds. Evidence: menu selftest 222/222 with every review reproduction kept as a permanent test, plus mutation controls in each round; the email/calendar suite passes 154/154, Responses 163/163 and subscription 188/188; all 18 CI guards and both scans pass; wire is 91/91 bodies identical; the lifecycle differential passes; browser, end-to-end and live-hub tests pass; smoke is 135/135.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.

Briglia CLI 0.2.35

Briglia CLI 0.2.35 (sequence 95)

Web research moves to GPT-6 Luna and follows the ChatGPT subscription. The main agent's requests are byte-identical to 0.2.34.

• GPT-6 Luna for web work and OCR. The Web researcher, page extraction, web_fetch page compression and the OCR/image preprocessor for text-only models now default to GPT-6 Luna instead of GPT-5.6 Luna. It costs half as much ($0.10 in / $0.50 out per million tokens), and spend limits count it at that price. No install stores these models explicitly, so every install switches on upgrade.
• Web research follows the ChatGPT subscription. While /provider is chatgpt, the Web researcher, extraction, web_fetch compression and the legacy web_search loop (when /websubagent off) all run through the subscription: no OpenAI key needed, nothing billed per request. Switching to another provider puts web research back on your /websearch choice. /websearch and briglia doctor explain the rule; chatgpt is not a storable /websearch value.
• A usage limit stops research cleanly. When the subscription reports its limit reached, web research fails with the same message the main agent gets. There is no paid fallback to an API key and no retry. The stop is honoured everywhere in the pipeline: no extra final-answer request, no raw page returned in place of the error, no further extraction chunks, and nothing cached as a success.
• Failed streamed responses are never used. A failed or cut-off subscription response is treated as an error: its partial text never counts as an answer and its tool calls never run.

OCR stays on your OpenAI API key (subscription models see images directly). Transcription and image generation also stay on the API key.

Implemented by Claude on the owner's request and accepted by Codex at 559e8a6 after three review rounds. Evidence: live research runs on a real subscription in an isolated copy (legacy loop and Web researcher both answered correctly); Web selftest 162/162 including every review reproduction as a permanent row; seven mutation controls; Responses 157/157 and subscription 188/188; 18 CI guards and both scans; wire 91/91 bodies identical; lifecycle differential passed; browser tests.

Upgrade with /upgrade (or briglia upgrade). Phones unchanged.