v4.100.252

Agents

• No "you just changed this file" after an edit that was refused. When an
  edit was turned down (for example "Read before editing … The file was not
  modified") and the task had no checklist, the next message told the model it
  had just changed that file. It is now said only about an edit that went
  through.
• Copying repetitive data is no longer taken for a reasoning loop. A model
  asked to embed a sound read the file as base64 and copied it into its
  thinking; the file's own padding is one character hundreds of times, and
  the loop guard cut the turn. The guard now checks what the model was given:
  repetition that is already there, at least as long, is the model restating
  what it read. Once the model writes more of it than the source holds, the
  guard cuts as before. Replayed over 88,000 recorded thinking blocks, this
  removes the four wrong cuts found and changes no other.

Ollama and xOllama

• Reasoning effort and thinking budget are two settings. The thinking
  dropdown used to send its choice as the model's thinking level, which on the
  fork's server also capped the thinking. They are now separate:
  • Thinking budget is the existing dropdown, renamed. It is the cap,
    sent as think_budget: Minimal to Max as a share of the reply, or Custom
    as a token count.
  • Reasoning effort is new. It is the model's own thinking level, sent
    as think and passed to its template. It lists only the levels the
    selected model states (for example low / medium / xhigh on qwen3.8). It is
    hidden for models that are only on or off. It does not cap anything.
• Saved profiles keep working without a re-save. The budget is read from
  where the old dropdown stored it. A profile saved before this release has
  no reasoning effort and uses Default, so it sends think: true with the
  same budget as before. On a current xOllama or the fork's Ollama, that
  gives the same cap the profile had.
• On stock Ollama, pick gpt-oss's level again. Stock Ollama has no
  think_budget. There, the old dropdown's choice reached gpt-oss as its
  level. If you relied on that, choose the level under Reasoning effort; the
  budget dropdown does nothing on stock Ollama.

llama.cpp and opencoti

• The thinking budget no longer sets the model's level, and "High" no
  longer fails. On a llama.cpp server, Cerebriline also sent the budget's
  word as reasoning_effort. llama.cpp passes that to the model's chat
  template. On a template that lists only xhigh / medium / low, "High"
  failed every turn with a server error, and "Low" changed the model's level
  as well as the budget. The budget is now sent only as
  reasoning_budget_tokens.
• Reasoning effort, from the model's own template. The llama.cpp and
  opencoti panels have a Reasoning effort dropdown. It lists the levels the
  loaded model's chat template states, read from the server's /props, and
  is sent as reasoning_effort. It is hidden when the template names no
  level. opencoti honours it from c13.
• A server that does not answer is named as the reason. When the server's
  /props cannot be read, the panel now says the levels are not known yet,
  instead of leaving the Reasoning effort dropdown out with no reason. A
  level already chosen is kept, and is not flagged as unsupported until the
  template has actually been read.
• "Default" means no budget. With thinking on and the budget left at
  Default, the generic OpenAI-compatible provider used to send a Medium
  budget and reasoning_effort: medium. It now sends neither, as the panel
  already said.
• Servers that publish no chat template get no level. vLLM and hosted APIs
  behind the generic OpenAI-compatible provider have no /props, so the
  Reasoning effort dropdown is not shown there and no reasoning_effort is
  sent. Before, the budget word reached them as one.

Generation notices (opencoti and xOllama)

• New: Generation notices. opencoti and xOllama profiles have a
  Generation notices switch, off by default. When it is on and the server
  supports notices, the server writes one short line into the model's own
  output as the model nears the end of its thinking or answer room, so it can
  wrap up instead of being cut off. Each phase takes up to four steps, as a
  percent of its room. The default is 60, 70, 80 and 90.
• A message you send mid-run is announced. A message queued or steered
  while the model works makes the server plant a line saying one is waiting.
  The message's text is not sent with it.
• The line is hidden from the chat and kept everywhere else. It stays in
  the conversation sent back to the server: removing it would make the server
  re-read the answer from that point on every turn.
• Only the conversation's own turns ask for notices. Compaction
  summaries, titles, commit messages and calls made for another conversation
  never do.
• Servers without notices are not affected. The setting is ignored on a
  server that does not report the capability. opencoti plans notices for its
  c13 build; until a server reports them, nothing changes.

v4.100.251

SDK

• The npm packages now carry the fork's own fixes to two libraries. The
  SDK changes the Ollama library and the EPUB library it uses, and those
  changes lived only in this repository. An installed @cerebriline/sdk got
  the unchanged libraries from npm instead. Both are now built into the
  packages. What that fixes for anyone using the SDK from npm:
  • Thinking effort on Ollama and xOllama. Every level was sent as a plain
    "think", so the server used the model's own budget whatever was asked.
    high is now sent as high.
  • Sampler settings the Ollama library does not know, such as a presence
    penalty of 0 or a thinking budget, were dropped from the request. They are
    sent.
  • EPUB files whose package files use namespace prefixes could not be
    read.
• A fresh install works. The packages asked for any zod 4 from 4.3.6 up,
  npm chose a newer one than the SDK was built with, and the first session
  with tools failed with "Cannot read properties of undefined (reading
  'push')". The packages now name the exact zod version they were built with.
