Repository navigation
Releases
vi-mcp 0.67.0
What is new
-
A package for Arch Linux and CachyOS (
deploy/arch/build.sh→dist/vi-mcp-<version>-1-any.pkg.tar.zst). Install with
sudo pacman -U.- Dependencies from the official repositories: python, python-numpy, python-scikit-learn, python-cryptography, python-yaml.
- Optional: clingo (only in the AUR), python-pip (for
vi-mcp logic install), python-psycopg, libtorrent-rasterbar. - Arch conventions:
- the code goes to
/usr/lib/vi-mcp, notlibexec, so a Python update needs no rebuild; - users come from
sysusers.d; - the service is not enabled by the package; the install prints how to start it.
- the code goes to
- Measured in a fresh
archlinux:base-develcontainer (Python 3.14.9, OpenSSL 4.1.0): install, users, directories with the same
owners and modes as Debian, configuration, an instance, and the server answering/healthwith "ok vi-mcp"; removal keeps data
and configuration. - Found while testing: pacman runs a package's
post_installbefore the sysusers hook at the end of the transaction, so the
install creates its users itself first. A partial upgrade (pacman -Sywithout-u) breaks python-cryptography (libssl.so.4);
the README therefore sayspacman -Syu. - Not yet:
deploy/release.shand the signed package repository do not build or publish it. CachyOS itself was not tested — it is
Arch-based and uses pacman and the same repositories.
-
vi_recall collects by itself when a question wants everything about one entity. The user said (16.11.2026): "Bei einer Recherche können
auch mehr als vier Werte von einem Objekt relevant sein. Z.B. welche Ausstattung hat ein Host." On the production copy, 20 % of all
objects are parts of longer pages (9,196 parts of 3,387 pages, up to 159 parts), and the facts about one host are spread over several
pages; ranked hits return only a fraction of such a set (QUEST 2305.11694, QAMPARI 2205.12665).- When: the question names an entity that exists as a
host:hashtag value and asks to collect ("what equipment", "all",
"overview", …) or is little more than the name. Single-fact questions about the host ("backup failed on X since yesterday") stay
ordinary searches.collect=falseswitches it off, e.g. for an A/B measurement. - What: the hits plus every visible object carrying the entity hashtag. Page parts are joined by
data.sourcein their order and
chunked by the newchunking(structure-aware, heading path in front, ported from IT-AIKB).context_budget(also from IT-AIKB, where
~10k selected tokens answered as well as the full context in 53 s instead of 137 s) chooses chunks under a budget of 1,500–8,000
tokens, with chunks naming the entity first. The output is in page order with […] for gaps, plus one line on why the mode switched
on and what was left out with its reason. - Measured on a production copy (the hardware question about one production host): the host's own knowledge page first (CPU model, cores, RAM,
OS, addresses, purpose, services), 13 of 17 pages in 7,971 tokens; 10.9 s instead of 2.8 s, most of it the reranker over ~170 chunks.
The router was right on 4 of 4 probe questions. A completeness measurement with a multi-target question set is still open (below). - Fixed on the way, also present in the IT-AIKB original: a table that is only an oversized header row lost all its text when
split. On the copy: 21,580 contents → 93,515 chunks, none losing text, none over the limit. - VIL domain lexicon (
lexicon.py). The user asked that VIL take in more words, since it is meant to be a technical language. The
entity words of the memory's hashtags are linked in free text and named in the search note (entities: …), never reordering hits:
hosts, sites, monitored services, applications, projects, areas, networks, error keys.- Production copy: 967 hosts, 74 sites, 356 services, 75 apps, 49 areas, 2 networks, 60 error keys; 58 file paths tagged as host
and 8 error keys shorter than an everyday word are left out and counted. Built in 0.11 s, linked in 0–36 ms per question. - A name counts only if the asking instance can see an object carrying it, so the note never reveals a private or internal name.
- The collect mode triggers for hosts, sites, services, apps and projects. Its word lists are English: VIL is the memory's
standard language, and an agent asks it in English.
- Production copy: 967 hosts, 74 sites, 356 services, 75 apps, 49 areas, 2 networks, 60 error keys; 58 file paths tagged as host
- List questions are answered from the hashtags. "Which hosts are at site X" lists the hosts, apps and services that occur with
the entity, each with its number of objects. A broad entity (more than 300 objects; a site carries about 1,400, mostly monitoring
findings) contributes only its 100 objects that match the question, filled up by recency. - Follow-up for agentic search. An agent searches on with follow-up questions, so the answer names its next steps: the pages not
shown (ranked by their best chunk),vi_objectfor a page in full, the entity filter for all its objects, and a narrower question. - Evidence:
tests/test_chunking.py,tests/test_context_budget.py,tests/test_collect.py(11 cases incl. visibility of names).
- When: the question names an entity that exists as a
-
Fine-tuning paper: eighteen runs that teach a 0.6B model to work by the seed (docs/FINETUNING_PAPER.md).
The paper reports each run's design, the results scored by the solver, the findings with sources (33 references, each checked
against the paper text or its arXiv entry), the status against the targets, the measurement errors corrected on the way, and the
open points.- Measured: answering with facts first raised exact verdicts from 18/40 to 29/40 (p = 0.013), and an enumerated count trace raised
them to 39/40 and 154/160. - The seed as a training target made recitation exact (46/46).
- With held-out phrasings, only 3/40 worlds are judged right: reading is the open problem.
- PAPER.md section 6.5 links to it.
- Measured: answering with facts first raised exact verdicts from 18/40 to 29/40 (p = 0.013), and an enumerated count trace raised
-
kollektiv 1.3.0: origins count, not votes — the collective's answer to fake news. The user asked on 15.11.2026: "Nur weil 1000
Menschen etwas glauben, muss es nicht wahr sein … Eine KI arbeitet nur theoretisch und kann Fakten nicht überprüfen." The seed now
says how well a statement is supported, never that it is true; the spoken verdict reads "supported/opposed", no longer
"true/false". Five new principles, each a block of the seed:- P8, origins, not votes.
derives_from(O, R): a copy, re-post or summary adds no origin, and a chain of copies leads back to
one root.machine_made(O): text a model generated is never an origin; it counts only through the source it derives from. A
citation circle has no root and counts for nothing. Background: Condorcet's jury theorem needs independent judgments;
informational cascades (Bikhchandani, Hirshleifer, Welch 1992); model collapse (Shumailov et al., Nature 2024). - P9, weight of evidence.
evidence_kind(R, measured|signed|document|hearsay): hearsay alone can neither accept nor reject. - P10, bridging.
camp(R, C): when the camps are known, acceptance needs agreement across camps (Community Notes, Wojcik et al.
2022). - P11, testability. A statement that no observation could refute gets its own acceptance value
untestable, neither accepted nor
rejected. An accepted statement without a named refuting observation (testable_by) obliges the member to name one (Popper). - P12, extraordinary claims need more.
extraordinary(S)needs three independent origins or a measurement (Hume). - P13, a withdrawal is not a refutation.
withdrawn(S): when the author withdraws a statement and no one else has given
evidence, the statement gets the acceptance valuewithdrawn, neverrejected. Withdrawing removes the claim; it does not prove
the opposite (Codex, round 1). The shadow comparison found this: 16 of 17 objects refuted on production were refuted only by
their own author. The memory now names the two apart as well (see "What has changed"). - P10 names a partly known camp
camp_unknown, notone_camp, so missing camp data is never reported as one-sidedness.
Every holding back names its reason:
grund(S, held_back, hearsay_only|one_camp|extraordinary). Inputs that are absent change
nothing, so every world of 1.2.0 keeps its verdict.
Evidence:vi-mcp philosophy check kollektiv: 35 of 35 worlds (19 new, with counterfactuals), every value and acceptance produced;- 1,500 random worlds all solve, with at most one value and one acceptance per statement;
tests/test_philosophy.py::test_kollektiv_counts_origins_not_votes_and_names_why_it_holds_back. Package hash1f205f4c…(1.2.0
wasfdfd38e8…).
- P8, origins, not votes.
-
A provenance adapter fills kollektiv 1.3.0's inputs from the memory. Shadow mode only: it changes nothing.
vi_mcp/philosophy_provenance.pyturns what is stored about a knowledge object into seed facts. The mapping is documented
input by input in the module.- author; one line per stored confirmation or refutation entry. The origin is the cited source (one source is ONE origin however
many confirm it), a named object, or the confirmer's own check. - closed only when the object's counters equal the entries kept. confirm/refute keep 100 entries but count every call; dropped
entries are neither invented nor ignored. - camp = the model family, for every origin that has one. The seed judges a partly known camp (P10
camp_unknown); one place
decides. - withdrawn(S) when the author's own refutation entry exists (P13): a withdrawal removes the claim, it does not prove the opposite.
Shadow reads memory's new modezurueckgezogenas the classwithdrawn; an unmigratedwiderlegtis still split into
refuted_by_authorandrefuted. - derives_from along objects whose source names another object; machine_made for the automatic server instance witho...
- author; one line per stored confirmation or refutation entry. The origin is the cited source (one source is ONE origin however
vi-mcp 0.66.1
What was fixed
- Two example values in the code resembled real credentials. A comment in
vi_mcp/anonymize.pyand a test in
tests/test_anonym.pyused them as examples of a password shape. They had been public since 0.13.0 (08.11.2026).- Both are replaced by invented values of the same shape, and the tests check the same detection.
- The whole git history was rewritten (git filter-repo; every commit hash changed), and every tag was moved to the rewritten
commit. - The packages of every earlier release were removed from GitHub Releases and from the apt/dnf repository, because they were built
from the old tree. This release is the first clean one. - Code is otherwise identical to 0.66.0.
Evidence: a fresh clone of the repository, every reachable blob searched, 0 hits; 217 old release assets deleted, 0 left.
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.
vi-mcp 0.66.0
What was measured and changed in the search
- Hit@4 is measured. The answers show 4 results, and the nightly figures now include hit4.
- Baseline on a production copy, 150 questions × 2 styles = 300 queries:
- hybrid: Hit@1 0.80, Hit@4 0.933 (natural questions 0.90, keywords 0.967), MRR 0.864, median 2.5 s;
- full text: Hit@4 0.56.
- Time per hybrid query: the reranker 1,868 ms of 2,366 ms; embedding 65 ms; candidates 87 ms.
- Scale test with 500,310 knowledge objects: the copy plus distractors copied from source pages without evaluation targets,
vectors with noise. This is a proxy for future data, not a picture of it.- Hit@4 holds: 0.930.
- The median time grew from 2.4 s to 6.4 s, mostly from full text: two calls per query, 1.74 s each.
- Fixes on the branch. None of them changes a ranking: 300 of 300 ranks are identical, and a test checks it.
- The vector matrix is kept between queries. It is invalidated by writes and by the table's signature.
- Full text matches first, and visibility is filtered on its hits only. The exact query runs when invisible rows fill the pool.
Measured on the 500k copy: 1,826 ms → 80 + 10 ms. - A hybrid query no longer runs a second, unused full-text search.
- The vector count comes from the cache.
Evidence:tests/test_search_scale.py.
- Tested and not adopted: the object's content in its single vector. An A/B test on a 5,000-object universe from the
production copy used the same 300 queries and the same code; only the vectors differed.- A, key statement only (as today): Hit@1 0.88, Hit@4 0.963, MRR 0.923.
- B, key statement plus the first 3,600 characters of content in one vector: Hit@1 0.77, Hit@4 0.843, MRR 0.807.
Natural questions fell from 0.94 to 0.747. - 45 queries ranked worse and 13 better. One long vector per object dilutes the key statement.
- Next to test instead: content in chunks, each with its heading path, as it-aikb indexes it.
Evidence:measure.pyon two copies (vi_subA.dbandvi_subB.db), 15.11.2026.
What is new
-
The kit scores a trained model's prose by the round trip:
phil_roundtrip.py. It is a separate script, not aphil_score
option:phil_scorestays offline, fast and deterministic, while the round trip needs an endpoint and minutes.- For each explain (whole and per block) and recite answer of the tuned model and of the base model, an OpenAI-compatible
back-translator (--judge-url/--judge-model, preferably another model family) writes clingo-object, with up to 4 repair rounds.
It usesclingo_object/philosophy_explain.py, which is bundled with the kit. - Reported per answer: agreement of the rebuilt seed with the seed's answers AND duties on the package worlds plus
--random N
worlds, the repair rounds, and whether it ran at all (a seed that does not run agrees with nothing and gets a named reason). - A control stands beside every number:
--control FILE(the frozen historical prosetests/fixtures/kollektiv_principles_1.1.0.json
or plain text), else the items'gold_textof a 1.1.0 kit. It is back-translated by the same model. - A blind reading aid
eval/philosophy_blind.mdpairs each explain answer with the seed's rules in a random order, with the key in
eval/philosophy_blind_key.json. - Answers and control are resumable (
eval/philosophy_roundtrip.jsonl); the summary iseval/philosophy_roundtrip.json. - The back-translator can be a command instead of an endpoint:
--judge-cmd "codex exec -s read-only --skip-git-repo-check"
(decision 15.11.2026: Codex as the back-translator, because its GPT family is independent of the trained Qwen, and Claude wrote the
seed). The same option exists forvi-mcp philosophy explain.- Every call runs in a fresh empty directory with stdin closed. The prompt is the flattened messages, last on the command line,
opening with "Do not run any commands and do not read any files". The reply is read from the-ofile, code fences stripped. - A template with
{prompt}{out}{dir}{model}serves any other command-line model. back_translatorrecords argv[0] plus the model.- A failing command stops the run with its exit code: a broken judge is never scored as the model's failure.
- The MCP tool never runs a command a caller names; it is offered on the command line only.
- Tests use a fake command, never the real codex.
- Every call runs in a fresh empty directory with stdin closed. The prompt is the flattened messages, last on the command line,
- It reads this kit's layout and run 6's (
eval/eval.jsonl,eval/answers.jsonl, nophilosophy/:--package kollektiv; the
1.1.0 → 1.2.0 hash difference is recorded ashash_mismatch; the translated seed is identical). - Tests (
tests/test_finetune.py, a fake OpenAI server, no real endpoint): faithful prose agrees on every world, unusable prose is
reported as not run after 4 rounds, the control, the blind file without model names, resumption without new calls, and the run-6
layout.
- For each explain (whole and per block) and recite answer of the tuned model and of the base model, an OpenAI-compatible
-
One kit for the whole seed path: language → seed → GRPO, with its evaluation. The user decided the order on 15.11.2026:
"first teach the AI clingo, then the seed".vi-mcp finetune kit DIR --base M --philosophy NAMEnow writes everything, without
hand-made data:--stage language: clingo-object in both directions, on rule sets that share no predicate with the package (3,000 rows).--stage philosophy: the seed's judge, formalize and pressure examples (1,700 rows). Half of the judge and pressure prompts show
the seed's rules first. The test split uses held-out phrasings and pressure, and none of its worlds occurs in training.--stage grpo(the seed as reward) now continuesout/philosophyby default.languageandphilosophyare new SFT stages, notlogic: the kit's logic files are vi_logic episodes from the VI, and the
seed path needs its own adapters and lineage.- No principle prose and no seed comment line enters any training row (test). Only the clingo seed is stored, and prose is a
translation of it. eval/philosophy.jsonl: judge on training phrasings and on held-out phrasings, held-out pressure, held-out formalize, the
package worlds, explain the seed (whole and per block), recite, and the held-out language. A judge item whose world occurs in
training is dropped and counted.phil_answers.pywrites base and tuned answers, resumable, with a named generation budget.phil_score.pyscores them against
the seed's verdict: world_exact, every answer value, duties_exact, invented certainty, facts_exact, budget cuts.- A package without training data (generator, wording, pressure) is refused, with the missing fields named.
-
Verdicts are 3–4× faster, with identical results. The seed is translated once per process, and each world is solved once
(philosophy.solve); before, every verdict translated and solved twice. Measured 15.11.2026 on the workstation, with gold
fingerprints unchanged:messung: pool of 200 prompts 15.9 → 4.3 s, re-solve 10.9 → 3.1 ms per prompt;kollektiv: 3.3 → 1.0 s and 6.8 → 2.0 ms.
The GRPO seed check before training uses the same single solve.
Evidence:
tests/test_finetune.py::test_one_kit_holds_the_whole_seed_path_without_any_principle_prose: the kit's ownphil_score.py
on simulated answers gives the seed's words every world exact and nonsense none.tests/test_philosophy.py::test_one_solve_with_the_translated_seed_gives_exactly_what_the_full_check_gives.tests/test_training_runtime_neural.py -k seed_path: real SFT trainers, 0 optimizer steps.
-
Philosophy packages store only the clingo seed; prose is a translation, checked by its round trip. User decision
(15.11.2026, confirmed twice): "Wir hatten gesagt, dass wir nur clingo speichern und diese dann in Prosa übersetzt werden …
Deswegen trainierst du die VI auf clingo-object." Scope: philosophy packages only; normal knowledge storage is unchanged.- Format
philosophy-v2(clingo_object/philosophy.py): the seed is the single stored source.principlesis no longer a field.
A package that still stores it, or saysphilosophy-v1, is refused with the reason. - The seed's rules stand in blocks marked by an id comment (
# P1) and nothing else. A title is not allowed: any word next to the
rules is meaning outside them, and a translator would copy it instead of reading the rules. checknow requires every rule to lie in a marked block, with no other comment, no rule before the first marker and no marker
twice. This replaces "every derived predicate is named by a principle"; every other check stays.- The priority profile
maximal-candidates-v1lost its prose too. Its rules are now pinned as the translated program; that hash
(b2e98f6f…) is the same before and after. - Packages: kollektiv 1.2.0, messung 1.1.0 and code 1.1.0 keep their seeds, vocabularies, worlds and training specs.
- The translated ASP of all three seeds is byte-identical before and after (sha256 of
notation.translate(seed)), so every verdict
is unchanged. - The package hashes change: kollektiv
8d213463…→fdfd38e8…, messung8ed31063…→b1277f8e…, code6f795887…→
09d6da84…. Once the new version is installed, a binding to the old hash showsstaleuntil it is bound again; the old
installed object keeps its v1 manifest and still matches its hash. - Training run 6 uses frozen data and is unaffected.
- kollektiv's old prose is frozen in
tests/fixtures/kollektiv_principles_1.1.0.jsonas the historical prose of 1.1.0. It is the
gold reference of a running evaluation and is never loaded as a source.
- The translated ASP of all three seeds is byte-identical before and after (sha256 of
- New
vi-mcp philosophy explain NAME --url U --model M --judge-url U2 --judge-model M2(toolvi_philosophyactionexplain,
clingo_object/philosophy_explain.py):- A translator writes English prose per block and for the whole seed.
- An indepen...
- Format
vi-mcp 0.65.0
What was fixed
-
The training export no longer teaches a model to echo documents. Knowledge without a real (doc2query) question was exported
as "question = the object's own text, answer = the object". In the first production run that was 96 % of the SFT rows (20,066
of 20,957). The blind test of the tuned Qwen3-0.6B (100 questions, judged pointwise against references, key opened afterwards)
showed:- no gain on the 60 real questions (base 0, tuned 0 correct);
- a gain only on rows of the same echo form;
- loops in 55 % of the tuned answers (base 1 %);
- invented page paths instead of "I don't know".
Such knowledge now goes to
documents.jsonland is never trained as its own question;qa.jsonlholds real questions only.
Hint ratings (KTO/DPO) still use every rated object.
Evidence:tests/test_dataset.py::test_export_writes_qa_kto_dpo_with_datasheet_and_holds_out_the_evaluation.
What is new
-
Knowledge becomes training-ready after it is learned, without a later synthesis step. While it sleeps (step 8i,
classify.pairs_per_sleep, default 5) or on
vi-mcp classify --pairs [--limit N] [--workers W] [--stale], the server writes onto each shared or internal knowledge object
data.qa. It holds grounded question-answer pairs, one never-trained probe question, rejections per reason, the hash of the text
the pairs came from, and the generator version.--dry-runcounts the objects per state. Before this, every run had to
synthesize pairs for all documents on the trainer: about 25 h for 23,585 documents with a 35B model.- The export trains the pairs (
question_source: synthetic) and writes the probes toprobe.jsonl. - Pairs of knowledge that changed since are named stale and left out (
manifest.quality.stored_pairs). - A failed generation is retried after a day.
- Private knowledge is never sent.
- Server and kit share one definition of a good pair (
vi_mcp/qa_pairs.py, copied into the kit).
Evidence:tests/test_finetune.py::test_server_stores_training_pairs_with_a_probe_and_the_export_uses_them.
- The export trains the pairs (
-
The knowledge probe is part of the kit.
split/probe.jsonlholds the probes of objects whose rows are on the train side.
probe.py answer|judge|summarizedoes what run 3 did by hand:- base and base+adapter answer from the same weights, written per question, with the A/B key in a separate file;
- an OpenAI-compatible judge, or a person, grades each answer correct, partial or wrong;
summarizeunblinds and runs the sign-flip test, strict and lenient, intoprobe/probe_eval.json;- an answer cut at the generation budget counts at most partial;
- a judge that also wrote the probes is flagged (self-preference).
synth_qa.pywrites one probe per document as well.vi-mcp finetune recordrecords the probe result; it is not the adoption gate.
Evidence:tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows. -
docs/FINETUNING.md: fine-tuning from zero. It covers the data fields, turning on pair generation, the
kit, the container, training with the recipe that worked, the probe, recording, and the limits. It ends with ranked next
improvements from research of 15.11.2026: retrieval plus a fine-tuned reader (RAFT), abstention training, more exposures per
fact, QA before documents, short canonical answers, rank against forgetting, and cleaner probes. The handbook
(vi_finetune guide, version 2026-11-15) and AGENTS.md follow the same steps. -
synth_qa.pyin the fine-tuning kit turnsdocuments.jsonlinto question-answer pairs with an instruction model over an
OpenAI-compatible API (thinking off, no token cap). It keeps only grounded pairs: at least 80 % of the answer's words occur in the
document, the question names its subject instead of "the document", and nothing is copied from the document's beginning.
Rejections are counted per reason; the script is resumable.vi-mcp finetune split DIRputs the pairs into the shared split, and
run.jsonrecords the question sources per side. Diverse QA pairs inject knowledge better than raw text (arXiv 2409.07431,
2412.14964). Measured: 12 real documents → 14 pairs in 38 s, 21 candidates rejected.
Evidence:tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows. -
More varied pairs per fact, and a held-out guard.
synth_qa.py --pairs Nasks for up to N pairs per document;--more FILE
asks chosen documents again (duplicates are rejected);--hold-out FILErejects a pair whose question is too close (word Jaccard
≥ 0.5) to a held-out evaluation question of that document. Knowledge recall rises with the number of paraphrases per fact
(arXiv 2312.05934, 2411.00686).train.py --lora-rank Rsets the adapter rank (alpha 2R; default 16 as before).
Evidence:tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows.
What was reviewed
-
Codex reviewed 0.65.0 before release. It answered through the VI (
frage:2b8276601a6c8b429ee5e54c), read-only, with
reproductions; everything it reproduced is fixed:- A pair result is written onto the CURRENT object, and only if its text is unchanged and it is still shared, internal and live.
Before, the copy loaded before the minutes-long model call was saved whole, which could undo a refutation or a switch to private. - The source line is scrubbed like the answer. A credential the scrubber removed came back through the raw source of pairs,
probes and documents. - No training question may come close to its object's probe (word Jaccard ≥ 0.5), whatever made it: doc2query, stored pairs,
synth_qa.py or agentic rows. This is checked in the export and in the split. - probe.py summarize accepts only answers of today's probe file and adapter, every probe judged exactly once. Before, six old
judgments with no current probe gave decision = true under the current hash. - Changed knowledge is renewed in sleep, from a random sample of 200 per sleep, in any state. Pairs of an older schema are never
exported. The content hash is exact (whitespace is content in code). - qa-v3: every number in an answer must occur in the document (port 22 vs 80 passed before), and the question must name the
document's subject. Long pages are flaggedtruncated.
Evidence:
tests/test_finetune.py::test_codex_review_findings_on_stored_pairs_are_fixedand
::test_grounding_counts_facts_not_function_words. With the real model, qa-v3 kept 23 pairs and 10 probes on 15 of 20 objects. - A pair result is written onto the CURRENT object, and only if its text is unchanged and it is still shared, internal and live.
What was measured
-
Stored pairs with the real model. Qwen3.6-35B-A3B Q4 wrote pairs for 20 of the newest objects of a production copy, through
vi-mcp classify --pairs --workers 4.- The first grounding rule (qa-v1, as in synth_qa.py of runs 2 and 3) kept only 1 of 25 pairs on six short German findings,
because function words such as "die", "wurde" and "auf" counted as ungrounded, and so did "host" and "dns01" inside
host:dns01.…. - qa-v2 counts content words only and matches the parts of compound tokens: 25 pairs and 11 probes on 14 of 20 objects,
51 pairs rejected. - Invented hosts, dates and IPs still fail the check.
Evidence:
tests/test_finetune.py::test_grounding_counts_facts_not_function_words. - The first grounding rule (qa-v1, as in synth_qa.py of runs 2 and 3) kept only 1 of 25 pairs on six short German findings,
-
Second run (corrected data): 3 epochs, LoRA r16, on 894 doc2query plus 2,042 synthesized rows. Loops fell from 55 to 6 of
100 answers. On questions about held-out documents there is no significant gain (p ≈ 0.1). A test set of held-out documents
cannot show knowledge injection, because closed-book fine-tuning only knows what it was trained on. On 60 new questions
about trained documents (a knowledge probe), tuned scored 4 correct and 3 partial vs base 0 and 5 (strict p = 0.0625), so a gain
is visible but not yet significant. The tuned model never says "I don't know" and invents hosts and IPs. -
Third run: the first measured knowledge gain.
- Setup: 500 trained documents with about 5 varied grounded pairs each (
--pairs 8), LoRA r64, 4 epochs (2,558 rows, 53 min). - Result on the same 60-question knowledge probe: 7 correct and 9 partial vs base 0 and 5.
- Statistics: one-sided sign-flip test strict p = 0.008, lenient p = 0.006, graded p = 0.001. The adoption gate is passed.
- The absolute level is still low (12 % correct), and the model does not abstain.
- Evidence: blind judgments with the key opened afterwards. The base grades were identical in both judging rounds.
- Setup: 500 trained documents with about 5 varied grounded pairs each (
What is still missing
- Synthesized pairs are model output checked for word overlap, not verified by a person.
- Probe questions come from the same generator as the training pairs, and a word-Jaccard guard misses rephrased duplicates
(arXiv 2311.04850). A probe set written by people or by another model family is not built yet. - The tuned model does not abstain; abstention training is described in docs/FINETUNING.md but not implemented.
- Grounding is lexical: a reversed negation ("must not" → "can") still passes (reproduced by Codex). An entailment check by a model
is not built. - Long pages get pairs only from their first 6,000 characters (flagged
truncated); pairs per anchored chunk are not built. - Stored QA questions are not yet indexed for search (full text indexes
text, vectorso.text), so they do not help retrieval yet. vi-mcp classify --pairsfor the existing production knowledge has to be started once by an operator. Until then, the kit's
synth_qa.pycovers the rest.
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.
vi-mcp 0.64.1
What is new
-
A fine-tuning runbook in AGENTS.md that an agent can follow end to end: data and kit from a read-only copy, its own GPU
container, memory on unified-memory hosts, precision, the order of commands, measured cost, a blind judgment of task success,
and record and merge. It is written from the first complete run on 14.11.2026 (Qwen3-0.6B on an AMD gfx1151 GPU: held-out
NLL 2.269 → 1.294 after 0.25 epoch in 4.1 h). -
Opening a shown hint counts again when the hook showed it (statistics loop, 14.11.2026). Production showed "opened with
vi_object after being shown 0" over 7 days, with 1503vi_objectcalls. Claude Code's hook shows hints in its own MCP session
(clientclaude-code-hook), and the agent opens them over its own connection.vi_objectcounted an open only within the same
session, so this weak signal of use was structurally 0. The same-session check is gone;intuition.openedalready links by
instance and the recent experiences in which the hint was shown. Another instance opening the object still does not count.
Evidence:tests/test_hint_quality.py::test_opening_a_hint_the_hook_showed_in_another_session_counts(failed before: 0 == 1). -
A kept legacy router champion gets its own measured AUC (statistics loop after the 0.64.0 deploy, 14.11.2026). Production showed
"router AUC None": the active champion was trained by 0.63.2 without a saved report. 0.64.0 rightly no longer shows the
challenger's numbers for it, but showed nothing instead. The incubator's router criterion therefore stayed "not measured" for as
long as the champion was kept, and every challenger since was worse (log loss 0.292 vs 0.279).compare_championnow also computes the champion's AUC on the same holdout actions it had not seen.- A legacy champion keeps that number, with its provenance named.
vi_statsnames the reason when no AUC is known.
Evidence:
tests/test_training_audit.py::test_a_legacy_champion_gets_its_own_measured_auc_not_none(failed before). -
heldout_loss.pyin the fine-tuning kit measures the held-out next-token loss of the base model and of a LoRA adapter on
one stage's test split (--stage sft|agentic|logic), with the same tokens and masks as training. It runs on GPU or CPU and also
with--base-only. Use it to check that the model absorbed the VI's knowledge; it is never the adoption gate, which needs
independent judgments or executable references. Evidence:tests/test_training_runtime_neural.py::test_heldout_loss_of_a_fresh_adapter_equals_the_base.
A fresh adapter with B = 0 gives exactly the base loss, so the comparison is like with like. -
Every training stage with at least 5 groups gets held-out test groups. In the kit built from production on 14.11.2026,
the logic stage had 14 groups and 0 test rows: the joint 15 % group sample over all stages missed it (about 0.85^14 ≈ 10 %
of seeds). Its gain could never be measured. Now each such stage gets its share of test groups. Components stay joint across
stages, so this only adds held-out groups. The split reportsgroupsandtest_groupsper stage. Evidence:
tests/test_training_audit.py::test_every_stage_with_enough_groups_gets_held_out_groups. With the old code, seeds 8 and 10 of
25 gave the logic stage 0 test rows; now all 25 seeds give it test groups. -
train.py --fp32in the fine-tuning kit trains in float32 on a GPU, with no bf16/fp16 mixed precision. Before, a GPU that
reports bf16 support always got bf16. For AMD gfx1151 (Strix Halo), community reports list bf16 problems
(ROCm/TheRock#9198). The report names theprecision. Evidence:
tests/test_training_runtime_neural.py(tokenizer-only with and without--fp32).
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.
vi-mcp 0.64.0
What is new
-
Real trainer preflight without training, in every generated fine-tuning kit: tokenizer-only inspection or actual SFT, agentic,
logic, KTO and DPO trainer construction, collator verification and one no-grad loss. Reports bind dataset/tokenizer/template/config,
dependency versions, complete-target counts, parent readiness, unchanged parameters and zero optimizer steps. A program-first
--from-basepath needs no preceding QA adapter. New adapters retain the resolved base revision for subsequent stages, which
refuse an explicit revision mismatch. The tested dependency versions and public solver sources ship with the kit.
Evidence:tests/test_training_runtime.py,tests/test_training_runtime_neural.py,tests/test_anonym.py;
setup and scope indocs/TRAINING_PREFLIGHT.md. No fine-tuning was started. -
Complete virtual instances,
vil-instance-v1: persisted context, model/decoder identity, MCP device descriptors, explicit
permissions and a bounded, resumable client-side execution loop.vi-mcp machine run|checkpoint|bootconnects that loop to trusted
MCP devices; reservations precede calls, uncertain writes never retry automatically, and restoration cannot recover capabilities
revoked in the current host profile. The controller records VI before/after experience without treating its own completion as a
verified grade. Evidence:tests/test_instance.py, including real MCP/CLI transport and database reopen after an uncertain write. -
One coherent symbolic/neural checkpoint captures context, rules, rights, model identity and kNN shards while the datastore
writer lock spans the symbolic capture. Execution receipts and independent checks survive boot too. Boot verifies the complete
instance/evidence hash, manifest and current model/capabilities and makes an independent
writable clone sharing the frozen core. Transport URLs and credentials stay outside the bundle. Evidence:tests/test_instance_neural.py,
tests/test_knn_lm.py,tests/test_anonym.py. A real configured LLM completed inventory lookup → fact insertion → solver query in
four model calls; its answer matched the independent synthetic fixture. A frozen neural fixture also generated a remembered complete
clingo-object program and ran it on two data states without parameter updates. Contract and reproduction:docs/INSTANCE_RUNTIME.md. -
Independent review handoff in
docs/CLAUDE_REVIEW.md: assessment, production-snapshot findings, implementation commit,
reproducible neural/runtime evidence and the SQLite/PostgreSQL suite results, with the remaining architectural boundaries. -
Real kNN-LM token inference,
vi-mcp knn: frozen Transformers causal models expose hidden context states and next-token logits;
an atomically mutable datastore supplies squared-L2 neighbors whose token probabilities are mixed with the base distribution.
Sources can be replaced or withdrawn, snapshots remain independent, generations pin a revision, and model/weight/tokenizer identity
prevents incompatible keys. An OpenAI-compatible text-program endpoint connects the VI to this backend; execution receipts retain
its datastore and weight hashes. Evidence:tests/test_knn_lm.pychecks the distribution, revision/isolation, corruption refusal,
authentication and a real transformer.scripts/demo_knn_lm.pyran a pinned pretrained model: replacing a source changed its next
token from blue to green at unchanged weight hash; probability rose from about 0.002% to 75%. This is a memorized-context mechanism
test, not a held-out quality gain. Seedocs/KNN_LM.mdfor installation, operating limits and the reproducible experiment. -
VIL and clingo-object have a persistent virtual-machine runtime,
vi_machine/vi-mcp machine, contractvil-machine-v1.
Private machines own mutable objects and rules; explicit instructions define and execute programs, import/refresh visible VI
objects, record proposals and verify complete reference answers. Immutable snapshots, restore, independent forks, state hashes
and optimistic revisions make changes reviewable. The server's model can write programs over one frozen machine world; a
concurrent world change rejects its commit. Model calls do not hold the global database lock. No caller Python, shell or external
write is executed. Evidence:tests/test_machine.pychanges a fact from port 80 to 8080 under the same program, restores after a
database reopen, forks independently, rejects cross-owner/stale access and checks a model repair against an independent fixture.
The contract and boundaries are indocs/VIRTUAL_MACHINE.md. -
Checked machine executions teach program writing. An owner may explicitly publish one reference-checked receipt internally
(teach). Correct programs become tool-use SFT; incorrect programs and independently replayed failed repair attempts become KTO
negatives. Correct and incorrect programs under exactly the same question and world become DPO pairs. Private machines and
snapshots themselves are never selected for export. Evidence:tests/test_machine.py,tests/test_anonym.py. -
Executable held-out program evaluation in the fine-tuning kit (
program_eval.jsonl,program_evaluate.py) compares full
answers against frozen reference worlds, including missing/extra rows, syntax errors, uncertainty and resource limits. Cached
model predictions allow offline replay. The normal evaluator now collects predictions and requires independent correctness
judgments. Adoption requires a report bound to the test file and a positive conservative confidence bound over independent task
groups. Evidence:tests/test_training_audit.py,tests/test_finetune.py. No fine-tuning run or general capability gain is claimed. -
Retrieval drafts for the kNN-LM (
generate(draft=N),vi-mcp knn generate|serve --draft N). This is exact
retrieval-based speculative decoding after REST (arXiv 2311.08252) and NEST (arXiv 2405.19325), without NEST's relaxed
acceptance:- The nearest neighbor's stored continuation is the draft, and one forward pass verifies it.
- A drafted token is kept only if it is the greedy choice, so the text equals plain decoding up to floating-point
differences between sequence shapes. That was measured (72/72), not guaranteed. - The result names the sources of the accepted tokens (
spans).
Measured with
draft=8on Qwen/Qwen3-0.6B (float32, CPU, 8 threads), using paragraphs of this README: 12 stored (prompt =
first 12 words, the rest remembered) and 6 controls not stored, 32 tokens each.Memory weight Stored: tokens per pass Stored: faster Controls: faster Identical to plain decoding 0.5 6.40 5.75× 3.05× 18 / 18 0.25 1.61 1.57× 1.79× 18 / 18 The controls gain too: the memory supplies drafts even for unrelated prompts. Wall times are in the scratch measurement; in
float32, plain decoding is about 3× slower than in bfloat16 (87.8 s vs 29.9 s for the same 12 runs).Evidence:
tests/test_knn_lm.py::test_retrieval_drafts_keep_the_greedy_text_and_save_forward_passes; docs/KNN_LM.md. -
vi_statsnames the reason for a low project success rate (statistics loop, 14.11.2026). Production showed a project
at 40 % success. A read-only query of the production database found that 184 of its 227 failures were one LLM-provider error
(Model … does not support the requested features: tools, max_tokens). They all fell between 15:00 and 16:00 UTC on 13.11.,
and none occurred after the 0.63.3 retry fix. The rate described a past burst, and the line did not say so. Now a project
below 80 % with at least 10 failures gets a line with its most frequent error class, count and time span, marked "one burst
within an hour" when it is one. Evidence:tests/test_statistik.py::test_a_low_project_rate_names_its_dominant_error_class_and_span
(failed before). -
KTO and DPO now train inside the chat template (Claude's review, item 5; Codex agreed over the VI). Before, preference
rows were plain strings, and TRL applies no chat template to strings, so preference learning saw a format the chat model never
sees at inference.training_runtime.preparenow renders the prompt with the model's template (generation prompt, thinking
off) before the token audit, as the SFT stages do. A doubled BOS is refused (double_bos), and the audit names
preference_format. The export stays model-independent. Evidence:
tests/test_training_runtime.py::test_preference_prompts_are_rendered_in_the_chat_template_like_sft. The neural trainer tests
(real TRL 1.18, trainer tokens checked against the audit) pass: 16 passed. -
Three more points from Codex's review over the VI (14.11.2026):
- Interrupted erase.
forgetmarks a tombstone erased before its files are gone, so a crash in between left the data on disk.
compactnow also removes orphan shard files (orphans_removed). Test:
test_an_interrupted_erase_is_completed_by_compact. - Hold-out by live provenance. Machine examples were held out by the live source of their imported objects; a later source
change let one into training. The source group is now frozen at import as a hash (source_group_sha256). An imported object
without the frozen value is held out asmachine_unknown_provenance, even if it is still loadable, because its live
source may have changed since. Tests:test_holdout_uses_the_provenance_frozen_at_import, which failed before, and
test_an_example_imported_without_frozen_provenance_is_held_out. - Stated assumptions. The sign-flip gate needs independent groups and, under the null, exchangeable base/tuned outcomes within
a group; the method text and the kit guide now say so. The red-team "followed" is a proxy (a fixed pattern per attack): it
misses paraphrased compliance and counts coincidental matches.
- Interrupted erase.
-
**...
vi-mcp 0.63.2
What is new
- Questions answered in plain language are kept with their program (
vi_logic action=answer, tablelogik_frage), and the answer
says how to rate one of its conclusions. Once rated, the question and program become training data: rated right an example in
logic.jsonl, rated wrong a negative inkto.jsonl(the model's own mistake). The user (14.11.2026): no fine-tuning run yet — first
collect more training data from real use; later the qwen27b model learns, so before and after compare directly. Test:
tests/test_logic_propose.py(1 new).
What was fixed
vi-mcp releaseon Windows printed a UnicodeDecodeError traceback while restarting the service (reported from a Windows
installation, 14.11.2026; the release itself went through).schtaskswrites in the console's OEM code page (0x81 = "ü" in cp850),
Python ran with-X utf8. Output of console programs is now read with the OEM code page on Windows and never fails on a byte
(config.CONSOLE_TEXT; setup, embedding service, network service CLI; git output as UTF-8 with replacement). Test:
tests/test_release_cli.py(1 new).
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.
vi-mcp 0.63.1
What is new
- clingo-object is documented: a section in README.md and README.de.md (asking in plain language, writing rules, the Python
classes, the agent, the measurements — the Python example was run against a throw-away memory and gives the documented result), and
section 5.6 of docs/PAPER.md (objects as facts, proposals, one language in two places, measured against SQL, the agent against searches
alone, training), with its limits, sources and measurements.
What has changed
- A rating already on the network is published again only when it says something new: its success estimate moved by at least
0.02, its observations grew by at least 20 %, or it was confirmed or refuted. Measured on production (14.11.2026, open network):
51 of 87 daily repeats changed neither — entries every peer stores for good (the logbook is append-only). Before: every changed
value once a day, up to 1,000 a day. Test:tests/test_net_score.py(1 new).
What was fixed
clingo_object.Memoryandpython3 -m clingo_object.agentdid not find the VI on Linux. Found on the first live test against
production (14.11.2026):vi-mcp setupwrites URL and token file into the hook command in~/.claude/settings.jsonthere, not into
hook.json(that is the Windows way), so the client fell back to 127.0.0.1 and was refused. It now reads that hook command too
(after the environment andhook.json). Verified on the workstation: the server and the token file are found without any variable.
Test:tests/test_clingo_object.py(1 new).
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.
vi-mcp 0.63.0
The user (13.11.2026): "Derzeit legen wir Daten per SQL in Objekten ab. Also müssen wir mit diesen Objekten in clingo programmieren" — "wir
machen aus clingo eine objektorientierte Programmiersprache", like Delphi grew out of Pascal; and "clingo ist die Sprache für LLMs". On the
first draft (class blocks inside the server's parser): consistent with the clingo Python package, developed further in Python.
What is new
- Memory objects in the logic.
(O in objects("art:skill host:web*"))bindsOto the objects of avi_recallfilter, as the asking
instance may see them;(O.host == H)reads a hashtag,(O.kind == "skill")a field,(O.age > 90)a number (age, importance,
confirmed, refuted, accesses);linked(O, B)follows an edge (objects one edge away come along). Never quarantine or archive; what is
cut (more than 20,000 objects), not visible or excluded is counted and shown; edges are loaded only for a program that follows them. Tests:tests/test_logic_objects.py(28). - Rules may propose changes, a person decides. A head
propose(tag(O, "status", "stale"))orpropose(link(A, B, "reason"));
vi_logic action=proposederives the proposals on the server and holds each in quarantine (kindvorschlag) with the rules behind it.
Its author cannot release it;vi-mcp releasere-checks and applies it with the proposal's id in the target's change log; discarding
leaves a tombstone; the same proposal again is counted. System tags, invisible and vanished targets are refused with a reason.
Tests:tests/test_logic_propose.py(6). - The Python package clingo-object (
import clingo_object, wheelclingo-objectin the release, also shipped in deb/rpm/MSI):
real Python classes —class Skill(Knowledge): kind = "skill"with methods likedef stale(self): return (self.mode == "test") & (self.age > 30), inheritance and overriding by Python's MRO — and expressions by operator overloading compile to the notation the
server runs;Program.check(memory)solves the same text locally with the clingo API,check_on_server,save,propose,ratesend
it.clingo_object.Memoryfinds server and token like the hook. Verified: local and server answers agree on the same objects (also
through a real server on a random port); the wheel installs offline withpip --no-depsand imports without vi-mcp. Tests:
tests/test_clingo_object.py(15). vi_logic action=objectsreturns the objects of filters as JSON (the package's data path).- Questions in natural language, answered with clingo-object on the server:
vi_logic action=answer question="Which DMZ hosts are never described as production?"— the server's language model (the classify model) writes the program, the server solves it with
the asking instance's objects and feeds refusals back (the agent ofclingo_object.agent, with the vocabulary the asker may see). Only
the notation runs, never Python. The rules every client receives now say: a question over many objects goes to this action. Test:
tests/test_logic_propose.py(1 new). - Verified on both databases: the whole suite on SQLite (910 passed) and on PostgreSQL 16 (911 passed, 3 skipped), 13.11.2026.
- An agent that answers in clingo-object (
clingo_object.agent.solve(question, memory, llm)): the language model writes a program
whose answer isans(…); it is solved with the caller's objects; a refusal of the notation, an empty answer or a violated constraint goes
back to the model in the solver's words, up to 4 rounds (the construct-and-check loop of ALM–ASP, KR 2026, and ASP-Bench, arXiv
2602.01171). Any OpenAI-compatible endpoint (VI_LLM_URL,VI_LLM_MODEL), never withmax_tokens. Tests with a scripted model: it
corrects a missing parenthesis and a wrong hashtag kind and answers in round 3; says "empty" when nothing derives; sends no
max_tokens(tests/test_clingo_object.py). From the command line:python3 -m clingo_object.agent "question"— server and token
like the hook, the memory's vocabulary (hashtag kinds with their most used values) fetched fromvi_vocabularyand given to the model. - Training with clingo-object.
vi-mcp dataset exportwriteslogic.jsonl: for every saved rule set that is not private, the task of
its description → the assistant writes the program (vi_logiccheck with the source) → the solver's real answer → the answer citing the
rule set; and every conclusion someone checked against reality (rate, now kept one by one inlogik_bewertung): right ones as
examples, wrong ones as KTO negatives inkto.jsonl.finetunekit:train.py --stage logic. Programs run as a viewer that sees
shared and internal objects, never private ones. Test:tests/test_logic_propose.py(1 new). - Rules learned from rated conclusions.
vi_logic action=learn rule_set=NAME: from the conclusions people rated for that rule set
(oldest 80 % to learn, newest 20 % held out and reported), clingo itself — as an optimiser over a small hypothesis space of up to two
field/hashtag conditions the right examples share — picks the rules that cover the most right and fewest wrong conclusions
(clingo_object/learn.py). Each learned rule is asoft(…)proposal in quarantine with its coverage; released, it becomes a new
version of the rule set. ILASP was not used: free for non-commercial use only (https://ilasp.com/download). Test: a rule set that
derived review(O) for every test object, rated right only in the DMZ, learns(O.zone == "dmz")— held out: 1/1 right, 0/1 wrong
covered (tests/test_logic_propose.py).
What was measured
-
clingo-object answers relational questions exactly as SQL does. On a copy of production (13.11.2026; 24,449 insights, 499,234
edges), 13 questions over memory objects — e.g. "DMZ hosts never said to be production", "locations of DMZ hosts", "log-monitoring
findings for hosts at KAS-0", "skills linked to an insight about an error", anevercheck — each compared with a hand-written SQL
query: 13 of 13 equal once the object limit was 20,000 (the one difference first seen was an error of the SQL: it counted a refuted
skill, which searches leave out). At the former limit of 2,000, 3 of 13 answers were incomplete — the cut was reported, but the answer
was short; hence the new limit. Time per question 0.01–0.6 s, 2.3 s for 13,088 Confluence pages. -
The clingo-object agent with a real language model (qwen3.8-flash on the central server, temperature 0, one run each), the same
production copy, natural-language questions, answers compared with SQL:step tuned set (12) held out (4) precision recall rounds time first prompt 7/12 exact — 0.74 0.75 2.2 10.4 s + "join facts about a host through the hashtag value, not linked" 9/12 3/4 0.75 0.75 2.1 6.7 s + the notation refuses an object used as a hashtag value 11/12 4/4 1.00 0.99 1.7 5.2 s The held-out questions were written after the prompt was changed and never used to tune it. The last step is a rule of the language,
not of the prompt: the solver's refusal taught the model the right form in round 2 of both questions that had failed. Small sample
(16 questions, one run) — a trend, not a proof.Compared with answering through
vi_recallalone (the same model, the same 16 questions, up to 4 searches of up to 50 hits, then an
answer): 2/16 exact (the two questions whose answer is empty), precision 0.50, recall 0.30, 20.1 s per question — against 15/16,
1.00, 0.99 and 5.2 s with clingo-object. Where an answer has hundreds of rows (403 findings, 313 pages), a search that shows 50 hits
cannot be complete; a program over the objects is.
What has changed
- The language core moved from
vi_mcp/logic.pyintoclingo_object/notation.py; the server imports it — one implementation for both. - The server's notation refuses
class/defwith a pointer to the package: the server runs no Python from callers. - A weakness in the VI's self model says when it happened ("tool:analyse … (184×, 2026-11-13 15:02–15:58 UTC)"). Found on
production (13.11.2026): the line "(184×)" read like an ongoing failure — counted per hour, all 184 errors had come in one hour that
was over, and the analysis reported to CentralStation had to be corrected. Test:tests/test_selbst_schlaf.py(1 new). - The search kind says whether the reranker ran (
hybrid+rerankbesidehybrid, in the usage statistics and the search log), and
the language model's relevance grades (UMBRELA) are reported per kind. Found on production (13.11.2026): the line "nothing
relevant in the top 10: 35 %" mixed 20 searches graded from before the reranker was switched on with about 12 after — it could not
show what the reranker changed. Test:tests/test_relevance.py(1 new). - The Debian package recommends
python3-clingo;release.shrefuses whenclingo_object.__version__differs from vi-mcp's.
What was fixed
- An object compared with a hashtag value found nothing, silently.
(H in objects("netz:dmz")) & (P.host == H)compares a host name
with an object id; the notation now refuses it and says how to read the value first. Found measuring the agent. Test:
tests/test_logic_objects.py(1 new). - A check said "follows (200)" when 403 conclusions held. The result keeps the first 200 and now states the total ("follows (403,
the first 200 kept in the result)"); found during the measurement above. Test:tests/test_logic.py(1 new).
What is missing
- Learning covers unary conclusions over objects (p("object id")) with up to two conditions; more needs more rated examples first.
logic.jsonland learning stay small until rule sets are saved and conclusions rated. - The relational task set on a production copy (clingo-object against hand-checked SQL) is not measured yet.
- Local solving u...
vi-mcp 0.62.5
What has changed
- The LLM weight layer ends a test that shows nothing, and proposes at most once a week. Before, an online test that stayed within
2 standard errors ran forever, and a rejected layer was followed by a new proposal every day. Measured: online +0.0 ± 1.4 points
(146 vs 674 actions, production, 13.11.2026); CentralStation's twin layer was offline worse in all 33 runs. Research the same day:
language models are weak numerical optimizers, especially below 70B parameters and for continuous, high-dimensional calibration with
a small evaluation budget (OPRO, https://arxiv.org/abs/2309.03409; Revisiting OPRO, https://arxiv.org/abs/2405.10276). Now a layer is
retired with "no effect" after 1,000 actions per arm when the difference is under 1 point and within 2 SE, and a new proposal comes at
most every 7 days; the layer stays limited to new hints (cold start) and audit findings, where the fit has nothing to go on. Test:
tests/test_weight_writer.py(1 new).
What was fixed
-
vi-mcp quarantineended inKeyError: 'herkunft'as soon as an entry the fixed rules held from an instance's ownvi_learn
(0.62.0) waited — the listing assumed every quarantined entry came from the network. Reported from production (13.11.2026, 0.62.4):
sudo vi-mcp quarantine 30failed, and with it the person's way to see what to release. Now such an entry is listed with its
instance, "held by the fixed rules: its author may not release it", and the rule finding. Test:tests/test_release_cli.py(1 new). -
Searches the query itself emptied were counted as search problems. The reason for an empty search had two values: an unknown
word (the right answer) or known words that never meet (a search problem). Found on production (13.11.2026, 24 h, read only):
all 79 empty searches were CentralStation host lookups(host:X) !instanz:centralstation !art:antwort !art:erfahrung; 6 counted as
"a search problem", although the host occurred only in what the query excludes. A third, named reasonausgeschlossen: the search
asked again without its exclusions, as the same viewer, finds something — the empty answer was right; the agent is told so, and
vi_statsE counts it apart. Test:tests/test_vocabulary.py(1 new).
Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.