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.