• The release's own install test now runs a session against a stand-in server
  and reads the request, so a package that loads but sends the wrong thing is
  caught before it is published.

The extension and the CLI were never affected: they are built inside the
repository, with the changed libraries.

v4.100.250

SDK

• A session reports what it was built with. onConfigResolved on the
  session configuration is called before the first request with the context
  window, the output cap, thinking, the sampler, the provider and session
  settings (secrets removed) and the system prompt as it will be sent. It also
  lists which provider fields came from a profile stored on disk and not from
  the caller. Throwing from it stops the session from starting. The result of
  starting a session carries the same report.
• A session can ignore the stored provider profile.
  storedProviderSettings: "ignore" builds it from the configuration passed
  in and nothing else, so one run cannot inherit a sampler, a window or a base
  URL from another.
• contextWindow on the session configuration sets the lead's window,
  including the num_ctx sent to a server that takes one.
• dataDir on ClineCore.create puts everything the process stores under
  one directory.

These are for programs that drive Cerebriline through @cerebriline/sdk, such
as a test harness. Nothing changes in the extension or the CLI.

v4.100.249

Images

• render_image: the model draws screens and diagrams by writing them.
  Asked for "rendered images showing the workflow of the application", a model
  used the image generator and got dashboards with garbled labels. An image
  model cannot write a word. The new tool takes HTML and CSS, SVG or a Mermaid
  diagram that the model writes and renders it in a headless Chrome, so every
  label is the text that was typed. The picture is exactly as large as what was
  drawn unless a size is asked for; width, height, scale and crop set
  it. Relative links resolve from the workspace, so a screen can use the
  project's own stylesheet. A diagram can be saved as .svg. It needs no image
  endpoint and no model, and answers to the browser's approval box.
• transform_image: resize, crop and convert. One side or both (with
  inside, cover, pad or stretch), a crop in pixels, and the format from
  the file name: .png, .jpg, .webp, .ico, .icns. The source is never
  changed. No shell command and no installed program is needed.
• generate_icon: proposals to choose from, then every icon file. With a
  prompt it draws several candidates and shows them on one numbered sheet; the
  model asks you which one. With the chosen one it writes .ico, .icns, a
  1024 pixel PNG and the PNG sizes a page and a phone ask for. An image you
  already have can be turned into an icon the same way. Offered when an image
  endpoint is set on the Images tab.
• generate_image no longer offers itself for mockups, and says to write
  anything with words in it as HTML, SVG or Mermaid instead.

Skills

• Three built-in skills for media, turned on by default: media-images,
  media-audio and media-video. A model had to be told that it could
  generate images at all. The skills say which tool fits which job, how to make
  a picture of a screen from the application's own markup, when a README wants
  a Mermaid block and when a rendered file, and where each tool is switched on
  when it is missing. Turn one off in the Skills tab.

Agents

• The agent's live output no longer blanks between steps. When an agent
  started a new step, the Inspect view was cleared at once and showed "Nothing
  generated yet" until the model answered. The previous step now stays on
  screen until the new one produces its first text.

v4.100.248

Compaction on local servers

• Compaction starts while the summary still fits. On Ollama, xOllama,
  llama.cpp and opencoti the summary is written as the conversation's next
  turn, which reuses what the server already holds. It only fits if the
  conversation, the summary and one more turn are inside the window. The
  trigger waited for 90% of the window, by which point the summary no longer
  fit: it was refused, the fallback released the conversation's window, and
  the next turn read the whole prompt again. The trigger now leaves that room,
  so on these servers compaction starts somewhat earlier than 90%.

• A summary that cannot fit is not attempted. The check before it starts
  now counts what the last turn added and the summary's own output.

• A summary request the server says is too large is not sent again. It was
  retried twice unchanged.

• No more refused request at the start of every xOllama session. A small
  probe sent when a session opens was booked too small and answered with an
  error before being sent again.

