Repository navigation
EverOS 1.6.0
EverOS 1.6.0 adds memory deletion aligned with the Cloud API, including
owner-scoped deletion by ID, and improves recovery when writes, background
tasks, and file updates overlap. It also unifies application assembly across
the server and CLI through MemoryService, KnowledgeService, and
OpsService.
This release adds safeguards for large search workloads and keeps unused
vectors out of returned query results. See the upgrade notes below for
configuration and Python API changes.
Added
-
POST /api/v2/memory/delete(#483):
delete byuser_id/agent_id, bysession_id, or one owner's session;
answers{"filters": [...], "count": N}. A session still being memorized
answers503 SESSION_BUSYand nothing is deleted. everos-mcp's
forget_sessionnow works against a self-hosted server. -
POST /api/v2/memory/delete_by_ids: delete episodes by memory id, with
what Reflection merged into them, their atomic facts and their cluster
membership. The optionaluser_idrestricts deletion to that owner;
deletedreports the number actually removed, excluding missing,
duplicate, or other-owner ids. -
Configuration:
[memorize] delete_wait_seconds(default10),
[cascade] delete_fence_warn_entries(default100000). -
Metrics:
everos_lock_wait_seconds/everos_lock_hold_seconds(by lock
kind),everos_lock_table_entries,everos_memory_delete_fence_entries/
_runs. -
An optional correctness gate for agent cases (
[agent_memory] case_gate_enabled, defaultfalse). On, the extraction LLM judges
whether the work in an agent conversation was completed correctly (one
extra call per conversation up to 50k tokens; longer ones are admitted
without a call), and only admitted conversations become cases, instead of
the complexity and value filters deciding. An admitted case drives skill
extraction whatever its quality score. The judge is
everos.component.llm.LLMCaseJudge. -
The log level is configuration (
[logging] level, default"INFO").
everos.service.configure_process(settings)sets up logging, tracing and
metrics once per process;build_applicationcalls it, and the CLI no
longer configures logging itself.server start --log-leveland
EVEROS_LOG_LEVELstill override the level for the server, and
interactive commands still logWARNING(INFOwith--verbose). -
One language decision per cell, pinned downstream. The episode is
still written in whatever language the model picks from the conversation;
that language is then detected from the episode text by Unicode script
(everos.core.utils.language.detect_output_language, one of everalgo's
OutputLanguagevalues) and carried on the episode and its
EpisodeExtracted/ProfileClusterUpdatedevents. Atomic facts are
extracted in it, and a profile is written in it and then frozen: the
first profile extraction that knows the language stores it as
primary_languageinuser.md, and later extractions keep that value
even when an episode arrives in another language (changing it is a manual
edit). Episode entries gain an inlinelanguagefield. Both are left out
while unknown, so episode logs anduser.mdwritten before this release
read back with no language and extraction falls back to everalgo's own
inference. The search index, the API and/getare unchanged.
Changed
-
Every markdown write of a memory owner holds that owner's lock and first
checks that what it was derived from still exists; a write whose source was
deleted is skipped and logged asmemory_write_skipped_source_gone. -
User clustering and the Reflection finish embed before taking their locks.
-
A succeeded OME run no longer keeps the triggering event (the conversation
text) inome.db; failed and dead-letter runs keep it for diagnosis. -
/getlists an episode Reflection merged from several sessions with
"session_id": nullinstead of failing the page. -
/add,/flushand/memory/deleterefuse asession_idwith leading or
trailing whitespace or a control character (422). A daily-log file
stores it as one trimmed line, so such an id was read back as another one
and could not be matched by a session filter or deleted. -
A SQLite write that waited out
[sqlite] busy_timeout_mson another
writer's lock answers503 EXTERNAL_SERVICE_UNAVAILABLEwith the fixed
message"database is busy"(retryable) instead of an unhandled500; the
failed statement, without its values, is logged as
sqlite_lock_wait_timed_out. A queued/addfailing that way records
last_error"StorageError: database is busy". -
Server log tracebacks are plain text (innermost 15 frames, no locals)
instead of rich's syntax-highlighted rendering, which blocked the event
loop for seconds per exception on a loaded host. CLI and TUI logs share
the same configuration. -
Internal module layout: one convention across
infraandservice.
Everyinfrasubpackage now keeps its implementation in private
directories behind its__init__facade (cascade/_projections,
cascade/_worker,markdown/_base|_mds|_readers|_writers,
sqlite/_base|_repos|_tables,lancedb/_base|_repos, matchingome);
the backfill steps live inservice/ops/backfill/; the index port
package no longer re-exports the record tables, which are imported from
everos.infra.persistence.records. Public facades are unchanged, and
import-linternow forbids the outer layers from reaching into
everos.infra.cascade.**as it already did forpersistence. Logger
names follow module paths, so a log filter on a renamed module (for
exampleeveros.infra.persistence.sqlite.repos.*) needs the_repos
spelling. -
IndexRepository.find_by_owneris removed. It read rows by
owner_idacross every(app_id, project_id)scope; nothing called it
(#480). Scoped reads go throughfind_wherewith an explicit filter or
find_by_owner_entries. -
The cascade and OME engine switches are settings.
[cascade] enabledand[cascade] watcher_enabledreplace the
EVEROS_DISABLE_CASCADEandEVEROS_DISABLE_CASCADE_WATCHERenvironment
variables, and the new[ome]section'smax_concurrent_runsand
run_timeout_seconds(0disables the ceiling) replace
EVEROS_OME_MAX_CONCURRENT_RUNSandEVEROS_OME_RUN_TIMEOUT_SECONDS.
The old variables are no longer read; set the keys ineveros.toml
instead. -
Building the application requires
[llm].build_providers(and so
build_application) raisesLLMNotConfiguredErrorwhen[llm]has no
api_keyorbase_url, instead of building without an extraction LLM
and leaving the server's start to refuse. The server still refuses to
start, now at assembly; everyeveros cascade …command builds the same
application, so those commands also need a configured[llm]and exit
with code 3 and the toml section to edit when it is missing. Python
callers that passedProviders(llm=None, …)must pass a client. -
GET /healthno longer reportscapabilities.llm. It was always
true-- a server without an extraction LLM does not start -- so it is
removed; clients that read it should drop the check.Capabilities.llm/
.deciderandProviderStatus.llmare removed fromeveros.servicefor
the same reason. -
everos.component.configis renamed toeveros.component.yaml_loader.
The package name no longer collides witheveros.config. Update imports to
from everos.component.yaml_loader import YamlConfigLoader; the class name
is unchanged. -
MemoryServicewrite use cases areaddandflush.
MemoryService.submit_add/submit_flushare nowadd/flush, the
names the HTTP API uses; the inlinememorize()/flush()steps are
private. Python callers of the facade update the two names; HTTP clients
are unaffected. -
Local parser input handling lives in the parser component. Application
assembly supplies the raw-file builder to ingestion, and ingestion no longer
falls back to a built-in one.everos.memory.extract.parser.mappingis
removed; importbuild_raw_file,read_file_uriandto_raw_filefrom
everos.component.parser;build_raw_fileandread_file_urinow require
asettings_sourceinstead of falling back toload_settings. URI checks,
allowlist rules, size checks and error behavior are preserved. Thefile_uri_hydratedlog event is now emitted by
theeveros.component.parser.inputlogger; update log filters that matched
the old module name. -
Multi-round search receives explicit configuration readers. Application
assembly supplies tuning and trace-path readers, andSearchManager,
LLMRoundDeciderandsearch_episodes_llm_multiroundnow require them
instead of falling back to a built-in reader. The existing settings cache,
legacy environment overrides and per-call read timing are preserved. Retry
defaults and execution rules are unchanged by this refactor. The
llm_multiround_bad_env_overridelog event is now emitted by the
everos.config.search_runtimelogger; update log filters that matched the
old module name. -
Reflection delegates file grouping to the Markdown stores. Retirement
keeps the existing file order, partial-write failure behavior and report
counts. The unreleasedEpisodeStore.deprecateand
AtomicFactStore.deprecatecontracts now accept orderedentriesand a
replaced_byID instead of a per-file replacement mapping. -
Index synchronization and vector backfill share embedding rules.
Episode, atomic fact, foresight, agent case, agent skill and knowledge topic
projections now use the same source-text and vector-column declarations.
Backfill keeps its existing partial-failure recovery and historical text
normalization behavior; no data migration is required. -
An agent memcell that produces no case now records why. everalgo
0.6 extracts an agent case only from a closed trajectory (a user request
through to the assistant's final answer); when boundary detection leaves
an unclosed slice -- typically by cutting just before the final answer --
that slice yields no case. The extraction outcome is now persisted on the
memcellrow:case_extracted_at,case_skip_reason(NULLexactly
when a case was produced; otherwise everalgo's skip reason, or
no_agent_sender) andcase_skip_detail_json. Existingsystem.db
files gain the three columns automatically at startup. -
everos.service.memorize_queueis gone. Theasync_modequeue now
lives in theMemoryServicepackage;TaskItem,TaskPage,
QueueHealthandTASK_STATUSESare imported fromeveros.service(or
everos.service.memory). -
Entry points import only the service. A new import-linter contract
(entrypoints-forbidden) keepseveros.entrypointsoffeveros.memory,
everos.infra,everos.componentandeveralgo; request / response
DTOs (GetRequest,SearchRequest, ...) are re-exported by
everos.service. -
everos.memory.ports.ClusterStorespeaks in cluster operations. The
port shrinks from eleven methods to seven:add_member,remove_members
andupdate_metadatabecome onereplace_members(cluster_id, *, removed, added, member_type, centroid, count, last_ts, preview), which swaps the
members and restamps the cluster in a single SQLite transaction (before,
a crash between the three calls could leave the membership and the
snapshot disagreeing).list_ids_and_member_countsandcountare gone:
readlen(cluster.members)fromlist_for_owner. CustomClusterStore
implementations need the same change. -
everos.entrypoints.api.utilsis noweveros.entrypoints.api.dependencies
(internal): it holds the FastAPI request dependencies (application,
extract_request_id), named as FastAPI's project layout names them. -
session_lock_timeout_secondssits under[memorize]in the shipped
default.toml(it had landed under[knowledge.search], where it was
ignored). The value, and so the behaviour, is unchanged. -
Timings are constructor arguments instead of module constants to patch.
LanceRepoBasetakestimeouts=LanceTimeouts(...)(andsweep_husks=),
LanceIndexBackendtakesschemas=,CascadeWorkertakes
maintenance_task_timeout_seconds/rebuild_conflict_backoffs_seconds/
loop_restart_backoffs_seconds/on_unrecoverable,CascadeConfiggains
drain_idle_limit_seconds,memory_root_locktakespoll_interval_seconds,
andMemorizeQueueWorkertakesstop_grace_seconds/mark_retry_seconds.
Every default is the previous constant. The lance husk sweep is public as
remove_empty_index_dirs. -
everos.service.memoryis a package (the facade stays importable from
the same path). The process-wide session-lock registry
(everos.service._session_lock) is gone: eachMemoryServiceowns its
per-session locks. -
The operator, upload and queueing rules moved from the HTTP routes and
the CLI into the service facades.OpsService.health()assembles the
/healthpayload (a failed probe still reads as an unhealthy block, never
a 500);OpsService.list_tasksvalidatesstatusand capspage_sizeat
100;MemoryService.submit_add/submit_flushdecide between running
inline and queueing (Queuedwhen queued);KnowledgeService.create_from_upload
/replace_from_uploadcheck the size, pick UTF-8 or the parser and
extract, andKnowledgeService.require_search_providersis the
embedding + rerank gate. HTTP status codes and bodies are unchanged.
everos.component.capabilitiesis removed;compute_disabled_featuresis
exported fromeveros.service. -
Backfill is part of
OpsService.everos.service.backfillis removed.
OpsService.backfill(phase, auto_yes=, presenter=, summary=)runs one
phase or"all", stops on a missing provider, a running server or a
declined prompt, and returns aBackfillOutcome; each phase's result
lands in the caller'sBackfillSummary. Its collaborators are injected as
oneBackfillDeps, so the service layer no longer importsinfra.
BackfillPresentergainsphase_started(phase);BackfillPhaseis gone
(the CLI keeps its own phase copy). The public result types are
VectorsPhaseResult,ClustersPhaseResultandSkillsPhaseResult. -
Applicationcloses its storage whether or not it was started, and
aclose()is idempotent;async with build_application(settings) as app:
closes on exit. The CLI uses it for every command. -
MemoryRootLockedError(everos.core.errors) is what callers catch
when another process holds the memory root. The OME engine's
EngineLockHeldErroris a subclass;everos.infra.ome.OmeLocktakes the
same lock from outside a running engine. -
The datetime helpers moved to
everos.core.utils.datetime.
everos.component.utilsis removed; importget_utc_now,
to_display_tz,UtcDatetimeand the other two-zone helpers from
everos.core.utils.datetimeinstead. They are stateless tools every layer
uses, the HTTP and CLI entry points included, so they live with the other
cross-cutting runtime code. -
The service layer's module-level functions are gone.
everos.service
no longer exportsmemorize,search,get,get_task,list_tasksor
the knowledge functions (create_document,search_knowledge, ...); build
anApplicationand callapplication.memory.*,application.knowledge.*
orapplication.ops.*.everos.service.memorize,.search,.getand
theeveros.core.lifespan/everos.entrypoints.api.lifespanspackages
are removed.create_app()takessettingsor a pre-builtapplication
instead oflifespan_providers. -
The process-wide provider accessors are gone.
everos.component.llm.get_llm_client/get_decider_llm_client/
get_multimodal_llm_client,everos.component.embedding.get_embedding_capability
andEmbeddingCapability,everos.component.rerank.get_rerank_capabilityand
RerankCapability, and theeveros.component.multimodalpackage are removed.
Take providers fromeveros.service.build_providers(settings)(a provider
that is not configured isNone) or build one with the component factories;
resolve_decider_confignow requires itssettingsargument.
everos.component.parser.aparse_filetakes the multimodal LLM asllm=.
missing_config_errormoved fromeveros.component.utils.config_hintsto
everos.config.set_metrics_registry/reset_metrics_registryare
replaced byconfigure_metrics(registry). -
The storage singletons are gone. The module-level repository
instances (episode_repo,atomic_fact_repo, ...,md_change_state_repo,
cluster_repo,knowledge_document_repo, ...), the engine / connection
accessors (everos.infra.persistence.sqlite.get_engine/
get_session_factory/dispose_engine,
everos.infra.persistence.lancedb.get_table/get_connection/
dispose_connection, the Milvusget_client/dispose_connection) and the
index facade functions (startup,shutdown,ensure_business_indexes,
drop_business_tables,read_embedding_model, ...) are removed, together
witheveros.infra.persistence.index.routerand thelancedb.indexes/
milvus.indexesmodules. Storage is now a set of objects built over one
memory root:SqliteDatabase+SqliteRepos.over(database),
LanceDbConnection/MilvusConnection, and theDerivedIndexreturned by
everos.infra.persistence.factories.build_derived_index(settings, root),
whoserepositoriesreplace the old index instances. The SQLite repository
classes are public (ClusterRepo,MdChangeStateRepo, ...; the knowledge
topic row repository isKnowledgeTopicRowRepo) and take their session
factory in the constructor.CascadeOrchestrator,CascadeAdmin,
CascadeScanner,CascadeWatcher,CascadeWorker,HandlerDepsand
KnowledgeServicetake the storage they use as constructor arguments, and
KindSpec.index_repois removed (a handler's repository comes from
HandlerDeps.index). -
One embedding provider per process. The cascade handlers and the startup
provenance check use the application's embedding provider instead of
building a second one, so[embedding] max_concurrentis no longer doubled
in practice. -
OMEConfig.jobstore_pathis required. The engine no longer resolves the
memory root on its own; the application passes<root>/.index/sqlite/ome.db. -
Backfill logs under
everos.service.backfill(was
everos.memory.cascade._backfill); update log filters keyed on the old name. -
A merged episode with an empty subject no longer writes an empty
### Subjectsection to its markdown. -
A profile JSON column that does not decode to a list reads as empty
instead of being passed through as-is. -
Reflection runs in two steps.
reflect_episodeswrites the merged
episode; the newfinish_reflectionstrategy deprecates the source episodes
once the merged episode's atomic facts exist. If fact extraction for the
merged episode dead-letters, the sources now stay searchable (they used to
be deprecated anyway), and the old 120 s wait is gone. -
UserPipelineStartedis published after its cell's episode is extracted
(it used to be published before any cell ran). Its only subscriber,
extract_foresight, ships disabled. -
Prompt slots are replaced by custom instructions.
config/prompt_slots/*.yaml(enabled+template, a whole replacement
prompt) andeveros.memory.prompt_slots.PromptLoaderare removed. The
user-memory operators now takecustom_instructions=, appended after
their bundled rules: configure them in
config/custom_instructions/<operator>.yaml(enabled+instructions)
forboundary_detection,episode_extract,profile_extractand
reflect, read byeveros.memory.custom_instructions.CustomInstructions.
See docs/custom_instructions.md. -
Boundary detection is a domain object.
everos.service._boundaryis
replaced byeveros.memory.extract.boundary.BoundaryDetection, which
MemoryServicereceives instead ofllm/prompt_loader. Both modes now
runeveralgo.boundary.adetect_boundaries(agent mode keeps tool rows in
the cells and now honours[boundary_detection]hard limits too). When
the model judges the trailing segment of a non-final call complete
(tail_complete), that segment is closed into a last cell and extracted
at once; a segment it judges open, or one no model judged, waits in the
buffer for the next batch or/flush. -
An unusable model reply is
everalgo.llm.LLMOutputError, no longer a
ValueError. Boundary detection and episode extraction try it three times
(everos.memory.extract.llm_retry, the one host-side retry), with no
backoff (episode extraction used to sleep 1 s and 2 s between attempts).
The session quarantine counts calls that end inLLMOutputError(after
its retries) or in aValueError-- a message everalgo refuses
(InvalidInputError) or a row that maps to no conversation item, such as
an orphan tool result -- which is never retried; other errors propagate
uncounted. -
Episode.summaryis required (everalgo 0.9 writes one for every
episode and every merge) andEpisode.subjectdefaults to""; episodes
indexed before either existed read back as"".AtomicFact.factis
renamedAtomicFact.content.Profile.explicit_info/
implicit_traitsholdExplicitInfoItem/ImplicitTraitItem(same
shape as everalgo's); a profile item stored as a bare sentence reads back
as an item with only itsdescription. A stored item with no
descriptionis dropped when the profile is read (/get,/search's
profile, the next profile update), with aprofile_entry_dropped
warning; writing a profile stays strict./getand/searchreturn every
profile item with all four keys (description,category/trait,
evidence/basis,observed_at), the ones a stored item lacks as
null-- an additive change. -
Agent memory says why it stayed empty. A memcell that yields no agent
case logsagent_case_skippedwith everalgo'sreason(for example
too_few_tool_rounds,filter_rejected) and itsdetail; a skill run
logsagent_skill_skippedfor a case below the quality floor and
agent_skill_op_droppedfor each operation the model proposed that was
dropped. The case quality floor before skill clustering is everalgo's
should_extract_skillinstead of a copy of its threshold.
AgentCase.from_algomoved toeveros.memory.mappers.agent_case. -
The multi-round retrieval decider speaks the everalgo LLM contract.
method="llm_multiround"asks its decider with
achat(..., response_format=...), so a reply must be the
{"core": [<int>...], "next_queries": [<str>...]}object exactly (the
provider retries an invalid one); a reply with prose around the JSON or
string indices is no longer accepted, and fails the attempt instead. The
trace fielddecider.tokensisnullfor the prompted decider (token
usage is reported by the LLM call observer). -
Index searches return domain records.
memory.ports.IndexHit(a row
read by column name) is replaced bySearchHit[T](itsstoredrecord andscore), and
knowledge-topic searches returnScoredKnowledgeTopic. Recall hands the
rank algorithms everalgoCandidates whosemetadataholds only the
fields an algorithm reads, with the stored records alongside
(RecallResult.stored_by_id); responses are built from those records.
An LLM rerank (enable_llm_rerank=true) no longer sees index-only columns
such asmd_path,content_sha256or the*_tokenscolumns in its
candidate JSON.everos.memoryno longer re-exports theAlgo*aliases
of everalgo's types. -
The knowledge service works through two ports.
KnowledgeService
takes aKnowledgeStore(markdown documents, taxonomy, uploaded
originals;MarkdownKnowledgeStore) and aKnowledgeCatalog(the
document / topic records;SqliteKnowledgeCatalog) instead of a memory
root and two repositories. Replacing a document now extracts its topics
before touching the old files.LLMNotConfiguredErrorlives in
everos.core.errors(still importable fromeveros.component.llm). -
everos.service.knowledgeis a package (the facade and its result
types stay importable from the same path). The unused
KnowledgeService.parse_filemethod is removed. Error types are no longer
reachable through the module: import them fromeveros.core.errors. -
KnowledgeDocumentcarries no storage path. Themd_pathfield is
removed; the knowledge store finds a document by its id.
KnowledgeStore.delete_documentno longer takesmd_path,
KnowledgeStore.update_documentreturns aWrittenDocument(which now
also carriesmd_path, the document'sindex.mdrelative to the memory
root), andKnowledgeCatalog.record_documenttakes thatmd_pathas a
keyword. API responses are unchanged. -
A request that needs a model while
[llm](or[multimodal]) is not
configured answers 422PROVIDER_NOT_CONFIGUREDinstead of 500
INTERNAL_ERROR. -
Vector backfill's row work moved into the index package. The vectors
phase's row-level events (cascade_backfill_row_*,
cascade_backfill_batch_*,cascade_backfill_table_*, ...) are now emitted
by theeveros.infra.persistence.index.vector_backfilllogger instead of
everos.service.backfill; update log filters that matched the old name.
BackfillDepstakes avectorsbackfill object in place of its
tokenizerandprune_retentionfields. -
The vector width is read from
[embedding] dimonce, by the
application, and nowhere else. The index record classes no longer read
the configuration while they are imported; they mark their embedding
columns (DenseVector) without a width, and each backend builds its tables
at the width the application hands it (schema_for(model, dim=...),
LanceIndexBackend(connection, dim=...),MilvusIndexBackend(connection, dim=...)). The startup error "the index record classes were built for
dim=... but configuration reports dim=..." can no longer occur, and the CLI
no longer pre-scans--rootbefore parsing its arguments. A table built at
another width is still refused at startup, as schema drift. For code that
imports the persistence package:everos.infra.persistence.recordsno
longer exportsLanceModel/Vector,BaseLanceTableis now
IndexRecord(a plain pydantic model with noto_arrow_schema), and the
LanceDB Arrow schema comes from
everos.infra.persistence.lancedb.base.arrow_schema_for. -
On Linux with glibc, the CLI defaults to two malloc arenas to reduce
retained allocator memory. ExplicitMALLOC_ARENA_MAXor
GLIBC_TUNABLES=glibc.malloc.arena_max=...settings take precedence;
importing EverOS as a library does not change the host's allocation policy. -
Agentic search falls back to relevance-ranked hybrid recall of 50
candidates when its first-round cluster expansion exceeds 1,000 episodes.
Smaller expansions keep their existing behavior, and the second round
retains its 40-candidate cap. The guard bounds reranking work for unusually
large groups; it can change recall in that case and does not cap the
initial owner-wide corpus snapshot.
Removed
everos.infra.ome.testingis no longer shipped.StrategyTestHarness
was a test fixture; it now lives in the repository's own test helpers.
Fixed
-
Keep fresh installs on
watchdog>=4.0.2,<7, matching the tested event
semantics. The lower bound includes the macOS fix required for filtered
notifications; watchdog 7.1 can stop recursive Linux notifications under
PYTHONWARNINGS=errorwhen nested directories are created concurrently. -
The filesystem watcher subscribes only to changes it handles, excluding
file-open/close notifications that could overflow Linux's inotify queue
during read-heavy searches and delay markdown indexing. -
A fresh
uv pip install everosnow resolves the parser dependency without
requiring a global prerelease override. The base install pins the same
parser version as the tested algorithm packages and the multimodal extra. -
/addand/flushno longer leave half-written state when a SQLite write
lock times out: boundary detection records the memcells, the session's
status and the remaining buffer in one transaction. Before, a timeout at
the second or third write left memcells that were never extracted, or
buffered messages behind a500the caller could not act on. -
A burst of searches no longer fails with
Too many open files: LanceDB
search queries are capped per process ([lancedb] max_concurrent_queries,
default32; metricseveros_lancedb_query_wait_seconds,
everos_lancedb_queries_in_flight), where one agentic search fanned out to
about 28 queries that each opened every data file of a table. The server
also raises its open-file soft limit to 8192 at start (capped at the hard
limit, never lowered; logged), from Linux's 1024 and macOS's 256. -
Searches that do not request vectors now omit unused vector columns in
the database query, before allocating result buffers or Python objects.
Vector search still uses vectors internally, and requests that explicitly
need vectors retain them. This reduces temporary allocations and work on
the event loop that can delay other requests' SQLite transactions. -
A second server using the same memory root now refuses startup before
opening shared storage or resetting active cascade claims (#545). The
existing exclusive lock stays held through storage shutdown. -
On Windows, reading a memory file no longer fails while another write
replaces it. Anopenthat racesos.replaceof the same file can be
refused for a moment (PermissionError, errno 13). Writes already waited
that out; reads did not, so a deletion could fail with
DeletionIncompleteError(500) and a cascade projection could fail
permanently. Every markdown read now goes through
MarkdownReader.read_text, which retries with the writer's budget
(about 2.5 s). Other platforms are unaffected. -
A cluster's
count, centroid andlast_tsnow include an episode that
joined it while Reflection was merging it
(#563). Reflection
wrote them from the members it read before its LLM call, so the new
member stayed in the cluster but was not counted, and the user-profile
gate, which sumscount, undercounted. -
One empty section no longer fails a daily-log file's whole batch. The
four daily-log handlers send every changed entry's text in one
embed_batchcall, and embedding endpoints reject an empty string inside
the input array — text-embeddings-inference answers
400 Input validation error: inputs cannot be empty. An entry whose
embedded section is blank (anatomic_factscaffold the extractor left
behind before its sentence was written, aforesightwith an empty
Foresight, …) therefore failed the call for the entire file, so its
other entries — already extracted, already on disk — never reached the
index, and the projection failed permanently over content the user never
sees. Blank texts are now left out of the request and written with
vector = None, the same soft-degrade a missing provider produces;
vector_backfillre-embeds the row once the md carries content. -
The agentic episode search reranks on the episode text. Its
cross-encoder readmetadata["episode"], which the bridge to everalgo's
prompt format had already turned into a{"subject", "content"}dict, so
every passage was that dict's Python repr; it now reads the plain body.
method="agentic"scores change accordingly (a fix, not a regression). -
Agent skill clustering failed on the 2026-10-13 everalgo line.
trigger_skill_clusteringawaitedcluster_by_llm, which is now a
blocking bridge that refuses to run inside the event loop, so no case was
clustered and no skill extracted; it now awaitsacluster_by_llm. -
The case→skill bridge matches again. On HYBRID + LLM-rerank agent
searches the bridge looked up skills by the matched cases' index row ids
(<agent_id>_ac_…), while a skill'ssource_case_idsholds the md-side
entry ids (ac_…), so no skill was ever bridged in (#478). The bridge is
now keyed by entry id, andSearchAgentCaseItemexposesentry_idso a
client can join cases to skills the same way. -
The first agent
/addno longer downloads tiktoken's encoding. The
algorithm library counts tokens witho200k_base, which tiktoken fetches
on first use; a fresh deployment paid for that download inside the first
agent write and answered a generic 500 when it failed (#277). The server
now warms the encoding at startup, before any storage is opened, and a
host that cannot load it fails to start withTokenizerAssetErrornaming
the cause and theTIKTOKEN_CACHE_DIRpre-cache option. -
OME crash recovery resumes every run of the previous process. It
used to skip RUNNING rows younger than 30 minutes on the theory that
APScheduler might still own them; it never does (a one-shot job leaves
the jobstore when it is submitted), so a run cut short by a restart
inside that window was lost for good (#540). The engine holds the
jobstore lock before it recovers, so every RUNNING row is a crash:
all of them are marked CRASHED and re-enqueued.
OMEConfig.crash_recovery_timeout_secondsis gone; it was not a
user-facing setting. -
radiusis a pre-fusion cosine floor on every vector route. It was
applied to the dense pool ofvectorandhybridsearches but also
passed into the ranker's input, which never read it, and theagentic
routes ignored it entirely (#394). The dead ranker field is gone and
the agentic dense recalls (cases, skills, episode facts) now apply the
same floor; the API reference states the semantics. -
A file restored with its old mtime is indexed again. When the
cascade worker found an enqueued file gone it folded the row into a
deletion but left it sayingdone / added, so a scan that later saw
the file back with the same mtime took it for indexed (#541). The
worker now records the applied change (deleted), and the reconciler
re-emits a present file whose row saysdeletedwhatever its mtime. -
Background tasks waiting for a partition lock release their OME
execution slot and reclaim it before entering the protected work. A
backlog for one owner therefore no longer consumes every execution slot
while other owners wait. Active run records remain recoverable even when
the bounded completed-run history is full.
Known limitations
- Profile extraction can miss a newly saved conversation if it runs before the
asynchronous episode index catches up. The conversation and extracted memories
remain searchable; a later conversation may refresh the profile. This also
exists in 1.5.1 and is deferred to 1.6.1. - Agent case and skill extraction can overstate an unverified outcome as
successful. One smoke-test trajectory exhibited this with the default
correctness gate disabled. Review generated procedural memories against their
source evidence.
Upgrade
pip install --upgrade everos # or: uv syncOne command, then a restart:
pip install --upgrade everos
# With uv, allow the pinned pre-release algorithm dependencies:
uv pip install --upgrade --prerelease=allow everos('everos[multimodal]' if that extra was installed.) The everalgo packages
are pinned exactly, so they move to the new contract line with it. Pip resolves
these exact pins without --pre; uv needs --prerelease=allow. The first start
after upgrading migrates system.db on its own (see below); Markdown, the index and the OME jobstore are untouched.
Four things a running deployment may have to change by hand; each is also
described under Changed above:
| If you | Then |
|---|---|
set EVEROS_DISABLE_CASCADE, EVEROS_DISABLE_CASCADE_WATCHER, EVEROS_OME_MAX_CONCURRENT_RUNS or EVEROS_OME_RUN_TIMEOUT_SECONDS |
move the values to [cascade] enabled / watcher_enabled and [ome] max_concurrent_runs / run_timeout_seconds in everos.toml; the variables are no longer read, so an unmoved EVEROS_DISABLE_CASCADE silently turns the cascade back on |
run everos cascade … on a root with no [llm] section |
add [llm]; building the application now requires it, and the command exits 3 with the file to edit |
read capabilities.llm from GET /health |
read status or cascade.healthy instead; the field is gone |
| replaced a prompt template through the old prompt slots | move the requirements your template added to config/custom_instructions/<operator>.yaml (details below); the template itself is no longer loaded |
Extraction output changes with the everalgo line: episodes, facts and
profiles are produced by the new prompts, and a profile's language is
frozen from its first extraction after the upgrade. No action is needed;
a different style in new entries is expected, not a fault.
Code that imports everos.service.memorize / search / get or calls
create_app(lifespan_providers=...) must switch to build_application and
the facades.
A deployment that customised a prompt slot must move it: keep only the
requirements the custom template added on top of the default prompt and put
them in config/custom_instructions/<operator>.yaml as instructions:
(the bundled prompt itself can no longer be replaced). Markdown and the
index schema are unchanged. The SQLite memcell table gains three nullable
columns (case_extracted_at, case_skip_reason, case_skip_detail_json);
the first start after upgrading adds them to an existing system.db on its
own (logged as sqlite_column_added), so there is nothing to run by hand.
This release pins the everalgo packages to one contract line, six of them
release candidates: everalgo-core 0.6.0, everalgo-boundary 0.4.1,
everalgo-user-memory 0.9.0rc4, everalgo-agent-memory 0.6.0rc3,
everalgo-rank 0.5.0rc3, everalgo-knowledge 0.3.0rc2,
everalgo-clustering 0.3.0rc2 and everalgo-parser 0.3.0rc2 (also required
by knowledge ingestion in a base installation). The pins are exact (==), so pip install everos resolves them without any pre-release flag; upgrade them together,
never one at a time.
Full changelog: v1.5.1...v1.6.0