Changelog

All notable changes to Svit will be documented here.

Unreleased

Added

• Carry provider reasoning artifacts and file references across the message boundary. Everruns ContentPart gained Reasoning and File; Svit re-exports ReasoningContentPart and ReasoningText, stores each reasoning part whole in the canonical event stream so providers can replay it verbatim in its issued position, and keeps that replay state host-owned: it never reaches the guest-visible /thread projection. Lampa shows readable reasoning on its own thinking channel and file parts by filename, and never renders a provider signature or encrypted payload.

• Bound canonical event history with an explicit retention cut. Svit::cut_thread_events and the ThreadHistoryRetention contract reclaim every event at or below a chosen boundary, and Svit::compacted_thread_events_through reports the largest boundary that is currently safe. A cut is refused unless a compaction checkpoint already replaced the prefix, the boundary sits inside the committed range, and no fork inherits it. The boundary is recorded durably, so reads start after it and appended events never reuse a reclaimed sequence. Turso schema version 3 adds thread_history_cuts; older databases upgrade in place.

• Give volatile Svit instances the same retention and compaction-checkpoint surface as durable ones, so an in-memory reason/act loop no longer grows for its whole lifetime.

• Reclaim the content-addressed envelopes a process transaction cut orphans. The cut now collects the hashes its covered rows referenced and removes each one no base, transaction, thread event, checkpoint, or snapshot still needs, so storage no longer accumulates unreachable envelopes across cuts.

• Bound the committed process tree as a whole. Limits::max_tree_nodes and Limits::max_tree_text_bytes are measured over the complete root at the same boundary that validates a commit, restore, or fork, so state accumulated one valid write at a time now fails closed instead of growing without end. Both appear under /system/limits; snapshots move to format 10.

Changed

• Advance the Everruns main lock from 18296be8 to 66c20400, including everruns 0.18.2, everruns-host 0.20.1, and test support 0.18.2.

• Update Lampa to Tuika 0.11.0 and tuika-codeformatters 0.5.0.

• Update Lampa to Tuika 0.10.0 and tuika-codeformatters 0.4.3.

• Define Svit as the primary runnable contract: one reason/act loop, durable conversation thread, and serializable Process, with the embedding application as host and Reasoner as model/provider configuration.

• Stop re-exporting Everruns simulator fixtures from the public svit API; tests and examples import them through direct development dependencies.

• Replace construction-time snapshot mounts with virtual mounts. /mounts/<name> commits only a descriptor — kind, host-disclosed source, locality, and granted access — while nodes below it resolve through a host-attached MountProvider when they are read, discovered, stated, or written. Mount data no longer enters the committed root, so mount size is independent of process and snapshot size.

• Replace SnapshotMount with Mount, MountProvider, MountDescriptor, MountNode, MountPath, MountAccess, and Locality. Mount::folder, Mount::writable_folder, Mount::value, Mount::writable_value, and Mount::turso_query cover the built-in providers.

• Process::read and DurableProcessHandle::read return owned values because mount nodes are resolved rather than borrowed from committed state.

• Bump snapshots to format 7 for the descriptor-only /mounts schema and the new max_mount_entries and max_mount_writes limits.

• Browse one namespace in Lampa. The console no longer holds a copy of the process root or a separate mount browser: every node is resolved through discover, stat, and read, so a mounted folder is browsed exactly like committed memory. Listings are fetched on expand, content on selection and for array-item summaries, bounded at 200 children per directory, and re-resolved on each committed version.

• Store each Lampa instance in instances/<instance-id>/svit.db, selected below LAMPA_DATA_DIR. Instance IDs are lowercase filesystem-safe address segments, and an existing database must contain its matching root address.

• Add explicit legacy shared-database import. ProcessStore::import preserves the current process version and root while beginning a new retained-history tail at the imported boundary.

• Track Everruns main and compose the process-owned loop through an explicit everruns-host HostComposition, the canonical event-log backend, and provider/model contracts.

• Configure each reasoning loop atomically through one Reasoner containing its provider-visible model ID and Everruns provider. One-shot model calls use the Everruns facade internally.

• Advance thread state to svit-thread@6; runtime construction records the canonical session.started event, uses the process address as runtime identity, and composes Svit-owned prompts with optional wrapped instructions.

• Keep Lampa as a presentation host: its entry point builds one Svit instance, while the TUI consumes commit notifications, inbox, and outbox without polling process state or assembling built-ins. Remove the separate direct Process script-execution command.

• Remove Ports::standard() and deferred port derivation. Hosts now register http, llm, and spawn individually; unrestricted HTTP requires the separately named http_unrestricted call. Lampa makes all three grants explicitly.

• Keep Lampa’s memory viewport stable when selecting lower visible rows and start with only the tree root expanded.

• Navigate Lampa panels backward with Shift+Tab while retaining forward traversal on plain Tab.

• Render Lampa conversation messages as Markdown and emit bare HTTP(S) URLs as OSC 8 terminal hyperlinks.

