v0.17.0

v0.17.0

Reviews come in layers now, and every layer knows who wrote it.

New & Noteworthy

Stacked proposals. One ever-growing pull request is where reviews go to
die, so sharing while a proposal is open now opens a new proposal stacked on
top of it instead of folding more work in. Every unit of knowledge gets its
own focused review; reviewers merge bottom-up, and merging the top lands the
whole chain in one click. Review feedback? Amend exactly the layer it belongs
to (--proposal <n> on the CLI, proposal on share_changes) and every
layer above re-bases itself. Withdrawing a middle layer repairs the chain,
and a chain wedged by a declined layer heals on the next share. On forges
without stacked pull requests, or with github.stacks off, the single
living proposal keeps working as before.

Personal share identities. An approval means little when everything ships
under one shared credential. Set github.share_identity to personal and
every share, amend and withdrawal goes out as the person doing it - their
name on the proposal, so nobody reviews their own work by accident. Connect
once in Fluid's profile card or with crystalline connect github --personal,
on the surface you share from. No connection means a refusal that says
exactly how to connect - there is no quiet fallback to somebody else's
credential, ever. Agents over HTTP share as the bot github.agent_identity
names. One requirement rides along: sharers need write access to the team
repository, because proposals are branches, never forks. The default
instance mode is unchanged, byte for byte.

File-scoped shares. A session that touched five unrelated things no
longer has to propose all five at once. Narrow a share to chosen files with
files on share_changes, repeatable --file on origin share, or
per-file checkboxes in Fluid - each chosen file's folder listing rides along
so the repository stays browsable, and everything left out simply waits for
a later share. On shared instances, Fluid preselects the files you wrote
(by recorded authorship - a correctable guess, never a rule) and the share
button counts what is yours: "2 of 5 unshared changes are yours".

Share nudges. Unshared changes are a scream in space: the team never
hears them. After a week, the evolve sweep says so (a judgment-class
finding - it proposes, a person decides), and the session-end reminder gains
a share line beside capture and evolve.

Smaller but handy. Proposals record their author in both modes, and the
stack rail and origin status show who owns each layer. users remove
sweeps the departing person's credential, and a CLI --disconnect now tells
a running daemon to drop the cached credential immediately.

Fixes

• A domain could get stuck answering "pull this domain first" to every share
  after upstream history was rewritten: pulls now consume merged proposals
  on every path, not just some.
• Starting a GitHub sign-in while another was still pending silently joined
  the running one; it now answers "another sign-in is in progress".
• Refusing to share used to look like a server error (HTTP 500, a raw
  INTERNAL over MCP). Refusals now teach: 422 / invalid_params with text
  naming the fix.

Breaking changes

None. state.json gains an optional author field per proposal; old records
load unchanged, no migration. One behavior change worth naming: in personal
mode the sync routes accept editors as well as admins - instance mode stays
admin-only exactly as before.

Upgrade notes

• Personal mode is opt-in. Before flipping it: every sharer needs
  collaborator access to the team repository, each person connects once on
  the surface they share from, and HTTP agents need github.agent_identity
  pointing at a connected bot account. Until then those writes refuse with
  teaching text, by design.
• A pre-0.17.0 state.json holding several open proposals keeps updating
  the oldest until the others resolve on the forge; stacking begins with the
  first share after that.

v0.16.0

New & Noteworthy

• Living proposals. Sharing a team domain twice no longer opens a duplicate pull request. While a proposal is open, share_changes updates it in place - same number, same review URL, a fresh commit reviewers are notified about, and a merge commit when the team's branch moved in between. Declined proposals are superseded automatically on the next share.
• The review loop closes. update_domain now returns each open proposal's review state and the reviewers' comments verbatim; origin_status shows the standing at a glance (approved / changes requested, an amended-branch flag, feedback counts) with one live check against GitHub. Read the feedback, refine the engrams, share again into the same proposal.
• Withdraw a proposal. The new withdraw_proposal tool (and crystalline origin withdraw) closes the pull request on GitHub, clears the record, and optionally restores the shared files - files edited since sharing are never touched. It replaces the offline-only origin discard.
• Collaboration tools appear when you enable them. With github.enabled off the five collaboration tools stay out of the MCP tool list entirely; turning it on - through the configure tool, the CLI, or Fluid's Connect button - adds them live, with a list-changed notification to subscribed clients.
• Guided sharing and conflict resolution. On clients that support interactive tool rounds, share_changes previews exactly what would go out (update or new proposal, title, changed files) and asks first, and resolve_conflict called without a resolution shows both sides and offers keep-mine or take-theirs.
• The whole loop in the browser. Fluid gains a proposals card (review standing, expandable feedback, withdraw with an optional file-restore), a share dialog with a change preview and editable title, and a conflict dialog showing both sides with keep mine, take theirs, or a hand-merged result.

