Semlith Files

Fixed

• An index run tells the truth about itself, everywhere it is shown. The owner's walk of this release found the run view guessed at almost everything: Start sat on "Starting…" with nothing behind it, the stage pills were thresholds on the file count, the log only ever said "indexing", and time left swung from 22 h to 1 h 34 within six percent. Now:
• The engine says every phase it enters — finding files, reading and chunking, starting a lane, embedding, loading the image model, finishing embeddings in flight, writing the index, finishing up — with a sentence and its timing, and the run card draws them as a timeline, each step held on screen long enough to read but never ahead of what happened. The log carries the same phase lines.
• Progress is the work itself: files read, chunks embedded and images embedded, against an expected total the scan counts exactly and each file corrects as it is chunked. The bar only climbs and reaches 100 % only at the end.
• Time left is that work over a smoothed rate, seeded by what this machine's lanes have managed (remembered per lane in lane-rates.json, first measured by embedding the known-answer fixture in batches). It moves at most a quarter in ten seconds, holds while a lane loads or the index is written, and follows the work when the work changes. The wizard's Index step estimates before Start, for the lanes ticked.
• Start lands on the run view at once and shows each request it makes; a person's decisions are recorded with the run and applied as its first phase. A decision on hundreds of files in the store's Review tab is one request per hundred, with a progress line, and the files it lets in are indexed as a run of their own.
• The scan before a review is a run that reports its walk, the files read, hashed and checked, and the rules, so the Review card follows it.
• The wizard and the store's Runs tab draw the same run card.
• Lanes stay loaded between a run's slices: on the walk the Neural Engine's worker went idle during each slice's drain and save, and every slice waited two minutes for it to load again.
• semlith index -v prints the phases and the same figures.
• A reviewed run counts its scan's whole total from its first second. It starts on the recently committed files while the walk finishes, and counted only those 48 until then, so the walk's run said "about 25 min" for an hour's work.
• Every stage is on the run's log as its own lines (files read and chunked, embedding every two seconds with each lane's rate, each index save), and the whole log is kept beside the store: the run history shows every line of a finished run, paged by /api/index/history/log, where it had kept the last 200.
• A run no longer stops to drain at each checkpoint (#203). A checkpoint saves what has been embedded and records as indexed only the files whose every chunk has landed, and a long run gives the writer back to the watcher only when the watcher has changes or another job is queued. On the owner's walk each 45-second slice had been followed by 10 to 12 minutes of "finishing embeddings in flight" on the CPU.
• Images are embedded on a thread of their own, so the text lanes keep embedding while the image model works; it had run on the writer and left the Neural Engine idle through a stretch of screenshots (#203).
• A run admitted behind another job on its store's writer can be taken out of the queue; the button said "nothing waiting in the queue".
• Time left counts the embedding alone. Files read stayed in its rate, and reading runs ahead of the lanes in bursts, so a 1,500-file run embedding at 18 chunks/s with 6,000 chunks left said "about 3 min". A held phase (a lane starting, a save) is no longer sampled into the rate either: a Core ML first start of 135 s after an update had put it 110 % over for minutes. While a lane starts, the line counts its seconds.
• The images total counts images with the image model and, on a reviewed run, the plan's from the first second (it read 1 / 34, then 2 / 18, then 55 / 55); the drain's "still embedding" no longer counts the window being filled twice.
• A long run gives the writer to file changes in its folders every five minutes rather than every 45 seconds, since each hand-over drains the lanes; a queued job still waits at most 45 seconds.
• Creating or deleting a store no longer waits for a search or graph in progress to finish.
• A phase said again with nothing new is logged once; under a stage filter the log folds a phase line that repeats the last one shown.
• The run log has one reader per run, shared by every card that shows it: the wizard's rebuilt card added every line twice.
• A progress bar redrawn in place moves: the page patched its width as a style attribute, which the portal's content-security policy drops, so the bar kept its first width while its percentage climbed.
• The WebGPU lane on Linux refuses to start when Vulkan has only a software device, and names the hardware device it uses. The known-answer failure on NVIDIA (#197) was never NVIDIA: the rented containers it was measured on lack the graphics capability, so Dawn ran on llvmpipe on the CPU while the device still reported the card. On a real NVIDIA Vulkan driver (an RTX PRO 6000) the lane passes at a minimum cosine of 0.99997 and embeds 1,408 chunks/s, against CUDA's 2,784 on the same card. A worker lane that embeds the fixture at under 2 chunks/s is also refused, as a backstop.
• A failed accelerator lane is tried again on the first run ten minutes after it failed, and the failure is written to the daemon's log. One transient load failure of the Neural Engine lane had left every run on the CPU until the daemon restarted (#188).
• A scoped search is no slower than an unscoped one on a large store: a <repo>/** scope is a range of a path index rather than a GLOB over every path, and the eight most recent resolved scopes are kept, so an agent moving between repositories does not resolve each one again (#183).
• A file that became empty, too large or unreadable is evicted, so its old chunks stop answering searches; an unusable image's vectors go with its rows.
• A query longer than CLIP's 77 tokens is never a confident image match. A screenshot of text had ranked first for 57 of 102 SWE-bench issues.
• A key-like secret whose random part happens to open on FAKE or DUMMY is no longer taken for a declared test dummy.
• Long log lines, attention rows and feed entries in the portal wrap instead of cutting off the reason.
• measure_the_store_at_scale takes each size's idle RSS as the median of five fresh opens, so a bimodal first figure on a hosted runner no longer fails the release suite (#199).

Added

• The portal matches Semlith Cloud on what the two share: full text on hover for anything cut off and a tip on every progress bar; sortable columns marked; filters and tabs kept across a reload, and the setup wizard too; a busy wizard button that says what it is doing; search store chips, the budget tip and the store before each result path; the ledger's read bars on one scale (a session that sent more than the whole file overflowed), its savings tables and chain footer; a "chain verified" chip on reports; a store error card and nav badge, an empty Stores state and a Sources table in Inside the index; the Review tab's loading state and the wizard's "nothing in the grey zone" note.

Changed

• semlith index -v splits the writer's time by part: rows and their keyword index, eviction, graph, vectors, commits, saves, hashes and the vector cache (#198). On a rented NVIDIA L4 the writer was about 30 % of a 93,563-chunk run, the same on the container's local disk as on its network volume, and nearly all of it SQLite: chunk rows, symbols and edges, and commits. The writer's per-row inserts now reuse prepared statements, which cut its time by 6–8 % there, and a chunk's keyword entry is written by its insert rather than a trigger, which cost twice the row's own insert (measured on 8,000 chunks of a real store). An older binary that puts the trigger back is undone at the next write.
• A failed known-answer check names every chunk under the floor, not only the worst (#197).
• semlith setup says what --hook-mode gate buys where the choice is made, and docs/clients.md records the measurement behind it (#189).

Security

• rustls 0.23.45, past RUSTSEC-2026-0285 (TLS 1.3 handshake messages accepted across encryption levels).

Install

macOS and Linux

:::sh
curl --proto '=https' --tlsv1.2 -fsSL https://raw.githubusercontent.com/semlith/semlith/main/install.sh | sh

Windows

:::powershell
irm https://raw.githubusercontent.com/semlith/semlith/main/install.ps1 | iex

Or download the archive for your platform below, unpack it, and put semlith on your PATH. Intel macOS has no prebuilt binary: ONNX Runtime no longer publishes x86_64 macOS builds.

Verify a download against SHA256SUMS before running it, and its provenance with gh attestation verify <file> --repo semlith/semlith.