• A background request no longer waits minutes behind its own
  conversation on xOllama. When the conversation held its whole window, the
  note written after the thinking budget is spent (and any other background
  request) waited for the server's idle timeout, up to five minutes, with
  "waiting for room" notices. The conversation's idle window is now released
  at once to make room, and the next turn re-reads the prompt.

• The "waiting for room" notice says when a request gave up. It used to
  say the request "was sent" after a wait that had in fact been cut short.

• Compaction no longer runs twice when the recent messages are too large to
  keep. It compacted keeping them, found the result still over the limit,
  threw it away and compacted again without them: about two and a half minutes
  instead of one on a local model. Their size is known before the first pass,
  so the pass that cannot fit is not run. The "recent messages were not kept"
  notice still appears.

• A tool call whose intent turns into the model's reasoning is cut. A
  model that stops using its thinking can write it into the intent of a
  call instead; one such call ran to 82,000 characters, could not be read and
  cost almost six minutes. A call whose intent passes 2,000 characters is
  now stopped while it is being written, and the model is told to make the
  call again with a one-sentence intent. It is one rule for every model and
  for agents. If the same call is stopped twice in a row, the third attempt
  is let through.

• "Cut runaway tool calls" is a switch in Features, on by default. Turn
  it off to check whether it is the cause of something odd; a change applies
  from the next task.

• xOllama shows a tool call while it is being written. With an xOllama
  that supports tool-call progress, a turn spent writing one long call
  reports progress instead of minutes of silence, and the cut above can act.
  Stock Ollama sends a call only when it is complete, so the cut has nothing
  to read there.

• A cut response now stops the server. When Cerebriline cut a response
  mid-stream (a runaway tool call, or reasoning going round in a loop), the
  server went on generating the abandoned reply to its end, beside the request
  that replaced it. The request is now closed at the cut: the server stops
  within a second and the next request picks up where the conversation was.
  In a test on xOllama the same task took 37 seconds where it took 65.

• A turn cut at the output limit no longer evicts the conversation. The
  note written from a discarded turn's thinking was a separate request; on
  xOllama it had no room beside the conversation's reserved window, so the
  conversation was released and the next turn read the whole prompt again.
  The note is now asked of the conversation itself, as one more turn that is
  not kept, whenever it fits what is left of the window.

• A run no longer ends on "admission rejected" while an agent is working.
  On a server with room for one conversation, an agent holds that room while
  it works. If the main conversation was woken in the meantime, the server
  refused its turn and the run ended there, with the agent's work unread. The
  main conversation now waits for room and retries, as agents already did.

• An agent no longer waits five minutes to start on a one-window xOllama
  server. The main conversation kept its whole window reserved while it did
  nothing but wait for the agent, so the agent's first turn was refused until
  the server's idle timeout. A refused turn now takes the window of an idle
  session of the same conversation: the waiting main conversation gives way
  to its agent, and a finished or stopped agent gives way to the main
  conversation. A session that is generating is never interrupted. The
  session that gave way reads its prompt again on its next turn.

• A compaction no longer releases its own conversation on xOllama. The
  retrospective step was a separate request with no room beside the
  conversation's reserved window, so the conversation was released mid-way and
  a notice said so. It now runs as part of the conversation when it fits,
  including when the review council is on (it used to run after the session
  had been handed back, so the notice still appeared at every compaction).

• The compaction row shows what the server counted. The figure after the
  arrow was an estimate and could disagree with the context bar (a row said
  39.9k where the next request measured 28.3k). It now reads "about" until the
  next request has run, then shows that request's count.

• Clearer wording when a background request has no room. The notice said
  "96000 booked, 0 free", which read as tokens in use. It now says the
  conversation keeps its whole window reserved while idle.

• The log shows how an unreadable tool call began and ended.

• The log says what the model was shown of its earlier thinking. One line
  per run states what Reasoning replay resolved to and what decided it (your
  setting, the server probe and its figures, or the default for an endpoint
  that was not probed).

Messages typed while the model is working

• A message typed while the model is working waits in the queue again. It
  is read when the model has finished what it is doing. It used to cut in at
  the model's next step, every time.
• Ctrl+Enter sends a message now. The model reads it at its next step
  instead of when it has finished (Cmd+Enter on a Mac; Ctrl+click on the send
  button does the same).
• A queued message has a "send now" button. The arrow on its row in the
  queue does for a waiting message what Ctrl+Enter does at send time.
• A removed thinking loop can be checked in the log. When repeated
  reasoning is removed from a turn, the log now records how many times the
  passage appeared, where in the turn its copies sat, and the passage itself
  ([reasoning-loop] in the extension log). It used to record only the size.