Fixes

• An interrupted share update (branch moved, process died before the record caught up) no longer wedges the proposal as falsely "reviewer-amended" - the next share heals it.
• Share branch names carry a random suffix, so two shares in the same second cannot collide.
• Review feedback fetching pages past GitHub's first 100 items, so the newest comments are never the ones dropped.
• Files applied by a share's freshness pull (including the share preview) are indexed immediately instead of waiting for the next poll.
• Merged-elsewhere and declined-elsewhere proposals are detected by origin_status without waiting for a pull, and consumed cleanly by the next one.
• The share preview, share, withdraw, and conflict REST routes gate consistently (read-only, team-domain, and connection checks), and resolving a conflict refreshes the domain tree and listings.

Breaking changes

• crystalline origin discard is gone; use crystalline origin withdraw <domain> [--proposal <n>] [--revert]. Withdraw closes the pull request on GitHub (discard never did) and keeps your local files unless --revert is passed.
• With github.enabled off, the five collaboration tools no longer appear in the MCP tool list (previously they were listed and refused at call time). A client holding a stale list still gets the explanatory refusal when calling.
• On-disk origin state gains additive fields (head_commit, base_commit, pending_head_commit, review_state, feedback, updated_at on proposal records); existing state.json files load unchanged. A pre-0.16.0 state holding several open proposals updates the oldest one until the others resolve on the forge.

v0.15.1

New & Noteworthy

• Confirmation rounds for destructive actions (MCP 2026-07-28). On clients that support interactive tool rounds (MRTR), delete_engram now previews exactly what a delete removes - references that will dangle, attachments left orphaned - and asks before acting. Acknowledging or un-acknowledging an evolve finding confirms the same way, and write_engram onto an existing permalink offers an overwrite-or-cancel choice instead of failing. Clients without the capability keep the exact single-round behavior they had.
• Un-acknowledge an evolve finding. set_frontmatter evolve_ack accepts remove <rule-id> to take an acknowledgment back, with the same write guards as recording one.
• Search hits carry addresses. Every search_engrams hit now includes its crystalline://domain/permalink resource link, so a follow-up read_engram or build_context needs no reconstruction.
• Vocabulary knows types and statuses. The vocabulary endpoint, crystalline vocabulary, and Fluid's suggestions now aggregate type and status values in use alongside tags and categories.
• Fluid sync card tells you when GitHub is disconnected, and Maintenance disclosures lead with a per-rule summary line.

Fixes

• Cross-domain moves read the source file strictly and report attachment carry problems as warnings in the move result instead of silently dropping content.
• Percent-encoded attachment references decode identically in the sweep and in Fluid (shared 16-case corpus test).
• Attachment renames that exhaust the collision suffix surface a warning instead of failing the move.
• A committed write is never reported as failed by its receipt decoration: permalink lookups on move, save, and restore tolerate store errors.
• POST /api/v1/domains/{domain}/sync answers 409 when GitHub collaboration is off or unconnected; the GET degrades gracefully with mode and a per-domain connection block.
• The delete preview never claims more than the delete does, and stays cheap on large domains (attachment enumeration bounded at 500 engrams).
• Maintenance's instruction panels keep valid aria-controls targets; the create-engram dialog fetches the vocabulary once instead of twice.

Breaking changes

• None. On-disk formats, the REST surface, and legacy MCP behavior are unchanged; new response fields are additive.

v0.15.0

New & Noteworthy

Engrams carry attachments now. Paste a screenshot, drop a slide deck,
attach the file an engram teaches from - straight into the Fluid editor,
which uploads it under the domain's assets/ folder and writes the
reference at your cursor. Images render inline in the reading view (and in
the editor while you type); documents open or download with one click. A
strict allowlist, a size cap and hard path validation gate every byte, and
both storage kinds carry them: files on disk for file domains, the
database for virtual ones. The zip archive now packs attachments too, in
both directions, so a backup is finally the whole domain - and moving an
engram to another domain brings its files along, copying instead of moving
whenever something else still references them.

Agents read what you attach. Reading an engram over MCP returns a
resource link for every attachment it references - name, type and size,
no bytes until they are wanted - and the attachment itself is one
resources/read away, as text for text formats and as the file for
everything else. Uploading stays a human act for now; the agent's side is
reading, verifying and capturing.

