chore(*): catch the ui-web rebuild up to main, round two

.github/workflows/ci.yml

@@ -273,6 +273,72 @@ jobs:
           if-no-files-found: ignore
           retention-days: 14
 
+  installer:
+    name: installer (${{ matrix.os }}) against the latest release
+    # The two installers are served from main and install the latest published
+    # release, so a script that reaches for something that release does not have
+    # breaks every one-line install the moment it merges -- which is how an
+    # ending on `raven web` shipped against a wheel that had no `web`. This job
+    # runs exactly that combination, piped the way users run it so remote mode
+    # is what gets exercised, and asks the installed raven to answer. Only PRs
+    # that touch an installer pay for it; every push to main runs it.
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 25
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Decide whether an installer changed
+        id: changed
+        shell: bash
+        run: |
+          if [ "${{ github.event_name }}" != "pull_request" ]; then
+            echo "run=true" >> "$GITHUB_OUTPUT"
+          elif git diff --name-only "origin/${{ github.base_ref }}...HEAD" -- install.sh install.ps1 | grep -q .; then
+            echo "run=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "run=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      # Node 22 up front: the script would otherwise fetch a private runtime,
+      # which is its business to get right but not what this job measures.
+      - uses: actions/setup-node@v6
+        if: steps.changed.outputs.run == 'true'
+        with:
+          node-version: "22"
+
+      - name: Install the latest release with install.sh, piped
+        if: steps.changed.outputs.run == 'true' && runner.os != 'Windows'
+        env:
+          RAVEN_MINIMAL: "1"
+          RAVEN_NO_LAUNCH: "1"
+          UV_TOOL_DIR: ${{ runner.temp }}/tools
+          UV_TOOL_BIN_DIR: ${{ runner.temp }}/bin
+          UV_CACHE_DIR: ${{ runner.temp }}/cache
+          RAVEN_HOME: ${{ runner.temp }}/home
+        run: |
+          cat install.sh | sh
+          "$UV_TOOL_BIN_DIR/raven" --version
+
+      - name: Install the latest release with install.ps1, piped
+        if: steps.changed.outputs.run == 'true' && runner.os == 'Windows'
+        shell: pwsh
+        env:
+          RAVEN_MINIMAL: "1"
+          RAVEN_NO_LAUNCH: "1"
+          UV_TOOL_DIR: ${{ runner.temp }}\tools
+          UV_TOOL_BIN_DIR: ${{ runner.temp }}\bin
+          UV_CACHE_DIR: ${{ runner.temp }}\cache
+          RAVEN_HOME: ${{ runner.temp }}\home
+        run: |
+          Get-Content install.ps1 -Raw | Invoke-Expression
+          & "$env:UV_TOOL_BIN_DIR\raven.exe" --version
+
   windows-upgrade:
     name: Windows self-upgrade
     runs-on: windows-latest

.github/workflows/release.yml

@@ -144,6 +144,58 @@ jobs:
       - name: Export locked constraints
         run: uv export --locked --all-extras --no-hashes --no-emit-workspace -o dist/raven-constraints.txt
 