• Route runnable Svit inbox, reasoning, process-tool, and built-in catalog transitions through an adapter-owned durable process handle.

Added

• stat(path) in Rust, Svit Lisp, the reasoning-loop tool set, and BuiltinContext. Every node — committed or mounted — answers with one facts record: kind, granted access, locality (cache, local, or remote), mount, path, source, attachment, and provider facts such as byte size, modification time, and a folder mount’s git branch and commit.

• Writable mounts. A descriptor grants read, write, or read-write. Activation writes and removals below a granted mount are buffered and applied at the commit point after every in-process validation, so a failed activation applies none of them. External sources still cannot join the transaction.

• Process::attach_mount and Svit::attach_mount so a host can restore mount authority after a snapshot restore, which never carries providers.

• Mount-aware search: the built-in walks a mount subtree node by node under an independent node budget and reports when a bound truncated the walk.

• Lampa mounts the current directory read-only as cwd and accepts --mount name=path and --mount-rw name=path.

• A content fact on directory nodes (object or array) completes the stat vocabulary, so a client can tell an array from a map without reading it.

• Initial Rust workspace with the svit library and Lampa process console.

• Transactional Svit Lisp activations, backed by Ketos, over one process state root.

• Named, discoverable scripts with guest-side transactional script creation.

• Structured logs and atomic buffered message intents.

• Versioned snapshots, integrity hashes, restore validation, and isolated forks.

• Execution deadline, interpreter memory, stack, namespace, syntax, integer, persistent-value, script, log, and message limits.

• Typed activation interceptor hooks.

• Transport-neutral Svit Control Protocol 1 with optimistic version checks, explicit conflicts, bounded retry receipts, additive-field compatibility, and an in-memory controller.

• Deterministic executable examples for persistence, self-reflection, atomic rollback, forks, sandbox limits, and multi-client control.

• OKF v0.2 knowledge bundle, threat model, public Svit skill, and repository validation tooling.

• Conventional discoverable process hierarchy with reserved future nodes and validated system identity, API, limits, lineage, runtime, capabilities, and outbox metadata. Snapshot format 6 records this root schema and host-managed reasoning-loop state.

• Schema-aligned ProcessBuilder::library construction for initial /lib entries, replacing the pre-release script builder method.

• One absolute-path discover, read, write, remove, and exec contract shared by Rust, agent tools, and Svit Lisp 2, including transactional, deadline-sharing, depth-bounded nested script execution.

• Bounded, read-only snapshot mounts for real UTF-8 folders and host-selected Turso query results, with a deterministic example covering both sources.

• A process-owned svit::Svit loop implemented with Everruns, with durable conversation events carried through snapshot, restore, and isolated forks.

• A live support-agent-svit consumer using gpt-5.6-terra through a process-owned Svit inbox and outbox.

• Explicit Ports builders for allowlisted or unrestricted HTTP, nested model calls, and one-turn child execution, plus a reusable redirect-denying reqwest transport.

• Explicit Svit Inbox, Outbox, and Events ports, commit notifications, atomic owned value/version reads, and sanitized terminal failures without exposing the mutable process tree or channel implementation.

• Bounded Lampa array-row previews for scalar and object items.

• Report what every transition changed. Process::write, remove, enqueue_inbox, acknowledge_inbox, replace_thread_state, and attach_mount now return a Change carrying the new version, the canonical changed paths, and the replayable mutations; Activation carries the same paths. Paths and mutations come from one fold, so a live observer and a stored durable event describe the same transition, and the Turso adapter no longer hand-builds a parallel mutation for each host call.

• SvitEvent::Committed(Change) replaces the payload-free notification, so a subscriber learns which paths went stale instead of invalidating everything. A notification carries version and paths but no values.

• Lampa invalidates only what a commit named. An unrelated commit no longer costs a re-walk of every open directory, and r in the memory panel reloads the tree for external changes no event can report.

Fixed

• Keep the selected Lampa row across a committed version. The console now remembers the path and restores it once the tree resolves it again, instead of falling back to the root.

Security

• TM-CAP-007: mount paths parse into validated segments that reject traversal, separators, empty, oversized, and NUL content before a provider observes the request.

• TM-CAP-008: mount providers are runtime state and are never serialized; a restored mount reads its descriptor with attached: false and fails closed until the host reattaches it.

• TM-EFF-006: mount writes are ordered with the process commit; a failed activation applies none of them.

• TM-DOS-010: mount listings, leaf reads, subtree searches, and console listings are bounded independently of committed-value limits.

• Guest environments use a fresh restricted Ketos interpreter with null I/O and a module loader that rejects every module.

• Ambient host APIs, modules, and randomness are unavailable to guest scripts.

• Guest diagnostics are sanitized and capped before crossing the public API.

• Folder snapshot imports reject symbolic links and special files; mount data is validated against process value limits and grants no live host authority.

• Guest scripts and model tools can inspect durable /thread history but cannot rewrite it; only the trusted process host can replace that bounded state.

No release has been published. The current API and snapshot format may change without compatibility guarantees.