• An agent's live output no longer shows each tool call twice on xOllama.
  The call appeared as the model wrote it and then again as JSON. Empty
  "tool call" entries that cut the thinking into fragments are gone too.
• No more false "doesn't support images" warning on Ollama and xOllama.
  A model the server lists as able to read images (for example
  deepseek-v4.1-flash:cloud) was flagged as unable to once it appeared in
  the server's model list. The chat box now asks the server.

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.

v4.100.246

Code search by meaning: agents and the CLI

• Agents the lead starts are now offered search_codebase's semantic
  mode in a folder that is indexed. The index is the lead's; the lines of a
  passage are given as they are in the agent's own copy of the folder.
• CLI: --code-index (or CLINE_CODE_INDEX=1) turns the mode on for the
  folder the run is in. It needs CLINE_EMBEDDING_BASE_URL and
  CLINE_EMBEDDING_MODEL, and downloads LanceDB into the data folder the first
  time.

xOllama: no more silent five-minute pauses

• On xOllama a run could go silent for about five minutes after a turn whose
  thinking hit its budget, or around a compaction. The note or summary written
  then is a request of its own, and it was refused for space the conversation
  itself was holding while idle; it only got through when the engine's
  five-minute idle timer released the conversation.
• Background requests (thinking notes, compaction summaries, titles, commit
  messages, generated prompts) now ask for exactly the space they need and
  get an answer at once.
• If the only thing in the way of a conversation's own note or summary is
  that conversation's idle window, the window is released straight away and
  the request runs. The next turn re-reads its prompt once, as it already did
  after the pause. The chat says so in a status row.
• In every other case nothing is released. The request waits as before, and
  the chat now shows a row when it starts waiting and when it is sent.
• Starting a new conversation right after closing one no longer waits five
  minutes with the model already loaded. Closing a conversation now gives
  its window back to xOllama at once; before, it stayed booked until the
  engine's idle timer ran out.

Web scraping for any task