Evolve tends the files, not just the words. Four new maintenance
rules close the loop: an attached file nobody analyzed yet asks to be
captured as knowledge; a file that changed after its analysis asks for a
re-read; a reference whose file is gone gets flagged; and a file no engram
references or claims is named for what it is - an orphan that should not
exist - with deletion one confirmed click away in Fluid, or one consented
delete_engram call away for an agent. The invariant behind all four:
an attachment always belongs to an engram's teaching.

Acknowledge the findings you mean to keep. Some findings are
deliberate - a lineage link to retired knowledge, a decorative image that
needs no analysis. Acknowledging one silences it for exactly as long as
its evidence holds: the sweep counts what it suppressed instead of hiding
it, a toggle shows the quiet ones with their notes, and when the evidence
changes the finding returns marked as such, asking to be re-acknowledged
rather than resurfacing as noise. Agents acknowledge through
edit_engram after your yes; the frontmatter carries who, when, why and
what exactly was acknowledged.

Images take direction. A small fragment on an image reference -
#left, #right, #center, #full, w=40% - floats, centers or sizes
it in Fluid, chosen from a toolbar menu that rewrites the reference in
place. Plain markdown viewers simply ignore the fragment, so an engram
stays portable to the byte.

Reads got cheaper. Engram, manifest and attachment reads answer
conditional requests: a strong validator on every response, one cheap 304
when nothing changed, and browsers told to revalidate instead of guessing
at freshness.

Fixes

• Refreshing provenance or a review date on a hand-written engram whose
  frontmatter uses block-form mappings no longer corrupts the file
• An acknowledgment note with newlines or control characters can no
  longer produce an engram that fails to parse; frontmatter writes now
  refuse to persist anything unparseable
• The engram write path refuses folders that would shadow the reserved
  assets space, closing a traversal that could place files above the
  domain root

Breaking changes

None. Attachments are a new capability; every existing domain, engram and
workflow behaves as before until a file is attached.

v0.14.0

New & Noteworthy

The agent tends what you write in Fluid. Knowledge you capture yourself no
longer sits unreviewed until someone stumbles over it. A new maintenance rule
(V006, "human capture never reviewed") picks up every engram a person wrote
directly - through the Fluid editor, a co-editing session or a create in the
browser - that is still current, still carries no verification and was recorded
before today, and puts it in the agent's work queue. Its instruction is
explicit about the division of labour: read it and verify the claim, align the
tags with the vocabulary in use, wire the relations both ways into the
neighbourhood it belongs to, then record a verified entry - and propose any
wording change and wait for a yes, because the words are yours. Every finding
of that kind is judgment class, so an agent asks before it acts.

Human authorship outranks the rest of the queue. It is not only the new
rule: any finding at all on a human-authored engram gets a priority boost, so
when a stale date and a half-finished retirement compete for attention, what a
person taught is worked first. The queue is still ranked, still read-only and
still returns the evidence and the exact next action for every item.

A maintenance ask that rides along with the session-end nudge. The capture
reminder your harness already runs at the end of a session can now carry a
second ask: call evolve_engrams and work the queue. It arms on either of two
counts - a week since the last sweep, or any domain a person has written to
since that sweep - and it names those domains so the agent scopes the sweep
instead of boiling the ocean. Whichever arm raises it, an ask goes out once a
day at most, and a sweep clears the domains it covered and restarts the weekly
clock. The weekly check stays quiet for a fresh install's first week; a pending
human write can still ask sooner, because a write is evidence there is
something to consolidate and a calendar is not.

A maintenance page in Fluid. Fluid gained a Maintenance entry in the top
bar: the same ranked queue the agent works, grouped by family, with priority
badges, mechanical and judgment chips, the per-rule instruction expandable
behind each finding, a domain filter and a refresh. It is read-only in both
directions - it changes nothing, and looking at the queue never counts as a
maintenance run, so opening the page does not silence the agent's ask. It is
served by a new read-only GET /api/v1/evolve endpoint.

"Captured by" in the details rail. Every engram page now shows who wrote
it, rendered for what the actor actually is: a person, an agent or a process.
Provenance stopped being frontmatter you had to go looking for.

Search that scales past a few hundred tags. The tag facet no longer renders
the whole vocabulary as a wall of chips: your selected tags stay visible, the
commonest fill the rail up to a cap, and a filter box searches the rest - with
a count of what it is holding back. Result rows lead with the matched text
instead of their tags (which now cap at two plus an overflow count), matched
terms are highlighted in titles too, and cross-domain searches say which domain
each hit lives in.

