17 Commits

Author SHA1 Message Date
Dizhan Xue
25c576859a
docs: add the technical report page and link it from the readmes (#812)
## Summary

Adds `docs/technical-report/README.md`, the landing page for the Raven
technical report: title, abstract, BibTeX entry, and a download link for
the PDF. It replaces the zero-byte `.gitkeep` that created the folder,
and `docs/README.md` gains the index entry that the placeholder change
deferred until real content landed.

Both root READMEs link the PDF itself rather than that page: a Technical
Report link leads the navigation line under the badges, and a closing
Citation section, after License, carries the same BibTeX entry and links
the same file. The English and Chinese READMEs change in the same
places, and the three BibTeX blocks are byte-identical.

The PDF itself (4,035,271 bytes, 82 pages) is not committed. AGENTS.md
section 7 keeps report assets and files over 1 MiB out of git, and
`scripts/check_large_files.py` rejects this file on both counts. It is
attached to the `tech-report-v1` release instead, published with
`--latest=false`: `/releases/latest` is what `install.sh`, `install.ps1`
and `raven/updates/upgrade.py` resolve, and all three accept only a
`vX.Y.Z` tag there. The report tag points at the v0.2.3 commit. A later
revision of the report gets its own release rather than replacing this
asset.

## Type

- [ ] Fix
- [ ] Feature
- [x] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

Every range below starts at the branch base, the #810 squash on `main`.

- `scripts/check_large_files.py <base>..HEAD`: exit 0.
- `scripts/check_source_language.py <base>..HEAD`: exit 0.
- `scripts/check_commit_messages.py <base>..HEAD`: exit 0.
- `commitlint --from <base> --to HEAD --config commitlint.config.cjs`:
exit 0.
- `pre-commit run --from-ref <base> --to-ref HEAD`: exit 0. The hooks
that match these files passed and modified nothing.
- `pytest -q tests/test_living_docs.py tests/test_docs_site.py
tests/test_large_file_check.py tests/test_docker_runtime.py`: 41 passed.
`test_docker_runtime.py` is the one test that reads both root READMEs.
- All three pages rendered through the GitHub markdown API. The landing
page shows the abstract's en dash, both emphasized terms, the two links
and the BibTeX block; each root README shows the Technical Report link
first in its navigation line, both of its report links resolve to the
PDF download URL, and it ends with the Citation section and its BibTeX
block.
- The release asset's digest equals the local file's SHA-256
(`14832f50...`). After publishing,
`https://github.com/EverMind-AI/Raven/releases/latest` still redirects
to `v0.2.3`, and the release page and the PDF download URL both return
200 to an anonymous request.

`make lint` was not run: `PYTHON_LINT_TARGETS` and the TypeScript lint
trees do not include `docs/` or the root READMEs.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

Docs only: nothing reads these files at runtime. The release is the part
with reach: it is public, publishing it notified release watchers, and
it must never become Latest. If it has to be withdrawn, `gh release
delete tech-report-v1 -R EverMind-AI/Raven --cleanup-tag` removes it and
its tag, and the landing page's links then 404 until the page is
reverted. Rolling back this PR is a revert of the squash commit.

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

## Related Issues

#804 created the folder this page fills.

---------

Co-authored-by: Claude (claude-opus-5-5[1m]) <noreply@anthropic.com>
2026-09-27 20:07:07 +08:00
Dizhan Xue
9b3ca145b6
docs: refresh bilingual readme showcases (#795)
## Summary

The README showcase now highlights three complete projects: THRESHOLD,
Raven RSI, and Raven's product launch kit. Each project pairs a concise
description with hosted videos, posters, presentations, and website or
README previews.

- Polish the English and Chinese titles, descriptions, and media labels.
- Preserve the previous 11 examples in `docs/showcase.md` and
`docs/showcase.zh-CN.md`, with links from both READMEs and the
documentation index.
- Keep all media hosted externally; this change contains five Markdown
files.

## Type

- [ ] Fix
- [ ] Feature
- [x] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

Commands run after rebasing onto the current target:

- `rtk proxy uv run --no-sync --all-extras pytest
tests/test_living_docs.py tests/test_docs_site.py
tests/test_docker_runtime.py
tests/test_cli_onboard_commands.py::test_readme_quickstart_matches_the_installer
-q` - 28 passed.
- `rtk proxy uv run --no-sync pre-commit run --from-ref origin/main
--to-ref HEAD` - all applicable hooks passed, including private-key
detection.
- `rtk proxy env UV_NO_SYNC=1 make check-large-files
check-source-language COMMIT_RANGE=origin/main..HEAD` - passed.
- `rtk proxy env PYTHONPATH=. uv run --no-sync python
scripts/check_commit_messages.py origin/main..HEAD` - passed.
- `rtk proxy git diff --check origin/main...HEAD` - passed.

The migrated showcase bodies match their originals byte for byte. GitHub
Markdown rendering produces three project headings, three tables, 11
images, and two video players per README, with no unrendered bold
markers. Relative links and domain terminology were checked.

All five project website links returned HTTP 200. Requests to the 19
GitHub attachment URLs returned HTTP 403 or timed out; a direct GET
retry also timed out, so media payload delivery could not be revalidated
from this environment.

Validation is scoped to documentation. Type checking is not applicable
to these Markdown-only changes. The full application and integration
suites were not run, and the showcase experiments were not rerun.

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

This changes the README presentation and adds navigation to the full
galleries. Runtime behavior, configuration, and dependencies are
unchanged. Media remains dependent on its external hosting. Revert this
documentation change to restore the previous layout.

## Related Issues

N/A
2026-09-26 01:18:48 +08:00
userName20260323
8a1ebdc577
docs: organize bilingual documentation navigation (#635)
## Summary

Reorganize the Raven documentation landing page and expand the bilingual
documentation site.

- Add bilingual guidance for agent collaboration, ACP and A2A protocols,
DAG orchestration, channels, browser collaboration, knowledge bases,
Playbooks, proactive follow-ups, Oncall, permissions, tracing,
trajectory replay, and Evolver.
- Group daily usage under `Use Raven` and `Using Raven`.
- Group `Technical Reference` and `Developer Guide` under `Explore the
documentation` while preserving separate cards.

## Type

- [ ] Fix
- [ ] Feature
- [x] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

- [x] Relevant tests pass locally
- [ ] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

Exact checks:

- `uv run --frozen --group docs mkdocs build -f docs-site/mkdocs.yml
--strict` - passed.
- `uv run --frozen --group docs pytest tests/test_docs_site.py
tests/test_living_docs.py
tests/integration/test_docs_site_controls_e2e.py -q -o addopts=''` - 77
passed.
- `uv run --frozen python scripts/check_commit_messages.py
origin/main..HEAD` - passed.
- `git diff --check origin/main...HEAD` - passed.
- `make check-large-files` - passed.

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

This is a documentation-only change. It does not change runtime
behavior, configuration semantics, or public APIs. Reverting the
documentation commits restores the previous site content and navigation.

## Related Issues

N/A

---------

Co-authored-by: userName20260323 <270284818+userName20260323@users.noreply.github.com>
Co-authored-by: Claude (claude) <noreply@anthropic.com>
2026-09-22 16:14:44 +08:00
Tong Li
608cedf180
feat(browser): give the model the shared browser, and a desktop MCP server to reach (#578)
## Summary

The browser existed on every side except the model's: `raven/browser`
drives a
Chromium the panel streams over CDP, and `browser.*` RPC gives the
reader hands
on it, but `raven/agent/tools/` had no browser tool at all -- a model
asked to
open a page had nothing to call. This registers eight `browser_*` tools
over
that same driver, with no MCP hop, so the page the model drives is the
page the
panel shows and a human can take the keyboard mid-task.

Desktop control reuses `macos-mcp` through the MCP client that was
already
there; the only new code for it is a market catalog entry.

What the tools add beyond the driver:

- **Reading back.** Every acting call returns the page as it is
afterwards
(url, title, the actionable refs, the visible text), so the next call
can be
aimed without a separate read. `browser_screenshot` is the one that
costs an
  image and is asked for on purpose; it goes out as an image block.
- **Who is acting.** Each call names an owner -- the sub-agent run in
flight,
else the conversation -- and the driver binds that owner to a tab. Two
agents
work in two tabs, neither can activate or close the other's, and a popup
a
click opens becomes the opener's tab. A reader's own clicks carry no
owner:
they are stamped, and the owner's next readback says the user touched
the
  browser, once.
- **Permissions.** Reading and navigating default to allow, on the
`web_fetch`
  reasoning (opening a page is a GET the agent could already make, and
`raven.browser.policy` refuses what a GET must not reach). Clicking,
typing
and pressing ask, keyed by site rather than by ref, so one approval
covers a
  site for the conversation.
- **Config.** `tools.browser.headfulOnAgentUse` pops the shared browser
out
into a real window on the model's first use. Off by default: a server
has no
  desktop to pop into.

The tool surface grew, so the `reserved_tools` tripwire moved:
descriptions
were trimmed first (~1270 to ~1090 tokens) and the bound raised from
6000 to
7400 against a measured 7115, with the trade written beside it. The
schemas are
only present where the browser extra is installed; without playwright
the tools
report themselves unconfigured and never reach the request.

No ui-web changes are in this PR. The web UI side of this work (a
browser pane
in the desk, a per-tab miniature, docking) is written against surfaces
that
`refactor/ui_web_architecture` removes, so it waits for that branch to
land.

## Type

- [x] Feature

## Verification

- `uv run pytest tests/ -q` -> 23755 passed, 121 skipped, 1 failed. The
failure
is
`test_cli_onboard_commands::test_clearing_does_not_disturb_a_key_the_user_exported_themselves`,
which reads the developer's own shell environment and fails the same way
on
  an unmodified `main` in this checkout.
- `uv run pytest tests/integration/test_browser_tools_real_web.py -q` ->
6
  passed against a real Chromium and a local form: fill and submit, a
screenshot arriving as an image block, two owners in two tabs with
neither
able to take the other's, a read leaving the front tab where the last
actor
put it, a `target=_blank` popup landing its opener on the new tab, and a
scripted model driving `AgentLoop`'s default tools end to end -- the
gate
asking once for the site, the grant covering the click that follows, and
the
  panel's `browser.frame` returning the page the model left.
- `uv run ruff check raven tests`, `uv run ruff format --check raven
tests`,
`uv run lint-imports`, `make check-source-language`, `make
check-large-files`
  -> clean.
- Desktop side exercised by hand through raven's own MCP client, over
stdio and
  over streamable-http with a bearer token: launch Calculator, read its
accessibility tree, click 2 + 3 =, read the result back. Screenshots
arrive
  as image blocks.

Not verified: the desktop flow was driven by a script rather than by a
model in
the loop; sub-agents that run in their own process (the ACP and cli
lanes) have
their own `Browser` singleton and are not given these tools; Windows and
Linux
desktop executors were not chosen.

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

Notes. The acting verbs sit on the ask tier by default and a grant is
scoped to
a site and a conversation, so an approved click on one host does not
carry to
another. Navigation goes through the existing outbound policy. The
desktop MCP
server runs locally under `uvx` and needs macOS Accessibility and Screen
Recording grants, which the operating system asks for itself; the
catalog entry
is opt-in like every other market entry. Nothing here changes an
existing
default: without the browser extra the tools are absent, and with it the
only
new always-on cost is the tool schema.

## Related Issues

N/A

---------

Co-authored-by: Claude (claude-fable-5-1) <noreply@anthropic.com>
2026-09-21 20:28:04 +08:00
Handsome-wzw
7b45527b5b fix(tools): an array sent as its own JSON is still an array
## 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.
2026-09-09 15:42:36 +00:00
forrestjgq
f01231fef6 fix(cli): overhaul trajectory browser interaction ux (#379)
## 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>
2026-09-05 23:58:20 +08:00
0xKT
ae4c792503 refactor(*): leave the machine a job runs on to the sub-agent that runs it
## Summary

The host held three machine-shaped things about a sub-agent, and all three are gone:

1. a per-node `machine` key reserved in the DAG tool's node `inputs`, which a node on a
   flagged agent was rejected without;
2. a pre-dispatch check on both the graph and the spawn path that read the owner's
   connection registry and refused the call while it held no usable row;
3. a `runsOnMachines` manifest and config flag naming which agent that check applied to.

Where a job runs is now settled inside the agent that runs it. That agent already reads
the same registry through its own `ops_connections` tool, and on an empty one it answers
with the seven things `raven ops connection add` asks for and tells the model to hand
that to the owner rather than look for a way onto a box. Nothing was lost from the ask
itself; only its timing moved.

The host keeps the registry: `raven/ops/connections.py`, the
`raven ops connection add/list/doctor` CLI, and the `RAVEN_CONNECTIONS` handoff that
points a sub-agent at the owner's store instead of a copy of it.

**One half of the flag was never about machines.** Watch-work steering reads the same
flag to answer a different question, which roster row owns run-and-watch work, so
deleting it outright would have silently taken that feature with it. That half is renamed
to `ownsWatchedWork`, and the declaration rides the agent table: `AgentRow` and
`AgentMeta` carry `owns_watched_work`, read off the validated config at admission, and
`oncall_agent` reads the metas the loop already holds. Nothing reopens config or a
folder's manifest, so the spelling question is answered once, at the one door, rather than
by a second reader free to disagree with the table being dispatched against.

A row or a manifest written before the rename still loads. `Base` sets
`populate_by_name`, so both `runsOnMachines` and `runs_on_machines` were valid, and the
validation alias carries both alongside the two new spellings. Without that the rename is
invisible: the model ignores the unknown key and the field defaults to `False`, which
cannot be told apart from the owner turning the steering off.

The on-call roster description gains one sentence asking the caller to name the machine
in the owner's own words. It is phrased that way on purpose: the calling agent has no
tool that can enumerate registered machines, so a sentence asking it to pick a
registered id would ask for something it has no means to do.

## Type

- [ ] Fix
- [ ] Feature
- [ ] Docs
- [ ] CI / tooling
- [x] Refactor
- [ ] Other

## Verification

- `ruff check raven/ tests/` -- All checks passed
- `ruff format --check` on every touched Python file -- already formatted
- `python3 scripts/check_vendored_subagents.py` -- clean, with `subagents/TREE_HASHES`
  re-recorded for `raven-oncall` in this commit
- `python3 scripts/check_commit_messages.py origin/main..HEAD` -- clean
- `pytest tests/ -k "spawn or organ or watch_work or subagent or dag or config_schema or
  ops_connection or registry"` -- 2318 passed, 16 skipped
- `pytest` on the directly changed suites (`test_watch_work.py`,
  `test_agents_oncall_launcher.py`, `test_agents_code_launcher.py`,
  `test_subagent_third_party.py`, `test_config_schema.py`, `test_ops_connections.py`,
  `test_cli_ops_connection_commands.py`, `test_subagent_manager.py`) -- 495 passed
- The legacy spellings were reproduced both ways: against `origin/main` both
  `runsOnMachines` and `runs_on_machines` set the flag on both third-party classes; each
  of the four spellings now reaches the dispensed row and is named by `oncall_agent`,
  driven through `discover_vendored_rows` and `_row_for` rather than through a stand-in.
- The new dispatch test was proved load-bearing by re-inserting an equivalent registry
  gate into the spawn path and watching it go red, then restoring the file.

Rebased onto the current `main`, which had moved 21 commits. Four conflicts, all in
files this branch already rewrites: the two modules it deletes (`main` had only renamed
`vendored_folder` to `product_folder` inside them, so the deletion stands), the ppt
launcher test (`main`'s engine-delta assertion kept, with only the flag rename applied),
and the two `CONTEXT.md` entries (this branch's text, carrying `main`'s de-vendored
vocabulary). One follow-up commit repoints the admission test at
`discover_product_rows`, which is what `main` renamed the discovery helper to.

Pre-existing failures, captured as failing IDs and diffed against `origin/main` in a
separate checkout through the same interpreter, at the rebased head: 7 on each side,
identical, so 0 introduced. They come from the separately distributed `everos-memory` and
`raven_ppt` packages being absent, along with 69 collection errors from the same cause. All 16 come from the
separately distributed `everos-memory` package being absent, and the 60 collection errors
under `tests/test_ppt_engine_*` from the same environment lacking the ppt extras. The one
failure only `origin/main` shows is `test_the_folder_ships_exactly_one_roster_manifest`,
which trips on stray `subagents-backup-*.json` files in that checkout rather than on
either tree. `tests/test_agents_ppt_launcher.py` fails identically on both sides.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

Behaviour changes, all deliberate:

- A graph or a spawn naming the on-call agent now dispatches on an installation with no
  machine registered. The owner is still asked for one, by the sub-agent, one sub-agent
  run later. That run is the cost of the change.
- The `machine` key in a node's `inputs` is no longer reserved, so a graph that sets it
  is now passing an ordinary input rather than choosing a machine.
- No node prompt is appended the machine's facts any more. A node that needs to size work
  to a box learns about it from the sub-agent that runs it, not from the graph.

`demos/oncall_heat2d` narrated the old refusal step by step, including a verbatim
transcript of it; its README is rewritten to the chain that now runs. The cold-start half
of that transcript has not been re-recorded live, and the README says so.

Two docstrings under `subagents/raven-oncall/Raven-Oncall/` are patched deliberately, and
`subagents/TREE_HASHES` is re-recorded for it: they are the vendored fork's own copies of
a claim this change makes false, and that source is where a reader of the on-call agent
would look for it.

- [x] Security impact considered -- the removal narrows what the host reads and what
  reaches a prompt; no address or credential ever crossed into an agent's view, and that
  split is enforced on the sub-agent side, which is untouched.
- [x] Backward compatibility considered -- covered by the legacy validation alias above.
- [x] Rollback path is clear for risky changes -- revert the commit; the registry file
  format, the CLI and the sub-agent's own tools are unchanged, so nothing on disk needs
  migrating in either direction.

Checked and deliberately not changed: `ThirdPartyOpenAISubagentConfig` never carried the
flag and still does not, so an OpenAI-kind roster row cannot be the watch-work
specialist. That gap predates this branch and closing it would widen the diff into an
unrelated transport.

## Related Issues

N/A
2026-09-06 06:15:56 +00:00
LivXue
a44664d1ba refactor(*): leave the machine a job runs on to the sub-agent that runs it
## Summary

The host held three machine-shaped things about a sub-agent, and all three are gone:

1. a per-node `machine` key reserved in the DAG tool's node `inputs`, which a node on a
   flagged agent was rejected without;
2. a pre-dispatch check on both the graph and the spawn path that read the owner's
   connection registry and refused the call while it held no usable row;
3. a `runsOnMachines` manifest and config flag naming which agent that check applied to.

Where a job runs is now settled inside the agent that runs it. That agent already reads
the same registry through its own `ops_connections` tool, and on an empty one it answers
with the seven things `raven ops connection add` asks for and tells the model to hand
that to the owner rather than look for a way onto a box. Nothing was lost from the ask
itself; only its timing moved.

The host keeps the registry: `raven/ops/connections.py`, the
`raven ops connection add/list/doctor` CLI, and the `RAVEN_CONNECTIONS` handoff that
points a sub-agent at the owner's store instead of a copy of it.

**One half of the flag was never about machines.** Watch-work steering reads the same
flag to answer a different question, which roster row owns run-and-watch work, so
deleting it outright would have silently taken that feature with it. That half is renamed
to `ownsWatchedWork`, and the declaration rides the agent table: `AgentRow` and
`AgentMeta` carry `owns_watched_work`, read off the validated config at admission, and
`oncall_agent` reads the metas the loop already holds. Nothing reopens config or a
folder's manifest, so the spelling question is answered once, at the one door, rather than
by a second reader free to disagree with the table being dispatched against.

A row or a manifest written before the rename still loads. `Base` sets
`populate_by_name`, so both `runsOnMachines` and `runs_on_machines` were valid, and the
validation alias carries both alongside the two new spellings. Without that the rename is
invisible: the model ignores the unknown key and the field defaults to `False`, which
cannot be told apart from the owner turning the steering off.

The on-call roster description gains one sentence asking the caller to name the machine
in the owner's own words. It is phrased that way on purpose: the calling agent has no
tool that can enumerate registered machines, so a sentence asking it to pick a
registered id would ask for something it has no means to do.

## Type

- [ ] Fix
- [ ] Feature
- [ ] Docs
- [ ] CI / tooling
- [x] Refactor
- [ ] Other

## Verification

- `ruff check raven/ tests/` -- All checks passed
- `ruff format --check` on every touched Python file -- already formatted
- `python3 scripts/check_vendored_subagents.py` -- clean, with `subagents/TREE_HASHES`
  re-recorded for `raven-oncall` in this commit
- `python3 scripts/check_commit_messages.py origin/main..HEAD` -- clean
- `pytest tests/ -k "spawn or organ or watch_work or subagent or dag or config_schema or
  ops_connection or registry"` -- 2318 passed, 16 skipped
- `pytest` on the directly changed suites (`test_watch_work.py`,
  `test_agents_oncall_launcher.py`, `test_agents_code_launcher.py`,
  `test_subagent_third_party.py`, `test_config_schema.py`, `test_ops_connections.py`,
  `test_cli_ops_connection_commands.py`, `test_subagent_manager.py`) -- 495 passed
- The legacy spellings were reproduced both ways: against `origin/main` both
  `runsOnMachines` and `runs_on_machines` set the flag on both third-party classes; each
  of the four spellings now reaches the dispensed row and is named by `oncall_agent`,
  driven through `discover_vendored_rows` and `_row_for` rather than through a stand-in.
- The new dispatch test was proved load-bearing by re-inserting an equivalent registry
  gate into the spawn path and watching it go red, then restoring the file.

Rebased onto the current `main`, which had moved 21 commits. Four conflicts, all in
files this branch already rewrites: the two modules it deletes (`main` had only renamed
`vendored_folder` to `product_folder` inside them, so the deletion stands), the ppt
launcher test (`main`'s engine-delta assertion kept, with only the flag rename applied),
and the two `CONTEXT.md` entries (this branch's text, carrying `main`'s de-vendored
vocabulary). One follow-up commit repoints the admission test at
`discover_product_rows`, which is what `main` renamed the discovery helper to.

Pre-existing failures, captured as failing IDs and diffed against `origin/main` in a
separate checkout through the same interpreter, at the rebased head: 7 on each side,
identical, so 0 introduced. They come from the separately distributed `everos-memory` and
`raven_ppt` packages being absent, along with 69 collection errors from the same cause. All 16 come from the
separately distributed `everos-memory` package being absent, and the 60 collection errors
under `tests/test_ppt_engine_*` from the same environment lacking the ppt extras. The one
failure only `origin/main` shows is `test_the_folder_ships_exactly_one_roster_manifest`,
which trips on stray `subagents-backup-*.json` files in that checkout rather than on
either tree. `tests/test_agents_ppt_launcher.py` fails identically on both sides.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

Behaviour changes, all deliberate:

- A graph or a spawn naming the on-call agent now dispatches on an installation with no
  machine registered. The owner is still asked for one, by the sub-agent, one sub-agent
  run later. That run is the cost of the change.
- The `machine` key in a node's `inputs` is no longer reserved, so a graph that sets it
  is now passing an ordinary input rather than choosing a machine.
- No node prompt is appended the machine's facts any more. A node that needs to size work
  to a box learns about it from the sub-agent that runs it, not from the graph.

`demos/oncall_heat2d` narrated the old refusal step by step, including a verbatim
transcript of it; its README is rewritten to the chain that now runs. The cold-start half
of that transcript has not been re-recorded live, and the README says so.

Two docstrings under `subagents/raven-oncall/Raven-Oncall/` are patched deliberately, and
`subagents/TREE_HASHES` is re-recorded for it: they are the vendored fork's own copies of
a claim this change makes false, and that source is where a reader of the on-call agent
would look for it.

- [x] Security impact considered -- the removal narrows what the host reads and what
  reaches a prompt; no address or credential ever crossed into an agent's view, and that
  split is enforced on the sub-agent side, which is untouched.
- [x] Backward compatibility considered -- covered by the legacy validation alias above.
- [x] Rollback path is clear for risky changes -- revert the commit; the registry file
  format, the CLI and the sub-agent's own tools are unchanged, so nothing on disk needs
  migrating in either direction.

Checked and deliberately not changed: `ThirdPartyOpenAISubagentConfig` never carried the
flag and still does not, so an OpenAI-kind roster row cannot be the watch-work
specialist. That gap predates this branch and closing it would widen the diff into an
unrelated transport.

## Related Issues

N/A
2026-09-06 06:15:56 +00:00
0xKT
3a7cc17aeb fix(*): raven-research takes the host web vendor and key, and the ask_user gate closes
## Summary

Three strands of raven-research work, held together because they all touch the vendored fork and so share one `subagents/TREE_HASHES` line.

**Web search and fetch route through the vendor the deployment picked.** Both tools in the research-flow plugin were pinned to Serper and Jina, so a host on Tavily or Brave still needed a Serper key for the pair. They now carry the kernel's vendor tables (seven search backends, five fetch) with per-vendor request encoding and response normalisation. Serper and Jina wire traffic is byte-identical to before. A vendor that publishes no result offset declares it up front (`SearchProviderSpec.paginates`), so the saturation rule never escalates to a page rung the vendor cannot answer.

The launcher resolves the vendor first and mirrors the SELECTED vendor's key into the plugin slice, never a key by fixed path: a mismatched pair sends one vendor's credential to another's endpoint and every call comes back unauthorized. Every vendor gets an env slot at the same path the host holds it, inherited from the host config when unset, so a deployment configures a vendor once, centrally. The two legacy vendors are also read from the vendor slot, where a host configured after the vendor table landed writes them. `require_search` follows the selection rather than the default.

**The research modes take the host's effort vocabulary**: `deep` becomes `high`, `ultra` becomes `max`, and `medium` is the baseline. This is what lets the companion MR's host tier reach this agent by name.

**The ask_user gate closes after a hook rollback**, and host questions take the conversation lock like every other route, including the `direct_ask` grant. The digest follows its session's mode, a typo in a mode overlay refuses to launch rather than running the base value under the overlay's label, and the reviewer records which model judged.

Three defects found while building it, each with the test that pins it:

- **A credential reached disk.** The retry rows of the search and fetch ledger recorded `str(exc)` for a status error, and httpx puts the whole request URL in that text. SerpApi authenticates by query parameter, so a 429 or 503 wrote the key into the JSONL file. The redaction the search and fetch rows already had is now one function, `_error_text`, used by both writers, in the plugin and in the vendored copy. The regression test drives a retryable status and reads the ledger file off disk; the previous test used 401, which is not retryable and so never reached the leaking write. The key never reached the model or the answer: the appendix partitions on `search` / `fetch` / `verify` / `force_finalize` and reads nothing from a retry row.
- **A keyless fetch backend refused every call.** The kernel's `web_fetch` degrades a keyed backend with no resolvable key to Jina, out loud. The plugin's replacement did not, and it REPLACES the kernel's, so `fetch.provider = tavily` with no Tavily key made a research run the single place that config could not read a page, while a plain raven on it read the page fine. The launcher itself produces that state: it writes the provider unconditionally and the key only when one resolves. Fixed at the build site, where the kernel resolves it, and a test asserts both implementations answer identically for every vendor.

  Reported by chandler.zhang and completed in `ac7d364c`: the degraded backend was still handed the key of the vendor it replaced, which is absent by definition, so a deployment holding a Jina key read pages authenticated through raven's built-in fetch and anonymously through the plugin -- losing the configured quota on the very fallback the rule exists to match. The kernel looks the key up a second time under the EFFECTIVE provider; the slice carries one key per role and no vendor table, so the launcher now mirrors the default reader's key beside the selected vendor's and the build picks by destination, a lookup keyed on the provider the tool will actually call. It is mirrored whenever the selection is not already the default rather than only when the fallback will fire, because the rule that decides that lives in `effective_provider` and a launcher second-guessing it would be the copy that drifts.
- **A typo in a vendor name refused to launch for the wrong reason.** The plugin degrades an unknown vendor to its default, which is right for a slice nothing validates. Carried through the launcher, the same typo had `require_search` demand a key for a vendor that does not exist while the working Serper key sat in the config -- sending the operator to set a credential they already had. The launcher now refuses naming the name and the valid list.

`.env.example` and the plugin docstrings were still describing the fixed Serper and Jina pair; both now cover the provider switch and the per-vendor key slots. The plugin MANIFEST was missed in that pass and is corrected in `18ce29df`, also on chandler.zhang's report: it still called `search.apiKey` a Serper key and `fetch.apiKey` a Jina reader key, and said web_search declines "when no Serper key resolves". A direct plugin user reaching it without the launcher could set `search.provider = tavily` and supply a Serper credential, which this code then sends to Tavily's endpoint.

`subagents/TREE_HASHES` is recorded once, in the final commit, rather than per commit: the hash covers every tracked byte under the fork, so an intermediate value goes stale the moment the next edit or a rebase lands.

## Type

- [x] Fix
- [ ] Feature
- [ ] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

Run on this branch at its current head:

- `uv run pytest` -- 5 failed, 18545 passed, 69 skipped. The five are this host's pre-existing baseline, identical on `origin/main`: `test_cli_doctor_commands.py::test_doctor_answers_where_the_memories_are` and four `test_security_network.py` NAT64 parameters. 0 introduced.
- `make lint-python` -- passed, 1787 files already formatted.
- `uv run lint-imports` -- 8 contracts kept, 0 broken.
- `make check-vendored-subagents` -- exit 0, hash recorded.
- `make check-vendored-invariants`, `make check-large-files`, `make lint-ui`, `make lint-tui`, `scripts/check_commit_messages.py origin/main..HEAD` -- all exit 0.
- The vendored fork's own suite, run with the fork on `PYTHONPATH` so `raven` resolves to its copy: 19 failed, 6223 passed, 4 errors. Reverting only this branch's change to the fork gives the same 19 failures and 4 errors, all in three files that never import the changed module, so 0 introduced. Those failures are an artifact of running the fork against the trunk's venv, not the fork's own.

Reverting each fix and confirming the matching test fails: the ledger redaction (the 429 case red, the 401 case correctly still green), the fetch degradation (4 keyed vendors red, Jina correctly unaffected), the vendor-name refusal (2 red), and the slice key following the selected vendor (2 red).

Three more for the review fix: the build passing the selected vendor's key to the reader that replaced it (1 red), the launcher not mirroring the fallback key (1 red), and the launcher mirroring it for the default vendor too (1 red, the case where a second copy of the same key is one more place for the pair to disagree).

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

Security: a credential stopped being written to disk. Any research-flow ledger file written before this change by a deployment on SerpApi may contain the key in a `search_retry` or `fetch_retry` row. Those files live under the plugin's state root, one per turn, and are unlinked at the end of the turn that wrote them; a process killed mid-turn leaves one behind. Treat a SerpApi key used on an affected build as exposed and rotate it, then check for leftover files.

Other user-visible changes:

- A research deployment that selected a keyed fetch vendor without its key now reads pages through Jina instead of failing every fetch, and does so on the host's configured Jina key rather than anonymously. Behaviour improves; the log says which vendor is serving.
- That fallback key now travels in the rendered plugin slice as `fetch.fallbackApiKey`, beside the selected vendor's key, wherever the rendered config already holds credentials. It is only ever handed to the default reader: the build looks the key up by destination, so a provider neither key belongs to gets none.
- An unknown vendor name in `search.provider` or `fetch.provider` now refuses to launch. A deployment running on a typo today would have been failing its search calls anyway.
- The research mode ids change: `deep` becomes `high` and `ultra` becomes `max`. A caller that names `deep` by id gets the agent's default instead.
- Ledger `*_retry` rows record `HTTPStatusError: HTTP <status>` where they recorded the full httpx message. The one offline reader, the fork's `bench/rollout.py`, buckets by status either way and already read the search and fetch rows in that shape.

Rollback: revert the commits on this branch. `TREE_HASHES` is recorded in its own final commit, so reverting the set restores the recorded hash with the tree.

## Related Issues

N/A

<!-- The repo guide says to leave this trailer to the commits, on the premise that
     the platform collects it into the squash commit. This GitLab does not, and the
     squash body is taken from this description, so it is repeated here to survive. -->

Co-authored-by: Claude (claude-fable-5-1) <noreply@anthropic.com>
Co-authored-by: Claude (claude-opus-5) <noreply@anthropic.com>
2026-09-06 04:12:09 +00:00
userName20260323
fec055779d fix(*): raven-research takes the host web vendor and key, and the ask_user gate closes
## Summary

Three strands of raven-research work, held together because they all touch the vendored fork and so share one `subagents/TREE_HASHES` line.

**Web search and fetch route through the vendor the deployment picked.** Both tools in the research-flow plugin were pinned to Serper and Jina, so a host on Tavily or Brave still needed a Serper key for the pair. They now carry the kernel's vendor tables (seven search backends, five fetch) with per-vendor request encoding and response normalisation. Serper and Jina wire traffic is byte-identical to before. A vendor that publishes no result offset declares it up front (`SearchProviderSpec.paginates`), so the saturation rule never escalates to a page rung the vendor cannot answer.

The launcher resolves the vendor first and mirrors the SELECTED vendor's key into the plugin slice, never a key by fixed path: a mismatched pair sends one vendor's credential to another's endpoint and every call comes back unauthorized. Every vendor gets an env slot at the same path the host holds it, inherited from the host config when unset, so a deployment configures a vendor once, centrally. The two legacy vendors are also read from the vendor slot, where a host configured after the vendor table landed writes them. `require_search` follows the selection rather than the default.

**The research modes take the host's effort vocabulary**: `deep` becomes `high`, `ultra` becomes `max`, and `medium` is the baseline. This is what lets the companion MR's host tier reach this agent by name.

**The ask_user gate closes after a hook rollback**, and host questions take the conversation lock like every other route, including the `direct_ask` grant. The digest follows its session's mode, a typo in a mode overlay refuses to launch rather than running the base value under the overlay's label, and the reviewer records which model judged.

Three defects found while building it, each with the test that pins it:

- **A credential reached disk.** The retry rows of the search and fetch ledger recorded `str(exc)` for a status error, and httpx puts the whole request URL in that text. SerpApi authenticates by query parameter, so a 429 or 503 wrote the key into the JSONL file. The redaction the search and fetch rows already had is now one function, `_error_text`, used by both writers, in the plugin and in the vendored copy. The regression test drives a retryable status and reads the ledger file off disk; the previous test used 401, which is not retryable and so never reached the leaking write. The key never reached the model or the answer: the appendix partitions on `search` / `fetch` / `verify` / `force_finalize` and reads nothing from a retry row.
- **A keyless fetch backend refused every call.** The kernel's `web_fetch` degrades a keyed backend with no resolvable key to Jina, out loud. The plugin's replacement did not, and it REPLACES the kernel's, so `fetch.provider = tavily` with no Tavily key made a research run the single place that config could not read a page, while a plain raven on it read the page fine. The launcher itself produces that state: it writes the provider unconditionally and the key only when one resolves. Fixed at the build site, where the kernel resolves it, and a test asserts both implementations answer identically for every vendor.

  Reported by chandler.zhang and completed in `ac7d364c`: the degraded backend was still handed the key of the vendor it replaced, which is absent by definition, so a deployment holding a Jina key read pages authenticated through raven's built-in fetch and anonymously through the plugin -- losing the configured quota on the very fallback the rule exists to match. The kernel looks the key up a second time under the EFFECTIVE provider; the slice carries one key per role and no vendor table, so the launcher now mirrors the default reader's key beside the selected vendor's and the build picks by destination, a lookup keyed on the provider the tool will actually call. It is mirrored whenever the selection is not already the default rather than only when the fallback will fire, because the rule that decides that lives in `effective_provider` and a launcher second-guessing it would be the copy that drifts.
- **A typo in a vendor name refused to launch for the wrong reason.** The plugin degrades an unknown vendor to its default, which is right for a slice nothing validates. Carried through the launcher, the same typo had `require_search` demand a key for a vendor that does not exist while the working Serper key sat in the config -- sending the operator to set a credential they already had. The launcher now refuses naming the name and the valid list.

`.env.example` and the plugin docstrings were still describing the fixed Serper and Jina pair; both now cover the provider switch and the per-vendor key slots. The plugin MANIFEST was missed in that pass and is corrected in `18ce29df`, also on chandler.zhang's report: it still called `search.apiKey` a Serper key and `fetch.apiKey` a Jina reader key, and said web_search declines "when no Serper key resolves". A direct plugin user reaching it without the launcher could set `search.provider = tavily` and supply a Serper credential, which this code then sends to Tavily's endpoint.

`subagents/TREE_HASHES` is recorded once, in the final commit, rather than per commit: the hash covers every tracked byte under the fork, so an intermediate value goes stale the moment the next edit or a rebase lands.

## Type

- [x] Fix
- [ ] Feature
- [ ] Docs
- [ ] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

Run on this branch at its current head:

- `uv run pytest` -- 5 failed, 18545 passed, 69 skipped. The five are this host's pre-existing baseline, identical on `origin/main`: `test_cli_doctor_commands.py::test_doctor_answers_where_the_memories_are` and four `test_security_network.py` NAT64 parameters. 0 introduced.
- `make lint-python` -- passed, 1787 files already formatted.
- `uv run lint-imports` -- 8 contracts kept, 0 broken.
- `make check-vendored-subagents` -- exit 0, hash recorded.
- `make check-vendored-invariants`, `make check-large-files`, `make lint-ui`, `make lint-tui`, `scripts/check_commit_messages.py origin/main..HEAD` -- all exit 0.
- The vendored fork's own suite, run with the fork on `PYTHONPATH` so `raven` resolves to its copy: 19 failed, 6223 passed, 4 errors. Reverting only this branch's change to the fork gives the same 19 failures and 4 errors, all in three files that never import the changed module, so 0 introduced. Those failures are an artifact of running the fork against the trunk's venv, not the fork's own.

Reverting each fix and confirming the matching test fails: the ledger redaction (the 429 case red, the 401 case correctly still green), the fetch degradation (4 keyed vendors red, Jina correctly unaffected), the vendor-name refusal (2 red), and the slice key following the selected vendor (2 red).

Three more for the review fix: the build passing the selected vendor's key to the reader that replaced it (1 red), the launcher not mirroring the fallback key (1 red), and the launcher mirroring it for the default vendor too (1 red, the case where a second copy of the same key is one more place for the pair to disagree).

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

Security: a credential stopped being written to disk. Any research-flow ledger file written before this change by a deployment on SerpApi may contain the key in a `search_retry` or `fetch_retry` row. Those files live under the plugin's state root, one per turn, and are unlinked at the end of the turn that wrote them; a process killed mid-turn leaves one behind. Treat a SerpApi key used on an affected build as exposed and rotate it, then check for leftover files.

Other user-visible changes:

- A research deployment that selected a keyed fetch vendor without its key now reads pages through Jina instead of failing every fetch, and does so on the host's configured Jina key rather than anonymously. Behaviour improves; the log says which vendor is serving.
- That fallback key now travels in the rendered plugin slice as `fetch.fallbackApiKey`, beside the selected vendor's key, wherever the rendered config already holds credentials. It is only ever handed to the default reader: the build looks the key up by destination, so a provider neither key belongs to gets none.
- An unknown vendor name in `search.provider` or `fetch.provider` now refuses to launch. A deployment running on a typo today would have been failing its search calls anyway.
- The research mode ids change: `deep` becomes `high` and `ultra` becomes `max`. A caller that names `deep` by id gets the agent's default instead.
- Ledger `*_retry` rows record `HTTPStatusError: HTTP <status>` where they recorded the full httpx message. The one offline reader, the fork's `bench/rollout.py`, buckets by status either way and already read the search and fetch rows in that shape.

Rollback: revert the commits on this branch. `TREE_HASHES` is recorded in its own final commit, so reverting the set restores the recorded hash with the tree.

## Related Issues

N/A

<!-- The repo guide says to leave this trailer to the commits, on the premise that
     the platform collects it into the squash commit. This GitLab does not, and the
     squash body is taken from this description, so it is repeated here to survive. -->

Co-authored-by: Claude (claude-fable-5-1) <noreply@anthropic.com>
Co-authored-by: Claude (claude-opus-5) <noreply@anthropic.com>
2026-09-06 04:12:09 +00:00
ZuyiZhou
25b57575a1 feat(research): audit a report for the defects that decided the head-to-head
The 2026-09-04 head-to-head against a competitor's top tier lost 9 dimensions
to 4. It did not lose on writing or honesty, where our report won: it lost on
four defect classes, three of which a parser can find in the delivered file.

`scripts/research_report_audit.py` finds them. It reads a report as delivered -
the markdown body plus the process appendix the flow already writes - and
reports only what a parser can settle: template sections, what the trail
recorded, how deep the fetches went, which table cells carry an estimate,
whether a ranking agrees with its own total column, and whether prose leaked in
front of the first heading. Three findings are hard and gate `--strict`, one per
class that cost a dimension:

- `estimate_in_quantitative_column`. Two size cells reading `(est.)` were off by
  an order of magnitude, and the candidates were scored and ranked on them. A
  cell that shows its arithmetic is exempt: deriving what the sources leave
  implicit is what the flow's identity prompt asks for, and an audit that flagged
  it would penalise the behaviour the product teaches.
- `rank_contradicts_total`. A rank column ascending while its totals rise.
- `citation_never_opened` / `citation_never_surfaced`, read off the appendix.

Soft findings are reported and not gated: the preamble leak (the model answering
its own harness, which ships as the reader's first sentence), a missing section,
rows the report marks not fetched, a median page under 3k characters (landing
pages, not papers), schemeless and fence-tag citations, an unreviewed answer.

The script is stdlib-only and reads any markdown report, so a competitor's file
goes through the same parser as ours. Without one parser a head-to-head is two
rubrics, which is how the same defect scored differently twice.

`docs/research-report-quality.md` is the protocol the script serves: the two
briefs, the run conditions a comparison is void without, the fifteen dimensions
with which are machine-settled and which need a reader, the 2026-09-04 baseline
with its four root causes, and the sequence of changes this grades.

Run conditions are in the doc because the last comparison had none: that run's
trail shows 46 searches against a `fast` ceiling of 40 tool iterations, so it was
not the default profile, and which deeper one it was cannot be recovered from the
report. An unrecorded mode makes every won or lost dimension unattributable.

- [ ] Fix
- [x] Feature
- [ ] Docs
- [ ] CI / tooling

```
pytest tests/test_research_report_audit.py            25 passed
  coverage of scripts/research_report_audit.py        96.64%
ruff check / ruff format --check                      clean
```

Run against the three reports on hand, the audit independently reproduced every
mechanical defect the hand scoring found, and nothing it found was absent from
the hand scoring.

fix(research): the audit reads ordinary markdown and the whole appendix

Three review findings, all cases where the audit could miss or invent the
defects it exists to settle.

**Table extraction is fence-aware and accepts valid GFM.** It required a row to
begin with a pipe and split on every pipe, so a table written without outer
pipes produced no tables at all - `--strict` exited 0 over an `(est.)` - while a
table shown inside a fenced block as an example was read as report data, and an
escaped `\|` both split a cell and made its row ragged. Rows are now recognised
by containing an unescaped pipe, cells split on unescaped pipes only, fenced
blocks are masked out before scanning, and the delimiter row must carry the
header's own width, which is what keeps a sentence over a horizontal rule from
reading as a one-column table.

**The appendix's other grounding outcome is read.** `N page(s) were read but the
answer cites no link` and `No links were cited above, so there was nothing to
check` had no pattern, so an entirely untraceable report came back with an empty
citation block and no citation finding. Both now set the citation count to zero
and raise `answer_cites_nothing`, hard: it means the grounding check did not run,
and scanned in a table of runs an absence of citation warnings reads as a pass.
The three warning patterns were also loosened off their emoji - the sentence is
the anchor, and a producer that re-marks its own warning must not silence the
parser.

**Fetch depth is no longer read off a truncated prefix.** `render()` lists at
most forty substantive pages and counts the rest, and the median was computed
over that prefix and reported as the run's depth - inventing or hiding a shallow
verdict depending on which fetches came first. The listings are now parsed per
`<details>` block (both are capped and both end with the same "and N more" line,
so read globally the queries' cap was attributed to the pages'), truncation is
detected from the marker or from the head's own count, and on a truncated listing
the depth verdict is withheld and replaced by `fetch_depth_from_a_truncated_list`,
which names the listed share and calls the prefix median what it is.

Four new tests build an appendix with the flow's own `process_appendix.render()`
and read it back, so the parser is pinned to the producer rather than to strings
copied out of one report - including the 41-page case that triggers the cap.

## Verification

```
pytest tests/test_research_report_audit.py       43 passed
  coverage of scripts/research_report_audit.py   97.84%
ruff check / format --check                      clean
```

Re-run against the three reports on hand, every previously reported finding is
unchanged: the 33 listed pages of the 2026-09-04 run are exactly its 36 read
minus its 3 thin, so that run is not truncated and keeps its depth verdict.

fix(research): a fence closes only on its own marker, as GFM says

Second review round on the table thread: `_fenced` toggled on any fence-shaped
line, so it re-entered the document at the inner fence of a four-backtick block
wrapping a three-backtick example - and at a `~~~` line inside a backtick block.
Both are the shape a convention table takes when it is shown as an example, and
both put its rows back in front of the estimate check as a hard false finding.

The opener is now remembered rather than counted, and a fence closes only on the
same marker character, at no less than the opening length, with nothing after it.
A backtick fence whose info string contains a backtick is not an opener at all -
that shape is inline code in a paragraph, and treating it as one would mask the
rest of the report and silence every finding after it.

Ten tests, one per rule and one per direction: the four-backtick and mixed-marker
examples yield no tables; a shorter run does not close a longer fence and a longer
one does; a closing fence may not carry an info string while an opening one may; an
inline-code line is not an opener; an unclosed fence masks to the end of the
document, as GFM ends it there; three spaces of indentation still fence.

## Verification

```
uv run --frozen --python 3.12 --all-extras pytest -q tests/test_research_report_audit.py
  53 passed
  coverage of scripts/research_report_audit.py   97.91%

uv run --frozen --python 3.12 --extra dev ruff check scripts tests
  All checks passed!
```

The reviewer's two manual probes, run through the CLI: the four-backtick outer
fence and the tilde-inside-backtick fence each exit 0 with no hard finding, while
the same table unfenced still exits 1 with its `(est.)` named. The 2026-09-04
report is unchanged at 6 hard and 5 soft findings.

fix(research): the audit finds rank and total by shape, not by header word

Rebased onto the governance batch, which makes `make check-source-language` a
gate: added lines must be English outside the owner-signed exemption zones. The
audit carried CJK in eight regexes, because the reports it reads are not all in
English - the product renders zh whenever the host config sets a language.

Two of those regexes were translation tables for `rank` and `total` headers, and
they were the wrong design anyway. Both columns are now found by shape:

- a rank is an unbroken ascending run of integers, in any column when it starts
  at 1 and in the first column when it starts anywhere else, so an excerpt of a
  longer table keeps the check while a criterion column that climbs over two rows
  does not gain it;
- a total is the column that equals the sum of the unbroken run of numeric columns
  ending just before it, on most rows. That verifies the total rather than trusting
  its label, and it works on a table whose header says nothing at all. A table too
  small to verify falls back to the English header word, and says so: a report that
  neither names its total in English nor lets it be checked keeps its ranking
  unaudited rather than mis-audited.

The remaining markers - a cell saying "approximately", "estimate", "not obtained",
"not fetched", "unverified", "derived" - are input data rather than prose, so they
are written as codepoint escapes with a `MARKER_GLOSSARY` naming each in English,
and a test holds the glossary and the patterns in step so one cannot quietly stop
firing. If the owner would rather have an exemption zone for this file than the
escapes, say so and I will swap them back; dropping zh recognition is the third
option and the one that loses a real check - the only hard finding in the Chinese
report on hand is an "approximately" cell in a scored column.

One test fixture heading was Chinese for no reason and is now English, which is
what the gate says about a fixture that would read the same either way.

The docs index conflict from the same batch is resolved onto main's rewritten
index, with the protocol filed among the live references rather than the dated
records.

## Verification

```
uv run --frozen --python 3.12 --all-extras pytest -q tests/test_research_report_audit.py
  59 passed
  coverage of scripts/research_report_audit.py   97.31%

PYTHONPATH=. uv run --frozen --python 3.12 --extra dev python scripts/check_source_language.py origin/main...HEAD
  clean

uv run --frozen --python 3.12 --extra dev ruff check scripts tests
  All checks passed!
```

Both reports on hand come back with exactly the findings they had before the
refactor: the English one at 6 hard and 5 soft with its rank inversion still
named, the Chinese one with its one hard estimate still caught.


## Type

- [ ] Fix
- [x] Feature
- [ ] Docs
- [ ] CI / tooling

## Verification

Rebased onto the subagent-discovery and governance batch. Exact commands at this head:

```
uv run --frozen --python 3.12 --all-extras pytest -q tests/test_research_report_audit.py
  59 passed
  coverage of scripts/research_report_audit.py   97.31%

PYTHONPATH=. uv run --frozen --python 3.12 --extra dev python scripts/check_source_language.py origin/main...HEAD
  clean

uv run --frozen --python 3.12 --extra dev ruff check scripts tests
  All checks passed!

uv run --frozen --python 3.12 --extra dev ruff format --check scripts tests
  816 files already formatted
```

Three review rounds landed on this branch after the first: fence-aware and GFM-correct
table extraction, the appendix's second no-link grounding outcome, fetch depth no longer
read off the capped page listing, a fence that closes only on its own marker, and - after
the rebase onto the governance batch - rank and total found by shape rather than by a
header word in two languages, which the new source-language gate would not carry and
which was the weaker design anyway.

Both reports on hand come back with the findings they had before each of those changes:
the English one at 6 hard and 5 soft with its rank inversion named, the Chinese one with
its one hard estimate caught.
2026-09-06 04:10:18 +00:00
0xKT
2f862d8ca2 feat(build): RAVEN_WHEEL_SLIM switch for a headless cloud wheel
## 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.
2026-09-05 17:09:13 +00:00
hylarucoder
c703db6ffd feat(build): RAVEN_WHEEL_SLIM switch for a headless cloud wheel
## 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.
2026-09-05 17:09:13 +00:00
0xKT
009d0474e6 feat(*): subagent discovery switches rails from the forks to agents/
## Summary

Subagent discovery switches rails from the subagents/ fork trees to the
agents/ product tree. This makes the five migrated products (code, oncall,
ppt, research, design) the factory default: a fresh install discovers them
without running any per-product installer, and the fork trees stop being
scanned entirely (they remain on disk, untouched, until their separately
scheduled retirement).

Key decisions:

- Discovery resolves an agents root through the same three levels the fork
  scan used: raven home copy, beside the package, wheel-embedded. The copy
  to raven home is kept folders-only so a product's .env survives upgrades.
- Readiness has new semantics: the launcher's absolute-path command tokens
  must exist, and a product-declared engine distribution must be importable
  (importlib find_spec). A product whose engine wheel is missing is listed
  but disabled, naming the wheel to install. Credential checks leave the
  discovery phase: the launcher itself refuses loudly, which live handshake
  smoke verified for all five products.
- Config rows keep whole-row precedence over discovered rows; the merge
  mechanics are unchanged (verified byte-equivalent modulo renames by an
  independent adversarial review).
- The main wheel now ships the five product launchers under raven/agents
  and no longer embeds raven/subagents (118 files / 1.3 MB, verified by
  building and listing the wheel; zero pyproject changes, the inclusion
  lives in the hatch build hook).
- The design/ppt manifests gain one machine-readable field,
  `engine: {package, wheel}`, consumed by the readiness probe; launch
  behavior is untouched and older readers ignore the field (verified).
- A discovered row whose readiness is clean but whose runtime probe misses
  now renders as attention instead of a dead Install button (fix from the
  adversarial review).

An independent adversarial review (verdict: land after fixes) preceded this
MR; its one HIGH (net test-coverage loss on host_can_lend_a_key edge
branches) and one MED (the Install dead-end above) are fixed in the commit,
with companion tests. Fork-era behaviors it confirmed as bit-identical
inheritances (home-first shadowing, path-with-spaces refusal) are recorded,
not changed.

## Type

- [x] Feature

## Verification

- Full canonical suite on the branch: `uv run pytest tests -q` under
  `uv sync --all-extras` -> 18494 passed, 40 skipped, exit 0 (rehearsal
  tree); 18472 passed, 62 skipped on the drafting stack. Net def-level
  movement vs baseline accounted name-for-name in the wave report.
- Targeted families at landing: tests/test_agents_ppt_launcher.py,
  tests/test_cli_subagent_setup.py, tests/test_hatch_build.py,
  tests/test_rpc_subagents.py, tests/test_subagent_dag_machines.py,
  tests/test_subagent_vendored_agents.py -> 242 passed.
- `make lint-python` -> exit 0; `uv run lint-imports` -> 8 kept, 0 broken;
  `make check-vendored-subagents`, `check-vendored-invariants`,
  `check-large-files` -> exit 0. subagents/ is byte-untouched.
- Wheel audit: `uv build --wheel`, listed contents -> 5 launchers +
  5 manifests under raven/agents, 0 raven/subagents entries, no secrets.
- Fresh-venv install test: wheel installed into an isolated venv discovers
  and materializes all five rows; design/ppt correctly disabled without
  their engine wheels; research launcher runs to its credential verdict.

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

User-visible change: fork rows stop appearing on fresh installs; the five
product rows appear instead. Machines with existing config rows are
unaffected (config precedence unchanged). The RPC wire shape is frozen
(vendored/building keys and subagents.build kept), so no client regeneration
is needed. Rollback: revert the squash commit; discovery returns to the
fork trees, which are still on disk in the repo and still embedded in any
wheel built before this change.

## Related Issues

N/A
2026-09-05 05:13:56 +00:00
0xKT
9a98c3107f feat(*): subagent discovery switches rails from the forks to agents/
## Summary

Subagent discovery switches rails from the subagents/ fork trees to the
agents/ product tree. This makes the five migrated products (code, oncall,
ppt, research, design) the factory default: a fresh install discovers them
without running any per-product installer, and the fork trees stop being
scanned entirely (they remain on disk, untouched, until their separately
scheduled retirement).

Key decisions:

- Discovery resolves an agents root through the same three levels the fork
  scan used: raven home copy, beside the package, wheel-embedded. The copy
  to raven home is kept folders-only so a product's .env survives upgrades.
- Readiness has new semantics: the launcher's absolute-path command tokens
  must exist, and a product-declared engine distribution must be importable
  (importlib find_spec). A product whose engine wheel is missing is listed
  but disabled, naming the wheel to install. Credential checks leave the
  discovery phase: the launcher itself refuses loudly, which live handshake
  smoke verified for all five products.
- Config rows keep whole-row precedence over discovered rows; the merge
  mechanics are unchanged (verified byte-equivalent modulo renames by an
  independent adversarial review).
- The main wheel now ships the five product launchers under raven/agents
  and no longer embeds raven/subagents (118 files / 1.3 MB, verified by
  building and listing the wheel; zero pyproject changes, the inclusion
  lives in the hatch build hook).
- The design/ppt manifests gain one machine-readable field,
  `engine: {package, wheel}`, consumed by the readiness probe; launch
  behavior is untouched and older readers ignore the field (verified).
- A discovered row whose readiness is clean but whose runtime probe misses
  now renders as attention instead of a dead Install button (fix from the
  adversarial review).

An independent adversarial review (verdict: land after fixes) preceded this
MR; its one HIGH (net test-coverage loss on host_can_lend_a_key edge
branches) and one MED (the Install dead-end above) are fixed in the commit,
with companion tests. Fork-era behaviors it confirmed as bit-identical
inheritances (home-first shadowing, path-with-spaces refusal) are recorded,
not changed.

## Type

- [x] Feature

## Verification

- Full canonical suite on the branch: `uv run pytest tests -q` under
  `uv sync --all-extras` -> 18494 passed, 40 skipped, exit 0 (rehearsal
  tree); 18472 passed, 62 skipped on the drafting stack. Net def-level
  movement vs baseline accounted name-for-name in the wave report.
- Targeted families at landing: tests/test_agents_ppt_launcher.py,
  tests/test_cli_subagent_setup.py, tests/test_hatch_build.py,
  tests/test_rpc_subagents.py, tests/test_subagent_dag_machines.py,
  tests/test_subagent_vendored_agents.py -> 242 passed.
- `make lint-python` -> exit 0; `uv run lint-imports` -> 8 kept, 0 broken;
  `make check-vendored-subagents`, `check-vendored-invariants`,
  `check-large-files` -> exit 0. subagents/ is byte-untouched.
- Wheel audit: `uv build --wheel`, listed contents -> 5 launchers +
  5 manifests under raven/agents, 0 raven/subagents entries, no secrets.
- Fresh-venv install test: wheel installed into an isolated venv discovers
  and materializes all five rows; design/ppt correctly disabled without
  their engine wheels; research launcher runs to its credential verdict.

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

User-visible change: fork rows stop appearing on fresh installs; the five
product rows appear instead. Machines with existing config rows are
unaffected (config precedence unchanged). The RPC wire shape is frozen
(vendored/building keys and subagents.build kept), so no client regeneration
is needed. Rollback: revert the squash commit; discovery returns to the
fork trees, which are still on disk in the repo and still embedded in any
wheel built before this change.

## Related Issues

N/A
2026-09-05 05:13:56 +00:00
0xKT
8f6ef4c0ce ci(*): the governance batch brings the rulebook current and makes it enforced
## Summary

Governance hardening batch: the collaboration rulebook catches up with the
post-layering tree, the repository's comments and records are brought up to
its own standards, and the standards themselves become enforced gates.

Five commits, in series:

1. docs: the rulebook catches up -- AGENTS.md gains the source-language rule
   with the owner-signed CJK zones, a portable PR check replaces the
   GitHub-only wording, README's repo-layout table becomes the canonical
   scope list, CONTEXT-MAP gains its third route, and CONTEXT.md records the
   migration vocabulary.
2. docs: 133 surgical comment fixes across 83 files -- comments now say why,
   and only why; edit markers and restated-what comments are gone.
3. docs: stale orphans leave -- 5 dead documents deleted, 4 dated records
   stamped as historical, the zh README shrinks to a translated landing
   page, and the living-docs guard widens its glob.
4. ci: the honor system grows teeth -- scripts/check_source_language.py
   (diff-based, three passes), a commitlint scope enum computed from the
   tree, tests/test_readme_scope_canon.py, and the CI/make wiring for all
   three.
5. fix: a second pass brings the batch current with what landed on main
   after it was drafted -- the design engine's two owner-signed zones enter
   the gate and the rulebook, the scope enum learns the fifth product and
   the wheel distributions, CONTEXT.md records the third distributed member
   and the Visual Domain Selector, and one zh fixture added by a follow-on
   wave is respelled to English with its placeholder semantics preserved.

The batch is docs and CI only: no runtime behavior changes. The one source
edit outside docs/CI is the fixture respell in commit 5, verified by its own
test family.

## Type

- [x] CI / tooling

## Verification

- Full suite on the batch tree: `uv run --frozen --all-extras pytest tests -q`
  -> 18513 passed, 40 skipped, exit 0.
- `make lint-python` -> All checks passed; `uv run lint-imports` -> 0 broken.
- Guard families after landing commit 5: `uv run pytest
  tests/test_playbook_generator.py tests/test_commit_lint.py
  tests/test_living_docs.py tests/test_readme_scope_canon.py
  tests/test_source_language_check.py -q` -> 55 passed.
- Language-gate self-run over the batch's own range and over main's history
  since the batch base: exit 0 (one genuine pre-existing violation found and
  fixed in commit 5).
- Commitlint over all five batch subjects: 5/5 pass; `make check-large-files`
  -> exit 0.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [x] User-facing docs or screenshots are updated when needed

## Risk

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

No runtime code paths change. The new CI gates can reject future commits by
design; if a gate misfires, reverting the squash commit removes the gates
and the rulebook text together. Existing CJK carriers in main's history are
exempt: the gate is diff-based and only judges new changes.

## Related Issues

N/A
2026-09-05 05:13:15 +00:00
Elliot Chen
88f28abca9 docs: add repository section guides (#35)
## Summary
- add lightweight overview files for top-level repository sections that
still displayed old non-conventional commit messages
- update existing benchmark and demo READMEs with public-facing guidance
- make the GitHub directory listing show a clean conventional commit
message after merge without rewriting main history

## Verification
- uv run pre-commit run --files LICENSES/README.md benchmarks/README.md
demos/README.md docs/README.md raven/README.md tests/README.md
- npx --no-install commitlint --from origin/main --to HEAD --config
commitlint.config.cjs
- PYTHONPATH=. python3 scripts/check_commit_messages.py
origin/main..HEAD
- uv run pre-commit run --from-ref origin/main --to-ref HEAD

## Note
A normal pull request cannot rename historical commits already merged
into main. This PR instead updates the affected directories with useful
public-facing overview docs so GitHub displays the new conventional
commit as the latest directory change.
2026-06-30 13:24:38 +08:00