v4.100.241

Built-in skills

Cerebriline now ships with skills of its own. They appear in the Skills tab
under Built-in Skills with nothing to install, in the extension, the CLI and
the SDK alike.

Sixteen to start with: the fifteen below, and the librarian, described under
The Library.

For deploying and running:

• mandatory-qa-prompt-and-issue-resolution (Chris) asks, after a change to
  code or configuration, whether to run QA on it, runs a QA plan fitted to the
  change and reports, then asks whether to fix what it found.
• docker-compose-deploy (Chris) deploys the open project to local Docker
  from its compose file or its Dockerfile, and verifies the deployment. Its
  commands now work in bash as well as PowerShell, and its reachability check
  waits for the app to come up.
• build-project builds the open project the way the repo defines, and its
  Docker image when it has one.
• run-project starts the open project, waits until it answers and opens it
  in the browser.

The last three refer to each other and are meant to be turned on together.

For test-driven development:

• tdd-wizard starts a project or a feature test-first. It learns about the
  project, takes your specification or writes one with you through questions
  about goals and scope, develops the test cases with you, then generates,
  validates and writes the tests. At the end it offers to carry on with the
  next phases or to leave them to you.
• tdd-gen writes the implementation that makes existing tests pass, without
  changing the tests.
• tdd-test runs the project's tests the way the repo defines and reports
  the failures.
• tdd-coverage measures coverage and proposes a test for each gap.

The TDD set follows the workflow in Duke Harewood's article
"Test-Driven Development with Claude Code: Practical Guide"; each skill credits it.

For spec-driven development, after Get Shit Done (GSD 2):

• sdd-wizard is the way in. It reads the project's planning files, says
  where the work stands and runs the next step, one at a time or, when asked,
  on its own until the milestone is done or something needs you.
• sdd-discuss turns an idea into an agreed specification: it reflects your
  vision back, reads the code, asks in short rounds, and writes the brief and
  the numbered requirements for you to approve.
• sdd-plan cuts a milestone into slices that can each be demonstrated,
  riskiest first, and a slice into small tasks that each name their files,
  their steps and the command that proves them.
• sdd-execute does one task, verifies it and writes down the evidence.
• sdd-verify closes a slice, writes and runs its acceptance script,
  reassesses the rest of the roadmap, and at the end audits the milestone
  against what was promised.
• sdd-quick is for a small change that needs none of that, and
  sdd-status reports where things stand.

The plan is kept in a database in your project (.sdd/sdd.db), and turning on
any of the seven gives the model one tool, sdd, to work it. The model asks
what the next step is and is given the one that is due, with the task's steps,
its files and the command that proves it. A step out of turn is refused with
the reason: no roadmap before you approved the requirements, no task marked
done without the output of its verification, no slice closed on a failed
acceptance check. A small model no longer has to keep its place by reading and
ticking files. The markdown beside the database is written from it after every
change, for you to read and review; the work continues in a new chat. With Subagents on, each task runs in an agent with a
fresh context and its changes are checked before they are adopted; with
Teammates on as well, independent slices can run side by side. In a git
repository a slice can be built in its own worktree and merged when it is
verified, so your working copy is untouched until then.

In the Skills tab, Built-in Skills and Global Skills now open one at a
time: opening one closes the other, and a closed list says how many skills it
holds and how many are on.

All ship turned off: turn on the ones you want. A built-in skill can be
switched on and off and opened to read, but not edited or deleted, since an
update replaces it. The switch is kept in your settings and survives updates.
To change what one does, create your own skill with the same name; yours
replaces it.

The Library

A place for what you want the model to be able to look things up in: ebooks,
manuals, papers, notes and web pages. Turn it on under Settings > Library,
a panel of its own beside Features and Terminal.

It is arranged like a library: sections, shelves in each section, and
books on the shelves. A book keeps the original files it was made from
(named by their sha256), the text read out of them, their pictures with a
description of each, and a short description of the book itself. The Library
is in Cerebriline's data folder and is the same in every workspace.

The model always has search_library, which returns the passages that best
answer a question, each with the book and chapter it is from, and
list_library, which shows the shelves and what a book was made from.