Table icons that name their verb. Delete row and delete column stopped
sharing one trash can: each now draws three tracks with the doomed one crossed
out. The column alignment menu got the same treatment - the alignment lines
sit inside a column frame, and the menu's trigger stopped impersonating "align
center".

Fixes

Nothing separate this time - everything in this release is new.

Breaking changes

None in this release.

v0.13.0

New & Noteworthy

Fluid, the web UI. Crystalline now has a face for people. The primary author of engrams stays the agent; Fluid is how you take part directly, without going through the LLM or spending a token on it. Everything an agent captures is a page you can read: frontmatter as a details rail, observations and relations as labelled chips, backlinks, an interactive graph of any engram's neighborhood, and an agent's-eye view showing exactly what the tools serve an agent for that page. Edit in place with a live-preview markdown editor (table editing, a frontmatter form, mermaid previews, wikilink completion across every domain), and collaborate in real time: everyone in the same engram sees everyone else's cursors and edits live, and changes merge conflict-free. Faceted search runs on the same hybrid ranking the agents use. Fluid is built into the binary and on by default at http://localhost:7411: the daemon your agents already talk to serves people and agents on one port, and the first visit creates your admin account in the browser. Accounts come in admin, editor and viewer roles (managed in the UI or with the new crystalline users command), with an anonymous read-only mode for published archives and a trusted-header mode for SSO proxies. A compose variant with nginx in front covers team servers; see docs/deployment.md.

The 2026-07-28 MCP protocol revision, served first class. The server now speaks every protocol revision its framework implements, from 2024-11-05 through 2026-07-28, and negotiates per client. On the newest era: onboarding instructions arrive through server/discover, list-change notifications flow through subscriptions/listen streams, list responses carry cache hints, and the tool list is identical for every client, with optional features refusing at call time with a clear message instead of hiding. The skills surface is resolved per harness via --harness on crystalline mcp plus the install receipt. Streamable HTTP bounds request bodies at 10 MiB, matching the REST API.

Fixes

• Domain names that are hostile on Windows (reserved device names, trailing dots and spaces, and lookalike superscript digits) are refused at creation.
• configure only touches the system keychain once GitHub collaboration is actually enabled.
• Importing an archive into an unregistered domain answers 404 before any decompression work happens.
• Path filters compare case-insensitively on both database backends.
• crystalline users on Windows now explains that a running daemon holds the auth database (and the two ways out) instead of surfacing a raw file-lock error; managing accounts while the daemon runs stays available through the web UI.
• Wide mermaid diagrams scroll inside their own frame instead of widening the page.

Breaking changes

• The daemon serves HTTP (the web UI and the JSON API) on 127.0.0.1:7411 by default. Use --http / the serve.http setting to move or disable it.
• The MCP tool list no longer varies by install receipt: every client sees the same tools, and gated features refuse at call time. Harness-specific tailoring of the skills surface moved to crystalline mcp --harness.
• Unsolicited tools/list_changed pushes are gone; modern clients subscribe through subscriptions/listen, and clients on older protocol revisions are unaffected.

v0.12.0

New & Noteworthy

Ask the archive what it needs. verify checks the format. doctor checks the index and the service. Neither one ever asked the question that actually matters, which is whether the knowledge is still true. That is evolve, the third pillar, arriving as the evolve_engrams tool and the crystalline evolve command.

It sweeps one domain or all of them and hands back a ranked queue. Fourteen detectors across three families: temporal and lifecycle debt (a valid_to that quietly elapsed while the status still reads current, a stale_after long past due, a replacement that landed while the retirement was never finished, a retired engram that live knowledge still leans on), structural gaps (unresolved links, one-sided relation pairs, orphans, engrams past the split budget, stubs) and redundancy (near-duplicate clusters, drifted tags).

Every finding carries its evidence and the exact next action. Findings marked mechanical finish something the archive already decided, so an agent can just do them. Findings marked judgment change what the archive claims, so they wait for your yes. The sweep is read-only throughout, which is a polite way of saying it will tell you the ship needs work and then hand you the wrench.

It also knows what it does not know. It reads dates, links and graph shape, never meaning. It will find you a retirement somebody left half finished. It will never tell you which of two engrams is right, and it says so out loud rather than guessing.