+      # 4c) The plugin list: the wheels this release ships beside raven, one
+      #     `name @ url` line each. The upgrade helper (and, once it reads it,
+      #     the installer) takes this file from the release directory next to
+      #     the wheel and the constraints and hands it to `uv tool install
+      #     --with-requirements`, so what a complete install is made of is
+      #     written here once, from what this job just built, and nowhere
+      #     else. Direct URLs on purpose: a bare name would be resolved against
+      #     PyPI, where none of these names are ours. The everos line is what
+      #     the helper keeps when the engines cannot build, so its name is a
+      #     contract (tests/test_release_plugin_list.py).
+      - name: Write the plugin list
+        run: |
+          base="https://github.com/${{ github.repository }}/releases/download/${{ github.ref_name }}"
+          : > dist/raven-plugins.txt
+          for whl in dist/everos_memory-*.whl dist/design_engine-*.whl dist/ppt_engine-*.whl; do
+            [ -f "$whl" ] || { echo "no wheel matches $whl"; exit 1; }
+            name="$(basename "$whl" | cut -d- -f1 | tr _ -)"
+            echo "$name @ $base/$(basename "$whl")" >> dist/raven-plugins.txt
+          done
+          cat dist/raven-plugins.txt
+          test "$(wc -l < dist/raven-plugins.txt)" -eq 3
+
+      # 4d) The release installs itself before anything is published: the wheel,
+      #     the constraints, the plugin list and the plugin wheels as one whole,
+      #     through install.sh piped the way users run it. The list's public URLs
+      #     resolve only once a human publishes the draft, so the gate installs
+      #     from a copy of the list rewritten to point at the release directory
+      #     here; the rewrite only matches the exact public prefix, so a list
+      #     that named any other place fails the grep below. Then the installed
+      #     raven has to answer, carry the three plugin packages, and have the
+      #     `web` the installer ends on.
+      - name: Install the release from dist with install.sh
+        env:
+          RAVEN_MINIMAL: "1"
+          RAVEN_NO_LAUNCH: "1"
+          UV_TOOL_DIR: ${{ runner.temp }}/gate/tools
+          UV_TOOL_BIN_DIR: ${{ runner.temp }}/gate/bin
+          UV_CACHE_DIR: ${{ runner.temp }}/gate/cache
+          RAVEN_HOME: ${{ runner.temp }}/gate/home
+        run: |
+          gate="$RUNNER_TEMP/gate/release"
+          mkdir -p "$gate"
+          cp dist/*.whl dist/raven-constraints.txt "$gate/"
+          prefix="https://github.com/${{ github.repository }}/releases/download/${{ github.ref_name }}/"
+          sed "s#$prefix#file://$gate/#" dist/raven-plugins.txt > "$gate/raven-plugins.txt"
+          if grep -q "https://" "$gate/raven-plugins.txt"; then echo "plugin list names a URL outside this release"; exit 1; fi
+          wheel="$(ls dist/raven-*-py3-none-any.whl)"
+          RAVEN_WHEEL_URL="file://$gate/$(basename "$wheel")" sh -c 'cat install.sh | sh'
+          "$UV_TOOL_BIN_DIR/raven" --version
+          "$UV_TOOL_DIR/raven/bin/python" -c "import raven_everos, raven_design, raven_ppt"
+          "$UV_TOOL_BIN_DIR/raven" web --help >/dev/null
+
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:
@@ -192,7 +244,7 @@ jobs:
             id=""
           fi
           if [ -z "$id" ]; then
-            draft_url=$(gh release create "$tag" dist/*.whl dist/*.tar.gz dist/raven-constraints.txt \
+            draft_url=$(gh release create "$tag" dist/*.whl dist/*.tar.gz dist/raven-constraints.txt dist/raven-plugins.txt \
               --title "Raven $ver ($today)" --notes-file "$RUNNER_TEMP/notes.md" --draft $pre)
             # A draft lives at releases/tag/untagged-<hash> and keeps serving that
             # stale page after publication, with no redirect to the real tag. Print

CHANGELOG.md

@@ -92,6 +92,47 @@ All notable changes to Raven are documented here.
 
 ### Fixed
 
+- A sub-agent that finishes while the host is shutting down no longer loses its
+  result. Its announce submits a turn to a scheduler that is already draining;
+  the refusal escaped the announcing task, and the only trace was asyncio's
+  "Task exception was never retrieved" in the log. The undelivered text now
+  goes to the log in full, with the conversation it was for, and `raven serve`,
+  the TUI and the gateway's page cancel their sub-agents before sealing the
+  spine, the order the gateway's own spine already kept. A spawn or
+  `run_subagent_dag` that arrives once shutdown has begun is refused with a
+  message that says so, in both DAG modes, rather than started into a process
+  about to exit -- or, for a blocking DAG call, parked through the shutdown
+  grace.
+
+- Raven serving ACP sends a run of thought tokens as one
+  `agent_thought_chunk` instead of one frame per token: consecutive thought
+  chunks of a session are held for 200ms or 512 characters and go out
+  together, ahead of anything that has to follow them (a chunk of the
+  answer, a tool call, the turn's end). One design run wrote 58,675 thought
+  frames averaging under six characters; each frame is a blocking write on
+  the client's pipe, and a client that stopped reading held the server on
+  that write. The same stream replays to 4,333 frames. The first thought
+  token of a turn therefore reaches an ACP client up to 200ms later than
+  before; the answer's own chunks are not held.
+
+- A failed turn names what failed. The failure event carried only
+  `str(exc)`, which is empty for the bare `TimeoutError` a stalled model
+  stream raises, so an ACP client was told `turn_failed (code -32099)` and
+  nothing else and the parent of a sub-agent read that as a crash of the
+  tool call it saw last. The event now carries the exception's class and
+  message (`ValueError: boom`, `TimeoutError`), and the per-chunk idle
+  stall raises `StreamIdleTimeoutError`, a `TimeoutError` whose message
+  says how long the stream was silent and which bound decided it.
+
+- An on-call campaign bills only its own runs. Campaigns of one task usually
+  keep their rounds in one `remote_dir`, and the spend measure walked that
+  directory's `jobs/`, so a later campaign was charged for every earlier one's
+  runs the moment it started: a second-round campaign with a 130-minute budget
+  read 125.6 spent on its first look, 34.6 of it its own, and stopped with 142
+  real minutes unspent. The backend now counts the jobs in the campaign's own
+  ledger (plus what it submitted itself), and `ops_declare` refuses a
+  `remote_dir` a live sibling campaign is still writing rounds into.
+
 - The web file viewer opens a sub-agent's report again. `/file` anchored the
   state-directory fence on the session's working directory whenever the page
   named a session, so the fence exempted `~/.raven/tmp/<channel>` and refused

CONTEXT.md

@@ -372,8 +372,12 @@ lines and the entry itself, and any other answer keeps the task on the entry. A
 targets (readiness kind `route`): a missing, unready or switched-off target disables the row
 with the reason on it. A route is admitted the way everything else at a boundary is
 (**Admission**): it declares what its target's pipeline spends (`needs`, from the closed
-`ROUTE_REQUIREMENTS` vocabulary) and the lowest tier it may open at (`minTier`), and the
-entry checks only what was declared -- a route declaring neither is dispatched as routes
+`ROUTE_REQUIREMENTS` vocabulary), a file the dispatch must hand over for the target to have
+anything to build on (`needsFile`, a suffix; read off the files the user attached -- a direct
+chat's media, or an attachment of the turn that the spawn task names -- and never off the task
+text alone, since every deck brief spells the deck's destination like a template), and the
+lowest tier it may open at (`minTier`),
+and the entry checks only what was declared -- a route declaring none is dispatched as routes
 were before the gate, since an empty declaration is verbatim pass-through. The readiness
 probe answers for the *routed target's* lane, reading that product folder's own settings
 first and falling back to what its launcher would inherit from the host; the host's own