The librarian. Tick Let the model act as librarian and ask: "act as a
librarian, catalogue these ebooks and add them to the Library". The model
reads each file, works out its title, authors and edition, writes a
description, and puts it on the shelf it belongs on, making a shelf or section
only when none fits. It is a built-in skill with its own tools: checking,
adding, reorganising, exporting and importing.

Duplicates and other editions. Before a file is added it is compared with
what is there: the same file, the same ISBN, the same title, and how much of
the text is the same. That last one needs no model and recognises the same
book as a PDF and as an EPUB. A duplicate is skipped. For another edition or
translation the librarian adds nothing and asks you whether to keep both or
replace the old one.

Pictures. A book's pictures are taken out and kept with it, and described
by a vision model so a figure can be found by what it shows. The Library panel
picks a saved profile for that (a cheap, fast model that reads images); with
none picked it is the Vision tab's model, and with none there the model of
the conversation when it reads images.

The trash. Nothing the model deletes is gone: books, the books of a deleted
shelf or section, and sources taken out of a book stay in a trash for 30 days,
where the model or you can put them back. Only you can empty it, in Settings.

Books from the web. "Create a book on GitHub recipes for Godot
development, call it Godot-Github": the librarian searches, chooses the
links, reads the pages and makes the book. The book keeps the query and the
links, so "is there anything new for Godot-Github?" reads them again and
lists what is new or changed, and the same book is not made twice. This uses a
Firecrawl endpoint, set under
Settings > Features > Web scraping for the librarian, and needs Allow
web scraping ticked in the API configuration as well. Without both, the web
tools are never offered.

The shelves in Settings. The Library panel shows sections, shelves and
books, and does by hand everything the librarian does: make, rename, move,
delete, restore, and look at what a book was made from.

Export and import. The whole Library, a section, a shelf or one book, as
one file holding the books' own files, text, pictures and descriptions.
Vectors are not in it; they are made again where it is imported.

It works on keyword search alone, with nothing to download and no model to
configure.

The Library and Memory panels each show a Search engine box: what is
stored, whether LanceDB is downloaded and working and which version, the
embedding model in use, and how much of what is stored has vectors. It has a
Download LanceDB button; enabling the Library or Memory alone downloads
nothing.

To search by meaning as well, tick Use an embedding model in the API
configuration and name the model on the new Embedding tab: on the session's
own provider, or on any endpoint that serves the OpenAI embeddings API (Ollama,
opencoti, llama.cpp, LM Studio, hosted services). The same tab takes an
optional reranking model, which reads the best passages against the
question and puts them in order.

The embedding model is picked from the server's own list: an Ollama or xOllama
shows only its embedding models. Check the embedding model and Check the
reranking model each make one real request and show what came back, so you
know whether the session's provider embeds before relying on it.

Changing the embedding model starts a new set of vectors and keeps the old one,
so search keeps working and going back costs nothing. The panels show how many
documents or notes still have no vectors for the model now set, with Embed
now to fill them and a list of the sets on disk, each with its size and a
delete.

The first time the box is ticked, Cerebriline downloads LanceDB, where the
vectors are kept: 200 to 390 MB depending on the platform, once, with every
file checked against a known checksum. It is not available on Intel Macs, where
the Library stays on keywords.

The panel holds how documents are split (passage size, overlap, at headings
first) and how they are searched (hybrid search, the balance between meaning
and keywords, how many passages are kept, the relevance threshold). The
defaults are a starting point and will be tuned.

A damaged EPUB is reported as damaged at once. A file cut short while it was
copied, downloaded or unpacked used to hold extract_document for its full
ten minutes, and the librarian for longer, with nothing shown.

Pictures can be described after a book is added. A book added with no vision
model set kept its pictures with only their captions, and the one way to get
descriptions was to add the whole book again. The librarian can now describe
the pictures of a book that is already in the Library: they are shown to the
vision model from the book's folder, and the descriptions go beside the
pictures in its text, after the caption. It works a batch at a time and goes
on where it stopped.

An import shows what it is doing. While the librarian checks or adds files,
its row lists every file: waiting, where it is (page 312 of 769, recognizing text, 705 pictures), done, or failed with the reason, and NOT MOVING with
the time when a file has stopped. Cancel import on that row ends the call
as a failure, and the model gets the full report and asks you how to go on.