• Settings > Features > Web scraping (was "Web scraping for the
  librarian") has a new tick, Only for the librarian, on by default: as
  before, only the librarian scrapes, to make books.
• Untick it and every task is offered a web_scrape tool, with or without
  the Library: search the web, list a site's pages, read a page, and
  crawl a site into a folder of the workspace.
• A crawl saves the site itself, unaltered: each page as the site served it
  and as the browser rendered it, every stylesheet, script, picture and font
  the pages use, and a markdown reading of each page, with an index.md
  listing it all. Use it for a site you want reworked or used as the source
  of new pages. Ask for "text only" to keep just the markdown, as notes.
• How much a site crawl may fetch is yours to set under Features: files
  (2,000), largest file (25 MB) and total (300 MB).
• The files go to disk, not into the model's context. The tool says whether
  the whole site was read or which linked pages were left out.
• When a crawl stops at one of your limits, the model is told first and asked
  to tell you: which limit, how much was left out, and the setting that
  raises it. The limits count the whole folder, so a resume does not get past
  them until you raise them.
• A crawl can be continued. Ask to resume it and only the pages not yet read
  and the files not yet fetched are downloaded; what is in the folder stays.
• "Allow web scraping" in the API configuration is still needed, and the page
  and depth limits under Features still cap every crawl.
• CLI: --web-scrape (or CLINE_WEB_SCRAPE=1).

Fewer "are you finished?" reminders

• A task that answered the end-of-run reminder by checking its work and then
  said it was done in one short sentence was asked again, sometimes twice.
  That sentence now ends the run.
• A task that did its work and then said it was complete is no longer asked
  whether it is finished. Neither is one that reports having stopped at a
  limit you set. Every other reply that calls nothing is asked as before,
  including a status with work still to do.
• The reminder no longer reads as an order to keep going when a task stopped
  at something only you can change, such as a limit you set.
• A reply opening "I have completed ..." counts as saying the work is
  complete, as "... is complete" already did.
• When the checklist has unticked items at the end of a run, only the
  checklist reminder is sent. The general reminder used to arrive with it
  and ask for a one-sentence answer, which left the boxes unticked and
  brought the checklist reminder back.

Searching files with very long lines

• A file search for text that sits on a very long line, as in a minified
  script, answered "No match" although the text was there. It now shows the
  part of the line around the match and says where in the line it is.
• A codebase search printed such lines from their start, so the match was
  often outside what was shown and one search could fill the whole reply.
  Long lines are now cut around the match.
• A codebase search could show the lines before a match under the previous
  file's result, and left out the matching line itself. Both are fixed.
• A file search called with a list of patterns instead of one pattern was
  refused. One entry is now taken as the pattern, and several as
  alternatives, as literal texts too.

Message history

• What you have typed in the message box and not sent is still there after
  the window reloads or the panel is closed and reopened.
• Ctrl+Up and Ctrl+Down in the message box walk through the messages you
  sent before. Ctrl+Down past the newest gives back what you were typing.
  On macOS the keys are Cmd+Up and Cmd+Down; in a box that holds text,
  Cmd+Up first moves the caret to the start, as in any text box.
• Settings > General > Message history switches this on or off and sets how
  many messages are kept (50 by default, 500 at most). Switching it off
  deletes what was kept.

v4.100.245

Commands whose end VS Code never reports

VS Code has open faults where a command sent to the terminal finishes but the
extension is never told: for some multi-line commands and ( ... ) subshells
the end signal is lost, and for some no output is delivered at all
(microsoft/vscode#250764, #316556, #324392). The command sat "running" until
the five-minute limit while the terminal was back at its prompt.

Three cases now end on their own:

• The end marker was read but the stream stayed open: the command finishes two
  seconds later, with its exit code.
• Output arrived, nothing reported the end, and the shell's own prompt has been
  the last thing printed for ten seconds: the command is treated as finished,
  and the result says the exit code is unknown. This applies to Windows prompts
  (PS C:\path>, C:\path>).
• The command started and nothing else arrived: the result says the output was
  not delivered, gives the terminal's visible contents, and suggests sending the
  command on one line or from a file.

A command the shell never started is still reported as such; the two are told
apart by whether VS Code saw the command start.

Code search by meaning

The model can now find code by describing it. In a folder you opt in,
search_codebase gains a semantic mode: the query is a question in plain
words ("where is a user's password checked") and the answer is the passages
that best match, each with its file and lines. It is for when the model does
not know what a thing is called; regex search and ask_lsp are still what it
uses when it does.

• Off by default, on per folder: Settings > Library > Index the code of
  this folder. Building the index sends every source file of the folder to the
  embedding model set in the API configuration.
• Files .gitignore leaves out are left out, and so are binaries, lockfiles,
  generated files and anything over 256 KB.
• The index is brought up to date when a task starts and with Update now;
  only changed files are read and embedded again.
• In a folder that is not indexed the tool is unchanged.
• Not yet offered to agents started by the lead, and not in the CLI.

v4.100.244

Check for updates, by hand and while the window stays open

The About tab in Settings has a Check for updates button. It asks GitHub
for the latest release at once and answers with a notification: a newer version
with Install, or that you are on the latest.

The automatic check also runs while a window stays open. It used to run once,
twenty seconds after the extension started, so a window left open for days
never heard of a release published after it started. It now looks again every
hour and asks GitHub at most once a day, as before.

An error count on each conversation

The history list shows how many errors a conversation had, as a red label on
its row: failed tool calls, failed requests and stopped runs. It makes the run
that went wrong findable without opening each one. The count starts with this
version; earlier conversations show no label.

The report collector (tools/Collect-CerebrilineReport.ps1, version 1.2.0)
shows the same count as an errors column in its session picker and writes it
to environment.json. A session recorded before the count existed shows -.

An unfinished shell command is reported, not waited on

When a command has an unclosed quote or bracket, PowerShell does not run it:
it stops at its continuation prompt (>>) and waits for the rest. The tool
used to wait with it for five minutes and then say the command was still
running, and the terminal stayed occupied for the rest of the session.

Such a command is now reported after a few seconds as not run, with the reason
and a note on PowerShell quoting, and the pending input is cancelled so the
terminal stays usable. Reading the terminal's contents as a fallback is limited
to five seconds, and the log records how a command ended whenever the shell did
not report its end.

v4.100.243

Scrolling a page is no longer stopped as a loop

Reading a long page in the browser is the same call sent again and again:
scroll_down, with nothing else in it. The loop guard counted those as
identical calls, on the premise that the same arguments give the same result,
and stopped the run at the seventh. For a scroll the premise is false: each
one shows the next part of the page.

scroll_down and scroll_up are no longer counted by that rule. The answer is
still compared, so a scroll that keeps showing the same screen, at the end of
the page, is still warned about.

A refused spawn_agent call says why

spawn_agent is not offered when the session's endpoint serves one request at
a time, which is what an empty "parallel sessions" field means on most
providers. A model that called it anyway was told only that the tool was
unavailable, with a list of every other tool, and usually sent the same call
again.

The refusal now gives the reason, names the configured agents that can be used
instead, says that calling it again will be refused the same way, and says the
user can change it by raising the profile's parallel sessions.