v4.100.247

Several VS Code windows at once

• Settings no longer revert. Every window kept its own copy of the
  settings from the moment it opened and wrote the whole copy back on any
  change, undoing what the other windows had changed in between. A window now
  writes only the setting it changed.
• A change shows up in the other windows within about a second, without a
  reload. Two things stay with the window they were made in: the Plan/Act
  mode, and a message being typed.
• A conversation belongs to one window. A conversation that is open in one
  window cannot be opened, continued or deleted from another; the other window
  says where it is open. "Delete all" leaves it alone too. It is free again as
  soon as the first window starts a new task, opens another conversation or
  closes. A window that crashed stops holding its conversation by itself.
• Conversations in different windows run in parallel as before. On a local
  model they still share one GPU: a second conversation may wait for space the
  first is using.

The chat in its own window

• Undock Chat (the new button in the Cerebriline title bar, or the command
  of that name) moves the chat out of the sidebar into a window of its own,
  for a second monitor or a small screen. The conversation carries on.
• While it is undocked, files and diffs the chat opens go to the main window,
  not on top of the chat. The window's title bar has the sidebar's buttons
  (new task, history, settings) and Dock Chat.
• Dock Chat, the button left in the sidebar, or closing the window brings
  the chat back.

Browser automation with Playwright

• MCP Servers > Add Local has presets. Playwright fills in Microsoft's
  Playwright MCP server (npx @playwright/mcp@latest): the model gets a real
  browser it can open pages in, click, fill forms and read.
• A new built-in skill, browser-automation, teaches the model to use it.
  Like the other built-in skills it ships turned off: switch it on in the
  Skills tab.

Synced with upstream Cline 4.1.23

This release brings in 375 upstream commits. What you will notice:

• A message sent while the model is answering now interrupts it. The
  response in flight stops, what it had written stays in the conversation, and
  the model answers your message next. Before, the message waited for the turn
  to end.
• A failed provider request is retried when the provider reports a
  temporary error, instead of ending the turn.
• Imported conversations compact like native ones.
• Settings links open the right place: a link to a setting now opens its
  tab and scrolls to the control.
• The CLI starts faster: it loads its core on first use.
• Yolo mode has a rewritten prompt, and the instruction to finish with
  submit_and_exit is firmer.
• With reasoning turned off, more providers are now told so explicitly.

Kept as they were in Cerebriline: the 32,000-token default output cap, the
compaction trigger and its summary floor, two request retries per call, and
the task-progress checklist, which upstream removed.

Fewer turns lost to broken calls, loops and a stale checklist

From a review of a day of v9-agentic runs:

• A tool call the model wrote wrongly no longer poisons the conversation.
  When a gemma-family model closes a string the wrong way, the call cannot be
  read and nothing runs. Cerebriline now recognises this, tells the model
  exactly what was wrong, and keeps the broken call out of the conversation.
  Before, the model was told it had "called nothing" and often wrote the same
  broken call again.
• A second broken call no longer ends the run. The model used to be asked
  to rewrite a broken call once per run; a second one, even a different one,
  ended the run with nothing done. It is now asked again whenever the broken
  call differs from the last one it was asked about. Writing the very same
  broken call twice in a row still ends the run.
• A compaction is no longer thrown away one turn later. When a turn of
  long thinking had been shortened to a note just before the conversation was
  compacted, the next request sent the whole uncompacted conversation again
  and compacted a second time. Seen as two compactions within a minute or
  two of each other. The saved compaction is now matched against the
  conversation as stored, so it stays in force.
• Recovering from a reply cut off by the output limit no longer discards
  the latest work. When that recovery had to trim the conversation a second
  time, it kept what the first trim had kept and dropped everything newer,
  so the model was sent the same conversation again and started over from a
  file it had already changed. Newer messages are now kept ahead of older
  ones.
• That recovery now leaves room for the retried reply. It used to trim
  the conversation only down to the point where compaction starts, nine
  tenths of the window, so the retried turn was often cut off again. It now
  trims to half of the space left after the system prompt and tools.
• The summary written during that recovery is kept. When the summary
  plus the recent turns came back too large, the whole summary was thrown
  away after several model calls. The recent turns are now shortened instead.
• Agents go to the server their own tab names. With the session on
  xOllama on one machine and the Agents tab on xOllama on another, agents
  were sent to the session's machine and failed with "model not found".
  The same applies to the Escalation tab.
• The thinking checkbox no longer switches itself off. Loading a saved
  configuration that says nothing about thinking, after one that had it on,
  used to store "thinking off" on the tab, and agents then ran without
  thinking. The box now stores only what you click. If a tab was affected,
  tick "Enable thinking" on it once and save the configuration again.
• An Agents or Escalation tab says when it follows the session. A tab
  that does not set thinking runs with the session's setting, and now says so
  under the checkbox.
• create_agent says which argument is missing. Called without a
  description it used to answer "Cannot read properties of undefined".
• Reasoning that repeats itself is removed at once. A turn that loops on
  one passage keeps a one-line note in place of the repeated text, so the next
  request does not carry it.
• Compaction leaves such a turn out when it is the last thing in the
  conversation.
• The task checklist is kept up to date. Changing a file while the
  checklist is missing, or says everything is done, now prompts the model to
  add the step it is working on. Checklist reminders also reach the model
  during a run now; before, they were dropped on most tools.
• The editor asks for path and the other short arguments before the
  text, which makes a long edit less likely to arrive without them.
• After compaction the model's own assessment of the work is carried as
  its own thinking, in plain prose, on a turn of its own. It mentions
  replies lost to the output limit, thinking that ran out of budget and loops,
  with the advice to work in smaller steps.
• Answering a message you send mid-run no longer draws a "make a tool
  call" prompt. The model is told only that its answer was passed on and
  that the work it was doing is still open.

The panel no longer runs out of memory on a long conversation

On a long conversation the Cerebriline panel could turn grey while the task carried on behind it. The panel's own process had run out of memory: while a model was streaming, the whole conversation was re-sent to the panel up to twenty times a second, and past a couple of thousand rows the panel needed longer to take each copy in than the time between them. The copies it had not reached yet piled up until it died.

• While a model is streaming, the whole conversation is now sent once a second. Each token still arrives straight away as its own small message.
• The panel takes a copy of the conversation in one pass, and rows that did not change are not redrawn.
• The panel now tells the extension when it has taken a copy in, and the extension holds the next one until then (or for two seconds at most).
• A message that is still being written is sent to the panel at most every 50 milliseconds instead of once per token.
• If the panel stops answering for thirty seconds while a task is running, the extension log now says so, and says again when it comes back. Before, a dead panel left no trace in the log.

Measured on a conversation of 4,000 rows at 60 tokens per second: the panel's memory stays near 100 MB. Before the fix it stopped responding within seconds on 2,000 rows and grew by several gigabytes in a minute and a half.