## Summary
Reported as "deliver_files is broken". It is not: **the tool never ran.**
Every `deliver_files` call on one install was refused before dispatch -- five in a row in a single session -- and nothing was ever delivered:
```
Error: Invalid parameters for tool 'deliver_files': files should be array
```
What the model sent was the array, spelled as a string:
```json
{"files": "[{\"path\": \"...poster.png\", \"title\": \"...\"}]", "message": "..."}
```
`cast_params` already forgives that spelling for every scalar type -- `"3"` for an integer, `"true"` for a boolean -- and did not for arrays or objects, which are exactly the types a model is most likely to stringify.
## Type
- [x] Fix
- [ ] Feature
## The edge of the forgiving is the design
When the value is a string, try `json.loads`, and take the result **only if it is the type the schema asked for**. A string that is not JSON, or is JSON of the wrong shape, is returned unchanged so the validator still names the real problem -- the point is to widen what is accepted, not to swallow a type error.
**Nothing here can raise.** Turning "your argument has the wrong type" into a traceback would be worse than the refusal it replaces, so the parse is wrapped and failure falls through.
**A `type: "string"` field is never parsed.** JSON is ordinary text in a message body or a file's content, and replacing it would hand the tool something it never asked for. Two independent things prevent it today (the string branch returns before the parse is reached, and the parse only wins on a type match), which is why the case pinning it is a tripwire rather than a load-bearing assertion -- said so in its own docstring rather than left to look like coverage.
## Not just deliver_files
Six built-in tools declare an array or object parameter and were all exposed:
| tool | parameter |
|---|---|
| `deliver_files` | `files` |
| `ask_user` | `questions` |
| `image_generate` | `images` |
| `message` | `media` |
| `create_playbook` | `skills` |
| `video_generate` | `params` |
The same failure was already seen from the other side: `acp_client/acp_agent.py` records `update_task_state` and `operations should be array` from a real dispatch.
## Verification
```
make lint-python ruff check + ruff format --check, 1850 files
make lint-imports 9 contracts kept, 0 broken
pytest tests/ 19,699 passed, 7 failed (all pre-existing, see below)
```
- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [ ] User-facing docs or screenshots -- no user-facing string
**End to end, through the real tool**, with the exact payload that failed five times in production:
```
files sent as: str -> [{"path": ".../poster.png", "title": "..."}]
returned: Delivered 1 file(s): poster.png (72 B).
still "should be array": False
registered in the store: True
```
Twelve cases, five mutations, each killing at least one:
| mutation | red |
|---|---|
| drop the whole branch (the old behaviour) | 3 |
| raise instead of falling through on a parse failure | 5 |
| accept the parse whatever type it yielded | 1 |
| do not re-cast the parsed value, so items are not cast | 1 |
| widen the tuple to include `string` | **survived -- unreachable** |
The last is worth stating rather than hiding: that mutation cannot change behaviour, because the `type == "string"` branch returns earlier and the type check would refuse the result anyway. I also tried moving the new block above that branch, alone and combined with widening the tuple, and neither reddens anything either. The invariant holds by construction; the case that documents it says so.
**Pre-existing failures, checked against the base.** 7 failed in the full run, all in `tests/test_security_network.py` (`test_a_redirect_to_a_dangerous_address_is_refused` and siblings). Running that file alone on this same tree gives 4 -- the count is order-dependent -- and the change touches only `raven/agent/tools/params.py` plus a new test file, neither of which `raven/security/network.py` imports. The failures are the box's resolver: it returns poisoned answers roughly half the time, which I measured separately (`en.wikipedia.org` came back as `2001::1` on 3 of 6 lookups). Not introduced here, and worth someone's attention on its own.
## Risk
- [x] Security impact considered -- widens what reaches a tool's own validation, not what bypasses it. A parsed value is still validated against the same schema, and a parse that yields the wrong type is refused exactly as before
- [x] Backward compatibility considered -- a call that worked before takes the identical path; the new branch is reached only by a `str` where an array or object is declared, which previously always failed
- [x] Rollback path is clear -- single-commit revert
## Related Issues
N/A
## Swept
`mr-review-patterns` pre-submit sweep, over `git diff origin/main...HEAD`.
- **1 (a write location moved)** -- nothing moved; a branch was added to an existing dispatch on `target_type`. Grepped every caller of `cast_params`: the registry is the only one, and it runs `validate_params` right after, which is the reader this affects.
- **2 (a value with several entry points)** -- the cast is the single funnel every tool argument passes through, which is why the fix belongs here and not in `deliver_files`.
- **3 (a guard)** -- checked both directions: what it wrongly lets through (JSON of the wrong type, non-JSON text -- both refused, with cases) and what it wrongly refuses (a real list, unaffected, with a case).
- **4 (tests)** -- five mutations above, one honestly reported as unreachable. Failing-ID sets diffed against the base rather than counts.
- **6 (stale text)** -- the module docstring enumerated what is coerced ("a string that should be an integer"); it now names arrays and objects too. Grepped the tracked tree for other statements of the rule: none.
- **9 (error handling)** -- the new path adds one way to end and it is caught: `json.loads` raises `ValueError` on bad text and `TypeError` on a non-string, and both fall through to the untouched value.
- **11** -- `git ls-files | grep -c node_modules` is 0; the commit-message gate was run, not eyeballed.
Not applicable, with reasons: **3b, 3c, 3d, 3e** (no tool schema produced, no state moved, one lane, no assertion lost its symbol); **4b, 4c, 4d** (no platform branch, no shell, no rendered number); **5, 5b** (no dependency; `json` is stdlib and already imported across this package); **6b, 6c** (no backup, no generated artifact); **7, 7b** (nothing on disk); **8** (no asset, no secret); **10** (no prompt text).
## Deliberately not fixed
The error text still ends with `[Analyze the error above and try a different approach.]`, and the model plainly did not -- it sent the same shape five times. A message naming the expected spelling (`files must be a JSON array, not a string containing one`) would give it something to act on. That is a change to the registry's error surface, affects every tool, and deserves its own argument.
## Moved from !594
Opened on a compliant source branch. AGENTS.md 2.1 asks for a 3-5 word snake_case description and the previous branch had seven; GitLab cannot change an existing merge request's source branch, so the change moves rather than the name.
Same commits, rebased onto `c2a9768f`. Both code findings from the review on !594 are already in them -- `RecursionError` caught with its regression case, and the implementation comment reduced to the two non-obvious reasons. Nothing else changed, so that review carries.
## Summary
Overhaul the interactive `raven trajectory` browser end to end, fixing
every
issue from real-terminal testing:
- Navigation: every screen opens with a help area under its title (page
purpose plus "[Key] function" hotkey hints, rendered in a new readable
help color). Esc walks one level up (action -> attempt -> session); on
the
top-level session screen Esc stays put and quitting is Ctrl+C only,
which
prints a single exit notice. Esc inside a running action cancels just
that
action through a dedicated exception at the action boundary, so the back
sentinel can never reach a conversion or the data layer; a cancelled
report keeps its pre-confirm bundle-and-pin side effects (the existing
declined-report contract). Back/Exit menu entries are gone; answered
prompts erase themselves and navigation is echoed as breadcrumb lines
with markup-escaped untrusted text.
- Tables: the session list is TITLE | ATTEMPTS | LAST ACTIVITY and the
attempt list is # | STARTED | TURNS | SPANS | VERDICT | PIN | MERGED |
PREVIEW with green check cells. Time cells keep the year. The layout is
budgeted per screen build from the live terminal width (row indent, a
safety margin, and inter-column gaps are all part of the math); PREVIEW
drops as a whole column when it no longer fits, and below the dynamic
minimum width the tightest layout is kept while the renderer clips
overlong lines at the terminal edge. Every dynamic cell passes a
single-line sanitization gate before width math (verdict sidecars only
guarantee a non-empty string), cells are measured and truncated by
terminal display width (CJK is 2 cells), and fixed column widths always
fit their headers.
- Space preview: Space on an attempt row prints that attempt's per-turn
input/output previews, collected in the same snapshot scan and sorted by
a fully-stringified key so ordering never follows log source order (the
table PREVIEW cell derives from the same sorted collection). Any key,
arrow keys included, returns with the cursor kept on the row; the waiter
passes the terminal's CPR reply through to the renderer instead of
treating it as a keypress, and Ctrl+C keeps the browser-wide cancel.
- Merge hotkey: with two or more attempts, m/M opens the multi-select
merge
(advertised in the help line; the old "Merge attempts" menu entry is
gone). The checkbox screen carries its own help line for toggle,
confirm,
and cancel. A single attempt neither binds nor advertises the key.
- Theme and feel: new success (green check) and help (readable hint
text)
colors in both palettes, all WCAG AA on their backgrounds; a lone ESC is
flushed after 50ms instead of prompt_toolkit's 0.5s default, removing
the
laggy Esc feel.
The data layer is untouched: changes are confined to
raven/cli/trajectory_browse.py, raven/cli/_theme.py, and their tests.
The
id-taking subcommands (raven trajectory save/list/...) behave as before.
## Type
- [x] Fix
- [ ] Feature
- [ ] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other
## Verification
- `COLORTERM=truecolor uv run pytest tests/test_cli_theme.py
tests/test_cli_trajectory_browse.py
tests/test_cli_trajectory_commands.py -q` -> 220 passed
- `COLORTERM=truecolor uv run pytest tests/ --ignore=tests/integration
-q` -> 6917 passed; the 10 failed + 20 errors are the pre-existing
environment-dependent set, identical file-by-file on a clean main
checkout (cron, everos server, config loader, tracing viewer)
- `uv run ruff check` and `uv run ruff format --check` on the four
touched files -> clean
- PTY smoke on a CPR-answering pseudo terminal at 100 and 58 columns:
full flow (preview, merge cancel, action screen, staged Esc backout,
Ctrl+C quit) and the narrow-width degradation contract
- New coverage includes real pipe-input key-binding tests (Esc on all
four prompt kinds, Space/m/M hits, waiter key paths with CPR
pass-through), table budget/clipping boundaries at the computed minimum
width, and corrupt verdict/timestamp corpora
- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed
## Risk
- The interactive browser's look and key protocol change wholesale (that
is
the point of this PR): Esc no longer quits from the top level (Ctrl+C
does), Back/Exit entries are gone, and lists render as tables. The
machine-facing subcommands and the trajectory data layer are untouched.
- Rollback: revert the squash commit; the browser returns to the
previous
interaction wholesale, no data migration involved.
- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes
## Related Issues
N/A
---------
Co-authored-by: 江国庆 <guoqingjiang@deepglint.com>
Co-authored-by: Claude (claude-fable-5) <noreply@anthropic.com>
## What
Adds a `RAVEN_WHEEL_SLIM=1` build switch to `hatch_build.py`: when set, the wheel build skips the vendored sub-agent tree and the prebuilt TUI/web bundle inclusion. Default builds are byte-identical to before.
## Why
The release wheel is ~106 MiB compressed; ~94% is the `subagents/` snapshots (raven-ppt alone carries 74 MiB of `.pptx` templates and fonts) plus UI bundles. A cloud provisioner that only ever runs `raven acp` inside a sandbox uploads all of that per instance for assets nothing there opens. The slim wheel is ~3.0 MiB with the full python package intact, cutting sandbox provisioning upload from 15-23s to under a second.
## Behavior on slim installs
- Sub-agents: absent by design; onboarding step 5 reports no tree (headless installs never reach it). Their own distribution channel is future work.
- `raven tui` / `raven serve`: fall back to the source-checkout resolvers exactly as a dev build without prebuilt bundles does today; headless installs never call them.
## Verified
- `RAVEN_WHEEL_SLIM=1 uv build --wheel` -> 3.0 MiB wheel, 734 files, `raven/acp` complete, no `raven/subagents` or UI dist entries.
- The slim wheel provisioned a real E2B-compatible sandbox and served a full `raven acp` session end to end (delegated task with shell execution, ask_user elicitation round trip, multi-turn session continuity).
- Default build without the variable is unchanged.
## What
Adds a `RAVEN_WHEEL_SLIM=1` build switch to `hatch_build.py`: when set, the wheel build skips the vendored sub-agent tree and the prebuilt TUI/web bundle inclusion. Default builds are byte-identical to before.
## Why
The release wheel is ~106 MiB compressed; ~94% is the `subagents/` snapshots (raven-ppt alone carries 74 MiB of `.pptx` templates and fonts) plus UI bundles. A cloud provisioner that only ever runs `raven acp` inside a sandbox uploads all of that per instance for assets nothing there opens. The slim wheel is ~3.0 MiB with the full python package intact, cutting sandbox provisioning upload from 15-23s to under a second.
## Behavior on slim installs
- Sub-agents: absent by design; onboarding step 5 reports no tree (headless installs never reach it). Their own distribution channel is future work.
- `raven tui` / `raven serve`: fall back to the source-checkout resolvers exactly as a dev build without prebuilt bundles does today; headless installs never call them.
## Verified
- `RAVEN_WHEEL_SLIM=1 uv build --wheel` -> 3.0 MiB wheel, 734 files, `raven/acp` complete, no `raven/subagents` or UI dist entries.
- The slim wheel provisioned a real E2B-compatible sandbox and served a full `raven acp` session end to end (delegated task with shell execution, ask_user elicitation round trip, multi-turn session continuity).
- Default build without the variable is unchanged.
A plugin hook or tool that needs a judgement -- a draft reviewer, a
sufficiency check, a page digest -- had no model to ask: the locator
carried workspace, the two identities and notify. Building a provider
from the config inside the plugin would be a second credential and a
second pool that a model switch never reaches. The grant is the loop's
own provider, handed through build_plugin_tools and build_plugin_hooks
by the assembly root; optional, None where the host has no model to
lend (a CLI listing plugins, a test building a locator). The first
RuntimeServices field, admitted by a demonstrated demand.
Co-authored-by: Claude (claude-fable-5) <noreply@anthropic.com>
Three renames, no behaviour change:
- raven/plugin/ -> raven/plugins/: the package holds many, and every
sibling package with a plural content is already plural.
- raven/plughub/ -> raven/market/: the hub sells; "market" says so
without colliding with the plugin vocabulary it serves.
- channels' manager / intake / outlet / live_probe and the cli's
_gateway_lock move into a new raven/gateway/ package: they are the
daemon's pipe work, not per-service adapter code and not command-line
surface. The lock goes public as gateway.lock because live_probe,
an inner module, may not import raven.cli.
raven/channels/__init__ stops re-exporting ChannelManager: the re-export
made channels import the gateway package, which imports the channel
contract back -- a cycle. Zero consumers used that path.
The sweep also caught two path constructions the dotted-import rewrite
cannot see: _plugin_stack and its discovery test build the bundled
plugins directory from path segments, and both still spelled "plugin" --
bundled discovery would have come up empty on every start.
Co-authored-by: Claude (claude-fable-5) <noreply@anthropic.com>
## Summary
Adds Hermes as a cold-start import source, alongside the existing Claude
Code
scanner, across three kinds of data.
**Memory files.** `MEMORY.md` and `USER.md` are discovered through the
same
profile resolution Hermes itself uses (`HERMES_HOME`, then
`active_profile`
redirecting to `<root>/profiles/<name>`). `USER.md` entries are
additionally
mirrored into the native `user_memory/profile/user.md`: six host
consumers
(Curator, Personalizer, four Sentinel producers) read that file directly
and
never see EverOS-only content. An LLM picks each entry's H2 heading;
every
failure path lands the entry under `## Notes`, which injection always
includes,
so a misclassification costs tokens rather than visibility.
**Conversations.** Sessions are enumerated by shelling out to
`hermes sessions export --dry-run`, whose listing is capped at 100 rows.
The
scanner walks time windows until every session is covered rather than
silently
importing the first 100. Only ended sessions are candidates, and
`reopen_session()` can clear `ended_at`, so the window reconciliation
documents
the resulting race in both directions instead of assuming monotonicity.
**Skills.** Provenance is classified from on-disk evidence -- the
`.bundled_manifest` name-to-md5 map, `.hub/lock.json`, and `.usage.json`
-- with
a `package_hash` byte-identical to Hermes' own `_dir_hash`, so a skill
still
matching its factory content is left alone and only user-authored or
curator-managed skills are copied into the local skill pool. Skills
never travel
as ScanResults, so the menus, the confirm line and the final summary all
state
the skill count explicitly; without it a run that installs 12 of 82
reads as
having dropped 70.
Failure isolation: `scan_all` now reports a failing scanner through an
`on_error` callback and keeps the other platforms' results, and a Hermes
run
whose conversations cannot be enumerated still returns its memory files.
Two pre-existing defects found while working here are fixed in the same
branch:
a multi-line recall hit escaped its bullet in the context segment
renderer, and
a recalled EverOS profile was rendered as a Python repr and left
uncapped.
Also in this branch, from hands-on testing of the finished flow:
- `raven import run` could never reach its interactive path. The
selectors
called questionary's synchronous `ask()` from inside `asyncio.run()`,
and
prompt_toolkit drives `Application.run()` through `asyncio.run()`, which
raises inside a running loop. No test covered it: every case passed
`--platform` and `--tier`, bypassing the selectors.
- Import outcomes now render as one block after the progress display
closes.
Printing them from `_build_and_run` sent them to this module's Console
while
onboard's live progress belongs to its themed Console, and Rich's Live
can
only hold back writes on its own console, so they landed mid-bar and
left the
bar duplicated.
- The `import run` selectors use the shared prompt style and glyphs
instead of
questionary's defaults; onboard's foreground import gains the phase
reporter
it never had, so the multi-second USER.md mirror is no longer silent
behind a
bar reading 100%.
The EverOS backend moves with it. Agent-track recall turned out to be
dead:
agent-track HYBRID fuses `agent_case` and `agent_skill` through a rerank
cross-encoder, and with no rerank provider the server refuses the
request
outright, which `recall` catches and turns into an empty list against a
file-only logger. A live 1.1.3 probe returns `RuntimeError:
owner_type='agent'
with method='hybrid' requires a rerank provider`. The adapter now reads
`capabilities.rerank` from `/health` and asks for the LLM lane only when
the
cross-encoder is genuinely absent -- always sending it would make every
correctly configured user pay an LLM call per recall, never sending it
leaves
the track dead for anyone who skipped the optional rerank role in
onboard.
That capability is only readable from everos 1.2.1, so the pin moves
1.1.3 ->
1.2.1, skipping 1.2.0 (built from a branch missing the 1.1.4 fixes,
including a
knowledge-upload path traversal). Memory endpoints move to `/api/v2`,
canonical
since 1.2.0; `/api/v1` still resolves to the same handlers but is
documented as
a legacy alias. Only everos endpoints move -- the Skill Hub and
OpenRouter
clients have their own v1 surfaces.
That upgrade also broke an assumption Raven was making. "Server running"
and
"server can recall" used to be the same statement; 1.2.1 boots with
`[llm]` alone
instead of aborting, so a misconfigured provider answers 200 and quietly
serves
less. Raven decided a role was configured by reading model + api_key out
of
`everos.toml`, which cannot see that. Capabilities are now read from
`/health` at
all three points where it matters: the memory step (right after the
server it
already starts), `raven doctor` (which had no EverOS check at all), and
`backend.start()` -- the only one of the three on the path every session
takes,
which is where an expired key actually surfaces. It follows the
precedent already
set there for native Windows and prints to stderr rather than a log
nobody reads,
but does not drop to a no-op: writes still land, and `everos cascade
backfill`
gives those rows their vectors once the provider is fixed.
The same reading makes the embedding role genuinely optional. It was not
before:
recall sends no `method`, so it took the server default of HYBRID, which
everos
refuses without an embedding provider -- skipping the role produced a
memory that
stored everything and returned nothing. The adapter now asks for KEYWORD
when no
embedding capability is reported, searching the same rows lexically
instead of
semantically, and that also rules out the rerank fallback because
KEYWORD's agent
path never reaches the cross-encoder. So the wizard stops requiring
embedding and
states what each role buys before asking for it -- llm alone gets
keyword recall,
embedding adds meaning, rerank sharpens ordering -- and skipping
embedding is
reported in colour rather than dim, because skipping rerank costs
ordering while
skipping embedding costs semantic recall entirely.
Fault and degradation are now distinguished rather than lumped together:
only a
missing llm sets doctor's exit code, and `raven doctor` names what each
unconfigured optional role costs, per role, since "optional" alone does
not help
anyone decide. The wizard also stops asking whether to enable memory at
all --
everos is the only backend, so the question framed a choice that does
not exist,
and both of its answers were described wrongly (declining was said to
use "native
Markdown memory", which does not exist: `raven/plugin/memory/` holds
only everos,
and `ContextAssembler.owns_compaction` is a hardcoded True that stops
the
consolidator from ever updating user.md). Backing out is still possible
and now
states the real consequence in colour. The memory LLM field is
pre-filled with
the user's own main model rather than a recommended id, because a
recommendation
is only reachable if their key carries it.
Two rounds of review on this branch found defects worth naming, since
each was
invisible for the same reason -- no test covered the path:
- **Skills were copied before the run's own `Proceed?` gate.** The two
early
returns that install a skills-only import sit above it, so a machine
whose only
importable data is skills had directories copied before being asked
anything.
Both paths now name the count and ask; the wizard's `Start?` gate is
further
down still, so its two call sites ask as well. Every covering test
passed
`--yes`, which is what hid it.
- **A cancelled run still ran both post-phases.** `run_import` returns
normally
once it sees the cancel file, so `raven import stop` halted the
conversation
loop and then started an LLM call per USER.md entry plus a full skill
copy.
- **Org-mirror skills were imported past a gate Hermes applies itself.**
Hermes
token-gates `_org/`: with no `.active_org` marker it prunes the whole
mirror,
and with one it descends only into the named org, so a stale mirror is
content
Hermes no longer loads. Discovery now mirrors that. Excluding `_org`
outright
would have been the opposite error -- it drops the active org's skills.
- **`doctor` and the wizard probed the default address.** Both took
`DEFAULT_EVEROS_BASE_URL` while the backend reads the configured
`base_url`, so
a user who moved everos off port 18791 was told it was not running -- by
the
checks added to make a degraded server visible.
- **An unbuilt multimodal role was reported by nobody.** The
section-to-capability
mapping had an entry both consumers skipped.
- **The USER.md progress line reached 100% before the last call.** Each
report
counted the call about to start; on a measured 9.4s run that left ~3s
sitting at
100%, the exact symptom the phase reporter was added to remove.
- **Registry-name collisions were only checked within one run**, so a
name an
earlier import or the user's own skill already claimed produced the
invisible
skill that `get(name)` never returns.
- **"All platforms" plus "run in background" could not work.** `import
run` has no
all-platforms flag, so the child reached its platform picker with
DEVNULL on
both streams and no terminal, after the wizard reported the import as
started.
It now runs in the foreground and says so.
The e2e tests this branch made dead are fixed too: identity moved to the
host, so
`config={"agent_id": ...}` is ignored, and the agent-track test wrote
under the
services default while querying the tag -- `hits` was empty, its per-hit
assertions vacuous, and an `xfail` absorbed it. The plugin manifest
moves to
1.1.0, which the upgrade SOP in this same diff asks for.
Not in scope: Codex, KimiCode and OpenClaw remain placeholders;
cold-start
import stays an EverOS-only path with no native fallback.
## Type
- [x] Feature
- [ ] Fix
## Verification
```
uv run --all-extras pytest -q 5405 passed, 30 skipped, 13 deselected
uv run ruff check . All checks passed!
uv run ruff format --check . 873 files already formatted
make check-large-files passed
```
Beyond the suite, the importer was run against a real Hermes install at
`--tier full`: memory files, conversations and skills all landed, EverOS
extracted agent cases from the imported conversations
(`quality_score=1.0` in
the server log), and a second run over the same data reported
`Submitted: 0, Skipped: 4`, confirming the checkpointing is idempotent.
The everos upgrade was verified against a live server holding real
imported
data: on 1.1.3 the agent track returns 500 and `/api/v2` returns 404; on
1.2.1
with this change the agent track returns an `agent_case` and the user
track is
unchanged at three episodes. Re-verified after killing the server and
cold
starting it, with the resolved binary printed to confirm which build
answered.
`raven doctor` and the wizard both report llm and embedding available
with
rerank absent against that server.
The suite was also run with HOME pointed at an empty directory, which is
how the
memory-probe and import-step tests were caught reading the developer's
own
configuration instead of their own fixtures. That pass also found the
test suite
waiting out `ensure_everos_server`'s 30s readiness timeout on every
machine
without a running server -- always, on CI -- which cost one file 34 of
its 35
seconds and is now stubbed.
The interactive flow was verified under a pty, comparing the two console
wirings directly, and each new assertion was mutation-tested: every
behavioural
change on this branch had its fix reverted and the covering test
confirmed red,
and only that test. Where a fix had a plausible wrong shape, that shape
was
mutated too -- excluding `_org` wholesale rather than token-gating it,
reporting
progress after the await instead of before, seeding the registry-name
check from
the pool without ordering it after the target resolution. Two of those
mutations
survived and were the more useful result: one showed a guard clause
could not
fire (`_target_for` only ever returns a path that does not exist, so
excluding it
from the pool lookup was dead code, now removed), the other showed the
wizard's
own confirmation sits below the returns it was supposed to cover.
- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
User-facing docs are unchanged: this adds a platform to an existing
documented
command rather than a new surface. The developer docs move with the code
--
`docs/memory-plugin-architecture.md` (the everos pin, and the upgrade
SOP now
stating that a one-way migration belongs in the release notes) and
`scripts/README.md` (two deleted scripts).
## Risk
- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes
The import writes to EverOS and to `user_memory/profile/user.md`, and
copies
skill directories into the local skill pool. EverOS has no delete
endpoint, so
an unwanted import is not undone by reverting this branch; the skill
copies and
the profile edits are plain files and can be removed by hand. Import
state
lives in `~/.raven/import_state.json` and can be deleted to start over.
Behaviour changes for existing users: the onboard wizard's import step
and
`raven import run` both look different (shared prompt style, skill
counts,
one summary block). `raven import run`'s interactive path changes from
"crashes immediately" to working. Rolling back restores the crash.
Three more, from the review round: a skills-only import now asks before
copying
(one extra prompt, skippable with `--yes`), an all-platforms import
chosen with
"run in background" runs in the foreground instead and says so, and
skills under
a stale `_org/` mirror are no longer imported -- Hermes does not load
them
either, but anyone who had them imported by an earlier build keeps them,
since
nothing here deletes.
Two consequences of the everos upgrade that operators need to know:
- **The index migration is one-way.** everos 1.2.1 migrates the LanceDB
schema
on first start and prunes older manifest versions, so once a machine has
run
this, its memory index can no longer be read by an older everos.
Reverting
the branch does not undo it.
- **A missing provider no longer aborts startup.** 1.2.1 boots with
`[llm]`
alone. A misconfigured embedding provider used to fail loudly; it now
degrades
to keyword search, and rows written in that state carry no vector until
`everos cascade backfill` is run. everos itself only logs one warning
line,
which is why the wizard, `raven doctor` and `backend.start()` all
surface it --
the last of those runs every session, so an expired key is reported
rather
than discovered.
- **Behaviour change for users who skip embedding.** Recall degrades to
keyword
matching instead of failing, and the wizard no longer stops them from
getting
there. That is the point of the change, but it means a user can now end
up with
a working memory that is measurably worse at recall than the previous
all-or-nothing setup would have allowed.
## Related Issues
N/A
---------
Co-authored-by: Claude (claude-opus-5) <noreply@anthropic.com>