Retiring an engram is a field assignment again. edit_engram gains a set_frontmatter operation for one lifecycle field at a time: status, valid_from, valid_to, stale_after, source_date, salience or verified. Flipping a status used to mean a text substitution against a raw frontmatter line, which first had to guess whether the file said stable or the older current. Now it lands either way. Omit the value to clear a field. Omit it on verified and it stamps who you are and when.

Fixes

Two backends, two answers. In The Matrix a déjà vu meant somebody had quietly changed something. Here it meant Postgres sorted text by locale while the embedded backend sorted by raw bytes, so nine queries returned the same rows in a different order depending on which backend you were running. Cosmetic, until you remember that several of those queries cap their output. read_engram shows at most five inbound references, so two installations could show two different fives and both be working as designed. The sort keys now agree, and a guard test reads the backend sources so the next query cannot reintroduce it while nobody is looking.

Tag drift stops recommending vandalism. The clusterer used to treat any two tags one character apart as the same idea. That is how it concluded preference and reference were the same word and offered to merge them for you, across six engrams, with total confidence. It thought audio and audit were siblings too. That rule is gone. Separator folding got better in the same pass, so e-bike and ebike still cluster, because those genuinely are the same thing.

Tag counts now see observation tags. A tag carried only by observations counted as zero uses. That read as broken, and it quietly decided which spelling a cluster treated as canonical, so the crystalline tags merge command it handed you could point at the wrong survivor.

Dependencies refreshed. Thirteen crates to current stable, including a FuturesUnordered memory leak and restored Windows time symbol linkage.

Breaking changes

None. vocabulary and doctor will report fewer tag clusters than before. That is the false positives leaving, not a change of contract.

v0.11.2

"These aren't the releases you're looking for." - Obi-Wan Kenobi, waving a hand at 0.11.0 and 0.11.1. Move along; 0.11.2 is the 0.11 release and always has been.

New & Noteworthy