Making a book from web pages, and checking or updating one, does the same
with a line per link: pages read so far while a site is crawled, and each
page under it that could not be read.

Every check and every add ends with a report for the model: each file, and
under it every page or picture that was left out, with the reason. Nothing is
left out silently.

A book added to the Library is read whole: every scanned page goes through
text recognition, where it used to stop after forty.

Checking books against the Library reads their text only, since a check
compares text. It used to take every picture out as well and keep it: an 88 MB
scanned book took over six minutes and more than a gigabyte.

In the CLI: --library to search, --librarian to run it.

Not yet: adding files from the panel itself (it imports an exported file), and
checking web books for news on a schedule.

Memory

Notes the model keeps from one task to the next, so what it worked out once is
not worked out again: a decision and its reason, how the project is built and
tested, a convention, something you said you prefer. Turn it on under
Settings > Memory, a panel of its own beside Library.

The model gets three tools: remember keeps a note, recall returns the notes
that best match a question, and forget removes one that no longer holds.
Notes are kept in Cerebriline's data folder, not in your repository.

There can be any number of memories: Main, which every workspace starts on,
and whichever others you make. The panel lists them all, whichever workspace is
open, and for the open workspace you tick the memories its tasks may recall
from (any number) and pick the one new notes are stored in. The model
cannot reach a memory you did not tick. A workspace with no memory of its own
is offered one, named after its folder, and a new memory is ticked for recall
where it was made. A memory can be renamed, deleted, exported to a file and
imported again, here or on another machine.

Notes are found by keyword, and by meaning as well once an embedding model is
named on the Embedding tab, which Memory shares with the Library.

Memory is also searched for you: with every message you send, the notes that
are about it are put beside the message for the model, and a line in the chat
says which. A note is attached only when something says it is about the
message (two meaningful words in common, closeness by meaning with an
embedding model, or the reranker's score), and a task is given each note once.

Expand the question first (HyDE) finds the notes that share a message's
meaning and none of its words. A second model writes the short note that would
answer your message, grounded on the notes already found, and Memory is
searched again with it. Pick that model in the Memory panel from the profiles
saved in the API configuration: a cheap, fast cloud model is the usual choice.
The approach is HyDE (Gao et al., 2022), in the order of work
claude-hooks uses.

In the CLI, --memory offers the same tools and the automatic recall.

Fixes

The context bar shows the window the model will run with. On Ollama and
xOllama it showed the catalog's number (128k for a model the catalog does not
know) on a new session and on a reopened one, until the first request replaced
it with the configured one. Sessions were never run at the wrong size: only the
bar was.

The extension can be reinstalled while VS Code is running, on Windows. Since
the built-in skills arrived, installing the version that was already running
failed with "Please restart VS Code before reinstalling": the skills folder
inside the extension was being watched for changes, and Windows will not
replace a folder that has anything inside it held open. Updating to a newer
version was not affected, since that goes into a folder of its own.

The Library's and Memory's databases are closed when the extension shuts
down. They were left open until the process ended. They are kept in the data
folder, not in the extension's, and are written so that a crash or a forced
update loses at most the change in progress.

A model named on the Vision tab, or in a saved profile, is sent to the server
that tab or profile names. With the session on one xOllama server and the
Vision tab on another, the picture describer asked the session's server for
the vision model and was told it was not found; every picture came back
without a description.

Only models that read images are offered for describing pictures. On the
Vision tab, the Ollama and xOllama model list leaves out the models the server
reports as having no vision capability, and says how many it left out. In the
Library panel, the list of profiles leaves out the ones whose model reports
none. A model already chosen that cannot read images is kept in view with a
warning. The server is the one asked (Ollama, xOllama, llama.cpp and
opencoti report it); a model nothing is known about stays on the list.

The model of the conversation describes a book's pictures when it reads
images and no other model is set for it. A second model was asked for even
when the first could do the job: a session on a vision-capable model, with no
profile picked in the Library panel and nothing on the Vision tab, kept every
picture without a description and said no vision model was set.