• Open Knowledge Format v0.2. Crystalline now produces conformant OKF v0.2 bundles end to end. Every folder of a file domain carries an auto-managed index.md (OKF §8 shape, okf_version: "0.2" declared at the bundle root), so a domain can be browsed statically - in an editor or on a git forge - without Crystalline running. The reserved names index.md and log.md are excluded from sync, search and verify, and the new index.files setting (default on) controls generation.
• Write provenance. New engrams record generated: { by, at } - who wrote them and when, in the OKF actor convention. The actor comes from the new identity.actor setting (env CRYSTALLINE_IDENTITY_ACTOR, also settable via crystalline config set and the MCP configure tool), falling back to the connected MCP client's own name and version. Legacy timestamp files are read forever and migrate lazily on their next edit.
• Trust and lifecycle fields. verified: { by, at } (a verification trail with actors) and stale_after are the canonical spellings; the legacy last_verified and review_after keys are read forever as aliases. stable is the canonical status wording and write default - current remains a first-class alias, and search treats the two as one equivalence class in both directions, so existing domains and foreign OKF bundles are equally visible.
• A wedged daemon can no longer lock you out. When a daemon holds the index lock but stops answering its socket, the next connecting client diagnoses it with a bounded probe, verifies the recorded process really is a crystalline binary and replaces it automatically. crystalline status reports the state honestly ("daemon unresponsive" instead of "not running") and crystalline doctor --fix performs the same dislodge on demand. A responsive daemon is never touched and an unidentifiable lock holder is never signalled.
• No more double onboarding for installed harnesses. A harness wired up by crystalline install already receives the routing block through its session hook and carries the skills as files - so the server detects that per connection (via the install receipt and the client's own handshake identity) and serves it a minimal instructions pointer instead of the full block. Remote clients, unknown clients and hookless installs keep the full surface. Saves roughly 330-485 tokens every session; the skills.serve setting becomes auto | true | false (default auto).
• Remote client onboarding. The five skills are served over MCP - as a gated tool, as skill:// resources and as prompts - behind the skills.serve setting, so remote harnesses without a CLI can onboard themselves. list_domains with include_routing=true returns the full onboarding index and crystalline prompt connector prints a paste-ready custom-instructions snippet for clients that show the model neither instructions nor prompts.
• Ready for tool search. The MCP initialize instructions fit Claude Code's tool-search budget: the behavior rules always survive truncation and large domain registries degrade deterministically to a compact index that is one list_domains call away. The README documents the recommended defer_loading connector configuration for Messages API users.
• Smarter knowledge curation. The skills teach contradiction hunting while reading, retirement without replacement and splitting large captures into a distilled summary plus a full type: source document under sources/, linked both ways - so most recalls stay lean while verbatim material remains available.

Fixes

• Semantic and hybrid search no longer spill enormous scratch files: the candidate query sorted every engram body once per chunk of that same engram, which on a corpus with very large engrams could write tens of GB of temp data per search and drive the daemon out of memory. The rewritten two-phase query spills nothing, holds a few MB of memory and is measurably faster; database scratch files now live in a crystalline-owned directory under the state dir, and the daemon sweeps stale ones at startup.
• A single blank-line-free markdown file could drive memory into the tens of gigabytes during embedding and permanently wedge the embedding backlog. Oversized paragraphs are now split at chunking time, the tokenizer input is capped (heals already-stored giant chunks on upgrade, no resync needed), the embed backlog is paginated and a rejected batch is skipped instead of aborting the pass.
• Full sync processes changed files in bounded slabs, lexical search caps its candidate set, the file watcher channel is bounded with overflow escalating to a full rescan and two small bookkeeping leaks are gone - memory stays proportional to the work rather than the corpus.
• crystalline doctor runs its service diagnosis before opening the index, so --fix works exactly when a wedged daemon is what holds the index lock.
• infer_schema no longer suggests engine-owned provenance keys that writes would ignore.

Breaking changes

• New engrams write generated: { by, at } instead of timestamp and default to status: stable instead of current. Existing files are never rewritten: all legacy keys and the current status stay readable forever, search folds stable and current into one class and no resync or migration is needed on upgrade.
• Generated index.md files appear in every knowledge-holding folder of file domains on the first write or sync after upgrade. Set index.files to false to opt out; the files are ignored by sync and search either way.

v0.10.1

New & Noteworthy

• Context comes back ranked. build_context no longer truncates the neighbourhood at the oldest rows: related engrams are ranked by how strongly they connect to the anchor, spreading activation through the relation and link graph the way recall follows associations, and max_related keeps the most relevant. Salient engrams rank higher on the way; seeds always come back complete.
• The learning loop closes at session end. The Stop hook's capture nudge now also asks the agent to raise the salience of a recalled engram that proved to be the key to the task, so knowledge that keeps paying off surfaces first in future sessions. Same once-per-session contract, about 120 tokens.
• Retired knowledge fades, it never disappears. An engram whose status is deprecated, superseded, archived or legacy now ranks below equally relevant current knowledge in every scored search mode and in context ranking - softly faded by the new search.retired_weight setting (0.0 to 1.0, default 0.6, 1.0 disables), also settable as CRYSTALLINE_SEARCH_RETIRED_WEIGHT. Nothing is ever filtered out by it: a superseded engram still answers "how did we do this before". The write surfaces teach the recognized retirement vocabulary, so agents pick a status the fade understands.

Fixes

• The Streamable HTTP transport no longer prepends an SSE priming event (retry: 3000) to POST responses. Strict intermediary parsers such as AWS Bedrock AgentCore Gateway rejected that optional field and failed every tool call; responses now open directly with the JSON-RPC message, the same minimal shape the Python MCP SDK emits. The deprecated 2024-11-05 HTTP+SSE transport was never served and now says so in the deployment docs; legacy clients get an immediate 400 naming the missing session

Breaking changes

• Default ranking changes for knowledge bases that hold retired engrams: they now rank below current ones instead of tying. Restore the old behavior with crystalline config set search.retired_weight 1.0
• build_context returns related engrams in relevance order instead of the previous undocumented storage order; integrations that relied on that order should rely on the ranking instead

v0.10.0

New & Noteworthy

• Salience: mark the memories that matter most. An engram can now carry a numeric salience key (0 to 10) in its metadata, the way a memory formed during an exceptional event encodes more strongly. Hybrid search gives salient engrams a small bounded lift, so they rank above equally relevant unmarked ones while relevance keeps the upper hand - the lift reorders results and never filters one out. An agent raises an engram's salience later when it proves to be the key to a task, so the knowledge that keeps paying off surfaces first. Tune the lift with the new search.salience_weight setting (0.0 to 1.0, default 0.15, 0 disables it), also settable as CRYSTALLINE_SEARCH_SALIENCE_WEIGHT.
• Agents learn the convention on their own. The tool descriptions, the routing block and the capture and memory skills all teach when to set salience and when to raise it; installed skills refresh themselves the first time this version runs.

Fixes

• Team-domain merges no longer garble conflict markers when a conflicting hunk sits at the end of a file without a trailing newline (diffy 0.5.1); tokio 1.53.1 is also picked up

Breaking changes

• None